nitc/ffi: allows to declare C type of extern classes from Nit

[nit.git] / src / native_interface / frontier.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2011 Alexis Laferrière <alexis.laf@xymus.net>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Information and tools relevant to the frontier files
module frontier

import metamodel

import ni_tools
import ni_metamodel

import syntax # FIXME: to remove since it breaks modularity

# Transitive variable through the frontier file
# Represents a variable going from Nit to C or from C to Nit
abstract class NiVariable
        fun ni_from_name : String is abstract
        fun ni_to_name : String is abstract
        fun ni_type : MMType is abstract

        # needs to be boxed or unboxed
        # anything using the GC
        fun needs_preparation : Bool
        do
                return ni_type.local_class.primitive_info == null or
                        ni_type.local_class.primitive_info.tagged or
                        ni_type.is_nullable
        end

        # prepare variable to callback to Nit
        fun prepare_for_nit( fc : FunctionCompiler )
        do
                if needs_preparation then
                        fc.decls.add( "val_t {ni_to_name};\n" )
                        fc.exprs.add( "{ni_type.assign_from_friendly( ni_to_name, ni_from_name )};\n" )
                end
        end

        fun prepare_for_c( fc : FunctionCompiler )
        do
                if needs_preparation then
                        ni_type.compile_new_local_ref( ni_to_name, fc, not self isa ReturnVariable ) # TODO
                        fc.exprs.add( "{ni_type.assign_to_friendly( ni_to_name, ni_from_name )};\n" )
                end
        end

        # format of the variable to callback to Nit
        fun as_arg_to_nit : String
        do
                if needs_preparation then
                        return ni_to_name
                else if ( ni_type.local_class.primitive_info != null or ni_type.local_class.global.is_extern ) and
                        not ni_type.is_nullable then # int, float, point/void* ...
                        return ni_type.boxtype(ni_from_name)
                else
                        return "{ni_from_name}->ref.val"
                end
        end

        # format of the variable to call C implementation functions
        fun as_arg_to_c : String
        do
                if needs_preparation then
                        return ni_to_name
                else
                        return ni_type.unboxtype( ni_from_name )
                end
        end
end

redef class MMParam
        super NiVariable

        redef fun ni_from_name do return name.to_s
        redef fun ni_to_name do return "trans___{name}"
        redef fun ni_type do return mmtype
end

class ReceiverVariable
        super NiVariable

        redef fun ni_from_name do return "recv"
        redef fun ni_to_name do return "trans_recv"

        redef var ni_type : MMType
        init ( t : MMType ) do ni_type = t
end

class ReturnVariable
        super NiVariable

        redef fun ni_from_name do return "orig_return"
        redef fun ni_to_name do return "trans_return"

        redef var ni_type : MMType
        init ( t : MMType ) do ni_type = t

        # used only by friendly callbacks to Nit
        redef fun prepare_for_c( fc )
        do
                fc.decls.add( "val_t {ni_from_name};\n" )
                ni_type.compile_new_local_ref( ni_to_name, fc, true )
        end
        redef fun prepare_for_nit( fc )
        do
                ni_type.compile_new_local_ref( ni_from_name, fc, false )
                fc.decls.add( "val_t {ni_to_name};\n" )
        end
end

redef class MMSrcModule
        fun compile_frontier( v : FrontierVisitor )
        do
                # assumes is extern hybrid (verified by caller)

                v.body.add( "#include \"{name}._nitni.h\"\n" )

                # guard
                v.header_top.add( "#include <nit_common.h>\n" )
                v.header_top.add( "#include \"{v.cprogram.module_header_name(self)}\"\n" )

                var guard_name = "{name.to_s.to_upper}_NITNI_H"
                v.header_top.add( "#ifndef {guard_name}\n" )
                v.header_top.add( "#define {guard_name}\n\n" )

                # import custom _nit.h file from frontier
                var native_header = "{directory.path}/{name}.nit.h"
                if not native_header.file_exists then # try old style
                        native_header = "{directory.path}/{name}_nit.h"
                end
                if native_header.file_exists then
                        var path = "..".join_path(native_header).simplify_path
                        v.body.add( "#include \"{path}\"\n" )
                        v.header.add( "#include \"{path}\"\n" )
                end

                for local_class in local_classes do
                        ### extern methods
                        for prop in local_class.local_local_properties do
                                # if defined of redefined in this module
                                # and is extern
                                if prop.mmmodule == self and
                                   prop isa MMSrcMethod and prop.is_extern then
                                        prop.compile_extern_to_frontier( v )
                                end
                        end
                end

                v.header.add( "#endif\n" )
        end
