src/ffi/light_ffi_base.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2012 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Tools and utilities for language targetted FFI implementations
  18 module light_ffi_base
  19
  20 import c_tools
  21 import parser
  22 import modelbuilder
  23 import nitni::nitni_utilities
  24
  25 redef class ToolContext
  26         var ffi_language_assignation_phase: Phase = new FFILanguageAssignationPhase(self, null)
  27 end
  28
  29 class FFILanguageAssignationPhase
  30         super Phase
  31
  32         # All supported languages
  33         var languages = new Array[FFILanguage]
  34
  35         redef fun process_nmodule(nmodule)
  36         do
  37                 for block in nmodule.n_extern_code_blocks do
  38                         verify_foreign_code_on_node( block )
  39                 end
  40         end
  41
  42         redef fun process_npropdef(npropdef)
  43         do
  44                 if npropdef isa AMethPropdef then
  45                         var code_block = npropdef.n_extern_code_block
  46                         if code_block != null then
  47                                 verify_foreign_code_on_node( code_block )
  48                         end
  49                 end
  50         end
  51
  52         redef fun process_nclassdef(nclassdef)
  53         do
  54                 if nclassdef isa AStdClassdef and nclassdef.n_extern_code_block != null then
  55                         verify_foreign_code_on_node( nclassdef.n_extern_code_block.as(not null) )
  56                 end
  57         end
  58
  59         private fun verify_foreign_code_on_node(n: AExternCodeBlock)
  60         do
  61                 var found = false
  62                 for v in languages do
  63                         var identified = v.identify_language(n)
  64                         if identified then
  65                                 if found and identified then
  66                                         toolcontext.error(n.location, "FFI Error: two languages identified as possible handlers.")
  67                                 end
  68                                 n.language = v
  69                                 found = true
  70                         end
  71                 end
  72
  73                 if not found then toolcontext.error(n.location, "FFI Error: unsupported language.")
  74         end
  75 end
  76
  77 redef class MModule
  78         var ffi_files = new Array[ExternFile]
  79 end
  80
  81 redef class AExternCodeBlock
  82         fun language_name: nullable String do
  83                 if n_in_language == null then return null
  84                 return n_in_language.n_string.without_quotes
  85         end
  86         fun language_name_lowered: nullable String do
  87                 if language_name == null then return null
  88                 return language_name.to_lower
  89         end
  90
  91         fun code: String do return n_extern_code_segment.without_guard
  92
  93         var language: nullable FFILanguage = null
  94 end
  95
  96 # Visitor for a specific languages. Works kinda like a `Phase` and is executed
  97 # by a `Phase`.
  98 class FFILanguage
  99         var ffi_language_assignation_phase: FFILanguageAssignationPhase
 100
 101         init
 102         do
 103                 ffi_language_assignation_phase.languages.add(self)
 104         end
 105
 106         # Is this `block` written in this language?
 107         fun identify_language(block: AExternCodeBlock ): Bool is abstract
 108
 109         # Generate wrapper code for this module/header code block
 110         fun compile_module_block(block: AExternCodeBlock, ecc: CCompilationUnit, mmodule: MModule) is abstract
 111
 112         # Generate wrapper code for this extern method
 113         fun compile_extern_method(block: AExternCodeBlock, m: AMethPropdef,
 114                 ecc: CCompilationUnit, nmodule: MModule) is abstract
 115
 116         # Generate wrapper code for this extern class
 117         fun compile_extern_class(block: AExternCodeBlock, m: AClassdef,
 118                 ecc: CCompilationUnit, mmodule: MModule) is abstract
 119
 120         # Get the foreign type of this extern class definition
 121         fun get_ftype(block: AExternCodeBlock, m: AClassdef): ForeignType is abstract
 122
 123         # Complete compilation of generated code
 124         fun compile_to_files(mmodule: MModule, directory: String) do end
 125 end
 126
 127 redef class TString
 128         # Returns the content of this node without both of the surrounding "
 129         fun without_quotes: String
 130         do
 131                 assert text.length >= 2
 132                 return text.substring(1, text.length-2)
 133         end
 134 end
 135
 136 redef class TExternCodeSegment
 137         # Returns the content of this node without the surrounding `{ and `}
 138         fun without_guard: String
 139         do
 140                 assert text.length >= 4
 141                 return text.substring(2, text.length-4)
 142         end
 143 end
 144
 145 redef class CCompilationUnit
 146         fun write_as_impl(mmodule: MModule, compdir: String)
 147         do
 148                 var base_name = "{mmodule.c_name}._ffi"
 149
 150                 var h_file = "{base_name}.h"
 151                 var guard = "{mmodule.c_name.to_upper}_NIT_H"
 152                 write_header_to_file(mmodule, "{compdir}/{h_file}", new Array[String], guard)
 153
 154                 var c_file = "{base_name}.c"
 155                 write_body_to_file(mmodule, "{compdir}/{c_file}", ["<stdlib.h>", "<stdio.h>", "\"{h_file}\""])
 156
 157                 files.add( "{compdir}/{c_file}" )
 158         end
 159
 160         fun write_header_to_file(mmodule: MModule, file: String, includes: Array[String], guard: String)
 161         do
 162                 var stream = new FileWriter.open( file )
 163
 164                 # header comments
 165                 var module_info = "/*\n\tExtern implementation of Nit module {mmodule.name}\n*/\n"
 166
 167                 stream.write( module_info )
 168
 169                 stream.write( "#ifndef {guard}\n" )
 170                 stream.write( "#define {guard}\n\n" )
 171
 172                 for incl in includes do stream.write( "#include {incl}\n" )
 173
 174                 compile_header_core( stream )
 175
 176                 # header file guard close
 177                 stream.write( "#endif\n" )
 178                 stream.close
 179         end
 180
 181         fun write_body_to_file(mmodule: MModule, file: String, includes: Array[String])
 182         do
 183                 var stream = new FileWriter.open(file)
 184
 185                 var module_info = "/*\n\tExtern implementation of Nit module {mmodule.name}\n*/\n"
 186
 187                 stream.write( module_info )
 188                 for incl in includes do stream.write( "#include {incl}\n" )
 189
 190                 compile_body_core( stream )
 191
 192                 stream.close
 193         end
 194 end
 195
 196 class ForeignType
 197         fun ctype: String do return "void*"
 198 end