src/ffi/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 ffi_base
  19
  20 import c_tools
  21 import parser
  22 import modelbuilder
  23 import nitni
  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, "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, "Unsupported language.")
  74         end
  75 end
  76
  77 redef class MModule
  78         var ffi_files = new Array[ExternFile]
  79
  80         # Callbacks used by this module, classified by language
  81         var ffi_callbacks = new HashMap[FFILanguage, Set[NitniCallback]]
  82 end
  83
  84 redef class AExternCodeBlock
  85         fun language_name: nullable String do
  86                 if n_in_language == null then return null
  87                 return n_in_language.n_string.without_quotes
  88         end
  89         fun language_name_lowered: nullable String do
  90                 if language_name == null then return null
  91                 return language_name.to_lower
  92         end
  93
  94         fun code: String do return n_extern_code_segment.without_guard
  95
  96         var language: nullable FFILanguage = null
  97 end
  98
  99 # Visitor for a specific languages. Works kinda like a `Phase` and is executed
 100 # by a `Phase`.
 101 class FFILanguage
 102         var ffi_language_assignation_phase: FFILanguageAssignationPhase
 103
 104         init
 105         do
 106                 ffi_language_assignation_phase.languages.add(self)
 107         end
 108
 109         # Is this `block` written in this language?
 110         fun identify_language(block: AExternCodeBlock ): Bool is abstract
 111
 112         # Generate wrapper code for this module/header code block
 113         fun compile_module_block(block: AExternCodeBlock, ecc: CCompilationUnit, mmodule: MModule) is abstract
 114
 115         # Generate wrapper code for this extern method
 116         fun compile_extern_method(block: AExternCodeBlock, m: AMethPropdef,
 117                 ecc: CCompilationUnit, nmodule: MModule) is abstract
 118
 119         # Generate wrapper code for this extern class
 120         fun compile_extern_class(block: AExternCodeBlock, m: AClassdef,
 121                 ecc: CCompilationUnit, mmodule: MModule) is abstract
 122
 123         # Get the foreign type of this extern class definition
 124         fun get_ftype(block: AExternCodeBlock, m: AClassdef): ForeignType is abstract
 125
 126         # Generate the code to offer this callback if foreign code
 127         fun compile_callback(callback: NitniCallback, mmodule: MModule,
 128                 mainmmodule: MModule, ecc: CCompilationUnit) is abstract
 129
 130         # Complete compilation of generated code
 131         fun compile_to_files(mmodule: MModule, directory: String) do end
 132 end
 133
 134 redef class TString
 135         # Returns the content of this node without both of the surrounding "
 136         fun without_quotes: String
 137         do
 138                 assert text.length >= 2
 139                 return text.substring(1, text.length-2)
 140         end
 141 end
 142
 143 redef class TExternCodeSegment
 144         # Returns the content of this node without the surrounding `{ and `}
 145         fun without_guard: String
 146         do
 147                 assert text.length >= 4
 148                 return text.substring(2, text.length-4)
 149         end
 150 end
 151
 152 redef class CCompilationUnit
 153         fun write_as_impl(mmodule: MModule, compdir: String)
 154         do
 155                 var base_name = "{mmodule.c_name}._ffi"
 156
 157                 var h_file = "{base_name}.h"
 158                 var guard = "{mmodule.c_name.to_upper}_NIT_H"
 159                 write_header_to_file(mmodule, "{compdir}/{h_file}", new Array[String], guard)
 160
 161                 var c_file = "{base_name}.c"
 162                 write_body_to_file(mmodule, "{compdir}/{c_file}", ["<stdlib.h>", "<stdio.h>", "\"{h_file}\""])
 163
 164                 files.add( "{compdir}/{c_file}" )
 165         end
 166
 167         fun write_header_to_file(mmodule: MModule, file: String, includes: Array[String], guard: String)
 168         do
 169                 var stream = new OFStream.open( file )
 170
 171                 # header comments
 172                 var module_info = "/*\n\tExtern implementation of Nit module {mmodule.name}\n*/\n"
 173
 174                 stream.write( module_info )
 175
 176                 stream.write( "#ifndef {guard}\n" )
 177                 stream.write( "#define {guard}\n\n" )
 178
 179                 for incl in includes do stream.write( "#include {incl}\n" )
 180
 181                 compile_header_core( stream )
 182
 183                 # header file guard close
 184                 stream.write( "#endif\n" )
 185                 stream.close
 186         end
 187
 188         fun write_body_to_file(mmodule: MModule, file: String, includes: Array[String])
 189         do
 190                 var stream = new OFStream.open(file)
 191
 192                 var module_info = "/*\n\tExtern implementation of Nit module {mmodule.name}\n*/\n"
 193
 194                 stream.write( module_info )
 195                 for incl in includes do stream.write( "#include {incl}\n" )
 196
 197                 compile_body_core( stream )
 198
 199                 stream.close
 200         end
 201 end
 202
 203 class ForeignType
 204         fun ctype: String do return "void*"
 205 end