end

redef class MMSrcMethod
        fun compile_extern_to_frontier( v : FrontierVisitor )
        do
                # defines types used in signature
                if signature != null then
                        signature.compile_frontier( v )
                end

                for imported in explicit_imports do
                        # adds friendly access to property
                        v.friendlys.add( imported )

                        # defines relevant types
                        imported.signature.compile_frontier( v )
                end

                # adds casts and as verifications
                for cast in explicit_casts do
                        v.casts.add( cast )

                        v.types.add( cast.from.direct_type )
                        v.types.add( cast.to.direct_type )
                end

                # adds super
                if need_super then
                        compile_super_to_frontier( v )
                end

                # adds function in frontier to be called by pure nit
                compile_out_to_frontier( v )
        end

        # Compiles body and header for the friendly super method.
        # The friendly super method is called by custom native code and
        # calls the generated C code to execute the real implementation.
        # It handles types conversion and verifications.
        fun compile_super_to_frontier( v : FrontierVisitor )
        do
                # header
                v.header.add( "\n/* friendly for super of {full_name} */\n" )
                v.header.add( "{frontier_super_csignature_from( mmmodule )};\n" )

                # Defines a local name for simplier use, as with friendlys.
                v.header.add( "#ifndef {friendly_super_cname}\n" )
                v.header.add( "#define {friendly_super_cname} {local_friendly_super_name_from( mmmodule )}\n" )
                v.header.add( "#endif\n" )

                # body
                v.body.add( "\n/* friendly for super of {full_name} */\n" )
                var fc = new FunctionCompiler( friendly_super_csignature )

                # params
                var params = new Array[NiVariable]
                params.add( signature.recv_ni_variable )
                params.add_all( signature.params )

                # prepare transition
                for p in params do p.prepare_for_nit( fc )

                # extract strings
                var args = new Array[String]
                for p in params do args.add( p.as_arg_to_nit )

                # hook to generated C
                var rnv = signature.return_ni_variable
                var s = new Buffer
                if rnv != null then
                        rnv.prepare_for_c( fc )
                        s.append( "{rnv.ni_from_name} = " )
                end

                s.append( "{super_meth_call}( {signature.recv_ni_variable.as_arg_to_nit} )" )
                s.append( "( {args.join( ", " )} );\n" )

                fc.exprs.add( s.to_s )

                # return
                if rnv != null then
                        fc.exprs.add( "{rnv.ni_type.assign_to_friendly( rnv.ni_to_name, rnv.ni_from_name )};\n" )
                        fc.exprs.add( "return {rnv.ni_to_name};\n" )
                end

                v.body.append( fc.to_writer )
        end

        # Compiles body and header for the out method.
        # The out method is called by generated C code
        # It handles variables conversions and verification
        fun compile_out_to_frontier( v : FrontierVisitor )
        do
                # a simple out method can be optimized
                # To qualify as simple this method must:
                #       - have no explicit imports (including super and casts)
                #       - return nothing or return a primitive to C
                var is_simple = explicit_imports.is_empty and not need_super and
                        explicit_casts.is_empty and (signature.return_type == null or
                        signature.return_type.local_class.primitive_info != null )

                # header
                v.header.add( "\n/* out/indirect function for {full_name} */\n" )
                v.header.add( "{out_csignature};\n" ) # incoming types boxed

                # body
                v.body.add( "/* out/indirect function for {full_name} */\n" )
                var fc = new FunctionCompiler( out_csignature )

                # params
                var params = new List[NiVariable]
                if not is_init then params.add( signature.recv_ni_variable )
                params.add_all( signature.params )

                var args = new List[String]

                for nv in params do
                        if not is_simple or nv.ni_type.local_class.primitive_info != null then
                                nv.prepare_for_c( fc )
                                args.add( nv.as_arg_to_c )
                        else
                                args.add( "NULL" )
                        end
                end

                # call to impl
                var rnv = signature.return_ni_variable
                if rnv == null and is_init then
                        rnv = new ReturnVariable( signature.recv )
                end

                var s = new Buffer
                if rnv != null then
                        rnv.prepare_for_nit( fc )
                        s.append( "{rnv.ni_from_name} = " )
                end

                s.append( "{extern_name.as(not null)}( {args.join( ", " )} );\n" )

                fc.exprs.add( s.to_s )

                if rnv != null then
                        fc.exprs.add( "{rnv.ni_type.assign_from_friendly( rnv.ni_to_name, rnv.ni_from_name )};\n" )
                end

                fc.exprs.add( "nitni_local_ref_clean(  );\n" )

                # return
                if rnv != null then
                        fc.exprs.add( "return {rnv.ni_to_name};\n" )
                end

                v.body.append( fc.to_writer )
        end

