self.toolcontext.info("*** GENERATING C ***", 1)
var compiler = new SeparateCompiler(mainmodule, self, runtime_type_analysis)
- compiler.compile_header
-
- # compile class structures
- self.toolcontext.info("Property coloring", 2)
- compiler.new_file("{mainmodule.name}.classes")
- compiler.do_property_coloring
- for m in mainmodule.in_importation.greaters do
- for mclass in m.intro_mclasses do
- if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue
- compiler.compile_class_to_c(mclass)
- end
- end
-
- # The main function of the C
- compiler.new_file("{mainmodule.name}.main")
- compiler.compile_nitni_global_ref_functions
- compiler.compile_main_function
- compiler.compile_finalizer_function
-
- # compile methods
- for m in mainmodule.in_importation.greaters do
- self.toolcontext.info("Generate C for module {m}", 2)
- compiler.new_file("{m.name}.sep")
- compiler.compile_module_to_c(m)
- end
-
- # compile live & cast type structures
- self.toolcontext.info("Type coloring", 2)
- compiler.new_file("{mainmodule.name}.types")
- var mtypes = compiler.do_type_coloring
- for t in mtypes do
- compiler.compile_type_to_c(t)
- end
- # compile remaining types structures (useless but needed for the symbol resolution at link-time)
- for t in compiler.undead_types do
- if mtypes.has(t) then continue
- compiler.compile_type_to_c(t)
- end
-
+ compiler.do_compilation
compiler.display_stats
var time1 = get_time
private var undead_types: Set[MType] = new HashSet[MType]
private var live_unresolved_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]]
- private var type_ids: Map[MType, Int]
- private var type_colors: Map[MType, Int]
- private var opentype_colors: Map[MType, Int]
- protected var method_colors: Map[PropertyLayoutElement, Int]
- protected var attr_colors: Map[MAttribute, Int]
+ private var type_ids: Map[MType, Int] is noinit
+ private var type_colors: Map[MType, Int] is noinit
+ private var opentype_colors: Map[MType, Int] is noinit
+ protected var method_colors: Map[PropertyLayoutElement, Int] is noinit
+ protected var attr_colors: Map[MAttribute, Int] is noinit
- init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do
- super(mainmodule, mmbuilder)
+ init do
var file = new_file("nit.common")
self.header = new CodeWriter(file)
- self.runtime_type_analysis = runtime_type_analysis
self.compile_box_kinds
end
+ redef fun do_compilation
+ do
+ var compiler = self
+ compiler.compile_header
+
+ var c_name = mainmodule.c_name
+
+ # compile class structures
+ modelbuilder.toolcontext.info("Property coloring", 2)
+ compiler.new_file("{c_name}.classes")
+ compiler.do_property_coloring
+ for m in mainmodule.in_importation.greaters do
+ for mclass in m.intro_mclasses do
+ #if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue
+ compiler.compile_class_to_c(mclass)
+ end
+ end
+
+ # The main function of the C
+ compiler.new_file("{c_name}.main")
+ compiler.compile_nitni_global_ref_functions
+ compiler.compile_main_function
+ compiler.compile_finalizer_function
+
+ # compile methods
+ for m in mainmodule.in_importation.greaters do
+ modelbuilder.toolcontext.info("Generate C for module {m.full_name}", 2)
+ compiler.new_file("{m.c_name}.sep")
+ compiler.compile_module_to_c(m)
+ end
+
+ # compile live & cast type structures
+ modelbuilder.toolcontext.info("Type coloring", 2)
+ compiler.new_file("{c_name}.types")
+ compiler.compile_types
+ end
+
+ # Color and compile type structures and cast information
+ fun compile_types
+ do
+ var compiler = self
+
+ var mtypes = compiler.do_type_coloring
+ for t in mtypes do
+ compiler.compile_type_to_c(t)
+ end
+ # compile remaining types structures (useless but needed for the symbol resolution at link-time)
+ for t in compiler.undead_types do
+ if mtypes.has(t) then continue
+ compiler.compile_type_to_c(t)
+ end
+
+ end
+
redef fun compile_header_structs do
self.header.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */")
self.compile_header_attribute_structs
var live_cast_types = runtime_type_analysis.live_cast_types
var mtypes = new HashSet[MType]
mtypes.add_all(live_types)
- mtypes.add_all(live_cast_types)
for c in self.box_kinds.keys do
mtypes.add(c.mclass_type)
end
# Compute colors
- var poset = poset_from_mtypes(mtypes)
+ var poset = poset_from_mtypes(mtypes, live_cast_types)
var colorer = new POSetColorer[MType]
colorer.colorize(poset)
type_ids = colorer.ids
return poset
end
- private fun poset_from_mtypes(mtypes: Set[MType]): POSet[MType] do
+ private fun poset_from_mtypes(mtypes, cast_types: Set[MType]): POSet[MType] do
var poset = new POSet[MType]
for e in mtypes do
poset.add_node(e)
- for o in mtypes do
+ for o in cast_types do
if e == o then continue
+ poset.add_node(o)
if e.is_subtype(mainmodule, null, o) then
poset.add_edge(e, o)
end
var res: nullable RuntimeVariable
var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
var ret = msignature.return_mtype
- if mmethod.is_new then
- ret = arguments.first.mtype
- res = self.new_var(ret)
- else if ret == null then
+ if ret == null then
res = null
else
res = self.new_var(ret)
var res: nullable RuntimeVariable
var ret = mmethoddef.msignature.return_mtype
- if mmethoddef.mproperty.is_new then
- ret = arguments.first.mtype
- res = self.new_var(ret)
- else if ret == null then
+ if ret == null then
res = null
else
ret = ret.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)
var ret = msignature.return_mtype
if ret != null then
sig.append("{ret.ctype} ")
- else if mmethoddef.mproperty.is_new then
- ret = recv
- sig.append("{ret.ctype} ")
else
sig.append("void ")
end
var ret = msignature.return_mtype
if ret != null then
sig.append("{ret.ctype} ")
- else if mmethoddef.mproperty.is_new then
- ret = recv
- sig.append("{ret.ctype} ")
else
sig.append("void ")
end