1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2008 Jean Privat <jean@pryen.org>
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
9 # http://www.apache.org/licenses/LICENSE-2.0
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.
17 # Compute and generate tables for classes and modules.
18 package compiling_global
20 private import compiling_icode
22 # Something that store color of table elements
24 var _colors
: HashMap[TableElt, Int] = new HashMap[TableElt, Int]
26 # The color of a table element.
27 fun color
(e
: TableElt): Int
32 # Is a table element already colored?
33 fun has_color
(e
: TableElt): Bool
35 return _colors
.has_key
(e
)
38 # Assign a color to a table element.
39 fun color
=(e
: TableElt, c
: Int)
43 for i
in [0..e
.length
[ do
44 _colors
[e
.item
(i
)] = idx
50 # All information and results of the global analysis.
53 # Associate global classes to compiled classes
54 readable var _compiled_classes
: HashMap[MMGlobalClass, CompiledClass] = new HashMap[MMGlobalClass, CompiledClass]
56 # The main module of the program globally analysed
57 readable var _module
: MMModule
59 # FIXME: do something better.
60 readable writable var _max_class_table_length
: Int = 0
62 init(module: MMModule)
68 class GlobalCompilerVisitor
69 special CompilerVisitor
70 # The global analysis result
71 readable var _global_analysis
: GlobalAnalysis
72 init(m
: MMModule, tc
: ToolContext, ga
: GlobalAnalysis)
79 # A compiled class is a class in a program
82 # The corresponding local class in the main module of the prgram
83 readable var _local_class
: MMLocalClass
85 # The identifier of the class
86 readable writable var _id
: Int = 0
88 # The full class table of the class
89 readable var _class_table
: Array[nullable TableElt] = new Array[nullable TableElt]
91 # The full instance table of the class
92 readable var _instance_table
: Array[nullable TableElt] = new Array[nullable TableElt]
94 # The proper class table part (no superclasses but all refinements)
95 readable writable var _class_layout
: TableEltComposite = new TableEltComposite(self)
97 # The proper instance table part (no superclasses but all refinements)
98 readable writable var _instance_layout
: TableEltComposite = new TableEltComposite(self)
100 init(c
: MMLocalClass) do _local_class
= c
103 redef class MMConcreteClass
104 # The table element of the subtype check
105 fun class_color_pos
: TableEltClassColor do return _class_color_pos
.as(not null)
106 var _class_color_pos
: nullable TableEltClassColor
108 # The proper local class table part (nor superclasses nor refinments)
109 readable var _class_layout
: Array[TableElt] = new Array[TableElt]
111 # The proper local instance table part (nor superclasses nor refinments)
112 readable var _instance_layout
: Array[TableElt] = new Array[TableElt]
114 # Build the local layout of the class and feed the module table
115 fun build_layout_in
(tc
: ToolContext, module_table
: Array[ModuleTableElt])
117 var clt
= _class_layout
118 var ilt
= _instance_layout
120 if global
.intro
== self then
121 module_table
.add
(new TableEltClassId(self))
122 var cpp
= new TableEltClassColor(self)
123 _class_color_pos
= cpp
124 module_table
.add
(cpp
)
125 clt
.add
(new TableEltClassInitTable(self))
127 for p
in local_local_properties
do
129 if pg
.intro
== p
then
130 if p
isa MMAttribute then
131 ilt
.add
(new TableEltAttr(p
))
132 else if p
isa MMMethod then
133 clt
.add
(new TableEltMeth(p
))
136 if p
isa MMMethod and p
.need_super
then
137 clt
.add
(new TableEltSuper(p
))
141 if not ilt
.is_empty
then
142 var teg
= new ModuleTableEltGroup
143 teg
.elements
.append
(ilt
)
144 module_table
.add
(teg
)
147 if not clt
.is_empty
then
148 var teg
= new ModuleTableEltGroup
149 teg
.elements
.append
(clt
)
150 module_table
.add
(teg
)
156 # The local table of the module (refers things introduced in the module)
157 var _local_table
: Array[ModuleTableElt] = new Array[ModuleTableElt]
159 # Builds the local tables and local classes layouts
160 fun local_analysis
(tc
: ToolContext)
162 for c
in local_classes
do
163 if c
isa MMConcreteClass then
164 c
.build_layout_in
(tc
, _local_table
)
169 # Do the complete global analysis
170 fun global_analysis
(cctx
: ToolContext): GlobalAnalysis
172 #print "Do the complete global analysis"
173 var ga
= new GlobalAnalysis(self)
174 var smallest_classes
= new Array[MMLocalClass]
175 var global_properties
= new HashSet[MMGlobalProperty]
176 var ctab
= new Array[TableElt]
177 var itab
= new Array[TableElt]
179 ctab
.add
(new TableEltClassSelfId)
180 ctab
.add
(new TableEltClassObjectSize)
181 itab
.add
(new TableEltVftPointer)
182 itab
.add
(new TableEltObjectId)
187 # We have to work on ALL the classes of the module
188 var classes
= new Array[MMLocalClass]
189 for c
in local_classes
do
190 c
.compute_super_classes
193 (new ClassSorter).sort
(classes
)
196 # Finish processing the class (if invisible)
198 c
.inherit_global_properties
200 # Associate a CompiledClass to the class
201 var cc
= new CompiledClass(c
)
202 ga
.compiled_classes
[c
.global
] = cc
204 # Assign a unique class identifier
205 # (negative are for primitive classes)
208 if c
.primitive_info
!= null then
210 pclassid
= pclassid
- 4
213 classid
= classid
+ 4
216 # Register is the class is a leaf
217 if c
.cshe
.direct_smallers
.is_empty
then
218 smallest_classes
.add
(c
)
221 # Store the colortableelt in the class table pool
222 var bc
= c
.global
.intro
223 assert bc
isa MMConcreteClass
224 ctab
.add
(bc
.class_color_pos
)
227 # Compute core and crown classes for colorization
228 var crown_classes
= new HashSet[MMLocalClass]
229 var core_classes
= new HashSet[MMLocalClass]
230 for c
in smallest_classes
do
231 while c
.cshe
.direct_greaters
.length
== 1 do
232 c
= c
.cshe
.direct_greaters
.first
235 core_classes
.add_all
(c
.cshe
.greaters_and_self
)
237 #print("nbclasses: {classes.length} leaves: {smallest_classes.length} crown: {crown_classes.length} core: {core_classes.length}")
239 # Colorize core color for typechecks
240 colorize
(ga
, ctab
, crown_classes
, 0)
242 # Compute tables for typechecks
245 var cc
= ga
.compiled_classes
[c
.global
]
246 if core_classes
.has
(c
) then
247 # For core classes, just build the table
248 build_tables_in
(cc
.class_table
, ga
, c
, ctab
)
249 if maxcolor
< cc
.class_table
.length
then maxcolor
= cc
.class_table
.length
251 # For other classes, it's easier: just append to the parent tables
252 var sc
= c
.cshe
.direct_greaters
.first
253 var scc
= ga
.compiled_classes
[sc
.global
]
254 assert cc
.class_table
.is_empty
255 cc
.class_table
.add_all
(scc
.class_table
)
256 var bc
= c
.global
.intro
257 assert bc
isa MMConcreteClass
258 var colpos
= bc
.class_color_pos
259 var colposcolor
= cc
.class_table
.length
260 ga
.color
(colpos
) = colposcolor
261 cc
.class_table
.add
(colpos
)
262 if maxcolor
< colposcolor
then maxcolor
= colposcolor
265 ga
.max_class_table_length
= maxcolor
+ 1
267 # Fill class table and instance tables pools
269 var cc
= ga
.compiled_classes
[c
.global
]
270 var cte
= cc
.class_layout
271 var ite
= cc
.instance_layout
272 for sc
in c
.crhe
.greaters_and_self
do
273 if sc
isa MMConcreteClass then
274 cte
.add
(sc
, sc
.class_layout
)
275 ite
.add
(sc
, sc
.instance_layout
)
279 if core_classes
.has
(c
) then
280 if cte
.length
> 0 then
283 if ite
.length
> 0 then
289 # Colorize all elements in pools tables
290 colorize
(ga
, ctab
, crown_classes
, maxcolor
+1)
291 colorize
(ga
, itab
, crown_classes
, 0)
293 # Build class and instance tables now things are colored
294 ga
.max_class_table_length
= 0
296 var cc
= ga
.compiled_classes
[c
.global
]
297 if core_classes
.has
(c
) then
298 # For core classes, just build the table
299 build_tables_in
(cc
.class_table
, ga
, c
, ctab
)
300 build_tables_in
(cc
.instance_table
, ga
, c
, itab
)
302 # For other classes, it's easier: just append to the parent tables
303 var sc
= c
.cshe
.direct_greaters
.first
304 var scc
= ga
.compiled_classes
[sc
.global
]
306 cc
.class_table
.add_all
(scc
.class_table
)
307 var bc
= c
.global
.intro
308 assert bc
isa MMConcreteClass
309 var colpos
= bc
.class_color_pos
310 cc
.class_table
[ga
.color
(colpos
)] = colpos
311 while cc
.class_table
.length
<= maxcolor
do
312 cc
.class_table
.add
(null)
314 append_to_table
(ga
, cc
.class_table
, cc
.class_layout
)
315 assert cc
.instance_table
.is_empty
316 cc
.instance_table
.add_all
(scc
.instance_table
)
317 append_to_table
(ga
, cc
.instance_table
, cc
.instance_layout
)
324 private fun append_to_table
(cc
: ColorContext, table
: Array[nullable TableElt], cmp
: TableEltComposite)
326 for j
in [0..cmp
.length
[ do
328 cc
.color
(e
) = table
.length
333 private fun build_tables_in
(table
: Array[nullable TableElt], ga
: GlobalAnalysis, c
: MMLocalClass, elts
: Array[TableElt])
335 var tab
= new HashMap[Int, TableElt]
338 if e
.is_related_to
(c
) then
339 var col
= ga
.color
(e
)
340 var l
= col
+ e
.length
349 if tab
.has_key
(i
) then
351 for j
in [0..e
.length
[ do
363 fun colorize
(ga
: GlobalAnalysis, elts
: Array[TableElt], classes
: Collection[MMLocalClass], startcolor
: Int)
365 var colors
= new HashMap[Int, Array[TableElt]]
366 var rel_classes
= new Array[MMLocalClass]
370 if ga
.has_color
(e
) then
375 if e
.is_related_to
(c
) then
379 var trycolor
= startcolor
380 while trycolor
!= color
do
382 for c
in rel_classes
do
385 if colors
.has_key
(trycolor
+ idx
) and not free_color
(colors
[trycolor
+ idx
], c
) then
386 trycolor
= trycolor
+ idx
+ 1
396 for idx
in [0..len
[ do
397 if colors
.has_key
(color
+ idx
) then
398 colors
[color
+ idx
].add
(e
)
400 colors
[color
+ idx
] = [e
]
406 private fun free_color
(es
: Array[TableElt], c
: MMLocalClass): Bool
409 if e2
.is_related_to
(c
) then
416 # Compile module and class tables
417 fun compile_tables_to_c
(v
: GlobalCompilerVisitor)
419 for m
in mhe
.greaters_and_self
do
420 m
.compile_local_table_to_c
(v
)
423 for c
in local_classes
do
424 c
.compile_tables_to_c
(v
)
426 var s
= new Buffer.from
("classtable_t TAG2VFT[4] = \{NULL")
427 for t
in ["Int","Char","Bool"] do
428 if has_global_class_named
(t
.to_symbol
) then
429 s
.append
(", (const classtable_t)VFT_{t}")
438 # Declare class table (for _sep.h)
439 fun declare_class_tables_to_c
(v
: GlobalCompilerVisitor)
441 for c
in local_classes
do
442 if c
.global
.module == self then
443 c
.declare_tables_to_c
(v
)
448 # Compile main part (for _table.c)
449 fun compile_main_part
(v
: GlobalCompilerVisitor)
451 v
.add_instr
("int main(int argc, char **argv) \{")
453 v
.add_instr
("prepare_signals();")
454 v
.add_instr
("glob_argc = argc; glob_argv = argv;")
455 var sysname
= once
"Sys".to_symbol
456 if not has_global_class_named
(sysname
) then
459 var sys
= class_by_name
(sysname
)
460 var name
= once
"main".to_symbol
461 if not sys
.has_global_property_by_name
(name
) then
464 var mainm
= sys
.select_method
(name
)
465 v
.add_instr
("G_sys = NEW_Sys();")
466 v
.add_instr
("{mainm.cname}(G_sys);")
469 v
.add_instr
("return 0;")
475 fun compile_mod_to_c
(v
: GlobalCompilerVisitor)
477 v
.add_decl
("extern const char *LOCATE_{name};")
478 if not v
.tc
.global
then
479 v
.add_decl
("extern const int SFT_{name}[];")
482 for e
in _local_table
do
485 value
= "{e.value(v.global_analysis)}"
487 value
= "SFT_{name}[{i}]"
490 e
.compile_macros
(v
, value
)
492 for c
in local_classes
do
493 if not c
isa MMConcreteClass then continue
494 for pg
in c
.global_properties
do
496 if p
.local_class
== c
and p
isa MMMethod then
497 p
.compile_property_to_c
(v
)
499 if pg
.is_init_for
(c
) then
500 # Declare constructors
501 var params
= new Array[String]
502 for j
in [0..p
.signature
.arity
[ do
503 params
.add
("val_t p{j}")
505 v
.add_decl
("val_t NEW_{c}_{p.global.intro.cname}({params.join(", ")});")
511 # Compile module file for the current module
512 fun compile_local_table_to_c
(v
: GlobalCompilerVisitor)
514 v
.add_instr
("const char *LOCATE_{name} = \"{location.file}\
";")
516 if v
.tc
.global
or _local_table
.is_empty
then
520 v
.add_instr
("const int SFT_{name}[{_local_table.length}] = \{")
522 for e
in _local_table
do
523 v
.add_instr
(e
.value
(v
.global_analysis
) + ",")
530 ###############################################################################
532 # An element of a class, an instance or a module table
533 abstract class AbsTableElt
534 # Compile the macro needed to use the element and other related elements
535 fun compile_macros
(v
: GlobalCompilerVisitor, value
: String) is abstract
538 # An element of a class or an instance table
539 # Such an elements represent method function pointers, attribute values, etc.
540 abstract class TableElt
542 # Is the element conflict to class `c' (used for coloring)
543 fun is_related_to
(c
: MMLocalClass): Bool is abstract
545 # Number of sub-elements. 1 if none
546 fun length
: Int do return 1
548 # Access the ith subelement.
549 fun item
(i
: Int): TableElt do return self
551 # Return the value of the element for a given class
552 fun compile_to_c
(v
: GlobalCompilerVisitor, c
: MMLocalClass): String is abstract
555 # An element of a module table
556 # Such an elements represent colors or identifiers
557 abstract class ModuleTableElt
559 # Return the value of the element once the global analisys is performed
560 fun value
(ga
: GlobalAnalysis): String is abstract
563 # An element of a module table that represents a group of TableElt defined in the same local class
564 class ModuleTableEltGroup
565 special ModuleTableElt
566 readable var _elements
: Array[TableElt] = new Array[TableElt]
568 redef fun value
(ga
) do return "{ga.color(_elements.first)} /* Group of ? */"
569 redef fun compile_macros
(v
, value
)
572 for e
in _elements
do
573 e
.compile_macros
(v
, "{value} + {i}")
579 # An element that represents a class property
580 abstract class TableEltProp
582 var _property
: MMLocalProperty
584 init(p
: MMLocalProperty)
590 # An element that represents a function pointer to a global method
593 redef fun compile_macros
(v
, value
)
595 var pg
= _property
.global
596 v
.add_decl
("#define {pg.meth_call}(recv) (({pg.intro.cname}_t)CALL((recv), ({value})))")
599 redef fun compile_to_c
(v
, c
)
601 var p
= c
[_property
.global
]
606 # An element that represents a function pointer to the super method of a local method
609 redef fun compile_macros
(v
, value
)
612 v
.add_decl
("#define {p.super_meth_call}(recv) (({p.cname}_t)CALL((recv), ({value})))")
615 redef fun compile_to_c
(v
, c
)
617 var pc
= _property
.local_class
618 var g
= _property
.global
619 var lin
= c
.che
.linear_extension
622 #print "{c.module}::{c} for {pc.module}::{pc}::{_property} try {s.module}:{s}"
625 else if found
and c
.che
< s
then
626 if s
.has_global_property
(g
) then
627 #print "found {s.module}::{s}::{p}"
636 # An element that represents the value stored for a global attribute
639 redef fun compile_macros
(v
, value
)
641 var pg
= _property
.global
642 v
.add_decl
("#define {pg.attr_access}(recv) ATTR(recv, ({value}))")
645 redef fun compile_to_c
(v
, c
)
647 var ga
= v
.global_analysis
648 var p
= c
[_property
.global
]
649 return "/* {ga.color(self)}: Attribute {c}::{p} */"
653 # An element representing a class information
654 class AbsTableEltClass
656 # The local class where the information comes from
657 var _local_class
: MMLocalClass
659 init(c
: MMLocalClass)
664 # The C macro name refering the value
665 fun symbol
: String is abstract
667 redef fun compile_macros
(v
, value
)
669 v
.add_decl
("#define {symbol} ({value})")
673 # An element of a class table representing a class information
676 special AbsTableEltClass
677 redef fun is_related_to
(c
)
679 var bc
= c
.module[_local_class
.global
]
684 # An element representing the id of a class in a module table
685 class TableEltClassId
686 special ModuleTableElt
687 special AbsTableEltClass
688 redef fun symbol
do return _local_class
.global
.id_id
692 return "{ga.compiled_classes[_local_class.global].id} /* Id of {_local_class} */"
696 # An element representing the constructor marker position in a class table
697 class TableEltClassInitTable
698 special TableEltClass
699 redef fun symbol
do return _local_class
.global
.init_table_pos_id
701 redef fun compile_to_c
(v
, c
)
703 var ga
= v
.global_analysis
704 var cc
= ga
.compiled_classes
[_local_class
.global
]
705 var linext
= c
.cshe
.reverse_linear_extension
707 while linext
[i
].global
!= _local_class
.global
do
710 return "{i} /* {ga.color(self)}: {c} < {cc.local_class}: superclass init_table position */"
714 # An element used for a cast
715 # Note: this element is both a TableElt and a ModuleTableElt.
716 # At the TableElt offset, there is the id of the super-class
717 # At the ModuleTableElt offset, there is the TableElt offset (ie. the color of the super-class).
718 class TableEltClassColor
719 special TableEltClass
720 special ModuleTableElt
721 redef fun symbol
do return _local_class
.global
.color_id
725 return "{ga.color(self)} /* Color of {_local_class} */"
728 redef fun compile_to_c
(v
, c
)
730 var ga
= v
.global_analysis
731 var cc
= ga
.compiled_classes
[_local_class
.global
]
732 return "{cc.id} /* {ga.color(self)}: {c} < {cc.local_class}: superclass typecheck marker */"
736 # A Group of elements introduced in the same global-class that are colored together
737 class TableEltComposite
739 var _table
: Array[TableElt]
740 var _cc
: CompiledClass
741 var _offsets
: HashMap[MMLocalClass, Int]
742 redef fun length
do return _table
.length
743 redef fun is_related_to
(c
) do return c
.cshe
<= _cc
.local_class
745 fun add
(c
: MMLocalClass, tab
: Array[TableElt])
747 _offsets
[c
] = _table
.length
751 redef fun item
(i
) do return _table
[i
]
753 redef fun compile_to_c
(v
, c
) do abort
755 init(cc
: CompiledClass)
758 _table
= new Array[TableElt]
759 _offsets
= new HashMap[MMLocalClass, Int]
763 # The element that represent the class id
764 class TableEltClassSelfId
766 redef fun is_related_to
(c
) do return true
767 redef fun compile_to_c
(v
, c
)
769 var ga
= v
.global_analysis
770 return "{v.global_analysis.compiled_classes[c.global].id} /* {ga.color(self)}: Identity */"
775 # The element that represent the Object Size
776 class TableEltClassObjectSize
778 redef fun is_related_to
(c
) do return true
779 redef fun compile_to_c
(v
, c
)
782 var ga
= v
.global_analysis
783 if c
.name
== "NativeArray".to_symbol
then
786 var cc
= ga
.compiled_classes
[c
.global
]
787 var itab
= cc
.instance_table
792 return "{nb} /* {ga.color(self)}: Object size (-1 if a NativeArray)*/"
796 # The element that represent the object id
797 class TableEltObjectId
799 redef fun is_related_to
(c
) do return true
800 redef fun compile_to_c
(v
, c
)
802 var ga
= v
.global_analysis
803 return "/* {ga.color(self)}: Object_id */"
808 class TableEltVftPointer
810 redef fun is_related_to
(c
) do return true
811 redef fun compile_to_c
(v
, c
)
813 var ga
= v
.global_analysis
814 return "/* {ga.color(self)}: Pointer to the classtable */"
818 ###############################################################################
820 # Used to sort local class in a deterministic total order
821 # The total order superset the class refinement and the class specialisation relations
823 special AbstractSorter[MMLocalClass]
824 redef fun compare
(a
, b
) do return a
.compare
(b
)
828 redef class MMLocalClass
829 # Comparaison in a total order that superset the class refinement and the class specialisation relations
830 fun compare
(b
: MMLocalClass): Int
835 else if a
.module.mhe
< b
.module then
837 else if b
.module.mhe
< a
.module then
847 return b
.name
.to_s
<=> a
.name
.to_s
851 # Declaration and macros related to the class table
852 fun declare_tables_to_c
(v
: GlobalCompilerVisitor)
855 var pi
= primitive_info
856 v
.add_decl
("extern const classtable_elt_t VFT_{name}[];")
857 if name
== "NativeArray".to_symbol
then
858 v
.add_decl
("val_t NEW_NativeArray(size_t length, size_t size);")
859 else if pi
== null then
860 # v.add_decl("val_t NEW_{name}(void);")
861 else if not pi
.tagged
then
863 var tbox
= "struct TBOX_{name}"
864 v
.add_decl
("{tbox} \{ const classtable_elt_t * vft; bigint object_id; {t} val;};")
865 v
.add_decl
("val_t BOX_{name}({t} val);")
866 v
.add_decl
("#define UNBOX_{name}(x) ((({tbox} *)(VAL2OBJ(x)))->val)")
870 # Compilation of table and new (or box)
871 fun compile_tables_to_c
(v
: GlobalCompilerVisitor)
873 var cc
= v
.global_analysis
.compiled_classes
[self.global
]
874 var ctab
= cc
.class_table
875 var clen
= ctab
.length
876 if v
.global_analysis
.max_class_table_length
> ctab
.length
then
877 clen
= v
.global_analysis
.max_class_table_length
880 v
.add_instr
("const classtable_elt_t VFT_{name}[{clen}] = \{")
884 v
.add_instr
("\{0} /* Class Hole :( */,")
886 v
.add_instr
("\{(bigint) {e.compile_to_c(v, self)}},")
889 if clen
> ctab
.length
then
890 v
.add_instr
("\{0},"*(clen-ctab
.length
))
894 var itab
= cc
.instance_table
897 v
.add_instr
("/* Instance Hole :( */")
899 v
.add_instr
(e
.compile_to_c
(v
, self))
903 var pi
= primitive_info
904 if name
== "NativeArray".to_symbol
then
905 v
.add_instr
("val_t NEW_NativeArray(size_t length, size_t size) \{")
907 v
.add_instr
("Nit_NativeArray array;")
908 v
.add_instr
("array = (Nit_NativeArray)alloc(sizeof(struct Nit_NativeArray) + ((length - 1) * size));")
909 v
.add_instr
("array->vft = (classtable_elt_t*)VFT_{name};")
910 v
.add_instr
("array->object_id = object_id_counter;")
911 v
.add_instr
("object_id_counter = object_id_counter + 1;")
912 v
.add_instr
("array->size = length;")
913 v
.add_instr
("return OBJ2VAL(array);")
916 else if pi
== null then
918 var iself
= new IRegister(get_type
)
920 var iroutine
= new IRoutine(new Array[IRegister], iself
)
921 var icb
= new ICodeBuilder(module, iroutine
)
922 var obj
= new INative("OBJ2VAL(obj)", null)
926 for g
in global_properties
do
928 var t
= p
.signature
.return_type
929 if p
isa MMAttribute and t
!= null then
931 if ir
== null then continue
932 # FIXME: Not compatible with sep compilation
933 var e
= icb
.inline_routine
(ir
, iselfa
, null).as(not null)
934 icb
.stmt
(new IAttrWrite(p
, iself
, e
))
938 var cname
= "NEW_{name}"
939 var args
= iroutine
.compile_signature_to_c
(v
, cname
, "new {name}", null, null)
942 v
.add_decl
("obj_t obj;")
943 v
.add_instr
("obj = alloc(sizeof(val_t) * {itab.length});")
944 v
.add_instr
("obj->vft = (classtable_elt_t*)VFT_{name};")
945 v
.add_instr
("obj[1].object_id = object_id_counter;")
946 v
.add_instr
("object_id_counter = object_id_counter + 1;")
947 var r
= iroutine
.compile_to_c
(v
, cname
, args
).as(not null)
948 v
.add_instr
("return {r};")
949 ctx_old
.append
(v
.ctx
)
957 var iself
= new IRegister(get_type
)
959 var iroutine
= new IRoutine(iselfa
, null)
960 var icb
= new ICodeBuilder(module, iroutine
)
961 for g
in global_properties
do
963 var t
= p
.signature
.return_type
964 if p
isa MMAttribute and t
!= null and not t
.is_nullable
then
965 icb
.add_attr_check
(p
, iself
)
968 var cname
= "CHECKNEW_{name}"
969 var args
= iroutine
.compile_signature_to_c
(v
, cname
, "check new {name}", null, null)
972 iroutine
.compile_to_c
(v
, cname
, args
)
973 ctx_old
.append
(v
.ctx
)
979 var init_table_size
= cshe
.greaters
.length
+ 1
980 var init_table_decl
= "int init_table[{init_table_size}] = \{0{", 0" * (init_table_size-1)}};"
982 for g
in global_properties
do
984 # FIXME skip invisible constructors
985 if not p
.global
.is_init_for
(self) then continue
986 assert p
isa MMMethod
988 var iself
= new IRegister(get_type
)
989 var iparams
= new Array[IRegister]
990 for i
in [0..p
.signature
.arity
[ do iparams
.add
(new IRegister(p
.signature
[i
]))
991 var iroutine
= new IRoutine(iparams
, iself
)
992 iroutine
.location
= p
.iroutine
.location
993 var icb
= new ICodeBuilder(module, iroutine
)
995 var inew
= new INative("NEW_{name}()", null)
999 iargs
.add_all
(iparams
)
1000 icb
.stmt
(new INative("{p.cname}(@@@{", @@@"*iparams.length}, init_table)", iargs
))
1001 icb
.stmt
(new INative("CHECKNEW_{name}(@@@)", [iself
]))
1003 var cname
= "NEW_{self}_{p.global.intro.cname}"
1004 var new_args
= iroutine
.compile_signature_to_c
(v
, cname
, "new {self} {p.full_name}", null, null)
1006 v
.ctx
= new CContext
1007 v
.add_instr
(init_table_decl
)
1008 var e
= iroutine
.compile_to_c
(v
, cname
, new_args
).as(not null)
1009 v
.add_instr
("return {e};")
1010 ctx_old
.append
(v
.ctx
)
1015 else if not pi
.tagged
then
1017 var tbox
= "struct TBOX_{name}"
1018 v
.add_instr
("val_t BOX_{name}({t} val) \{")
1020 v
.add_instr
("{tbox} *box = ({tbox}*)alloc(sizeof({tbox}));")
1021 v
.add_instr
("box->vft = VFT_{name};")
1022 v
.add_instr
("box->val = val;")
1023 v
.add_instr
("box->object_id = object_id_counter;")
1024 v
.add_instr
("object_id_counter = object_id_counter + 1;")
1025 v
.add_instr
("return OBJ2VAL(box);")
1032 redef class MMMethod
1033 fun compile_property_to_c
(v
: CompilerVisitor)
1038 var more_params
: nullable String = null
1039 if global
.is_init
then more_params
= "int* init_table"
1040 var args
= ir
.compile_signature_to_c
(v
, cname
, full_name
, null, more_params
)
1042 v
.ctx
= new CContext
1044 v
.out_contexts
.clear
1046 var itpos
: nullable String = null
1047 if global
.is_init
then
1048 itpos
= "itpos{v.new_number}"
1049 v
.add_decl
("int {itpos} = VAL2OBJ({args.first})->vft[{local_class.global.init_table_pos_id}].i;")
1050 v
.add_instr
("if (init_table[{itpos}]) return;")
1053 var s
= ir
.compile_to_c
(v
, cname
, args
)
1055 if itpos
!= null then
1056 v
.add_instr
("init_table[{itpos}] = 1;")
1059 v
.add_instr
("return;")
1061 v
.add_instr
("return ", s
, ";")
1064 ctx_old
.append
(v
.ctx
)
1069 for ctx
in v
.out_contexts
do v
.ctx
.merge
(ctx
)