nitlanguage / nit.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
compile: Superstring compilation bug
[nit.git] / src / compiling / compiling_methods.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Copyright 2008 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 # Compile method bodies, statments and expressions to C.
18 package compiling_methods
19
20 import compiling_base
21 private import syntax
22
23 redef class CompilerVisitor
24 # Compile a statment node
25 meth compile_stmt(n: PExpr)
26 do
27 add_instr("/* Compile stmt {n.locate} */")
28 n.prepare_compile_stmt(self)
29 var i = cfc._variable_index
30 n.compile_stmt(self)
31 cfc._variable_index = i
32 end
33
34 # Compile is expression node
35 meth compile_expr(n: PExpr): String
36 do
37 add_instr("/* Compile expr {n.locate} */")
38 var i = cfc._variable_index
39 var s = n.compile_expr(self)
40 cfc._variable_index = i
41 if s[0] == ' ' then
42 return s
43 end
44 var v = cfc.get_var("Result for expr {n.locate}")
45 add_assignment(v, s)
46 return v
47 end
48
49 # Ensure that a c expression is a var
50 meth ensure_var(s: String, comment: String): String
51 do
52 if s.substring(0,3) == "variable" then
53 return s
54 end
55 var v = cfc.get_var(null)
56 add_assignment(v, "{s} /* Ensure var: {comment}*/")
57 return v
58 end
59
60 # Add a assignment between a variable and an expression
61 meth add_assignment(v: String, s: String)
62 do
63 if v != s then
64 add_instr("{v} = {s};")
65 end
66 end
67
68 readable writable attr _cfc: CFunctionContext
69
70 readable writable attr _nmc: NitMethodContext
71
72 # C outputs written outside the current C function.
73 readable writable attr _out_contexts: Array[CContext] = new Array[CContext]
74
75 # Generate an fprintf to display an error location
76 meth printf_locate_error(node: PNode): String
77 do
78 var s = new Buffer.from("fprintf(stderr, \"")
79 if nmc != null then s.append(" in %s")
80 s.append(" (%s:%d)\\n\", ")
81 if nmc != null then s.append("LOCATE_{nmc.method.cname}, ")
82 s.append("LOCATE_{module.name}, {node.line_number});")
83 return s.to_s
84 end
85
86 redef init(module: MMSrcModule)
87 do
88 super
89 end
90
91 meth invoke_super_init_calls_after(start_prop: MMMethod)
92 do
93 var n = nmc.method.node
94 assert n isa AConcreteInitPropdef
95
96 if n.super_init_calls.is_empty then return
97 var i = 0
98 var j = 0
99 #var s = ""
100 if start_prop != null then
101 while n.super_init_calls[i] != start_prop do
102 #s.append(" {n.super_init_calls[i]}")
103 i += 1
104 end
105 i += 1
106 #s.append(" {start_prop}")
107
108 while n.explicit_super_init_calls[j] != start_prop do
109 j += 1
110 end
111 j += 1
112 end
113 var stop_prop: MMMethod = null
114 if j < n.explicit_super_init_calls.length then
115 stop_prop = n.explicit_super_init_calls[j]
116 end
117 var l = n.super_init_calls.length
118 #s.append(" [")
119 while i < l do
120 var p = n.super_init_calls[i]
121 if p == stop_prop then break
122 var cargs = new Array[String]
123 if p.signature.arity == 0 then
124 cargs.add(cfc.varname(nmc.method_params[0]))
125 else
126 for va in nmc.method_params do
127 cargs.add(cfc.varname(va))
128 end
129 end
130 #s.append(" {p}")
131 p.compile_call(self, cargs)
132 i += 1
133 end
134 #s.append(" ]")
135 #while i < l do
136 # s.append(" {n.super_init_calls[i]}")
137 # i += 1
138 #end
139 #if stop_prop != null then s.append(" (stop at {stop_prop})")
140 #n.printl("implicit calls in {n.method}: {s}")
141 end
142 end
143
144 # A C function currently written
145 class CFunctionContext
146 readable attr _visitor: CompilerVisitor
147
148 # Next available variable number
149 attr _variable_index: Int = 0
150
151 # Total number of variable
152 attr _variable_index_max: Int = 0
153
154 # Association between nit variable and the corrsponding c variable index
155 attr _varindexes: Map[Variable, Int] = new HashMap[Variable, Int]
156
157 # Are we currenlty in a closure definition?
158 readable writable attr _closure: NitMethodContext = null
159
160 # Return the cvariable of a Nit variable
161 meth varname(v: Variable): String
162 do
163 if v isa ClosureVariable then
164 return closure_variable(_varindexes[v])
165 else
166 return variable(_varindexes[v])
167 end
168 end
169
170 # Return the next available variable
171 meth get_var(comment: String): String
172 do
173 var v = variable(_variable_index)
174 _variable_index = _variable_index + 1
175 if _variable_index > _variable_index_max then
176 _variable_index_max = _variable_index
177 end
178 if comment != null then
179 visitor.add_instr("/* Register {v}: {comment} */")
180 end
181 return v
182 end
183
184 meth register_variable(v: Variable): String
185 do
186 _varindexes[v] = _variable_index
187 var s = get_var("Local variable")
188 return s
189 end
190
191 # Next available closure variable number
192 attr _closurevariable_index: Int = 0
193
194 meth register_closurevariable(v: ClosureVariable): String
195 do
196 var s = "closurevariable[{_closurevariable_index}]"
197 _varindexes[v] = _closurevariable_index
198 _closurevariable_index += 1
199 if _closure != null then
200 return "(closctx->{s})"
201 else
202 return s
203 end
204 end
205
206 # Return the ith cvariable
207 protected meth variable(i: Int): String
208 do
209 if closure != null then
210 var vn = once new Array[String]
211 if vn.length <= i then
212 for j in [vn.length..i] do
213 vn[j] = "(closctx->variable[{j}])"
214 end
215 end
216 return vn[i]
217 else
218 var vn = once new Array[String]
219 if vn.length <= i then
220 for j in [vn.length..i] do
221 vn[j] = "variable[{j}]"
222 end
223 end
224 return vn[i]
225 end
226 end
227
228 # Return the ith closurevariable
229 protected meth closure_variable(i: Int): String
230 do
231 if closure != null then
232 return "(closctx->closurevariable[{i}])"
233 else
234 return "closurevariable[{i}]"
235 end
236 end
237
238 # Mark the variable available
239 meth free_var(v: String)
240 do
241 # FIXME: So ugly..
242 if v == variable(_variable_index-1) then
243 _variable_index = _variable_index - 1
244 end
245 end
246
247 # Generate the local variable declarations
248 # To use at the end of the C function once all variables are known
249 meth generate_var_decls
250 do
251 if _variable_index_max > 0 then
252 visitor.add_decl("val_t variable[{_variable_index_max}];")
253 else
254 visitor.add_decl("val_t *variable = NULL;")
255 end
256 if _closurevariable_index > 0 then
257 visitor.add_decl("struct WBT_ *closurevariable[{_closurevariable_index}];")
258 else
259 visitor.add_decl("struct WBT_ **closurevariable = NULL;")
260 end
261 end
262
263 init(v: CompilerVisitor) do _visitor = v
264 end
265
266 # A Nit method currenlty compiled
267 class NitMethodContext
268 # Current method compiled
269 readable attr _method: MMSrcMethod
270
271 # Association between parameters and the corresponding variables
272 readable writable attr _method_params: Array[ParamVariable]
273
274 # Where a nit return must branch
275 readable writable attr _return_label: String
276
277 # Where a nit break must branch
278 readable writable attr _break_label: String
279
280 # Where a nit continue must branch
281 readable writable attr _continue_label: String
282
283 # Variable where a functionnal nit return must store its value
284 readable writable attr _return_value: String
285
286 # Variable where a functionnal nit break must store its value
287 readable writable attr _break_value: String
288
289 # Variable where a functionnal nit continue must store its value
290 readable writable attr _continue_value: String
291
292 init(method: MMSrcMethod)
293 do
294 _method = method
295 end
296 end
297
298 ###############################################################################
299
300 redef class ClosureVariable
301 readable writable attr _ctypename: String
302 end
303
304 redef class MMMethod
305 # Compile a call on self for given arguments
306 # Most calls are compiled with a table access,
307 # primitive calles are inlined
308 # == and != are guarded and possibly inlined
309 meth compile_call(v: CompilerVisitor, cargs: Array[String]): String
310 do
311 var i = self
312 if i isa MMSrcMethod then
313 if i isa MMMethSrcMethod and i.node isa AInternMethPropdef or
314 (i.local_class.name == (once "Array".to_symbol) and name == (once "[]".to_symbol))
315 then
316 var e = i.do_compile_inside(v, cargs)
317 return e
318 end
319 end
320 var ee = once "==".to_symbol
321 var ne = once "!=".to_symbol
322 if name == ne then
323 var eqp = signature.recv.local_class.select_method(ee)
324 var eqcall = eqp.compile_call(v, cargs)
325 return "TAG_Bool(!UNTAG_Bool({eqcall}))"
326 end
327 if global.is_init then
328 cargs = cargs.to_a
329 cargs.add("init_table /*YYY*/")
330 end
331
332 var m = "{global.meth_call}({cargs[0]})"
333 var vcall = "{m}({cargs.join(", ")}) /*{local_class}::{name}*/"
334 if name == ee then
335 vcall = "UNTAG_Bool({vcall})"
336 var obj = once "Object".to_symbol
337 if i.local_class.name == obj then
338 vcall = "(({m}=={i.cname})?(IS_EQUAL_NN({cargs[0]},{cargs[1]})):({vcall}))"
339 end
340 vcall = "TAG_Bool(({cargs.first} == {cargs[1]}) || (({cargs.first} != NIT_NULL) && {vcall}))"
341 end
342 if signature.return_type != null then
343 return vcall
344 else
345 v.add_instr(vcall + ";")
346 return null
347 end
348 end
349
350 # Compile a call on self for given arguments and given closures
351 meth compile_call_and_closures(v: CompilerVisitor, cargs: Array[String], clos_defs: Array[PClosureDef]): String
352 do
353 var ve: String = null
354 var arity = 0
355 if clos_defs != null then arity = clos_defs.length
356
357 # Prepare result value.
358 # In case of procedure, the return value is still used to intercept breaks
359 var old_bv = v.nmc.break_value
360 ve = v.cfc.get_var("Closure return value and escape marker")
361 v.nmc.break_value = ve
362
363 # Compile closure to c function
364 var realcargs = new Array[String] # Args to pass to the C function call
365 var closcns = new Array[String] # Closure C structure names
366 realcargs.add_all(cargs)
367 for i in [0..arity[ do
368 var cn = clos_defs[i].compile_closure(v, closure_cname(i))
369 closcns.add(cn)
370 realcargs.add(cn)
371 end
372 for i in [arity..signature.closures.length[ do
373 realcargs.add("NULL")
374 end
375
376 v.nmc.break_value = old_bv
377
378 # Call
379 var e = compile_call(v, realcargs)
380 if e != null then
381 v.add_assignment(ve, e)
382 e = ve
383 end
384
385 # Intercept returns and breaks
386 for i in [0..arity[ do
387 # A break or a return is intercepted
388 v.add_instr("if ({closcns[i]}->has_broke != NULL) \{")
389 v.indent
390 # A passtrought break or a return is intercepted: go the the next closure
391 v.add_instr("if ({closcns[i]}->has_broke != &({ve})) \{")
392 v.indent
393 if v.cfc.closure == v.nmc then v.add_instr("closctx->has_broke = {closcns[i]}->has_broke; closctx->broke_value = {closcns[i]}->broke_value;")
394 v.add_instr("goto {v.nmc.return_label};")
395 v.unindent
396 # A direct break is interpected
397 if e != null then
398 # overwrite the returned value in a function
399 v.add_instr("\} else {ve} = {closcns[i]}->broke_value;")
400 else
401 # Do nothing in a procedure
402 v.add_instr("\}")
403 end
404 v.unindent
405 v.add_instr("\}")
406 end
407 return e
408 end
409
410 # Compile a call as constructor with given args
411 meth compile_constructor_call(v: CompilerVisitor, recvtype: MMType, cargs: Array[String]): String
412 do
413 return "NEW_{recvtype.local_class}_{global.intro.cname}({cargs.join(", ")}) /*new {recvtype}*/"
414 end
415
416 # Compile a call as call-next-method on self with given args
417 meth compile_super_call(v: CompilerVisitor, cargs: Array[String]): String
418 do
419 var m = "{super_meth_call}({cargs[0]})"
420 var vcall = "{m}({cargs.join(", ")}) /*super {local_class}::{name}*/"
421 return vcall
422 end
423
424 # Cname of the i-th closure C struct type
425 protected meth closure_cname(i: Int): String
426 do
427 return "FWBT_{cname}_{i}"
428 end
429 end
430
431 redef class MMAttribute
432 # Compile an acces on selffor a given reciever.
433 # Result is a valid C left-value for assigment
434 meth compile_access(v: CompilerVisitor, recv: String): String
435 do
436 return "{global.attr_access}({recv}) /*{local_class}::{name}*/"
437 end
438 end
439
440 redef class MMLocalProperty
441 # Compile the property as a C property
442 meth compile_property_to_c(v: CompilerVisitor) do end
443 end
444
445 redef class MMSrcMethod
446
447 # Compile and declare the signature to C
448 protected meth decl_csignature(v: CompilerVisitor, args: Array[String]): String
449 do
450 var params = new Array[String]
451 params.add("val_t {args[0]}")
452 for i in [0..signature.arity[ do
453 var p = "val_t {args[i+1]}"
454 params.add(p)
455 end
456
457 var first_closure_index = signature.arity + 1 # Wich parameter is the first closure
458 for i in [0..signature.closures.length[ do
459 var closcn = closure_cname(i)
460 var cs = signature.closures[i].signature # Closure signature
461 var subparams = new Array[String] # Parameters of the closure
462 subparams.add("struct WBT_ *")
463 for j in [0..cs.arity[ do
464 var p = "val_t"
465 subparams.add(p)
466 end
467 var r = "void"
468 if cs.return_type != null then r = "val_t"
469 params.add("struct WBT_ *{args[first_closure_index+i]}")
470 v.add_decl("typedef {r} (*{closcn})({subparams.join(", ")});")
471 end
472
473 if global.is_init then
474 params.add("int* init_table")
475 end
476
477 var ret: String
478 if signature.return_type != null then
479 ret = "val_t"
480 else
481 ret = "void"
482 end
483
484 var p = params.join(", ")
485 var s = "{ret} {cname}({p})"
486 v.add_decl("typedef {ret} (* {cname}_t)({p});")
487 v.add_decl(s + ";")
488 return s
489 end
490
491 redef meth compile_property_to_c(v)
492 do
493 v.cfc = new CFunctionContext(v)
494
495 var args = new Array[String]
496 args.add(" self")
497 for i in [0..signature.arity[ do
498 args.add(" param{i}")
499 end
500 for i in [0..signature.closures.length[ do
501 args.add(" wd{i}")
502 end
503 var cs = decl_csignature(v, args)
504 v.add_decl("#define LOCATE_{cname} \"{full_name}\"")
505
506 v.add_instr("{cs} \{")
507 v.indent
508 var ctx_old = v.ctx
509 v.ctx = new CContext
510
511 v.out_contexts.clear
512
513 var ln = 0
514 var s = self
515 if s.node != null then ln = s.node.line_number
516 v.add_decl("struct trace_t trace = \{NULL, NULL, {ln}, LOCATE_{cname}};")
517 v.add_instr("trace.prev = tracehead; tracehead = &trace;")
518 v.add_instr("trace.file = LOCATE_{module.name};")
519 var s = do_compile_inside(v, args)
520 v.add_instr("tracehead = trace.prev;")
521 if s == null then
522 v.add_instr("return;")
523 else
524 v.add_instr("return {s};")
525 end
526
527 v.cfc.generate_var_decls
528
529 ctx_old.append(v.ctx)
530 v.ctx = ctx_old
531 v.unindent
532 v.add_instr("}")
533
534 for ctx in v.out_contexts do v.ctx.merge(ctx)
535 end
536
537 # Compile the method body inline
538 meth do_compile_inside(v: CompilerVisitor, params: Array[String]): String is abstract
539 end
540
541 redef class MMReadImplementationMethod
542 redef meth do_compile_inside(v, params)
543 do
544 return node.prop.compile_access(v, params[0])
545 end
546 end
547
548 redef class MMWriteImplementationMethod
549 redef meth do_compile_inside(v, params)
550 do
551 v.add_assignment(node.prop.compile_access(v, params[0]), params[1])
552 return null
553 end
554 end
555
556 redef class MMMethSrcMethod
557 redef meth do_compile_inside(v, params)
558 do
559 return node.do_compile_inside(v, self, params)
560 end
561 end
562
563 redef class MMImplicitInit
564 redef meth do_compile_inside(v, params)
565 do
566 var f = params.length - unassigned_attributes.length
567 var recv = params.first
568 for sp in super_inits do
569 assert sp isa MMMethod
570 var args_recv = [recv]
571 if sp == super_init then
572 var args = new Array[String].with_capacity(f)
573 args.add(recv)
574 for i in [1..f[ do
575 args.add(params[i])
576 end
577 sp.compile_call(v, args)
578 else
579 sp.compile_call(v, args_recv)
580 end
581 end
582 for i in [f..params.length[ do
583 var attribute = unassigned_attributes[i-f]
584 v.add_assignment(attribute.compile_access(v, recv), params[i])
585 end
586 return null
587 end
588 end
589
590 redef class MMType
591 # Compile a subtype check to self
592 # Return a NIT Bool
593 meth compile_cast(v: CompilerVisitor, recv: String): String
594 do
595 # Fixme: handle formaltypes
596 var g = local_class.global
597 return "TAG_Bool(({recv}==NIT_NULL) || VAL_ISA({recv}, {g.color_id}, {g.id_id})) /*cast {self}*/"
598 end
599
600 # Compile a cast assertion
601 meth compile_type_check(v: CompilerVisitor, recv: String, n: PNode)
602 do
603 # Fixme: handle formaltypes
604 var g = local_class.global
605 v.add_instr("if (({recv}!=NIT_NULL) && !VAL_ISA({recv}, {g.color_id}, {g.id_id})) \{ fprintf(stderr, \"Cast failled\"); {v.printf_locate_error(n)} nit_exit(1); } /*cast {self}*/;")
606 end
607 end
608
609 ###############################################################################
610
611 redef class AMethPropdef
612 # Compile the method body
613 meth do_compile_inside(v: CompilerVisitor, method: MMSrcMethod, params: Array[String]): String is abstract
614 end
615
616 redef class PSignature
617 meth compile_parameters(v: CompilerVisitor, orig_sig: MMSignature, params: Array[String]) is abstract
618 end
619
620 redef class ASignature
621 redef meth compile_parameters(v: CompilerVisitor, orig_sig: MMSignature, params: Array[String])
622 do
623 for ap in n_params do
624 var cname = v.cfc.register_variable(ap.variable)
625 v.nmc.method_params.add(ap.variable)
626 var orig_type = orig_sig[ap.position]
627 if not orig_type < ap.variable.stype then
628 # FIXME: do not test always
629 # FIXME: handle formal types
630 v.add_instr("/* check if p<{ap.variable.stype} with p:{orig_type} */")
631 ap.variable.stype.compile_type_check(v, params[ap.position], ap)
632 end
633 v.add_assignment(cname, params[ap.position])
634 end
635 for i in [0..n_closure_decls.length[ do
636 var wd = n_closure_decls[i]
637 var cname = v.cfc.register_closurevariable(wd.variable)
638 wd.variable.ctypename = v.nmc.method.closure_cname(i)
639 v.add_assignment(cname, "{params[orig_sig.arity + i]}")
640 end
641 end
642 end
643
644 redef class AConcreteMethPropdef
645 redef meth do_compile_inside(v, method, params)
646 do
647 var old_nmc = v.nmc
648 v.nmc = new NitMethodContext(method)
649
650 var selfcname = v.cfc.register_variable(self_var)
651 v.add_assignment(selfcname, params[0])
652 params.shift
653 v.nmc.method_params = [self_var]
654
655 if n_signature != null then
656 var orig_meth: MMLocalProperty = method.global.intro
657 var orig_sig = orig_meth.signature_for(method.signature.recv)
658 n_signature.compile_parameters(v, orig_sig, params)
659 end
660
661 var itpos: String = null
662 if self isa AConcreteInitPropdef then
663 itpos = "VAL2OBJ({selfcname})->vft[{method.local_class.global.init_table_pos_id}].i"
664 # v.add_instr("printf(\"{method.full_name}: inittable[%d] = %d\\n\", {itpos}, init_table[{itpos}]);")
665 v.add_instr("if (init_table[{itpos}]) return;")
666 end
667
668 v.nmc.return_label = "return_label{v.new_number}"
669 v.nmc.return_value = v.cfc.get_var("Method return value and escape marker")
670 if self isa AConcreteInitPropdef then
671 v.invoke_super_init_calls_after(null)
672 end
673 if n_block != null then
674 v.compile_stmt(n_block)
675 end
676 v.add_instr("{v.nmc.return_label}: while(false);")
677 if self isa AConcreteInitPropdef then
678 v.add_instr("init_table[{itpos}] = 1;")
679 end
680
681 var ret: String = null
682 if method.signature.return_type != null then
683 ret = v.nmc.return_value
684 end
685
686 v.nmc = old_nmc
687 return ret
688 end
689 end
690
691 redef class ADeferredMethPropdef
692 redef meth do_compile_inside(v, method, params)
693 do
694 v.add_instr("fprintf(stderr, \"Deferred method called\");")
695 v.add_instr(v.printf_locate_error(self))
696 v.add_instr("nit_exit(1);")
697 if method.signature.return_type != null then
698 return("NIT_NULL")
699 else
700 return null
701 end
702 end
703 end
704
705 redef class AExternMethPropdef
706 redef meth do_compile_inside(v, method, params)
707 do
708 var ename = "{method.module.name}_{method.local_class.name}_{method.local_class.name}_{method.name}_{method.signature.arity}"
709 if n_extern != null then
710 ename = n_extern.text
711 ename = ename.substring(1, ename.length-2)
712 end
713 var sig = method.signature
714 if params.length != sig.arity + 1 then
715 printl("par:{params.length} sig:{sig.arity}")
716 end
717 var args = new Array[String]
718 args.add(sig.recv.unboxtype(params[0]))
719 for i in [0..sig.arity[ do
720 args.add(sig[i].unboxtype(params[i+1]))
721 end
722 var s = "{ename}({args.join(", ")})"
723 if sig.return_type != null then
724 return sig.return_type.boxtype(s)
725 else
726 v.add_instr("{s};")
727 return null
728 end
729 end
730 end
731
732 redef class AInternMethPropdef
733 redef meth do_compile_inside(v, method, p)
734 do
735 var c = method.local_class.name
736 var n = method.name
737 var s: String = null
738 if c == once "Int".to_symbol then
739 if n == once "object_id".to_symbol then
740 s = "{p[0]}"
741 else if n == once "unary -".to_symbol then
742 s = "TAG_Int(-UNTAG_Int({p[0]}))"
743 else if n == once "output".to_symbol then
744 v.add_instr("printf(\"%ld\\n\", UNTAG_Int({p[0]}));")
745 else if n == once "ascii".to_symbol then
746 s = "TAG_Char(UNTAG_Int({p[0]}))"
747 else if n == once "succ".to_symbol then
748 s = "TAG_Int(UNTAG_Int({p[0]})+1)"
749 else if n == once "prec".to_symbol then
750 s = "TAG_Int(UNTAG_Int({p[0]})-1)"
751 else if n == once "to_f".to_symbol then
752 s = "BOX_Float((float)UNTAG_Int({p[0]}))"
753 else if n == once "+".to_symbol then
754 s = "TAG_Int(UNTAG_Int({p[0]})+UNTAG_Int({p[1]}))"
755 else if n == once "-".to_symbol then
756 s = "TAG_Int(UNTAG_Int({p[0]})-UNTAG_Int({p[1]}))"
757 else if n == once "*".to_symbol then
758 s = "TAG_Int(UNTAG_Int({p[0]})*UNTAG_Int({p[1]}))"
759 else if n == once "/".to_symbol then
760 s = "TAG_Int(UNTAG_Int({p[0]})/UNTAG_Int({p[1]}))"
761 else if n == once "%".to_symbol then
762 s = "TAG_Int(UNTAG_Int({p[0]})%UNTAG_Int({p[1]}))"
763 else if n == once "<".to_symbol then
764 s = "TAG_Bool(UNTAG_Int({p[0]})<UNTAG_Int({p[1]}))"
765 else if n == once ">".to_symbol then
766 s = "TAG_Bool(UNTAG_Int({p[0]})>UNTAG_Int({p[1]}))"
767 else if n == once "<=".to_symbol then
768 s = "TAG_Bool(UNTAG_Int({p[0]})<=UNTAG_Int({p[1]}))"
769 else if n == once ">=".to_symbol then
770 s = "TAG_Bool(UNTAG_Int({p[0]})>=UNTAG_Int({p[1]}))"
771 else if n == once "lshift".to_symbol then
772 s = "TAG_Int(UNTAG_Int({p[0]})<<UNTAG_Int({p[1]}))"
773 else if n == once "rshift".to_symbol then
774 s = "TAG_Int(UNTAG_Int({p[0]})>>UNTAG_Int({p[1]}))"
775 else if n == once "==".to_symbol then
776 s = "TAG_Bool(({p[0]})==({p[1]}))"
777 else if n == once "!=".to_symbol then
778 s = "TAG_Bool(({p[0]})!=({p[1]}))"
779 end
780 else if c == once "Float".to_symbol then
781 if n == once "object_id".to_symbol then
782 s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
783 else if n == once "unary -".to_symbol then
784 s = "BOX_Float(-UNBOX_Float({p[0]}))"
785 else if n == once "output".to_symbol then
786 v.add_instr("printf(\"%f\\n\", UNBOX_Float({p[0]}));")
787 else if n == once "to_i".to_symbol then
788 s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
789 else if n == once "+".to_symbol then
790 s = "BOX_Float(UNBOX_Float({p[0]})+UNBOX_Float({p[1]}))"
791 else if n == once "-".to_symbol then
792 s = "BOX_Float(UNBOX_Float({p[0]})-UNBOX_Float({p[1]}))"
793 else if n == once "*".to_symbol then
794 s = "BOX_Float(UNBOX_Float({p[0]})*UNBOX_Float({p[1]}))"
795 else if n == once "/".to_symbol then
796 s = "BOX_Float(UNBOX_Float({p[0]})/UNBOX_Float({p[1]}))"
797 else if n == once "<".to_symbol then
798 s = "TAG_Bool(UNBOX_Float({p[0]})<UNBOX_Float({p[1]}))"
799 else if n == once ">".to_symbol then
800 s = "TAG_Bool(UNBOX_Float({p[0]})>UNBOX_Float({p[1]}))"
801 else if n == once "<=".to_symbol then
802 s = "TAG_Bool(UNBOX_Float({p[0]})<=UNBOX_Float({p[1]}))"
803 else if n == once ">=".to_symbol then
804 s = "TAG_Bool(UNBOX_Float({p[0]})>=UNBOX_Float({p[1]}))"
805 end
806 else if c == once "Char".to_symbol then
807 if n == once "object_id".to_symbol then
808 s = "TAG_Int(UNTAG_Char({p[0]}))"
809 else if n == once "unary -".to_symbol then
810 s = "TAG_Char(-UNTAG_Char({p[0]}))"
811 else if n == once "output".to_symbol then
812 v.add_instr("printf(\"%c\", (unsigned char)UNTAG_Char({p[0]}));")
813 else if n == once "ascii".to_symbol then
814 s = "TAG_Int((unsigned char)UNTAG_Char({p[0]}))"
815 else if n == once "succ".to_symbol then
816 s = "TAG_Char(UNTAG_Char({p[0]})+1)"
817 else if n == once "prec".to_symbol then
818 s = "TAG_Char(UNTAG_Char({p[0]})-1)"
819 else if n == once "to_i".to_symbol then
820 s = "TAG_Int(UNTAG_Char({p[0]})-'0')"
821 else if n == once "+".to_symbol then
822 s = "TAG_Char(UNTAG_Char({p[0]})+UNTAG_Char({p[1]}))"
823 else if n == once "-".to_symbol then
824 s = "TAG_Char(UNTAG_Char({p[0]})-UNTAG_Char({p[1]}))"
825 else if n == once "*".to_symbol then
826 s = "TAG_Char(UNTAG_Char({p[0]})*UNTAG_Char({p[1]}))"
827 else if n == once "/".to_symbol then
828 s = "TAG_Char(UNTAG_Char({p[0]})/UNTAG_Char({p[1]}))"
829 else if n == once "%".to_symbol then
830 s = "TAG_Char(UNTAG_Char({p[0]})%UNTAG_Char({p[1]}))"
831 else if n == once "<".to_symbol then
832 s = "TAG_Bool(UNTAG_Char({p[0]})<UNTAG_Char({p[1]}))"
833 else if n == once ">".to_symbol then
834 s = "TAG_Bool(UNTAG_Char({p[0]})>UNTAG_Char({p[1]}))"
835 else if n == once "<=".to_symbol then
836 s = "TAG_Bool(UNTAG_Char({p[0]})<=UNTAG_Char({p[1]}))"
837 else if n == once ">=".to_symbol then
838 s = "TAG_Bool(UNTAG_Char({p[0]})>=UNTAG_Char({p[1]}))"
839 else if n == once "==".to_symbol then
840 s = "TAG_Bool(({p[0]})==({p[1]}))"
841 else if n == once "!=".to_symbol then
842 s = "TAG_Bool(({p[0]})!=({p[1]}))"
843 end
844 else if c == once "Bool".to_symbol then
845 if n == once "object_id".to_symbol then
846 s = "TAG_Int(UNTAG_Bool({p[0]}))"
847 else if n == once "unary -".to_symbol then
848 s = "TAG_Bool(-UNTAG_Bool({p[0]}))"
849 else if n == once "output".to_symbol then
850 v.add_instr("(void)printf(UNTAG_Bool({p[0]})?\"true\\n\":\"false\\n\");")
851 else if n == once "ascii".to_symbol then
852 s = "TAG_Bool(UNTAG_Bool({p[0]}))"
853 else if n == once "to_i".to_symbol then
854 s = "TAG_Int(UNTAG_Bool({p[0]}))"
855 else if n == once "==".to_symbol then
856 s = "TAG_Bool(({p[0]})==({p[1]}))"
857 else if n == once "!=".to_symbol then
858 s = "TAG_Bool(({p[0]})!=({p[1]}))"
859 end
860 else if c == once "NativeArray".to_symbol then
861 if n == once "object_id".to_symbol then
862 s = "TAG_Int(UNBOX_NativeArray({p[0]}))"
863 else if n == once "[]".to_symbol then
864 s = "UNBOX_NativeArray({p[0]})[UNTAG_Int({p[1]})]"
865 else if n == once "[]=".to_symbol then
866 v.add_instr("UNBOX_NativeArray({p[0]})[UNTAG_Int({p[1]})]={p[2]};")
867 else if n == once "copy_to".to_symbol then
868 v.add_instr("(void)memcpy(UNBOX_NativeArray({p[1]}), UNBOX_NativeArray({p[0]}), UNTAG_Int({p[2]})*sizeof(val_t));")
869 end
870 else if c == once "NativeString".to_symbol then
871 if n == once "object_id".to_symbol then
872 s = "TAG_Int(UNBOX_NativeString({p[0]}))"
873 else if n == once "atoi".to_symbol then
874 s = "TAG_Int(atoi(UNBOX_NativeString({p[0]})))"
875 else if n == once "[]".to_symbol then
876 s = "TAG_Char(UNBOX_NativeString({p[0]})[UNTAG_Int({p[1]})])"
877 else if n == once "[]=".to_symbol then
878 v.add_instr("UNBOX_NativeString({p[0]})[UNTAG_Int({p[1]})]=UNTAG_Char({p[2]});")
879 else if n == once "copy_to".to_symbol then
880 v.add_instr("(void)memcpy(UNBOX_NativeString({p[1]})+UNTAG_Int({p[4]}), UNBOX_NativeString({p[0]})+UNTAG_Int({p[3]}), UNTAG_Int({p[2]}));")
881 end
882 else if n == once "object_id".to_symbol then
883 s = "TAG_Int((bigint){p[0]})"
884 else if n == once "sys".to_symbol then
885 s = "(G_sys)"
886 else if n == once "is_same_type".to_symbol then
887 s = "TAG_Bool((VAL2VFT({p[0]})==VAL2VFT({p[1]})))"
888 else if n == once "exit".to_symbol then
889 v.add_instr("exit(UNTAG_Int({p[1]}));")
890 else if n == once "calloc_array".to_symbol then
891 s = "BOX_NativeArray((val_t*)malloc((UNTAG_Int({p[1]}) * sizeof(val_t))))"
892 else if n == once "calloc_string".to_symbol then
893 s = "BOX_NativeString((char*)malloc((UNTAG_Int({p[1]}) * sizeof(char))))"
894
895 else
896 v.add_instr("fprintf(stderr, \"Intern {n}\\n\"); nit_exit(1);")
897 end
898 if method.signature.return_type != null and s == null then
899 s = "NIT_NULL /*stub*/"
900 end
901 return s
902 end
903 end
904
905 ###############################################################################
906
907 redef class PExpr
908 # Compile the node as an expression
909 # Only the visitor should call it
910 meth compile_expr(v: CompilerVisitor): String is abstract
911
912 # Prepare a call of node as a statement
913 # Only the visitor should call it
914 # It's used for local variable managment
915 meth prepare_compile_stmt(v: CompilerVisitor) do end
916
917 # Compile the node as a statement
918 # Only the visitor should call it
919 meth compile_stmt(v: CompilerVisitor) do printl("Error!")
920 end
921
922 redef class ABlockExpr
923 redef meth compile_stmt(v)
924 do
925 for n in n_expr do
926 v.compile_stmt(n)
927 end
928 end
929 end
930
931 redef class AVardeclExpr
932 redef meth prepare_compile_stmt(v)
933 do
934 v.cfc.register_variable(variable)
935 end
936
937 redef meth compile_stmt(v)
938 do
939 var cname = v.cfc.varname(variable)
940 if n_expr == null then
941 v.add_instr("/*{cname} is variable {variable.name}*/")
942 else
943 var e = v.compile_expr(n_expr)
944 v.add_assignment(cname, e)
945 end
946 end
947 end
948
949 redef class AReturnExpr
950 redef meth compile_stmt(v)
951 do
952 if n_expr != null then
953 var e = v.compile_expr(n_expr)
954 v.add_assignment(v.nmc.return_value, e)
955 end
956 if v.cfc.closure == v.nmc then v.add_instr("closctx->has_broke = &({v.nmc.return_value});")
957 v.add_instr("goto {v.nmc.return_label};")
958 end
959 end
960
961 redef class ABreakExpr
962 redef meth compile_stmt(v)
963 do
964 if n_expr != null then
965 var e = v.compile_expr(n_expr)
966 v.add_assignment(v.nmc.break_value, e)
967 end
968 if v.cfc.closure == v.nmc then v.add_instr("closctx->has_broke = &({v.nmc.break_value}); closctx->broke_value = *closctx->has_broke;")
969 v.add_instr("goto {v.nmc.break_label};")
970 end
971 end
972
973 redef class AContinueExpr
974 redef meth compile_stmt(v)
975 do
976 if n_expr != null then
977 var e = v.compile_expr(n_expr)
978 v.add_assignment(v.nmc.continue_value, e)
979 end
980 v.add_instr("goto {v.nmc.continue_label};")
981 end
982 end
983
984 redef class AAbortExpr
985 redef meth compile_stmt(v)
986 do
987 v.add_instr("fprintf(stderr, \"Aborted\"); {v.printf_locate_error(self)} nit_exit(1);")
988 end
989 end
990
991 redef class ADoExpr
992 redef meth compile_stmt(v)
993 do
994 if n_block != null then
995 v.compile_stmt(n_block)
996 end
997 end
998 end
999
1000 redef class AIfExpr
1001 redef meth compile_stmt(v)
1002 do
1003 var e = v.compile_expr(n_expr)
1004 v.add_instr("if (UNTAG_Bool({e})) \{ /*if*/")
1005 v.cfc.free_var(e)
1006 if n_then != null then
1007 v.indent
1008 v.compile_stmt(n_then)
1009 v.unindent
1010 end
1011 if n_else != null then
1012 v.add_instr("} else \{ /*if*/")
1013 v.indent
1014 v.compile_stmt(n_else)
1015 v.unindent
1016 end
1017 v.add_instr("}")
1018 end
1019 end
1020
1021 redef class AIfexprExpr
1022 redef meth compile_expr(v)
1023 do
1024 var e = v.compile_expr(n_expr)
1025 v.add_instr("if (UNTAG_Bool({e})) \{ /*if*/")
1026 v.cfc.free_var(e)
1027 v.indent
1028 var e = v.ensure_var(v.compile_expr(n_then), "Then value")
1029 v.unindent
1030 v.add_instr("} else \{ /*if*/")
1031 v.cfc.free_var(e)
1032 v.indent
1033 var e2 = v.ensure_var(v.compile_expr(n_else), "Else value")
1034 v.add_assignment(e, e2)
1035 v.unindent
1036 v.add_instr("}")
1037 return e
1038 end
1039 end
1040
1041 redef class AControlableBlock
1042 meth compile_inside_block(v: CompilerVisitor) is abstract
1043 redef meth compile_stmt(v)
1044 do
1045 var old_break_label = v.nmc.break_label
1046 var old_continue_label = v.nmc.continue_label
1047 var id = v.new_number
1048 v.nmc.break_label = "break_{id}"
1049 v.nmc.continue_label = "continue_{id}"
1050
1051 compile_inside_block(v)
1052
1053
1054 v.nmc.break_label = old_break_label
1055 v.nmc.continue_label = old_continue_label
1056 end
1057 end
1058
1059 redef class AWhileExpr
1060 redef meth compile_inside_block(v)
1061 do
1062 v.add_instr("while (true) \{ /*while*/")
1063 v.indent
1064 var e = v.compile_expr(n_expr)
1065 v.add_instr("if (!UNTAG_Bool({e})) break; /* while*/")
1066 v.cfc.free_var(e)
1067 if n_block != null then
1068 v.compile_stmt(n_block)
1069 end
1070 v.add_instr("{v.nmc.continue_label}: while(0);")
1071 v.unindent
1072 v.add_instr("}")
1073 v.add_instr("{v.nmc.break_label}: while(0);")
1074 end
1075 end
1076
1077 redef class AForExpr
1078 redef meth compile_inside_block(v)
1079 do
1080 var e = v.compile_expr(n_expr)
1081 var ittype = meth_iterator.signature.return_type
1082 v.cfc.free_var(e)
1083 var iter = v.cfc.get_var("For iterator")
1084 v.add_assignment(iter, meth_iterator.compile_call(v, [e]))
1085 v.add_instr("while (true) \{ /*for*/")
1086 v.indent
1087 var ok = v.cfc.get_var("For 'is_ok' result")
1088 v.add_assignment(ok, meth_is_ok.compile_call(v, [iter]))
1089 v.add_instr("if (!UNTAG_Bool({ok})) break; /*for*/")
1090 v.cfc.free_var(ok)
1091 var e = meth_item.compile_call(v, [iter])
1092 e = v.ensure_var(e, "For item")
1093 var cname = v.cfc.register_variable(variable)
1094 v.add_assignment(cname, e)
1095 var n_block = n_block
1096 if n_block != null then
1097 v.compile_stmt(n_block)
1098 end
1099 v.add_instr("{v.nmc.continue_label}: while(0);")
1100 e = meth_next.compile_call(v, [iter])
1101 assert e == null
1102 v.unindent
1103 v.add_instr("}")
1104 v.add_instr("{v.nmc.break_label}: while(0);")
1105 end
1106 end
1107
1108 redef class AAssertExpr
1109 redef meth compile_stmt(v)
1110 do
1111 var e = v.compile_expr(n_expr)
1112 var s = ""
1113 if n_id != null then
1114 s = " '{n_id.text}' "
1115 end
1116 v.add_instr("if (!UNTAG_Bool({e})) \{ fprintf(stderr, \"Assert%s failed\", \"{s}\"); {v.printf_locate_error(self)} nit_exit(1);}")
1117 end
1118 end
1119
1120 redef class AVarExpr
1121 redef meth compile_expr(v)
1122 do
1123 return " {v.cfc.varname(variable)} /*{variable.name}*/"
1124 end
1125 end
1126
1127 redef class AVarAssignExpr
1128 redef meth compile_stmt(v)
1129 do
1130 var e = v.compile_expr(n_value)
1131 v.add_assignment(v.cfc.varname(variable), "{e} /*{variable.name}=*/")
1132 end
1133 end
1134
1135 redef class AVarReassignExpr
1136 redef meth compile_stmt(v)
1137 do
1138 var e1 = v.cfc.varname(variable)
1139 var e2 = v.compile_expr(n_value)
1140 var e3 = assign_method.compile_call(v, [e1, e2])
1141 v.add_assignment(v.cfc.varname(variable), "{e3} /*{variable.name}*/")
1142 end
1143 end
1144
1145 redef class ASelfExpr
1146 redef meth compile_expr(v)
1147 do
1148 return v.cfc.varname(v.nmc.method_params[0])
1149 end
1150 end
1151
1152 redef class AOrExpr
1153 redef meth compile_expr(v)
1154 do
1155 var e = v.ensure_var(v.compile_expr(n_expr), "Left 'or' operand")
1156 v.add_instr("if (!UNTAG_Bool({e})) \{ /* or */")
1157 v.cfc.free_var(e)
1158 v.indent
1159 var e2 = v.compile_expr(n_expr2)
1160 v.add_assignment(e, e2)
1161 v.unindent
1162 v.add_instr("}")
1163 return e
1164 end
1165 end
1166
1167 redef class AAndExpr
1168 redef meth compile_expr(v)
1169 do
1170 var e = v.ensure_var(v.compile_expr(n_expr), "Left 'and' operand")
1171 v.add_instr("if (UNTAG_Bool({e})) \{ /* and */")
1172 v.cfc.free_var(e)
1173 v.indent
1174 var e2 = v.compile_expr(n_expr2)
1175 v.add_assignment(e, e2)
1176 v.unindent
1177 v.add_instr("}")
1178 return e
1179 end
1180 end
1181
1182 redef class ANotExpr
1183 redef meth compile_expr(v)
1184 do
1185 return " TAG_Bool(!UNTAG_Bool({v.compile_expr(n_expr)}))"
1186 end
1187 end
1188
1189 redef class AEeExpr
1190 redef meth compile_expr(v)
1191 do
1192 var e = v.compile_expr(n_expr)
1193 var e2 = v.compile_expr(n_expr2)
1194 return "TAG_Bool(IS_EQUAL_NN({e},{e2}))"
1195 end
1196 end
1197
1198 redef class AIsaExpr
1199 redef meth compile_expr(v)
1200 do
1201 var e = v.compile_expr(n_expr)
1202 return n_type.stype.compile_cast(v, e)
1203 end
1204 end
1205
1206 redef class AAsCastExpr
1207 redef meth compile_expr(v)
1208 do
1209 var e = v.compile_expr(n_expr)
1210 n_type.stype.compile_type_check(v, e, self)
1211 return e
1212 end
1213 end
1214
1215 redef class ATrueExpr
1216 redef meth compile_expr(v)
1217 do
1218 return " TAG_Bool(true)"
1219 end
1220 end
1221
1222 redef class AFalseExpr
1223 redef meth compile_expr(v)
1224 do
1225 return " TAG_Bool(false)"
1226 end
1227 end
1228
1229 redef class AIntExpr
1230 redef meth compile_expr(v)
1231 do
1232 return " TAG_Int({n_number.text})"
1233 end
1234 end
1235
1236 redef class AFloatExpr
1237 redef meth compile_expr(v)
1238 do
1239 return "BOX_Float({n_float.text})"
1240 end
1241 end
1242
1243 redef class ACharExpr
1244 redef meth compile_expr(v)
1245 do
1246 return " TAG_Char({n_char.text})"
1247 end
1248 end
1249
1250 redef class AStringFormExpr
1251 redef meth compile_expr(v)
1252 do
1253 compute_string_info
1254 var i = v.new_number
1255 var cvar = v.cfc.get_var("Once String constant")
1256 v.add_decl("static val_t once_value_{i} = NIT_NULL; /* Once value for string {cvar}*/")
1257 v.add_instr("if (once_value_{i} != NIT_NULL) {cvar} = once_value_{i};")
1258 v.add_instr("else \{")
1259 v.indent
1260 v.cfc.free_var(cvar)
1261 var e = meth_with_native.compile_constructor_call(v, stype , ["BOX_NativeString(\"{_cstring}\")", "TAG_Int({_cstring_length})"])
1262 v.add_assignment(cvar, e)
1263 v.add_instr("once_value_{i} = {cvar};")
1264 v.unindent
1265 v.add_instr("}")
1266 return cvar
1267 end
1268
1269 # The raw string value
1270 protected meth string_text: String is abstract
1271
1272 # The string in a C native format
1273 protected attr _cstring: String
1274
1275 # The string length in bytes
1276 protected attr _cstring_length: Int
1277
1278 # Compute _cstring and _cstring_length using string_text
1279 protected meth compute_string_info
1280 do
1281 var len = 0
1282 var str = string_text
1283 var res = new Buffer
1284 var i = 0
1285 while i < str.length do
1286 var c = str[i]
1287 if c == '\\' then
1288 i = i + 1
1289 var c2 = str[i]
1290 if c2 != '{' and c2 != '}' then
1291 res.add(c)
1292 end
1293 c = c2
1294 end
1295 len = len + 1
1296 res.add(c)
1297 i = i + 1
1298 end
1299 _cstring = res.to_s
1300 _cstring_length = len
1301 end
1302 end
1303
1304 redef class AStringExpr
1305 redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1306 end
1307 redef class AStartStringExpr
1308 redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1309 end
1310 redef class AMidStringExpr
1311 redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1312 end
1313 redef class AEndStringExpr
1314 redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1315 end
1316
1317 redef class ASuperstringExpr
1318 redef meth compile_expr(v)
1319 do
1320 var array = meth_with_capacity.compile_constructor_call(v, atype, ["TAG_Int({n_exprs.length})"])
1321 array = v.ensure_var(array, "Array (for super-string)")
1322
1323 for ne in n_exprs do
1324 var e = v.ensure_var(v.compile_expr(ne), "super-string element")
1325 if ne.stype != stype then
1326 v.cfc.free_var(e)
1327 e = meth_to_s.compile_call(v, [e])
1328 end
1329 v.cfc.free_var(e)
1330 meth_add.compile_call(v, [array, e])
1331 end
1332
1333 return meth_to_s.compile_call(v, [array])
1334 end
1335 end
1336
1337 redef class ANullExpr
1338 redef meth compile_expr(v)
1339 do
1340 return " NIT_NULL /*null*/"
1341 end
1342 end
1343
1344 redef class AArrayExpr
1345 redef meth compile_expr(v)
1346 do
1347 var recv = meth_with_capacity.compile_constructor_call(v, stype, ["TAG_Int({n_exprs.length})"])
1348 recv = v.ensure_var(recv, "Literal array")
1349
1350 for ne in n_exprs do
1351 var e = v.compile_expr(ne)
1352 meth_add.compile_call(v, [recv, e])
1353 end
1354 return recv
1355 end
1356 end
1357
1358 redef class ARangeExpr
1359 redef meth compile_expr(v)
1360 do
1361 var e = v.compile_expr(n_expr)
1362 var e2 = v.compile_expr(n_expr2)
1363 return meth_init.compile_constructor_call(v, stype, [e, e2])
1364 end
1365 end
1366
1367 redef class ASuperExpr
1368 redef meth compile_stmt(v)
1369 do
1370 var e = compile_expr(v)
1371 if e != null then v.add_instr("{e};")
1372 end
1373
1374 redef meth compile_expr(v)
1375 do
1376 var arity = v.nmc.method_params.length - 1
1377 if init_in_superclass != null then
1378 arity = init_in_superclass.signature.arity
1379 end
1380 var args = new Array[String].with_capacity(arity + 1)
1381 args.add(v.cfc.varname(v.nmc.method_params[0]))
1382 if n_args.length != arity then
1383 for i in [0..arity[ do
1384 args.add(v.cfc.varname(v.nmc.method_params[i + 1]))
1385 end
1386 else
1387 for na in n_args do
1388 args.add(v.compile_expr(na))
1389 end
1390 end
1391 #return "{prop.cname}({args.join(", ")}) /*super {prop.local_class}::{prop.name}*/"
1392 if init_in_superclass != null then
1393 return init_in_superclass.compile_call(v, args)
1394 else
1395 if prop.global.is_init then args.add("init_table")
1396 return prop.compile_super_call(v, args)
1397 end
1398 end
1399 end
1400
1401 redef class AAttrExpr
1402 redef meth compile_expr(v)
1403 do
1404 var e = v.compile_expr(n_expr)
1405 return prop.compile_access(v, e)
1406 end
1407 end
1408
1409 redef class AAttrAssignExpr
1410 redef meth compile_stmt(v)
1411 do
1412 var e = v.compile_expr(n_expr)
1413 var e2 = v.compile_expr(n_value)
1414 v.add_assignment(prop.compile_access(v, e), e2)
1415 end
1416 end
1417 redef class AAttrReassignExpr
1418 redef meth compile_stmt(v)
1419 do
1420 var e1 = v.compile_expr(n_expr)
1421 var e2 = prop.compile_access(v, e1)
1422 var e3 = v.compile_expr(n_value)
1423 var e4 = assign_method.compile_call(v, [e2, e3])
1424 v.add_assignment(e2, e4)
1425 end
1426 end
1427
1428 redef class ASendExpr
1429 redef meth compile_expr(v)
1430 do
1431 var recv = v.compile_expr(n_expr)
1432 var cargs = new Array[String]
1433 cargs.add(recv)
1434 for a in arguments do
1435 cargs.add(v.compile_expr(a))
1436 end
1437
1438 var e: String
1439 if prop_signature.closures.is_empty then
1440 e = prop.compile_call(v, cargs)
1441 else
1442 e = prop.compile_call_and_closures(v, cargs, closure_defs)
1443 end
1444
1445 if prop.global.is_init then
1446 v.invoke_super_init_calls_after(prop)
1447 end
1448 return e
1449 end
1450
1451 redef meth compile_stmt(v)
1452 do
1453 var e = compile_expr(v)
1454 if e != null then
1455 v.add_instr(e + ";")
1456 end
1457 end
1458 end
1459
1460 redef class ASendReassignExpr
1461 redef meth compile_expr(v)
1462 do
1463 var recv = v.compile_expr(n_expr)
1464 var cargs = new Array[String]
1465 cargs.add(recv)
1466 for a in arguments do
1467 cargs.add(v.compile_expr(a))
1468 end
1469
1470 var e2 = read_prop.compile_call(v, cargs)
1471 var e3 = v.compile_expr(n_value)
1472 var e4 = assign_method.compile_call(v, [e2, e3])
1473 cargs.add(e4)
1474 return prop.compile_call(v, cargs)
1475 end
1476 end
1477
1478 redef class ANewExpr
1479 redef meth compile_expr(v)
1480 do
1481 var cargs = new Array[String]
1482 for a in arguments do
1483 cargs.add(v.compile_expr(a))
1484 end
1485 return prop.compile_constructor_call(v, stype, cargs)
1486 end
1487 end
1488
1489 redef class PClosureDef
1490 # Compile the closure definition as a function in v.out_contexts
1491 # Return the cname of the function
1492 meth compile_closure(v: CompilerVisitor, closcn: String): String is abstract
1493
1494 # Compile the closure definition inside the current C function.
1495 meth do_compile_inside(v: CompilerVisitor, params: Array[String]): String is abstract
1496 end
1497
1498 redef class AClosureDef
1499 # The cname of the function
1500 readable attr _cname: String
1501
1502 redef meth compile_closure(v, closcn)
1503 do
1504 var ctx_old = v.ctx
1505 v.ctx = new CContext
1506 v.out_contexts.add(v.ctx)
1507
1508 var cfc_old = v.cfc.closure
1509 v.cfc.closure = v.nmc
1510
1511 var old_rv = v.nmc.return_value
1512 var old_bv = v.nmc.break_value
1513 if cfc_old == null then
1514 v.nmc.return_value = "closctx->{old_rv}"
1515 v.nmc.break_value = "closctx->{old_bv}"
1516 end
1517
1518 var cname = "OC_{v.nmc.method.cname}_{v.out_contexts.length}"
1519 _cname = cname
1520 var args = new Array[String]
1521 for i in [0..closure.signature.arity[ do
1522 args.add(" param{i}")
1523 end
1524
1525 var cs = decl_csignature(v, args, closcn)
1526
1527 v.add_instr("{cs} \{")
1528 v.indent
1529 var ctx_old2 = v.ctx
1530 v.ctx = new CContext
1531
1532 v.add_decl("struct trace_t trace = \{NULL, NULL, {line_number}, LOCATE_{v.nmc.method.cname}};")
1533 v.add_instr("trace.prev = tracehead; tracehead = &trace;")
1534
1535 v.add_instr("trace.file = LOCATE_{v.module.name};")
1536 var s = do_compile_inside(v, args)
1537
1538 v.add_instr("{v.nmc.return_label}:")
1539 v.add_instr("tracehead = trace.prev;")
1540 if s == null then
1541 v.add_instr("return;")
1542 else
1543 v.add_instr("return {s};")
1544 end
1545
1546 ctx_old2.append(v.ctx)
1547 v.ctx = ctx_old2
1548 v.unindent
1549 v.add_instr("}")
1550 v.ctx = ctx_old
1551
1552 v.cfc.closure = cfc_old
1553 v.nmc.return_value = old_rv
1554 v.nmc.break_value = old_bv
1555
1556 # Build closure
1557 var closcnv = "wbclos{v.new_number}"
1558 v.add_decl("struct WBT_ {closcnv};")
1559 v.add_instr("{closcnv}.fun = (fun_t){cname};")
1560 v.add_instr("{closcnv}.has_broke = NULL;")
1561 if cfc_old != null then
1562 v.add_instr("{closcnv}.variable = closctx->variable;")
1563 v.add_instr("{closcnv}.closurevariable = closctx->closurevariable;")
1564 else
1565 v.add_instr("{closcnv}.variable = variable;")
1566 v.add_instr("{closcnv}.closurevariable = closurevariable;")
1567 end
1568
1569 return "(&{closcnv})"
1570 end
1571
1572 protected meth decl_csignature(v: CompilerVisitor, args: Array[String], closcn: String): String
1573 do
1574 var params = new Array[String]
1575 params.add("struct WBT_ *closctx")
1576 for i in [0..closure.signature.arity[ do
1577 var p = "val_t {args[i]}"
1578 params.add(p)
1579 end
1580 var ret: String
1581 if closure.signature.return_type != null then
1582 ret = "val_t"
1583 else
1584 ret = "void"
1585 end
1586 var p = params.join(", ")
1587 var s = "{ret} {cname}({p})"
1588 v.add_decl("typedef {ret} (* {cname}_t)({p});")
1589 v.add_decl(s + ";")
1590 return s
1591 end
1592
1593 redef meth do_compile_inside(v, params)
1594 do
1595 for i in [0..variables.length[ do
1596 var vacname = v.cfc.register_variable(variables[i])
1597 v.add_assignment(vacname, params[i])
1598 end
1599
1600 var old_cv = v.nmc.continue_value
1601 var old_cl = v.nmc.continue_label
1602 var old_bl = v.nmc.break_label
1603
1604 v.nmc.continue_value = v.cfc.get_var("Continue value and escape marker")
1605 v.nmc.continue_label = "continue_label{v.new_number}"
1606 v.nmc.break_label = v.nmc.return_label
1607
1608 if n_expr != null then v.compile_stmt(n_expr)
1609
1610 v.add_instr("{v.nmc.continue_label}: while(false);")
1611
1612 var ret: String = null
1613 if closure.signature.return_type != null then ret = v.nmc.continue_value
1614
1615 v.nmc.continue_value = old_cv
1616 v.nmc.continue_label = old_cl
1617 v.nmc.break_label = old_bl
1618
1619 return ret
1620 end
1621 end
1622
1623 redef class PClosureDecl
1624 meth do_compile_inside(v: CompilerVisitor, params: Array[String]): String is abstract
1625 end
1626 redef class AClosureDecl
1627 redef meth do_compile_inside(v, params)
1628 do
1629 if n_signature != null then n_signature.compile_parameters(v, variable.closure.signature, params)
1630
1631 var old_cv = v.nmc.continue_value
1632 var old_cl = v.nmc.continue_label
1633 var old_bl = v.nmc.break_label
1634
1635 v.nmc.continue_value = v.cfc.get_var("Continue value and escape marker")
1636 v.nmc.continue_label = "continue_label{v.new_number}"
1637 v.nmc.break_label = v.nmc.return_label
1638
1639 if n_expr != null then v.compile_stmt(n_expr)
1640
1641 v.add_instr("{v.nmc.continue_label}: while(false);")
1642
1643 var ret: String = null
1644 if variable.closure.signature.return_type != null then ret = v.nmc.continue_value
1645
1646 v.nmc.continue_value = old_cv
1647 v.nmc.continue_label = old_cl
1648 v.nmc.break_label = old_bl
1649
1650 return ret
1651 end
1652 end
1653
1654 redef class AClosureCallExpr
1655 redef meth compile_expr(v)
1656 do
1657 var cargs = new Array[String]
1658 for a in arguments do cargs.add(v.compile_expr(a))
1659 var va: String = null
1660 if variable.closure.signature.return_type != null then va = v.cfc.get_var("Closure call result value")
1661
1662 if variable.closure.is_optional then
1663 v.add_instr("if({v.cfc.varname(variable)}==NULL) \{")
1664 v.indent
1665 var n = variable.decl
1666 assert n isa AClosureDecl
1667 var s = n.do_compile_inside(v, cargs)
1668 if s != null then v.add_assignment(va, s)
1669 v.unindent
1670 v.add_instr("} else \{")
1671 v.indent
1672 end
1673
1674 var ivar = v.cfc.varname(variable)
1675 var cargs2 = [ivar]
1676 cargs2.append(cargs)
1677 var s = "(({variable.ctypename})({ivar}->fun))({cargs2.join(", ")}) /* Invoke closure {variable} */"
1678 if va != null then
1679 v.add_assignment(va, s)
1680 else
1681 v.add_instr("{s};")
1682 end
1683 v.add_instr("if ({ivar}->has_broke) \{")
1684 v.indent
1685 if n_closure_defs != null and n_closure_defs.length == 1 then do
1686 n_closure_defs.first.do_compile_inside(v, null)
1687 end
1688 if v.cfc.closure == v.nmc then v.add_instr("if ({ivar}->has_broke) \{ closctx->has_broke = {ivar}->has_broke; closctx->broke_value = {ivar}->broke_value;\}")
1689 v.add_instr("goto {v.nmc.return_label};")
1690 v.unindent
1691 v.add_instr("\}")
1692
1693 if variable.closure.is_optional then
1694 v.unindent
1695 v.add_instr("\}")
1696 end
1697 return va
1698 end
1699 end
1700
1701 redef class AProxyExpr
1702 redef meth compile_expr(v)
1703 do
1704 return v.compile_expr(n_expr)
1705 end
1706 end
1707
1708 redef class AOnceExpr
1709 redef meth compile_expr(v)
1710 do
1711 var i = v.new_number
1712 var cvar = v.cfc.get_var("Once expression result")
1713 v.add_decl("static val_t once_value_{i}; static int once_bool_{i}; /* Once value for {cvar}*/")
1714 v.add_instr("if (once_bool_{i}) {cvar} = once_value_{i};")
1715 v.add_instr("else \{")
1716 v.indent
1717 v.cfc.free_var(cvar)
1718 var e = v.compile_expr(n_expr)
1719 v.add_assignment(cvar, e)
1720 v.add_instr("once_value_{i} = {cvar};")
1721 v.add_instr("once_bool_{i} = true;")
1722 v.unindent
1723 v.add_instr("}")
1724 return cvar
1725 end
1726 end
Nit language project; an oo programing language and its tool suite.