end

redef class MMSignature
        var recv_ni_variable : ReceiverVariable
        var return_ni_variable : nullable ReturnVariable
        redef init( params, return_type, recv_type )
        do
                super

                if return_type != null then
                        return_ni_variable = new ReturnVariable( return_type )
                else
                        return_ni_variable = null
                end
                recv_ni_variable = new ReceiverVariable( recv_type )
        end

        fun compile_frontier( v : FrontierVisitor )
        do
                # receiver
                v.types.add( recv.direct_type )

                # params
                for p in params do v.types.add( p.mmtype.direct_type )

                # return
                var rt = return_type
                if rt != null then
                        v.types.add( rt.direct_type )
                end
        end
end

class FrontierVisitor
        # frontier file header

        # header comments, imports, guard and types
        var header_top : Writer = new Writer

        # rest of header
        var header : Writer = new Writer

        # frontier file body
        var body : Writer = new Writer

        # set of imported functions, cached to avoid repetitions
        var friendlys : Set[ MMExplicitImport ] = new HashSet[ MMExplicitImport ]

        # set of relevant types, cached to avoid repetitions
        var types : Set[ MMType ] = new HashSet[ MMType ]

        # set of imported casts and as, cached to avoid repetitions
        var casts : Set[ MMImportedCast ] = new HashSet[ MMImportedCast ]

        var mmmodule : MMModule

        var cprogram : CProgram

        fun compile_cached
        do
                # types
                for t in types do t.compile_to_frontier( self )

                # friendlys
                for friendly in friendlys do friendly.compile_friendly_to_frontier( self )

                # casts
                for cast in casts do cast.compile_to_frontier( self )
        end

        fun write_to_files( base_path : String )
        do
                var path = "{base_path}._nitni.h"
                var stream = new OFStream.open( path )
                header_top.write_to_stream( stream )
                header.write_to_stream( stream )
                stream.close

                path = "{base_path}._nitni.c"
                stream = new OFStream.open( path )
                body.write_to_stream( stream )
                stream.close
        end
end

