nitg-s: all extern type use the C structures of kernel::Pointer

Signed-off-by: Alexis Laferrière <alexis.laf@xymus.net>

diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit
index d671df3..4b16636 100644 (file)
--- a/src/separate_compiler.nit
+++ b/src/separate_compiler.nit
@@ -724,6 +724,7 @@ class SeparateCompiler
        do
                var mtype = mclass.intro.bound_mtype
                var c_name = mclass.c_name
+               var c_instance_name = mclass.c_instance_name
 
                var vft = self.method_tables[mclass]
                var attrs = self.attr_tables[mclass]
@@ -755,20 +756,22 @@ class SeparateCompiler
                end
 
                if mtype.ctype != "val*" then
-                       #Build instance struct
-                       self.header.add_decl("struct instance_{c_name} \{")
-                       self.header.add_decl("const struct type *type;")
-                       self.header.add_decl("const struct class *class;")
-                       self.header.add_decl("{mtype.ctype} value;")
-                       self.header.add_decl("\};")
+                       if mtype.mclass.name == "Pointer" or mtype.mclass.kind != extern_kind then
+                               #Build instance struct
+                               self.header.add_decl("struct instance_{c_instance_name} \{")
+                               self.header.add_decl("const struct type *type;")
+                               self.header.add_decl("const struct class *class;")
+                               self.header.add_decl("{mtype.ctype} value;")
+                               self.header.add_decl("\};")
+                       end
 
                        if not self.runtime_type_analysis.live_types.has(mtype) then return
 
                        #Build BOX
-                       self.header.add_decl("val* BOX_{c_name}({mtype.ctype});")
+                       self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype});")
                        v.add_decl("/* allocate {mtype} */")
                        v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{")
-                       v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));")
+                       v.add("struct instance_{c_instance_name}*res = nit_alloc(sizeof(struct instance_{c_instance_name}));")
                        v.require_declaration("type_{c_name}")
                        v.add("res->type = &type_{c_name};")
                        v.require_declaration("class_{c_name}")
@@ -779,7 +782,7 @@ class SeparateCompiler
                        return
                else if mclass.name == "NativeArray" then
                        #Build instance struct
-                       self.header.add_decl("struct instance_{c_name} \{")
+                       self.header.add_decl("struct instance_{c_instance_name} \{")
                        self.header.add_decl("const struct type *type;")
                        self.header.add_decl("const struct class *class;")
                        # NativeArrays are just a instance header followed by an array of values
@@ -793,7 +796,7 @@ class SeparateCompiler
                        var res = v.new_named_var(mtype, "self")
                        res.is_exact = true
                        var mtype_elt = mtype.arguments.first
-                       v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));")
+                       v.add("{res} = nit_alloc(sizeof(struct instance_{c_instance_name}) + length*sizeof({mtype_elt.ctype}));")
                        v.add("{res}->type = type;")
                        hardening_live_type(v, "type")
                        v.require_declaration("class_{c_name}")
@@ -939,7 +942,7 @@ class SeparateCompilerVisitor
                else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then
                        return value
                else if value.mtype.ctype == "val*" then
-                       return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
+                       return self.new_expr("((struct instance_{mtype.c_instance_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
                else if mtype.ctype == "val*" then
                        var valtype = value.mtype.as(MClassType)
                        var res = self.new_var(mtype)
@@ -948,6 +951,7 @@ class SeparateCompilerVisitor
                                self.add("printf(\"Dead code executed!\\n\"); show_backtrace(1);")
                                return res
                        end
+                       self.require_declaration("BOX_{valtype.c_name}")
                        self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */")
                        return res
                else if value.mtype.cname_blind == "void*" and mtype.cname_blind == "void*" then
@@ -1259,7 +1263,7 @@ class SeparateCompilerVisitor
                                # The attribute is primitive, thus we store it in a box
                                # The trick is to create the box the first time then resuse the box
                                self.add("if ({attr} != NULL) \{")
-                               self.add("((struct instance_{mtype.c_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
+                               self.add("((struct instance_{mtype.c_instance_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
                                self.add("\} else \{")
                                value = self.autobox(value, self.object_type.as_nullable)
                                self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
@@ -1498,12 +1502,12 @@ class SeparateCompilerVisitor
                        end
                end
                if primitive != null then
-                       test.add("((struct instance_{primitive.c_name}*){value1})->value == ((struct instance_{primitive.c_name}*){value2})->value")
+                       test.add("((struct instance_{primitive.c_instance_name}*){value1})->value == ((struct instance_{primitive.c_instance_name}*){value2})->value")
                else if can_be_primitive(value1) and can_be_primitive(value2) then
                        test.add("{value1}->class == {value2}->class")
                        var s = new Array[String]
                        for t, v in self.compiler.box_kinds do
-                               s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_name}*){value1})->value == ((struct instance_{t.c_name}*){value2})->value)"
+                               s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_instance_name}*){value1})->value == ((struct instance_{t.c_instance_name}*){value2})->value)"
                        end
                        test.add("({s.join(" || ")})")
                else
@@ -1573,7 +1577,7 @@ class SeparateCompilerVisitor
        do
                var elttype = arguments.first.mtype
                var nclass = self.get_class("NativeArray")
-               var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
+               var recv = "((struct instance_{nclass.c_instance_name}*){arguments[0]})->values"
                if pname == "[]" then
                        self.ret(self.new_expr("{recv}[{arguments[1]}]", ret_type.as(not null)))
                        return
@@ -1581,7 +1585,7 @@ class SeparateCompilerVisitor
                        self.add("{recv}[{arguments[1]}]={arguments[2]};")
                        return
                else if pname == "copy_to" then
-                       var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
+                       var recv1 = "((struct instance_{nclass.c_instance_name}*){arguments[1]})->values"
                        self.add("memcpy({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
                        return
                end
@@ -1786,6 +1790,23 @@ end
 
 redef class MType
        fun const_color: String do return "COLOR_{c_name}"
+
+       # C name of the instance type to use
+       fun c_instance_name: String do return c_name
+end
+
+redef class MClassType
+       redef fun c_instance_name do return mclass.c_instance_name
+end
+
+redef class MClass
+       # Extern classes use the C instance of kernel::Pointer
+       fun c_instance_name: String
+       do
+               if kind == extern_kind then
+                       return "kernel__Pointer"
+               else return c_name
+       end
 end
 
 redef class MProperty