nitlanguage / nit.git / blob
? search:


511cb7533134fd294b0fecfc5860e9569d3a48b0
[nit.git] / src / compiler / separate_erasure_compiler.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 # http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14
15 # Separate compilation of a Nit program with generic type erasure
16 module separate_erasure_compiler
17
18 intrude import separate_compiler
19
20 # Add separate erased compiler specific options
21 redef class ToolContext
22 # --erasure
23 var opt_erasure = new OptionBool("Erase generic types", "--erasure")
24 # --rta
25 var opt_rta = new OptionBool("Activate RTA (implicit with --global and --separate)", "--rta")
26 # --no-check-erasure-cast
27 var opt_no_check_erasure_cast = new OptionBool("Disable implicit casts on unsafe return with erasure-typing policy (dangerous)", "--no-check-erasure-cast")
28
29 redef init
30 do
31 super
32 self.option_context.add_option(self.opt_erasure, self.opt_no_check_erasure_cast, opt_rta)
33 end
34
35 redef fun process_options(args)
36 do
37 super
38
39 if opt_no_check_all.value then
40 opt_no_check_erasure_cast.value = true
41 end
42
43 # Temporary disabled. TODO: implement tagging in the erasure compiler.
44 if opt_erasure.value then
45 opt_no_tag_primitives.value = true
46 end
47 end
48
49 var erasure_compiler_phase = new ErasureCompilerPhase(self, null)
50 end
51
52 class ErasureCompilerPhase
53 super Phase
54 redef fun process_mainmodule(mainmodule, given_mmodules) do
55 if not toolcontext.opt_erasure.value then return
56
57 var modelbuilder = toolcontext.modelbuilder
58 var analysis = null
59 if toolcontext.opt_rta.value then
60 analysis = modelbuilder.do_rapid_type_analysis(mainmodule)
61 end
62 modelbuilder.run_separate_erasure_compiler(mainmodule, analysis)
63 end
64 end
65
66 redef class ModelBuilder
67 fun run_separate_erasure_compiler(mainmodule: MModule, runtime_type_analysis: nullable RapidTypeAnalysis)
68 do
69 var time0 = get_time
70 self.toolcontext.info("*** GENERATING C ***", 1)
71
72 var compiler = new SeparateErasureCompiler(mainmodule, self, runtime_type_analysis)
73 compiler.do_compilation
74 compiler.display_stats
75 var time1 = get_time
76 self.toolcontext.info("*** END GENERATING C: {time1-time0} ***", 2)
77 write_and_make(compiler)
78 end
79 end
80
81 class SeparateErasureCompiler
82 super SeparateCompiler
83
84 private var class_ids: Map[MClass, Int] is noinit
85 private var class_colors: Map[MClass, Int] is noinit
86 protected var vt_colors: Map[MVirtualTypeProp, Int] is noinit
87
88 init do
89
90 # Class coloring
91 var poset = mainmodule.flatten_mclass_hierarchy
92 var mclasses = new HashSet[MClass].from(poset)
93 var colorer = new POSetColorer[MClass]
94 colorer.colorize(poset)
95 class_ids = colorer.ids
96 class_colors = colorer.colors
97 class_tables = self.build_class_typing_tables(mclasses)
98
99 # lookup vt to build layout with
100 var vts = new HashMap[MClass, Set[MVirtualTypeProp]]
101 for mclass in mclasses do
102 vts[mclass] = new HashSet[MVirtualTypeProp]
103 for mprop in self.mainmodule.properties(mclass) do
104 if mprop isa MVirtualTypeProp then
105 vts[mclass].add(mprop)
106 end
107 end
108 end
109
110 # vt coloration
111 var vt_colorer = new POSetBucketsColorer[MClass, MVirtualTypeProp](poset, colorer.conflicts)
112 vt_colors = vt_colorer.colorize(vts)
113 vt_tables = build_vt_tables(mclasses)
114 end
115
116 fun build_vt_tables(mclasses: Set[MClass]): Map[MClass, Array[nullable MPropDef]] do
117 var tables = new HashMap[MClass, Array[nullable MPropDef]]
118 for mclass in mclasses do
119 var table = new Array[nullable MPropDef]
120 # first, fill table from parents by reverse linearization order
121 var parents = new Array[MClass]
122 if mainmodule.flatten_mclass_hierarchy.has(mclass) then
123 parents = mclass.in_hierarchy(mainmodule).greaters.to_a
124 self.mainmodule.linearize_mclasses(parents)
125 end
126 for parent in parents do
127 if parent == mclass then continue
128 for mproperty in self.mainmodule.properties(parent) do
129 if not mproperty isa MVirtualTypeProp then continue
130 var color = vt_colors[mproperty]
131 if table.length <= color then
132 for i in [table.length .. color[ do
133 table[i] = null
134 end
135 end
136 for mpropdef in mproperty.mpropdefs do
137 if mpropdef.mclassdef.mclass == parent then
138 table[color] = mpropdef
139 end
140 end
141 end
142 end
143
144 # then override with local properties
145 for mproperty in self.mainmodule.properties(mclass) do
146 if not mproperty isa MVirtualTypeProp then continue
147 var color = vt_colors[mproperty]
148 if table.length <= color then
149 for i in [table.length .. color[ do
150 table[i] = null
151 end
152 end
153 for mpropdef in mproperty.mpropdefs do
154 if mpropdef.mclassdef.mclass == mclass then
155 table[color] = mpropdef
156 end
157 end
158 end
159 tables[mclass] = table
160 end
161 return tables
162 end
163
164 # Build class tables
165 fun build_class_typing_tables(mclasses: Set[MClass]): Map[MClass, Array[nullable MClass]] do
166 var tables = new HashMap[MClass, Array[nullable MClass]]
167 for mclass in mclasses do
168 var table = new Array[nullable MClass]
169 var supers = new Array[MClass]
170 if mainmodule.flatten_mclass_hierarchy.has(mclass) then
171 supers = mclass.in_hierarchy(mainmodule).greaters.to_a
172 end
173 for sup in supers do
174 var color = class_colors[sup]
175 if table.length <= color then
176 for i in [table.length .. color[ do
177 table[i] = null
178 end
179 end
180 table[color] = sup
181 end
182 tables[mclass] = table
183 end
184 return tables
185 end
186
187 redef fun compile_header_structs do
188 self.header.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */")
189 self.compile_header_attribute_structs
190 self.header.add_decl("struct class \{ int id; const char *name; int box_kind; int color; const struct vts_table *vts_table; const struct type_table *type_table; nitmethod_t vft[]; \}; /* general C type representing a Nit class. */")
191 self.header.add_decl("struct type_table \{ int size; int table[]; \}; /* colorized type table. */")
192 self.header.add_decl("struct vts_entry \{ short int is_nullable; const struct class *class; \}; /* link (nullable or not) between the vts and is bound. */")
193 self.header.add_decl("struct vts_table \{ int dummy; const struct vts_entry vts[]; \}; /* vts list of a C type representation. */")
194 self.header.add_decl("typedef struct instance \{ const struct class *class; nitattribute_t attrs[1]; \} val; /* general C type representing a Nit instance. */")
195 end
196
197 redef fun compile_class_to_c(mclass: MClass)
198 do
199 var mtype = mclass.intro.bound_mtype
200 var c_name = mclass.c_name
201
202 var class_table = self.class_tables[mclass]
203 var v = self.new_visitor
204
205 var rta = runtime_type_analysis
206 var is_dead = false # mclass.kind == abstract_kind or mclass.kind == interface_kind
207 if not is_dead and rta != null and not rta.live_classes.has(mclass) and not mtype.is_c_primitive and mclass.name != "NativeArray" then
208 is_dead = true
209 end
210
211 v.add_decl("/* runtime class {c_name} */")
212
213 self.provide_declaration("class_{c_name}", "extern const struct class class_{c_name};")
214 v.add_decl("extern const struct type_table type_table_{c_name};")
215
216 # Build class vft
217 v.add_decl("const struct class class_{c_name} = \{")
218 v.add_decl("{class_ids[mclass]},")
219 v.add_decl("\"{mclass.name}\", /* class_name_string */")
220 v.add_decl("{self.box_kind_of(mclass)}, /* box_kind */")
221 v.add_decl("{class_colors[mclass]},")
222 if not is_dead then
223 if build_class_vts_table(mclass) then
224 v.require_declaration("vts_table_{c_name}")
225 v.add_decl("&vts_table_{c_name},")
226 else
227 v.add_decl("NULL,")
228 end
229 v.add_decl("&type_table_{c_name},")
230 v.add_decl("\{")
231 var vft = self.method_tables.get_or_null(mclass)
232 if vft != null then for i in [0 .. vft.length[ do
233 var mpropdef = vft[i]
234 if mpropdef == null then
235 v.add_decl("NULL, /* empty */")
236 else
237 assert mpropdef isa MMethodDef
238 if rta != null and not rta.live_methoddefs.has(mpropdef) then
239 v.add_decl("NULL, /* DEAD {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
240 continue
241 end
242 var rf = mpropdef.virtual_runtime_function
243 v.require_declaration(rf.c_name)
244 v.add_decl("(nitmethod_t){rf.c_name}, /* pointer to {mpropdef.full_name} */")
245 end
246 end
247 v.add_decl("\}")
248 end
249 v.add_decl("\};")
250
251 # Build class type table
252
253 v.add_decl("const struct type_table type_table_{c_name} = \{")
254 v.add_decl("{class_table.length},")
255 v.add_decl("\{")
256 for msuper in class_table do
257 if msuper == null then
258 v.add_decl("-1, /* empty */")
259 else
260 v.add_decl("{self.class_ids[msuper]}, /* {msuper} */")
261 end
262 end
263 v.add_decl("\}")
264 v.add_decl("\};")
265
266 if mtype.is_c_primitive or mtype.mclass.name == "Pointer" then
267 #Build instance struct
268 self.header.add_decl("struct instance_{c_name} \{")
269 self.header.add_decl("const struct class *class;")
270 self.header.add_decl("{mtype.ctype} value;")
271 self.header.add_decl("\};")
272
273 #Build BOX
274 self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype_extern});")
275 v.add_decl("/* allocate {mtype} */")
276 v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype_extern} value) \{")
277 v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));")
278 v.require_declaration("class_{c_name}")
279 v.add("res->class = &class_{c_name};")
280 v.add("res->value = value;")
281 v.add("return (val*)res;")
282 v.add("\}")
283
284 if mtype.mclass.name != "Pointer" then return
285
286 v = new_visitor
287 self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}();")
288 v.add_decl("/* allocate {mtype} */")
289 v.add_decl("{mtype.ctype} NEW_{c_name}() \{")
290 if is_dead then
291 v.add_abort("{mclass} is DEAD")
292 else
293 var res = v.new_named_var(mtype, "self")
294 res.is_exact = true
295 v.add("{res} = nit_alloc(sizeof(struct instance_{mtype.c_name}));")
296 v.require_declaration("class_{c_name}")
297 v.add("{res}->class = &class_{c_name};")
298 v.add("((struct instance_{mtype.c_name}*){res})->value = NULL;")
299 v.add("return {res};")
300 end
301 v.add("\}")
302 return
303 else if mclass.name == "NativeArray" then
304 #Build instance struct
305 self.header.add_decl("struct instance_{c_name} \{")
306 self.header.add_decl("const struct class *class;")
307 self.header.add_decl("int length;")
308 self.header.add_decl("val* values[];")
309 self.header.add_decl("\};")
310
311 #Build NEW
312 self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}(int length);")
313 v.add_decl("/* allocate {mtype} */")
314 v.add_decl("{mtype.ctype} NEW_{c_name}(int length) \{")
315 var res = v.get_name("self")
316 v.add_decl("struct instance_{c_name} *{res};")
317 var mtype_elt = mtype.arguments.first
318 v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));")
319 v.require_declaration("class_{c_name}")
320 v.add("{res}->class = &class_{c_name};")
321 v.add("{res}->length = length;")
322 v.add("return (val*){res};")
323 v.add("\}")
324 return
325 else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
326 var pointer_type = mainmodule.pointer_type
327
328 self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}();")
329 v.add_decl("/* allocate {mtype} */")
330 v.add_decl("{mtype.ctype} NEW_{c_name}() \{")
331 if is_dead then
332 v.add_abort("{mclass} is DEAD")
333 else
334 var res = v.new_named_var(mtype, "self")
335 res.is_exact = true
336 v.add("{res} = nit_alloc(sizeof(struct instance_{pointer_type.c_name}));")
337 #v.add("{res}->type = type;")
338 v.require_declaration("class_{c_name}")
339 v.add("{res}->class = &class_{c_name};")
340 v.add("((struct instance_{pointer_type.c_name}*){res})->value = NULL;")
341 v.add("return {res};")
342 end
343 v.add("\}")
344 return
345 end
346
347 #Build NEW
348 self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}(void);")
349 v.add_decl("/* allocate {mtype} */")
350 v.add_decl("{mtype.ctype} NEW_{c_name}(void) \{")
351 if is_dead then
352 v.add_abort("{mclass} is DEAD")
353 else
354
355 var res = v.new_named_var(mtype, "self")
356 res.is_exact = true
357 var attrs = self.attr_tables.get_or_null(mclass)
358 if attrs == null then
359 v.add("{res} = nit_alloc(sizeof(struct instance));")
360 else
361 v.add("{res} = nit_alloc(sizeof(struct instance) + {attrs.length}*sizeof(nitattribute_t));")
362 end
363 v.require_declaration("class_{c_name}")
364 v.add("{res}->class = &class_{c_name};")
365 if attrs != null then
366 self.generate_init_attr(v, res, mtype)
367 v.set_finalizer res
368 end
369 v.add("return {res};")
370 end
371 v.add("\}")
372 end
373
374 private fun build_class_vts_table(mclass: MClass): Bool do
375 if self.vt_tables[mclass].is_empty then return false
376
377 self.provide_declaration("vts_table_{mclass.c_name}", "extern const struct vts_table vts_table_{mclass.c_name};")
378
379 var v = new_visitor
380 v.add_decl("const struct vts_table vts_table_{mclass.c_name} = \{")
381 v.add_decl("0, /* dummy */")
382 v.add_decl("\{")
383
384 for vt in self.vt_tables[mclass] do
385 if vt == null then
386 v.add_decl("\{-1, NULL\}, /* empty */")
387 else
388 var is_null = 0
389 var bound = retrieve_vt_bound(mclass.intro.bound_mtype, vt.as(MVirtualTypeDef).bound)
390 while bound isa MNullableType do
391 bound = retrieve_vt_bound(mclass.intro.bound_mtype, bound.mtype)
392 is_null = 1
393 end
394 var vtclass = bound.as(MClassType).mclass
395 v.require_declaration("class_{vtclass.c_name}")
396 v.add_decl("\{{is_null}, &class_{vtclass.c_name}\}, /* {vt} */")
397 end
398 end
399 v.add_decl("\},")
400 v.add_decl("\};")
401 return true
402 end
403
404 private fun retrieve_vt_bound(anchor: MClassType, mtype: nullable MType): MType do
405 if mtype == null then
406 print "NOT YET IMPLEMENTED: retrieve_vt_bound on null"
407 abort
408 end
409 if mtype isa MVirtualType then
410 return mtype.anchor_to(mainmodule, anchor)
411 else if mtype isa MParameterType then
412 return mtype.anchor_to(mainmodule, anchor)
413 else
414 return mtype
415 end
416 end
417
418 redef fun compile_types
419 do
420 compile_color_consts(vt_colors)
421 end
422
423 redef fun new_visitor do return new SeparateErasureCompilerVisitor(self)
424
425 # Stats
426
427 private var class_tables: Map[MClass, Array[nullable MClass]] is noinit
428 private var vt_tables: Map[MClass, Array[nullable MPropDef]] is noinit
429
430 redef fun display_sizes
431 do
432 print "# size of subtyping tables"
433 print "\ttotal \tholes"
434 var total = 0
435 var holes = 0
436 for t, table in class_tables do
437 total += table.length
438 for e in table do if e == null then holes += 1
439 end
440 print "\t{total}\t{holes}"
441
442 print "# size of resolution tables"
443 print "\ttotal \tholes"
444 total = 0
445 holes = 0
446 for t, table in vt_tables do
447 total += table.length
448 for e in table do if e == null then holes += 1
449 end
450 print "\t{total}\t{holes}"
451
452 print "# size of methods tables"
453 print "\ttotal \tholes"
454 total = 0
455 holes = 0
456 for t, table in method_tables do
457 total += table.length
458 for e in table do if e == null then holes += 1
459 end
460 print "\t{total}\t{holes}"
461
462 print "# size of attributes tables"
463 print "\ttotal \tholes"
464 total = 0
465 holes = 0
466 for t, table in attr_tables do
467 total += table.length
468 for e in table do if e == null then holes += 1
469 end
470 print "\t{total}\t{holes}"
471 end
472 end
473
474 class SeparateErasureCompilerVisitor
475 super SeparateCompilerVisitor
476
477 redef fun compile_callsite(callsite, arguments)
478 do
479 var res = super
480 if callsite.erasure_cast and not self.compiler.as(SeparateErasureCompiler).modelbuilder.toolcontext.opt_no_check_erasure_cast.value then
481 assert res != null
482 var mtype = callsite.msignature.return_mtype
483 assert mtype != null
484 self.add("/* Erasure cast for return {res} isa {mtype} */")
485 var cond = self.type_test(res, mtype, "erasure")
486 self.add("if (!{cond}) \{")
487 #var x = self.class_name_string(res)
488 #var y = self.class_name_string(arguments.first)
489 #self.add("PRINT_ERROR(\"Erasure cast: expected {mtype} (self is %s), got %s for {res}\\n\", {y}, {x});")
490 self.add_abort("Cast failed")
491 self.add("\}")
492 end
493 return res
494 end
495
496 redef fun init_instance(mtype)
497 do
498 self.require_declaration("NEW_{mtype.mclass.c_name}")
499 return self.new_expr("NEW_{mtype.mclass.c_name}()", mtype)
500 end
501
502 redef fun type_test(value, mtype, tag)
503 do
504 self.add("/* type test for {value.inspect} isa {mtype} */")
505
506 var res = self.new_var(bool_type)
507
508 var cltype = self.get_name("cltype")
509 self.add_decl("int {cltype};")
510 var idtype = self.get_name("idtype")
511 self.add_decl("int {idtype};")
512
513 var maybe_null = self.maybe_null(value)
514 var accept_null = "0"
515 if mtype isa MNullableType then
516 mtype = mtype.mtype
517 accept_null = "1"
518 end
519 if mtype isa MParameterType then
520 # Here we get the bound of the the formal type (eh, erasure...)
521 mtype = mtype.resolve_for(self.frame.mpropdef.mclassdef.bound_mtype, self.frame.mpropdef.mclassdef.bound_mtype, self.frame.mpropdef.mclassdef.mmodule, false)
522 if mtype isa MNullableType then
523 mtype = mtype.mtype
524 accept_null = "1"
525 end
526 end
527
528 if value.mcasttype.is_subtype(self.frame.mpropdef.mclassdef.mmodule, self.frame.mpropdef.mclassdef.bound_mtype, mtype) then
529 self.add("{res} = 1; /* easy {value.inspect} isa {mtype}*/")
530 if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
531 self.compiler.count_type_test_skipped[tag] += 1
532 self.add("count_type_test_skipped_{tag}++;")
533 end
534 return res
535 end
536
537 var class_ptr
538 if not value.mtype.is_c_primitive then
539 class_ptr = "{value}->class->"
540 else
541 var mclass = value.mtype.as(MClassType).mclass
542 self.require_declaration("class_{mclass.c_name}")
543 class_ptr = "class_{mclass.c_name}."
544 end
545
546 if mtype isa MClassType then
547 self.require_declaration("class_{mtype.mclass.c_name}")
548 self.add("{cltype} = class_{mtype.mclass.c_name}.color;")
549 self.add("{idtype} = class_{mtype.mclass.c_name}.id;")
550 if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
551 self.compiler.count_type_test_resolved[tag] += 1
552 self.add("count_type_test_resolved_{tag}++;")
553 end
554 else if mtype isa MVirtualType then
555 var recv = self.frame.arguments.first
556 var recv_ptr
557 if not recv.mtype.is_c_primitive then
558 recv_ptr = "{recv}->class->"
559 else
560 var mclass = recv.mtype.as(MClassType).mclass
561 self.require_declaration("class_{mclass.c_name}")
562 recv_ptr = "class_{mclass.c_name}."
563 end
564 var entry = self.get_name("entry")
565 self.add("struct vts_entry {entry};")
566 self.require_declaration(mtype.mproperty.const_color)
567 self.add("{entry} = {recv_ptr}vts_table->vts[{mtype.mproperty.const_color}];")
568 self.add("{cltype} = {entry}.class->color;")
569 self.add("{idtype} = {entry}.class->id;")
570 if maybe_null and accept_null == "0" then
571 var is_nullable = self.get_name("is_nullable")
572 self.add_decl("short int {is_nullable};")
573 self.add("{is_nullable} = {entry}.is_nullable;")
574 accept_null = is_nullable.to_s
575 end
576 if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
577 self.compiler.count_type_test_unresolved[tag] += 1
578 self.add("count_type_test_unresolved_{tag}++;")
579 end
580 else
581 self.debug("type_test({value.inspect}, {mtype})")
582 abort
583 end
584
585 # check color is in table
586 if maybe_null then
587 self.add("if({value} == NULL) \{")
588 self.add("{res} = {accept_null};")
589 self.add("\} else \{")
590 end
591 self.add("if({cltype} >= {class_ptr}type_table->size) \{")
592 self.add("{res} = 0;")
593 self.add("\} else \{")
594 self.add("{res} = {class_ptr}type_table->table[{cltype}] == {idtype};")
595 self.add("\}")
596 if maybe_null then
597 self.add("\}")
598 end
599
600 return res
601 end
602
603 redef fun unbox_extern(value, mtype)
604 do
605 if mtype isa MClassType and mtype.mclass.kind == extern_kind and
606 mtype.mclass.name != "CString" then
607 var pointer_type = compiler.mainmodule.pointer_type
608 var res = self.new_var_extern(mtype)
609 self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"
610 return res
611 else
612 return value
613 end
614 end
615
616 redef fun box_extern(value, mtype)
617 do
618 if mtype isa MClassType and mtype.mclass.kind == extern_kind and
619 mtype.mclass.name != "CString" then
620 var valtype = compiler.mainmodule.pointer_type
621 var res = self.new_var(mtype)
622 if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then
623 self.add("/*no boxing of {value.mtype}: {value.mtype} is not live! */")
624 self.add("PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);")
625 return res
626 end
627 self.require_declaration("BOX_{valtype.c_name}")
628 self.add("{res} = BOX_{valtype.c_name}({value}); /* boxing {value.mtype} */")
629 self.require_declaration("class_{mtype.c_name}")
630 self.add("{res}->class = &class_{mtype.c_name};")
631 return res
632 else
633 return value
634 end
635 end
636
637 redef fun class_name_string(value)
638 do
639 var res = self.get_name("var_class_name")
640 self.add_decl("const char* {res};")
641 if not value.mtype.is_c_primitive then
642 self.add "{res} = {value} == NULL ? \"null\" : {value}->class->name;"
643 else
644 self.require_declaration("class_{value.mtype.c_name}")
645 self.add "{res} = class_{value.mtype.c_name}.name;"
646 end
647 return res
648 end
649
650 redef fun native_array_instance(elttype, length)
651 do
652 var nclass = mmodule.native_array_class
653 var mtype = nclass.get_mtype([elttype])
654 var res = self.new_var(mtype)
655 res.is_exact = true
656 self.require_declaration("NEW_{nclass.c_name}")
657 length = autobox(length, compiler.mainmodule.int_type)
658 self.add("{res} = NEW_{nclass.c_name}({length});")
659 return res
660 end
661 end
Nit language project; an oo programing language and its tool suite.