redef class MMImportedCast
        # Defines functions to cast types and verify the type of an object.
        fun compile_to_frontier( v : FrontierVisitor )
        do
                # compile isa check
                if not ( is_about_nullable_only and is_not_null_to_nullable ) then
                        v.header.add( "\n/* Type check for {from} with {to} */\n" )
                        v.header.add( "{is_a_local_csignature( v.mmmodule )};\n" )

                        v.header.add( "#ifndef {is_a_friendly_extern_name}\n" )
                        v.header.add( "#define {is_a_friendly_extern_name} {is_a_local_cname( v.mmmodule )}\n" )
                        v.header.add( "#endif\n" )

                        var fc = compile_is( v.mmmodule )
                        v.body.append( fc.to_writer )
                end

                # compile cast itself
                v.header.add( "\n/* Cast for {from} to {to} */\n" )
                v.header.add( "{as_local_csignature( v.mmmodule )};\n" )

                v.header.add( "#ifndef {as_friendly_extern_name}\n" )
                v.header.add( "#define {as_friendly_extern_name} {as_local_cname( v.mmmodule )}\n" )
                v.header.add( "#endif\n" )

                var fc = compile_as( v.mmmodule )
                v.body.append( fc.to_writer )
        end

        # Compiles a function to cast an object to a different type.
        # Verify type and if it is null.
        fun compile_as( m : MMModule ) : FunctionCompiler
        do
                var fc = new FunctionCompiler( as_local_csignature( m ) )

                var out_name = "out"
                var temp_name = "temp"

                fc.decls.add( "val_t {temp_name};\n" )
                to.compile_new_local_ref( out_name, fc, true )

                fc.exprs.add( "{from.assign_from_friendly(temp_name, in_name)};\n" )

                # makes sur it is not null if it cannot be
                if not to.is_nullable then
                        compile_check_is_not_null( fc, temp_name )
                end

                # makes sure it's the right type, unless it's only a cast about null
                if not is_about_nullable_only then # inter types
                        to.compile_check_isa( fc, temp_name )
                end

                fc.exprs.add( "{to.assign_to_friendly(out_name, temp_name)};\n" )

                fc.exprs.add( "return {out_name};\n" )

                return fc
        end

        # Compiles a function to verify if an object is of the given type.
        # Verify type and if it is null.
        fun compile_is( m : MMModule ) : FunctionCompiler
        do
                var fc = new FunctionCompiler( is_a_local_csignature( m ) )

                var temp_name = "temp"
                fc.decls.add( "val_t {temp_name};\n" )

                fc.exprs.add( "{from.assign_from_friendly(temp_name, in_name)};\n" )

                if is_nullable_to_not_null then # from null
                        if is_about_nullable_only then # opposite, we want to know if null
                                fc.exprs.add( "if ( ! ISNULL({temp_name}) ) return 0;\n" )
                        else
                                fc.exprs.add( "if ( ISNULL({temp_name}) ) return 0;\n" )
                        end
                end

                if not is_about_nullable_only then # inter types
                        fc.exprs.add( "if ( ! {to.compile_condition_isa( temp_name )} ) return 0;\n" )
                end

                fc.exprs.add( "return 1;\n" )

                return fc
        end

        # Compiles lines of code to check if an object is not null.
        # Is to be nested within another function.
        fun compile_check_is_not_null( fc : FunctionCompiler, name : String )
        do
                fc.exprs.add( "if ( ISNULL({name}) )\{" )
                fc.exprs.add( "\tfprintf( stderr, \"Casting from {from} to {to} failed because value is null.\" );\n" )
                fc.exprs.add( "\tabort();\n" )
                fc.exprs.add( "\}" )
        end

        redef fun ==( other )
        do
                return other isa MMImportedCast and
                        other.from == from and other.to == to
        end
        redef fun hash
        do
                return from.hash + to.hash
        end
end

redef class MMType
        # Compiles a lines of code to ensure that an object is of the given type.
        # Aborts when it is of the wrong type
        # Does not check if it is null.
        # Is to be nested within another function.
        fun compile_check_isa( fc : FunctionCompiler, name : String )
        do
                fc.exprs.add( "if ( ! {compile_condition_isa( name )} )\{\n" )
                fc.exprs.add( "\tfprintf( stderr, \"Casting to {self} failed because value is not a {self}.\" );\n" )
                fc.exprs.add( "\tabort();\n" )
                fc.exprs.add( "\}\n" )
        end

        # Compiles an expression to verify if an object is of the given type.
        # To be nested within a condition.
        fun compile_condition_isa( var_name : String ) : String
        do
                return "( ISOBJ( {var_name} ) ? OBJISA( {var_name}, {local_class.cname} ): VALISA( {var_name}, {local_class.cname} ) )"
        end

        # Defines a friendly type in C for a given Nit type.
        # Standard Nit classes are kept within a struct.
        fun compile_to_frontier( v : FrontierVisitor )
        do
                var pi = local_class.primitive_info
                if pi == null or is_nullable then
                        var name = friendly_extern_name
                        var guard = "{name.to_s.to_upper}_TYPE"

                        # defines struct
                        v.header_top.add( "#ifndef {guard}\n" )
                        v.header_top.add( "#define {guard}\n" )
                        v.header_top.add( "struct s_{name}\{\n" )
                        v.header_top.add( "\t\tstruct nitni_ref ref; /* real ref struct, must be first */\n" )
                        v.header_top.add( "\};\n" )
                        v.header_top.add( "typedef struct s_{name} *{name};\n" )

                        # add null version, as a struct
                        if is_nullable then
                                var local_null_getter = local_friendly_null_getter_from( mmmodule )

                                v.header_top.add( "#ifndef {friendly_null_getter}\n" )
                                v.header_top.add( "#define {friendly_null_getter} {local_null_getter}\n" )
                                v.header_top.add( "#endif\n" )

                                v.header_top.add( "{name} {local_null_getter}();\n" )

                                var fc = new FunctionCompiler( "{name} {local_null_getter}()" )
                                compile_new_local_ref( "n", fc, true )
                                fc.exprs.add( "return n;\n" )
                                v.body.append( fc.to_writer )
                        end

                        # reference incr
                        var incr_name = "{as_notnull.mangled_name}_incr_ref"
                        v.header_top.add( "#define {incr_name}( x ) nitni_global_ref_incr( (struct nitni_ref*)(x) )\n" )

                        # reference decr
                        var decr_name = "{as_notnull.mangled_name}_decr_ref"
                        v.header_top.add( "#define {decr_name}( x ) nitni_global_ref_decr( (struct nitni_ref*)(x) )\n" )

                        v.header_top.add( "#endif\n" )
                end
        end

        fun compile_new_local_ref( var_name : String, fc : FunctionCompiler, stack_it : Bool )
        do
                var type_name = friendly_extern_name

                fc.decls.add( "{type_name} {var_name};\n" )
                if uses_nitni_ref then
                        fc.exprs.add( "{var_name} = malloc( sizeof( struct s_{type_name} ) );\n" )
                        fc.exprs.add( "{var_name}->ref.val = NIT_NULL;\n" )
                        fc.exprs.add( "{var_name}->ref.count = 0;\n" )
                        if stack_it then
                                fc.exprs.add( "nitni_local_ref_add( (struct nitni_ref *){var_name} );\n" )
                        end
                end
        end

        # compiles a stub local reference for unused references
        # allows to maintain static typing but avoids malloc and free
        fun compile_stub_local_ref( var_name : String, fc : FunctionCompiler )
        do
                var type_name = friendly_extern_name
                fc.decls.add( "{type_name} {var_name};\n" )
                if uses_nitni_ref then
                        fc.exprs.add( "{var_name} = ({type_name})NULL;\n" )
                end
        end
