nitlanguage / nit.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
compile: cnames for classes and modules
[nit.git] / src / compiling / compiling_icode.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Copyright 2009 Jean Privat <jean@pryen.org>
4 #
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
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
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.
16
17 # Generate C code from intermediate code representation
18 package compiling_icode
19
20 import icode
21 private import analysis
22 import compiling_base
23
24 # Compiler context from ICode to C
25 class I2CCompilerVisitor
26 # Associate things
27 var _ids: HashMap[Object, String] = new HashMap[Object, String]
28 # Associate other things
29 var _ids2: HashMap[Object, String] = new HashMap[Object, String]
30
31 # Return the string associated with a register
32 fun register(e: IRegister): String
33 do
34 if e.stype isa MMTypeNone then return "NIT_NULL"
35 var ids = _ids
36 if closure and not e.is_local then ids = _ids2
37 if ids.has_key(e) then
38 return ids[e]
39 else
40 var i = e.slot_index
41 if i == null then
42 # The register is dead
43 var s = "NIT_NULL"
44 ids[e] = s
45 return s
46 else
47 var s: String
48 var strs: HashMap[Int, String]
49 if e.in_tag_slots then
50 strs = once new HashMap[Int, String]
51 if not strs.has_key(i) then strs[i] = "REGB{i}"
52 else if closure and not e.is_local then
53 strs = once new HashMap[Int, String]
54 if not strs.has_key(i) then strs[i] = "closctx->REG[{i}]"
55 else
56 strs = once new HashMap[Int, String]
57 if not strs.has_key(i) then strs[i] = "fra.me.REG[{i}]"
58 end
59 s = strs[i]
60 ids[e] = s
61 return s
62 end
63 end
64 end
65
66 # Return the strings associated with registers
67 fun registers(a: Collection[IRegister]): Array[String]
68 do
69 var r = new Array[String].with_capacity(a.length)
70 for e in a do
71 r.add(register(e))
72 end
73 return r
74 end
75
76 var _last_number: Int = 0
77 # Give a new unique number (unique for the visitor)
78 fun new_number: Int
79 do
80 _last_number += 1
81 return _last_number
82 end
83
84 # Return the string associated with a escape label
85 fun lab(e: ISeq): String
86 do
87 if _ids.has_key(e) then
88 return _ids[e]
89 else
90 var s = "label{new_number}"
91 _ids[e] = s
92 return s
93 end
94 end
95
96 # The rank (number) of each closure
97 readable var _closures: HashMap[IClosureDecl, String] = new HashMap[IClosureDecl, String]
98
99 # The functionnal type of each closure
100 readable var _clostypes: HashMap[IClosureDecl, String] = new HashMap[IClosureDecl, String]
101
102 # label locally accessibles
103 readable writable var _local_labels: HashSet[ISeq] = new HashSet[ISeq]
104
105 # Not local escaped labels
106 # The integer value is an index identifying the label
107 readable writable var _escaped_labels: HashMap[ISeq, Int] = new HashMap[ISeq, Int]
108
109 # Register a escape to a non local label and return an index identifying the label
110 fun register_escape_label(e: ISeq): Int
111 do
112 if _escaped_labels.has_key(e) then
113 return _escaped_labels[e]
114 else
115 var res = _escaped_labels.length + 1
116 _escaped_labels[e] = res
117 return res
118 end
119 end
120
121 # Add a C label mark (if needed)
122 fun add_label(e: ISeq)
123 do
124 if _ids.has_key(e) then
125 add_instr("{_ids[e]}: while(0);")
126 end
127 end
128
129 # Add a goto to a label (even outside a closure)
130 fun add_goto(seq: ISeq)
131 do
132 if local_labels.has(seq) then
133 add_instr("goto {lab(seq)};")
134 else
135 assert closure
136 var ind = register_escape_label(seq)
137 add_instr("closctx->has_broke = {ind};")
138 add_instr("goto {lab(return_label.as(not null))};")
139 end
140 end
141
142 # Association between IEscapeMarks and visited ISeq
143 readable var _marks_to_seq: Map[IEscapeMark, ISeq] = new HashMap[IEscapeMark, ISeq]
144
145 # Are we in a closure ?
146 readable writable var _closure: Bool = false
147
148 # The current compiler visitor
149 readable var _visitor: CompilerVisitor
150
151 # The current compiled iroutine
152 readable var _iroutine: IRoutine
153
154 # The return label of the current compiling C function
155 readable writable var _return_label: nullable ISeq = null
156
157 fun add_decl(s: String)
158 do
159 visitor.add_decl(s)
160 end
161
162 # Prepare a new instuction (indent, comment)
163 # Caller must ensure to add a new line to finish its instr
164 fun new_instr: Writer
165 do
166 var w = visitor.writer
167 var l = _next_location
168 if l != null then
169 visitor.add_indent(w)
170 w.add("/* ")
171 w.add(l.file)
172 w.add(":")
173 w.add(l.line_start.to_s)
174 w.add(" */\n")
175 _next_location = null
176 end
177 visitor.add_indent(w)
178 return w
179 end
180
181 fun add_instr(s: String)
182 do
183 new_instr.add(s).add("\n")
184 end
185
186 fun indent
187 do
188 visitor.indent
189 end
190
191 fun unindent
192 do
193 visitor.unindent
194 end
195
196 fun add_assignment(to, from: String)
197 do
198 visitor.add_assignment(to, from)
199 end
200
201 var _last_location: nullable Location = null
202 var _next_location: nullable Location = null
203
204 # Add location information in a comment
205 # Do nothing if the last location added is the same
206 fun add_location(l: nullable Location)
207 do
208 var last = _last_location
209 if last == l or l == null then return
210 _last_location = l
211 if last != null and last.file == l.file and last.line_start == l.line_start then
212 return
213 else
214 _next_location = l
215 end
216 end
217
218 # The C fonction name of the iroutine
219 readable var _basecname: String
220
221 init(v: CompilerVisitor, ir: IRoutine, cname: String)
222 do
223 _visitor = v
224 _iroutine = ir
225 _basecname = cname
226 end
227 end
228
229 redef class IRoutine
230 # Declare and start a C function that match the routine
231 # Return what must be given to compile_inside_to_c or to compile_to_c
232 # After the method, an openinig { and and indent is added.
233 # So, do not forget to add a sub_context, to unintent and to add a closing }
234 fun compile_signature_to_c(v: CompilerVisitor, cname: String, human_name: nullable String, before_params, after_params: nullable String): Array[String]
235 do
236 var cargs = new Array[String]
237 var cparams = new Array[String]
238 if before_params != null then cparams.add(before_params)
239 for i in [0..params.length[ do
240 cargs.add("p{i}")
241 cparams.add("val_t p{i}")
242 end
243 if closure_decls != null then
244 cparams.add("struct stack_frame_t *closctx_param")
245 for i in [0..closure_decls.length[ do
246 var closcn = "CLOS_{cname}_{i}"
247 var cs = closure_decls[i].closure.signature
248 var subparams = new Array[String] # Parameters of the closure
249 subparams.add("struct stack_frame_t *")
250 for j in [0..cs.arity[ do
251 subparams.add("val_t")
252 end
253 var rr = "void"
254 if cs.return_type != null then rr = "val_t"
255 v.add_decl("typedef {rr} (*{closcn})({subparams.join(", ")});")
256 cargs.add("clos_fun{i}")
257 cparams.add("fun_t clos_fun{i}")
258 end
259 end
260 if after_params != null then cparams.add(after_params)
261 var r = "void"
262 if result != null then r = "val_t"
263 var p: String
264 if cparams.is_empty then
265 p = "void"
266 else
267 p = cparams.join(", ")
268 end
269 if human_name != null then v.add_decl("static const char * const LOCATE_{cname} = \"{human_name}\";")
270 v.add_decl("{r} {cname}({p});")
271 v.add_decl("typedef {r} (*{cname}_t)({p});")
272 v.add_instr("{r} {cname}({p})\{")
273 v.indent
274 return cargs
275 end
276
277 # Compile the body of the routine, return the result value is any
278 fun compile_inside_to_c(v: I2CCompilerVisitor, args: Array[String]): nullable String
279 do
280 # Create and push the stack frame
281 var ll = 0
282 if location != null then
283 ll = location.line_start
284 end
285 # Encapsulate the frame ('me') in a larger structure ('fra') that has enough space to store the local variables (REG)
286 if std_slots_nb > 1 then
287 v.add_decl("struct \{struct stack_frame_t me; val_t MORE_REG[{std_slots_nb-1}];\} fra;")
288 else
289 v.add_decl("struct \{struct stack_frame_t me;\} fra;")
290 end
291 v.add_instr("fra.me.prev = stack_frame_head; stack_frame_head = &fra.me;")
292 v.add_instr("fra.me.file = LOCATE_{v.visitor.mmmodule.cname};")
293 v.add_instr("fra.me.line = {ll};")
294 v.add_instr("fra.me.meth = LOCATE_{v.basecname};")
295 v.add_instr("fra.me.has_broke = 0;")
296 v.add_instr("fra.me.REG_size = {std_slots_nb};")
297
298 # Declare/initialize local variables
299 for i in [0..std_slots_nb[ do
300 v.add_instr("fra.me.REG[{i}] = NIT_NULL;")
301 end
302 for i in [0..tag_slots_nb[ do
303 v.add_decl("val_t REGB{i};")
304 end
305 var iclosdecls = closure_decls
306 if iclosdecls != null then
307 v.add_decl("fun_t CREG[{iclosdecls.length}];")
308 v.add_instr("fra.me.closure_ctx = closctx_param;")
309 v.add_instr("fra.me.closure_funs = CREG;")
310 end
311 var k = 0
312 for r in params do
313 if r.slot_index != null then v.add_assignment(v.register(r), args[k])
314 k += 1
315 end
316 if iclosdecls != null then
317 for i in [0..iclosdecls.length[ do
318 var iclosdecl = iclosdecls[i]
319 v.add_instr("CREG[{i}] = {args[params.length+i]};")
320 v.closures[iclosdecl] = i.to_s
321 var cs = iclosdecl.closure.signature # Closure signature
322 var subparams = new Array[String] # Parameters of the closure
323 subparams.add("struct stack_frame_t *")
324 for j in [0..cs.arity[ do
325 var p = "val_t"
326 subparams.add(p)
327 end
328 var r = "void"
329 if cs.return_type != null then r = "val_t"
330 v.clostypes[iclosdecl] = "{r} (*)({subparams.join(", ")})"
331 end
332 end
333 v.add_decl("val_t tmp;")
334
335 # Prepare return
336 var old_rl = v.return_label
337 v.return_label = body
338
339 # Compile body
340 body.compile_to_c(v)
341
342 v.add_instr("stack_frame_head = fra.me.prev;")
343 v.return_label = old_rl
344 var r = result
345 if r != null then
346 return v.register(r)
347 else
348 return null
349 end
350 end
351
352 # Full compilation of the routine
353 # cv must be in the correct function
354 fun compile_to_c(cv: CompilerVisitor, cname: String, args: Array[String]): nullable String
355 do
356 var v = new I2CCompilerVisitor(cv, self, cname)
357 return compile_inside_to_c(v, args)
358 end
359 end
360
361 redef class ICode
362 # Full compilation of the icode
363 fun compile_to_c(v: I2CCompilerVisitor) is abstract
364
365 # Is a result really needed
366 private fun need_result: Bool
367 do
368 var r = result
369 return r != null and r.slot_index != null
370 end
371
372 # Store s in the result value of self
373 private fun store_result(v: I2CCompilerVisitor, w: nullable Writer)
374 do
375 var r = result
376 if r != null and r.slot_index != null then
377 assert w != null
378 var w2 = v.new_instr
379 w2.add(v.register(r))
380 w2.add(" = ")
381 w2.append(w)
382 w2.add(";\n")
383 else if w != null and not is_pure then
384 # ICode with side effects must be evaluated
385 # even if the result is not wanted
386 var w2 = v.new_instr
387 w2.append(w)
388 w2.add(";\n")
389 end
390 end
391
392 # Prepare a writer if the expression icode need to be compiled
393 # * Result assigment is automatic if needed
394 private fun new_result(v: I2CCompilerVisitor): Writer
395 do
396 assert need_result or not is_pure
397 var w2 = v.new_instr
398 var r = result
399 if r != null and r.slot_index != null then
400 w2.add(v.register(r))
401 w2.add(" = ")
402 end
403 var w = w2.sub
404 w2.add(";\n")
405 return w
406 end
407 end
408
409 redef class ISeq
410 redef fun compile_to_c(v)
411 do
412 v.add_location(location)
413 v.local_labels.add(self)
414 var mark = iescape_mark
415 if mark != null then v.marks_to_seq[mark] = self
416 for ic in icodes do
417 ic.compile_to_c(v)
418 end
419 v.add_label(self)
420 end
421 end
422
423 redef class IIf
424 redef fun compile_to_c(v)
425 do
426 v.add_location(location)
427 var w = v.new_instr
428 w.add("if (UNTAG_Bool(")
429 w.add(v.register(expr))
430 w.add(")) \{\n")
431 if not then_seq.icodes.is_empty then
432 v.indent
433 then_seq.compile_to_c(v)
434 v.unindent
435 end
436 if not else_seq.icodes.is_empty then
437 v.add_instr("\} else \{")
438 v.indent
439 else_seq.compile_to_c(v)
440 v.unindent
441 end
442 v.add_instr("\}")
443 end
444 end
445
446 redef class ILoop
447 redef fun compile_to_c(v)
448 do
449 v.add_location(location)
450 v.local_labels.add(self)
451 var mark = iescape_mark
452 if mark != null then v.marks_to_seq[mark] = self
453 v.add_instr("while(1) \{")
454 v.indent
455 for ic in icodes do
456 ic.compile_to_c(v)
457 end
458 v.unindent
459 v.add_instr("\}")
460 v.add_label(self)
461 end
462 end
463
464 redef class IEscape
465 redef fun compile_to_c(v)
466 do
467 v.add_location(location)
468 v.add_goto(v.marks_to_seq[iescape_mark])
469 end
470 end
471
472 redef class IAbsCall
473 redef fun compile_to_c(v)
474 do
475 v.add_location(location)
476 var args = v.registers(exprs)
477
478 # Compile closure definitions
479 var old_el = v.escaped_labels
480 var closdefs = closure_defs
481 var closctx: nullable String = null # The closure context of closdefs
482 if closdefs != null then
483 # Get the closure context
484 if v.closure then
485 closctx = "closctx"
486 else
487 closctx = "(&(fra.me))"
488 end
489
490 # First aditionnal arguments is the closure context
491 args.add(closctx)
492
493 # We are in a new escape boundary
494 v.escaped_labels = new HashMap[ISeq, Int]
495
496 # Compile each closures and add each sub-function as an other additionnal parameter
497 for cd in closdefs do
498 if cd != null then
499 var cn = cd.compile_closure(v)
500 args.add(cn)
501 else
502 args.add("NULL")
503 end
504 end
505 end
506
507 # Compile the real call
508 var call = compile_call_to_c(v, args)
509 var res: nullable Writer = call
510
511 # Intercept escapes
512 if closctx != null then
513 var els = v.escaped_labels
514 v.escaped_labels = old_el
515 # Is there possible escapes?
516 if not els.is_empty then
517 # Call in a tmp variable to avoid 'break' overwrite
518 var w = v.new_instr
519 if need_result then
520 w.add("tmp")
521 w.add(" = ")
522 w.append(call)
523 w.add(";\n")
524 res = new Writer
525 res.add("tmp")
526 else
527 res = null
528 w.append(call)
529 w.add(";\n")
530 end
531 # What are the expected escape indexes
532 v.new_instr.add("switch (").add(closctx).add("->has_broke) \{\n")
533 v.indent
534 # No escape occured, continue as usual
535 v.add_instr("case 0: break;")
536 var lls = v.local_labels
537 var iels = els.iterator
538 var forward_escape = false
539 while iels.is_ok do
540 var seq = iels.key
541 if lls.has(seq) then
542 # Local escape occured
543 # Clear the has_broke information and go to the target
544 v.new_instr.add("case ").add(iels.item.to_s).add(": ").add(closctx).add("->has_broke = 0; goto ").add(v.lab(seq)).add(";\n")
545 else
546 # Forward escape occured: register the escape label
547 assert v.closure
548 v.register_escape_label(seq)
549 forward_escape = true
550 end
551 iels.next
552 end
553 # If forward escape occured, just pass to the next one
554 if forward_escape then
555 # Do not need to copy 'has_broke' value since it is shared by the next one.
556 # So just exit the C function.
557 v.new_instr.add("default: goto ").add(v.lab(v.return_label.as(not null))).add(";\n")
558 end
559 v.unindent
560 v.add_instr("\}")
561 end
562 end
563
564 if res != null then
565 var w = new_result(v)
566 w.append(res)
567 end
568 end
569
570 # The single invocation witout fancy stuffs
571 private fun compile_call_to_c(v: I2CCompilerVisitor, args: Array[String]): Writer is abstract
572 end
573
574 redef class ICall
575 redef fun compile_call_to_c(v, args)
576 do
577 var w = new Writer
578 var prop = property
579 if prop.global.is_init then args.add("init_table")
580 w.add(prop.global.meth_call)
581 w.add("(")
582 w.add(args.first)
583 w.add(")(")
584 w.add_all(args, ", ")
585 w.add(")")
586 return w
587 end
588 end
589
590 redef class ISuper
591 redef fun compile_call_to_c(v, args)
592 do
593 var prop = property
594 if prop.global.is_init then args.add("init_table")
595 var w = new Writer
596 w.add(prop.super_meth_call)
597 w.add("(")
598 w.add(args.first)
599 w.add(")(")
600 w.add_all(args, ", ")
601 w.add(")")
602 return w
603 end
604 end
605
606 redef class INew
607 redef fun compile_call_to_c(v, args)
608 do
609 var w = new Writer
610 w.add("NEW_")
611 w.add(stype.local_class.to_s)
612 w.add("_")
613 w.add(property.global.intro.cname)
614 w.add("(")
615 w.add_all(args, ", ")
616 w.add(")")
617 return w
618 end
619 end
620
621 redef class IAllocateInstance
622 redef fun compile_to_c(v)
623 do
624 v.add_location(location)
625 var w = new_result(v)
626 w.add("NEW_")
627 w.add(stype.local_class.cname)
628 w.add("()")
629 end
630 end
631
632 redef class ICheckInstance
633 redef fun compile_to_c(v)
634 do
635 v.add_location(location)
636 var w = new_result(v)
637 w.add("CHECKNEW_")
638 w.add(stype.local_class.cname)
639 w.add("(")
640 w.add(v.register(expr))
641 w.add(")")
642 end
643 end
644
645 redef class IInitAttributes
646 redef fun compile_to_c(v)
647 do
648 v.add_location(location)
649 var w = v.new_instr
650 w.add("INIT_ATTRIBUTES__")
651 w.add(stype.local_class.cname)
652 w.add("(")
653 w.add(v.register(expr))
654 w.add(");\n")
655 end
656 end
657
658 redef class IStaticCall
659 redef fun compile_call_to_c(v, args)
660 do
661 var prop = property
662 if prop.global.is_init then args.add("init_table")
663 var w = new Writer
664 w.add(property.cname)
665 w.add("(")
666 w.add_all(args, ", ")
667 w.add(")")
668 return w
669 end
670 end
671
672 redef class INative
673 redef fun compile_to_c(v)
674 do
675 v.add_location(location)
676 if method.is_intern then
677 compile_intern_method_to_c(v)
678 else
679 compile_extern_method_to_c(v)
680 end
681 end
682
683 fun compile_extern_method_to_c(v: I2CCompilerVisitor)
684 do
685 var ename = method.extern_name.as(not null)#"{method.module.name}_{method.local_class.name}_{method.local_class.name}_{method.name}_{method.signature.arity}"
686 var sig = method.signature
687 assert exprs.length == sig.arity + 1
688
689 var regs = v.registers(exprs)
690
691 var args = new Array[String]
692 args.add(sig.recv.unboxtype(regs[0]))
693 for i in [0..sig.arity[ do
694 args.add(sig[i].unboxtype(regs[i+1]))
695 end
696 var s = "{ename}({args.join(", ")})"
697
698 if need_result then s = sig.return_type.boxtype(s)
699 var w = new_result(v)
700 w.add(s)
701 end
702
703 fun compile_intern_method_to_c(v: I2CCompilerVisitor)
704 do
705 var sig = method.signature
706 assert exprs.length == sig.arity + 1
707 var c = method.local_class.name
708 var n = method.name
709 var regs = v.registers(exprs)
710 var s: nullable String = null
711 if c == once "Int".to_symbol then
712 if n == once "object_id".to_symbol then
713 s = regs[0]
714 else if n == once "unary -".to_symbol then
715 s = "TAG_Int(-UNTAG_Int({regs[0]}))"
716 else if n == once "output".to_symbol then
717 s = "printf(\"%ld\\n\", UNTAG_Int({regs[0]}));"
718 else if n == once "ascii".to_symbol then
719 s = "TAG_Char(UNTAG_Int({regs[0]}))"
720 else if n == once "succ".to_symbol then
721 s = "TAG_Int(UNTAG_Int({regs[0]})+1)"
722 else if n == once "prec".to_symbol then
723 s = "TAG_Int(UNTAG_Int({regs[0]})-1)"
724 else if n == once "to_f".to_symbol then
725 s = "BOX_Float((float)UNTAG_Int({regs[0]}))"
726 else if n == once "+".to_symbol then
727 s = "TAG_Int(UNTAG_Int({regs[0]})+UNTAG_Int({regs[1]}))"
728 else if n == once "-".to_symbol then
729 s = "TAG_Int(UNTAG_Int({regs[0]})-UNTAG_Int({regs[1]}))"
730 else if n == once "*".to_symbol then
731 s = "TAG_Int(UNTAG_Int({regs[0]})*UNTAG_Int({regs[1]}))"
732 else if n == once "/".to_symbol then
733 s = "TAG_Int(UNTAG_Int({regs[0]})/UNTAG_Int({regs[1]}))"
734 else if n == once "%".to_symbol then
735 s = "TAG_Int(UNTAG_Int({regs[0]})%UNTAG_Int({regs[1]}))"
736 else if n == once "<".to_symbol then
737 s = "TAG_Bool(UNTAG_Int({regs[0]})<UNTAG_Int({regs[1]}))"
738 else if n == once ">".to_symbol then
739 s = "TAG_Bool(UNTAG_Int({regs[0]})>UNTAG_Int({regs[1]}))"
740 else if n == once "<=".to_symbol then
741 s = "TAG_Bool(UNTAG_Int({regs[0]})<=UNTAG_Int({regs[1]}))"
742 else if n == once ">=".to_symbol then
743 s = "TAG_Bool(UNTAG_Int({regs[0]})>=UNTAG_Int({regs[1]}))"
744 else if n == once "lshift".to_symbol then
745 s = "TAG_Int(UNTAG_Int({regs[0]})<<UNTAG_Int({regs[1]}))"
746 else if n == once "rshift".to_symbol then
747 s = "TAG_Int(UNTAG_Int({regs[0]})>>UNTAG_Int({regs[1]}))"
748 else if n == once "==".to_symbol then
749 s = "TAG_Bool(({regs[0]})==({regs[1]}))"
750 else if n == once "!=".to_symbol then
751 s = "TAG_Bool(({regs[0]})!=({regs[1]}))"
752 end
753 else if c == once "Float".to_symbol then
754 if n == once "object_id".to_symbol then
755 s = "TAG_Int((bigint)UNBOX_Float({regs[0]}))"
756 else if n == once "unary -".to_symbol then
757 s = "BOX_Float(-UNBOX_Float({regs[0]}))"
758 else if n == once "output".to_symbol then
759 s = "printf(\"%f\\n\", UNBOX_Float({regs[0]}));"
760 else if n == once "to_i".to_symbol then
761 s = "TAG_Int((bigint)UNBOX_Float({regs[0]}))"
762 else if n == once "+".to_symbol then
763 s = "BOX_Float(UNBOX_Float({regs[0]})+UNBOX_Float({regs[1]}))"
764 else if n == once "-".to_symbol then
765 s = "BOX_Float(UNBOX_Float({regs[0]})-UNBOX_Float({regs[1]}))"
766 else if n == once "*".to_symbol then
767 s = "BOX_Float(UNBOX_Float({regs[0]})*UNBOX_Float({regs[1]}))"
768 else if n == once "/".to_symbol then
769 s = "BOX_Float(UNBOX_Float({regs[0]})/UNBOX_Float({regs[1]}))"
770 else if n == once "<".to_symbol then
771 s = "TAG_Bool(UNBOX_Float({regs[0]})<UNBOX_Float({regs[1]}))"
772 else if n == once ">".to_symbol then
773 s = "TAG_Bool(UNBOX_Float({regs[0]})>UNBOX_Float({regs[1]}))"
774 else if n == once "<=".to_symbol then
775 s = "TAG_Bool(UNBOX_Float({regs[0]})<=UNBOX_Float({regs[1]}))"
776 else if n == once ">=".to_symbol then
777 s = "TAG_Bool(UNBOX_Float({regs[0]})>=UNBOX_Float({regs[1]}))"
778 end
779 else if c == once "Char".to_symbol then
780 if n == once "object_id".to_symbol then
781 s = "TAG_Int(UNTAG_Char({regs[0]}))"
782 else if n == once "unary -".to_symbol then
783 s = "TAG_Char(-UNTAG_Char({regs[0]}))"
784 else if n == once "output".to_symbol then
785 s = "printf(\"%c\", (unsigned char)UNTAG_Char({regs[0]}));"
786 else if n == once "ascii".to_symbol then
787 s = "TAG_Int((unsigned char)UNTAG_Char({regs[0]}))"
788 else if n == once "succ".to_symbol then
789 s = "TAG_Char(UNTAG_Char({regs[0]})+1)"
790 else if n == once "prec".to_symbol then
791 s = "TAG_Char(UNTAG_Char({regs[0]})-1)"
792 else if n == once "to_i".to_symbol then
793 s = "TAG_Int(UNTAG_Char({regs[0]})-'0')"
794 else if n == once "+".to_symbol then
795 s = "TAG_Char(UNTAG_Char({regs[0]})+UNTAG_Char({regs[1]}))"
796 else if n == once "-".to_symbol then
797 s = "TAG_Char(UNTAG_Char({regs[0]})-UNTAG_Char({regs[1]}))"
798 else if n == once "*".to_symbol then
799 s = "TAG_Char(UNTAG_Char({regs[0]})*UNTAG_Char({regs[1]}))"
800 else if n == once "/".to_symbol then
801 s = "TAG_Char(UNTAG_Char({regs[0]})/UNTAG_Char({regs[1]}))"
802 else if n == once "%".to_symbol then
803 s = "TAG_Char(UNTAG_Char({regs[0]})%UNTAG_Char({regs[1]}))"
804 else if n == once "<".to_symbol then
805 s = "TAG_Bool(UNTAG_Char({regs[0]})<UNTAG_Char({regs[1]}))"
806 else if n == once ">".to_symbol then
807 s = "TAG_Bool(UNTAG_Char({regs[0]})>UNTAG_Char({regs[1]}))"
808 else if n == once "<=".to_symbol then
809 s = "TAG_Bool(UNTAG_Char({regs[0]})<=UNTAG_Char({regs[1]}))"
810 else if n == once ">=".to_symbol then
811 s = "TAG_Bool(UNTAG_Char({regs[0]})>=UNTAG_Char({regs[1]}))"
812 else if n == once "==".to_symbol then
813 s = "TAG_Bool(({regs[0]})==({regs[1]}))"
814 else if n == once "!=".to_symbol then
815 s = "TAG_Bool(({regs[0]})!=({regs[1]}))"
816 end
817 else if c == once "Bool".to_symbol then
818 if n == once "object_id".to_symbol then
819 s = "TAG_Int(UNTAG_Bool({regs[0]}))"
820 else if n == once "unary -".to_symbol then
821 s = "TAG_Bool(-UNTAG_Bool({regs[0]}))"
822 else if n == once "output".to_symbol then
823 s = "(void)printf(UNTAG_Bool({regs[0]})?\"true\\n\":\"false\\n\");"
824 else if n == once "ascii".to_symbol then
825 s = "TAG_Bool(UNTAG_Bool({regs[0]}))"
826 else if n == once "to_i".to_symbol then
827 s = "TAG_Int(UNTAG_Bool({regs[0]}))"
828 else if n == once "==".to_symbol then
829 s = "TAG_Bool(({regs[0]})==({regs[1]}))"
830 else if n == once "!=".to_symbol then
831 s = "TAG_Bool(({regs[0]})!=({regs[1]}))"
832 end
833 else if c == once "NativeArray".to_symbol then
834 if n == once "object_id".to_symbol then
835 s = "TAG_Int(((Nit_NativeArray){regs[0]})->object_id)"
836 else if n == once "[]".to_symbol then
837 s = "((Nit_NativeArray){regs[0]})->val[UNTAG_Int({regs[1]})]"
838 else if n == once "[]=".to_symbol then
839 s = "((Nit_NativeArray){regs[0]})->val[UNTAG_Int({regs[1]})]={regs[2]}"
840 else if n == once "copy_to".to_symbol then
841 s = "(void)memcpy(((Nit_NativeArray ){regs[1]})->val, ((Nit_NativeArray){regs[0]})->val, UNTAG_Int({regs[2]})*sizeof(val_t))"
842 end
843 else if c == once "NativeString".to_symbol then
844 if n == once "object_id".to_symbol then
845 s = "TAG_Int(UNBOX_NativeString({regs[0]}))"
846 else if n == once "atoi".to_symbol then
847 s = "TAG_Int(atoi(UNBOX_NativeString({regs[0]})))"
848 else if n == once "[]".to_symbol then
849 s = "TAG_Char(UNBOX_NativeString({regs[0]})[UNTAG_Int({regs[1]})])"
850 else if n == once "[]=".to_symbol then
851 s = "UNBOX_NativeString({regs[0]})[UNTAG_Int({regs[1]})]=UNTAG_Char({regs[2]});"
852 else if n == once "copy_to".to_symbol then
853 s = "(void)memcpy(UNBOX_NativeString({regs[1]})+UNTAG_Int({regs[4]}), UNBOX_NativeString({regs[0]})+UNTAG_Int({regs[3]}), UNTAG_Int({regs[2]}));"
854 end
855 else if n == once "object_id".to_symbol then
856 s = "TAG_Int((bigint)((obj_t){regs[0]})[1].object_id)"
857 else if n == once "sys".to_symbol then
858 s = "(G_sys)"
859 else if n == once "is_same_type".to_symbol then
860 s = "TAG_Bool((VAL2VFT({regs[0]})==VAL2VFT({regs[1]})))"
861 else if n == once "exit".to_symbol then
862 s = "exit(UNTAG_Int({regs[1]}));"
863 else if n == once "calloc_array".to_symbol then
864 s = "NEW_NativeArray(UNTAG_Int({regs[1]}), sizeof(val_t))"
865 else if n == once "calloc_string".to_symbol then
866 s = "BOX_NativeString((char*)raw_alloc((UNTAG_Int({regs[1]}) * sizeof(char))))"
867 end
868 if s == null then
869 var ll = location
870 if ll != null then v.add_instr("fprintf(stderr, \"{ll.to_s}: \");")
871 v.add_instr("fprintf(stderr, \"Fatal error: unknown intern method {method.full_name}.\\n\");")
872 v.add_instr("nit_exit(1);")
873 s = "NIT_NULL"
874 end
875 if result == null then
876 v.new_instr.add(s).add(";\n")
877 else if need_result then
878 var w = new_result(v)
879 w.add(s)
880 end
881 end
882 end
883
884 redef class IIntValue
885 redef fun compile_to_c(v)
886 do
887 v.add_location(location)
888 var w = new_result(v)
889 w.add("TAG_Int(").add(value.to_s).add(")")
890 end
891 end
892
893 redef class IBoolValue
894 redef fun compile_to_c(v)
895 do
896 v.add_location(location)
897 var w = new_result(v)
898 w.add("TAG_Bool(")
899 if value then w.add("true") else w.add("false")
900 w.add(")")
901 end
902 end
903
904 redef class ICharValue
905 redef fun compile_to_c(v)
906 do
907 v.add_location(location)
908 var w = new_result(v)
909 w.add("TAG_Char(").add(value).add(")")
910 end
911 end
912
913 redef class IFloatValue
914 redef fun compile_to_c(v)
915 do
916 v.add_location(location)
917 var w = new_result(v)
918 w.add("BOX_Float(").add(value).add(")")
919 end
920 end
921
922 redef class IStringValue
923 redef fun compile_to_c(v)
924 do
925 v.add_location(location)
926 var w = new_result(v)
927 w.add("BOX_NativeString(\"").add(value).add("\")")
928 end
929 end
930
931 redef class IAbort
932 redef fun compile_to_c(v)
933 do
934 v.add_location(location)
935 var w = v.new_instr
936 w.add("nit_abort(\"")
937 w.add(texts[0])
938 if texts.length > 1 then
939 w.add("\", \"")
940 w.add(texts[1])
941 w.add("\"")
942 else
943 w.add("\", NULL")
944 end
945 w.add(", LOCATE_")
946 w.add(module_location.cname)
947 var ll = location
948 if ll != null then
949 w.add(", ")
950 w.add(ll.line_start.to_s)
951 else
952 w.add(", 0")
953 end
954 w.add(");\n")
955 end
956 end
957
958 redef class IMove
959 redef fun compile_to_c(v)
960 do
961 if not need_result then return
962 var e = v.register(expr)
963 var r = v.register(result.as(not null))
964 if e == r then return
965 v.add_location(location)
966 var w = v.new_instr
967 w.add(r)
968 w.add(" = ")
969 w.add(e)
970 w.add(";\n")
971 end
972 end
973
974 redef class IAttrRead
975 redef fun compile_to_c(v)
976 do
977 if not need_result then return
978 v.add_location(location)
979 var w = new_result(v)
980 w.add(property.global.attr_access)
981 w.add("(")
982 w.add(v.register(expr))
983 w.add(")")
984 end
985 end
986
987 redef class IAttrIsset
988 redef fun compile_to_c(v)
989 do
990 if not need_result then return
991 v.add_location(location)
992 var w = new_result(v)
993 w.add("TAG_Bool(")
994 w.add(property.global.attr_access)
995 w.add("(")
996 w.add(v.register(expr))
997 w.add(")!=NIT_NULL)")
998 end
999 end
1000
1001 redef class IAttrWrite
1002 redef fun compile_to_c(v)
1003 do
1004 v.add_location(location)
1005 var w = v.new_instr
1006 w.add(property.global.attr_access)
1007 w.add("(")
1008 w.add(v.register(expr1))
1009 w.add(") = ")
1010 w.add(v.register(expr2))
1011 w.add(";\n")
1012 end
1013 end
1014
1015 redef class ITypeCheck
1016 redef fun compile_to_c(v)
1017 do
1018 if not need_result then return
1019 # FIXME handle formaltypes
1020 v.add_location(location)
1021 var g = stype.local_class.global
1022 var recv = v.register(expr)
1023 var w = new_result(v)
1024 w.add("TAG_Bool(")
1025 if expr.stype.is_nullable then
1026 if stype.is_nullable then
1027 w.add("(")
1028 w.add(recv)
1029 w.add("==NIT_NULL) || ")
1030 else if stype.as_nullable == expr.stype then
1031 w.add(recv)
1032 w.add("!=NIT_NULL)")
1033 return
1034 else
1035 w.add("(")
1036 w.add(recv)
1037 w.add("!=NIT_NULL) && ")
1038 end
1039 end
1040 w.add("VAL_ISA(")
1041 w.add(recv)
1042 w.add(", ")
1043 w.add(g.color_id)
1044 w.add(", ")
1045 w.add(g.id_id)
1046 w.add(")) /*cast ")
1047 w.add(stype.to_s)
1048 w.add("*/")
1049 end
1050 end
1051
1052 redef class IIs
1053 redef fun compile_to_c(v)
1054 do
1055 if not need_result then return
1056 v.add_location(location)
1057 var w = new_result(v)
1058 w.add("TAG_Bool(")
1059 var t1 = expr1.stype
1060 var t2 = expr2.stype
1061 if t1 isa MMTypeNone then
1062 if t2 isa MMTypeNone then
1063 w.add("1)")
1064 return
1065 else if t2.is_nullable then
1066 w.add(v.register(expr2))
1067 w.add("==NIT_NULL)")
1068 return
1069 else
1070 w.add("0)")
1071 return
1072 end
1073 else if t1.is_nullable then
1074 if t2 isa MMTypeNone then
1075 w.add(v.register(expr1))
1076 w.add("==NIT_NULL)")
1077 return
1078 else if t2.is_nullable then
1079 w.add("IS_EQUAL_NN(")
1080 else
1081 w.add("IS_EQUAL_ON(")
1082 w.add(v.register(expr2))
1083 w.add(",")
1084 w.add(v.register(expr1))
1085 w.add("))")
1086 return
1087 end
1088 else
1089 if t2 isa MMTypeNone then
1090 w.add("0)")
1091 return
1092 else if t2.is_nullable then
1093 w.add("IS_EQUAL_ON(")
1094 else
1095 w.add("IS_EQUAL_OO(")
1096 end
1097 end
1098 w.add(v.register(expr1))
1099 w.add(",")
1100 w.add(v.register(expr2))
1101 w.add("))")
1102 end
1103 end
1104
1105 redef class INot
1106 redef fun compile_to_c(v)
1107 do
1108 if not need_result then return
1109 v.add_location(location)
1110 var w = new_result(v)
1111 w.add("TAG_Bool(!UNTAG_Bool(")
1112 w.add(v.register(expr))
1113 w.add("))")
1114 end
1115 end
1116
1117 redef class IOnce
1118 redef fun compile_to_c(v)
1119 do
1120 v.add_location(location)
1121 var i = v.new_number
1122 var res = result.as(not null)
1123 if res.stype.is_nullable then
1124 v.add_decl("static val_t once_value_{i}; static int once_bool_{i}; /* Once value */")
1125 v.add_instr("if (!once_bool_{i}) \{")
1126 else
1127 # Since the value is not nullable, we use the null value to represent the boolean
1128 v.add_decl("static val_t once_value_{i}; /* Once value */")
1129 v.add_instr("if (!once_value_{i}) \{")
1130 end
1131 v.indent
1132 body.compile_to_c(v)
1133 var e = v.register(res)
1134 v.add_instr("once_value_{i} = {e};")
1135 v.add_instr("register_static_object(&once_value_{i});")
1136 if res.stype.is_nullable then v.add_instr("once_bool_{i} = true;")
1137 v.unindent
1138 v.add_instr("\} else {e} = once_value_{i};")
1139 var w = new_result(v)
1140 w.add(e)
1141 end
1142 end
1143
1144 redef class IClosCall
1145 redef fun compile_to_c(v: I2CCompilerVisitor)
1146 do
1147 v.add_location(location)
1148 var ivar: String
1149 var args: Array[String]
1150 if v.closure then
1151 ivar = "closctx->closure_funs[{v.closures[closure_decl]}]"
1152 args = ["closctx->closure_ctx"]
1153 else
1154 ivar = "CREG[{v.closures[closure_decl]}]"
1155 args = ["closctx_param"]
1156 end
1157 args.append(v.registers(exprs))
1158
1159 var s = "(({v.clostypes[closure_decl]})({ivar}))({args.join(", ")})"
1160 var w = new Writer
1161 w.add(s)
1162 store_result(v, w)
1163
1164 # Intercept escape
1165 v.add_instr("if ({args.first}->has_broke) \{")
1166 v.indent
1167 var bs = break_seq
1168 if bs != null then
1169 bs.compile_to_c(v)
1170 end
1171 v.add_goto(v.iroutine.body)
1172 v.unindent
1173 v.add_instr("\}")
1174 end
1175 end
1176
1177 redef class IHasClos
1178 redef fun compile_to_c(v)
1179 do
1180 if not need_result then return
1181 v.add_location(location)
1182 var w = new_result(v)
1183 w.add("TAG_Bool(")
1184 if v.closure then
1185 w.add("closctx->closure_funs[")
1186 w.add(v.closures[closure_decl])
1187 w.add("]")
1188 else
1189 w.add("CREG[")
1190 w.add(v.closures[closure_decl])
1191 w.add("]")
1192 end
1193 w.add(" != NULL)")
1194 end
1195 end
1196
1197 redef class IClosureDef
1198 # Compile the closure as a separate C function in the visitor out_contexts.
1199 # Return a fun_t pointer to the function.
1200 fun compile_closure(v: I2CCompilerVisitor): String
1201 do
1202 var cv = v.visitor
1203
1204 # We are now in a closure
1205 var cfc_old = v.closure
1206 v.closure = true
1207
1208 # We are now in a escape boundary
1209 var lls_old = v.local_labels
1210 v.local_labels = new HashSet[ISeq]
1211
1212 # We are now in a new C context
1213 var decl_writer_old = cv.decl_writer
1214 var writer_old = cv.writer
1215 cv.writer = cv.top_writer.sub
1216 cv.decl_writer = cv.header_writer.sub
1217
1218 # Generate the C function
1219 var cname = "OC_{v.basecname}_{v.new_number}"
1220 var args = compile_signature_to_c(v.visitor, cname, null, "struct stack_frame_t *closctx", null)
1221 cv.decl_writer = cv.writer.sub
1222
1223 var s = compile_inside_to_c(v, args)
1224 if s == null then
1225 v.add_instr("return;")
1226 else
1227 v.add_instr("return {s};")
1228 end
1229 v.unindent
1230 v.add_instr("\}")
1231
1232 # Restore things
1233 cv.writer = writer_old
1234 cv.decl_writer = decl_writer_old
1235 v.closure = cfc_old
1236 v.local_labels = lls_old
1237 return "((fun_t){cname})"
1238 end
1239 end
Nit language project; an oo programing language and its tool suite.