end

redef class MMExplicitImport
        fun compile_friendly_to_frontier( v : FrontierVisitor )
        do
                # prototype in header
                v.header.add( "/* friendly for {method.full_name} */\n" )
                v.header.add( "{method.frontier_csignature_from( v.mmmodule, local_class )};\n" )

                # Defines a simplier name to be used within this module and to prevent
                # conflict with other modules importing the same friendly.
                v.header.add( "#ifndef {method.friendly_extern_name( local_class )}\n" )
                v.header.add( "#define {method.friendly_extern_name( local_class )} {method.local_friendly_name_from( v.mmmodule, local_class )}\n" )
                v.header.add( "#endif\n" )

                # implementation in body
                v.body.add( "/* friendly for {method.full_name} */\n" )

                var fc = new FunctionCompiler( method.frontier_csignature_from( v.mmmodule, local_class ) )

                # params
                var params = new Array[NiVariable]
                if not method.is_init then params.add( signature.recv_ni_variable )
                params.add_all( signature.params )

                for nv in params do nv.prepare_for_nit( fc )

                # handles return of method or constructor
                var rnv = signature.return_ni_variable
                if rnv == null and method.is_init then
                        rnv = new ReturnVariable( signature.recv )
                end
                var s = new Buffer
                if rnv != null then
                        rnv.prepare_for_c( fc )
                        s.append( "{rnv.ni_from_name} = " )
                end

                # hook to generated C code
                if method.is_init then
                        s.append( "NEW_{local_class}_{method.global.intro.cname}" )
                else
                        s.append( "{method.global.meth_call}( {signature.recv_ni_variable.as_arg_to_nit} )" )
                end

                var args = new Array[String]
                for p in params do args.add( p.as_arg_to_nit )

                s.append( "( {args.join( ", " )} );\n" )

                fc.exprs.add( s.to_s )

                # return
                if rnv != null then
                        fc.exprs.add( "{rnv.ni_type.assign_to_friendly( rnv.ni_to_name, rnv.ni_from_name )};\n" )
                        fc.exprs.add( "return {rnv.ni_to_name};\n" )
                end

                v.body.append( fc.to_writer )
        end

        redef fun hash
        do
                return method.global.to_s.hash + local_class.to_s.hash
        end
        redef fun == ( other )
        do
                return other isa MMExplicitImport and
                        method == other.method and local_class == other.local_class
        end
end