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                 n.prepare_compile_stmt(self)
  28                 var i = cfc._variable_index
  29                 n.compile_stmt(self)
  30                 cfc._variable_index = i
  31         end
  32
  33         # Compile is expression node
  34         meth compile_expr(n: PExpr): String
  35         do
  36                 var i = cfc._variable_index
  37                 var s = n.compile_expr(self)
  38                 cfc._variable_index = i
  39                 if s[0] == ' ' then
  40                         return s
  41                 end
  42                 var v = cfc.get_var
  43                 add_assignment(v, s)
  44                 return v
  45         end
  46
  47         # Ensure that a c expression is a var
  48         meth ensure_var(s: String): String
  49         do
  50                 if s.substring(0,3) == "variable" then
  51                         return s
  52                 end
  53                 var v = cfc.get_var
  54                 add_assignment(v, s)
  55                 return v
  56         end
  57
  58         # Add a assignment between a variable and an expression
  59         meth add_assignment(v: String, s: String)
  60         do
  61                 if v != s then
  62                         add_instr("{v} = {s};")
  63                 end
  64         end
  65
  66         readable writable attr _cfc: CFunctionContext
  67
  68         readable writable attr _nmc: NitMethodContext
  69
  70         # Generate an fprintf to display an error location
  71         meth printf_locate_error(node: PNode): String
  72         do
  73                 var s = "fprintf(stderr, \""
  74                 if nmc != null then s.append(" in %s")
  75                 s.append(" (%s:%d)\\n\", ")
  76                 if nmc != null then s.append("LOCATE_{nmc.method.cname}, ")
  77                 s.append("LOCATE_{module.name}, {node.line_number});")
  78                 return s
  79         end
  80
  81         redef init(module: MMSrcModule)
  82         do
  83                 super
  84         end
  85
  86         meth invoke_super_init_calls_after(start_prop: MMMethod)
  87         do
  88                 var n = nmc.method.node
  89                 assert n isa AConcreteInitPropdef
  90
  91                 if n.super_init_calls.is_empty then return
  92                 var i = 0
  93                 var j = 0
  94                 #var s = ""
  95                 if start_prop != null then
  96                         while n.super_init_calls[i] != start_prop do
  97                                 #s.append(" {n.super_init_calls[i]}")
  98                                 i += 1
  99                         end
 100                         i += 1
 101                         #s.append(" {start_prop}")
 102
 103                         while n.explicit_super_init_calls[j] != start_prop do
 104                                 j += 1
 105                         end
 106                         j += 1
 107                 end
 108                 var stop_prop: MMMethod = null
 109                 if j < n.explicit_super_init_calls.length then
 110                         stop_prop = n.explicit_super_init_calls[j]
 111                 end
 112                 var l = n.super_init_calls.length
 113                 #s.append(" [")
 114                 while i < l do
 115                         var p = n.super_init_calls[i]
 116                         if p == stop_prop then break
 117                         var cargs = new Array[String]
 118                         if p.signature.arity == 0 then
 119                                 cargs.add(cfc.varname(nmc.method_params[0]))
 120                         else
 121                                 for va in nmc.method_params do
 122                                         cargs.add(cfc.varname(va))
 123                                 end
 124                         end
 125                         #s.append(" {p}")
 126                         p.compile_call(self, cargs)
 127                         i += 1
 128                 end
 129                 #s.append(" ]")
 130                 #while i < l do
 131                 #       s.append(" {n.super_init_calls[i]}")
 132                 #       i += 1
 133                 #end
 134                 #if stop_prop != null then s.append(" (stop at {stop_prop})")
 135                 #n.printl("implicit calls in {n.method}: {s}")
 136         end
 137 end
 138
 139 # A C function currently written
 140 class CFunctionContext
 141         readable attr _visitor: CompilerVisitor
 142
 143         # Next available variable number
 144         attr _variable_index: Int = 0
 145
 146         # Total number of variable
 147         attr _variable_index_max: Int = 0
 148
 149         # Association between nit variable and the corrsponding c variable
 150         attr _varnames: Map[Variable, String] = new HashMap[Variable, String]
 151
 152         meth varname(v: Variable): String
 153         do
 154                 return _varnames[v]
 155         end
 156
 157         # Return the next available variable
 158         meth get_var: String
 159         do
 160                 var v = variable(_variable_index)
 161                 _variable_index = _variable_index + 1
 162                 if _variable_index > _variable_index_max then
 163                         _variable_index_max = _variable_index
 164                 end
 165                 return v
 166         end
 167
 168         meth register_variable(v: Variable): String
 169         do
 170                 var s = get_var
 171                 _varnames[v] = "variable[{_variable_index-1}]"
 172                 return s
 173         end
 174
 175         # Return the ith variable
 176         protected meth variable(i: Int): String
 177         do
 178                 return "variable[{i}]"
 179         end
 180
 181         # Mark the variable available
 182         meth free_var(v: String)
 183         do
 184                 # FIXME: So ugly..
 185                 if v == variable(_variable_index-1) then
 186                         _variable_index = _variable_index - 1
 187                 end
 188         end
 189
 190         # Generate the local variable declarations
 191         # To use at the end of the C function once all variables are known
 192         meth generate_var_decls
 193         do
 194                 if _variable_index_max > 0 then
 195                         visitor.add_decl("val_t variable[{_variable_index_max}];")
 196                 else
 197                         visitor.add_decl("val_t *variable = NULL;")
 198                 end
 199         end
 200
 201         init(v: CompilerVisitor) do _visitor = v
 202 end
 203
 204 # A Nit method currenlty compiled
 205 class NitMethodContext
 206         # Current method compiled
 207         readable attr _method: MMSrcMethod
 208
 209         # Is a "return" found in the method body
 210         readable writable attr _has_return: Bool = false
 211
 212         # Association between parameters and the corresponding variables
 213         readable writable attr _method_params: Array[ParamVariable]
 214
 215         # Where a nit return must branch
 216         readable writable attr _return_label: String
 217
 218         # Where a nit break must branch
 219         readable writable attr _break_label: String
 220
 221         # Where a nit continue must branch
 222         readable writable attr _continue_label: String
 223
 224         # Variable where a functionnal nit return must store its value
 225         readable writable attr _return_value: String
 226
 227         init(method: MMSrcMethod)
 228         do
 229                 _method = method
 230         end
 231 end
 232
 233 ###############################################################################
 234
 235 redef class MMMethod
 236         # Compile a call on self for given arguments
 237         # Most calls are compiled with a table access,
 238         # primitive calles are inlined
 239         # == and != are guarded and possibly inlined
 240         meth compile_call(v: CompilerVisitor, cargs: Array[String]): String
 241         do
 242                 var i = self
 243                 if i isa MMSrcMethod then
 244                         if i isa MMMethSrcMethod and i.node isa AInternMethPropdef or
 245                                 (i.local_class.name == (once "Array".to_symbol) and name == (once "[]".to_symbol))
 246                         then
 247                                 var e = i.do_compile_inside(v, cargs)
 248                                 return e
 249                         end
 250                 end
 251                 var ee = once "==".to_symbol
 252                 var ne = once "!=".to_symbol
 253                 if name == ne then
 254                         var eqp = signature.recv.local_class.select_method(ee)
 255                         var eqcall = eqp.compile_call(v, cargs)
 256                         return "TAG_Bool(!UNTAG_Bool({eqcall}))"
 257                 end
 258                 if global.is_init then
 259                         cargs = cargs.to_a
 260                         cargs.add("init_table /*YYY*/")
 261                 end
 262
 263                 var m = "(({cname}_t)CALL({cargs[0]},{global.color_id}))"
 264                 var vcall = "{m}({cargs.join(", ")}) /*{local_class}::{name}*/"
 265                 if name == ee then
 266                         vcall = "UNTAG_Bool({vcall})"
 267                         var obj = once "Object".to_symbol
 268                         if i.local_class.name == obj then
 269                                 vcall = "(({m}=={i.cname})?(IS_EQUAL_NN({cargs[0]},{cargs[1]})):({vcall}))"
 270                         end
 271                         vcall = "TAG_Bool(({cargs.first} == {cargs[1]}) || (({cargs.first} != NIT_NULL) && {vcall}))"
 272                 end
 273                 if signature.return_type != null then
 274                         return vcall
 275                 else
 276                         v.add_instr(vcall + ";")
 277                         return null
 278                 end
 279         end
 280
 281         # Compile a call as constructor with given args
 282         meth compile_constructor_call(v: CompilerVisitor, recvtype: MMType, cargs: Array[String]): String
 283         do
 284                 var recv = v.cfc.get_var
 285                 v.add_instr("{recv} = NEW_{recvtype.local_class}_{global.intro.cname}({cargs.join(", ")}); /*new {recvtype}*/")
 286                 return recv
 287         end
 288
 289         # Compile a call as call-next-method on self with given args
 290         meth compile_super_call(v: CompilerVisitor, cargs: Array[String]): String
 291         do
 292                 var m = "(({cname}_t)CALL({cargs[0]},{color_id_for_super}))"
 293                 var vcall = "{m}({cargs.join(", ")}) /*super {local_class}::{name}*/"
 294                 return vcall
 295         end
 296 end
 297
 298 redef class MMAttribute
 299         # Compile an acces on selffor a given reciever.
 300         # Result is a valid C left-value for assigment
 301         meth compile_access(v: CompilerVisitor, recv: String): String
 302         do
 303                 return "{global.attr_access}({recv}) /*{local_class}::{name}*/"
 304         end
 305 end
 306
 307 redef class MMLocalProperty
 308         # Compile the property as a C property
 309         meth compile_property_to_c(v: CompilerVisitor) do end
 310 end
 311
 312 redef class MMSrcMethod
 313         # Compile and declare the signature to C
 314         protected meth decl_csignature(v: CompilerVisitor, args: Array[String]): String
 315         do
 316                 var params = new Array[String]
 317                 params.add("val_t {args[0]}")
 318                 for i in [0..signature.arity[ do
 319                         var p = "val_t {args[i+1]}"
 320                         params.add(p)
 321                 end
 322                 if global.is_init then
 323                         params.add("int* init_table")
 324                 end
 325                 var ret: String
 326                 if signature.return_type != null then
 327                         ret = "val_t"
 328                 else
 329                         ret = "void"
 330                 end
 331                 var p = params.join(", ")
 332                 var s = "{ret} {cname}({p})"
 333                 v.add_decl("typedef {ret} (* {cname}_t)({p});")
 334                 v.add_decl(s + ";")
 335                 return s
 336         end
 337
 338         redef meth compile_property_to_c(v)
 339         do
 340                 v.cfc = new CFunctionContext(v)
 341
 342                 var args = new Array[String]
 343                 args.add(" self")
 344                 for i in [0..signature.arity[ do
 345                         args.add(" param{i}")
 346                 end
 347                 var cs = decl_csignature(v, args)
 348                 v.add_decl("#define LOCATE_{cname} \"{full_name}\"")
 349
 350                 v.add_instr("{cs} \{")
 351                 v.indent
 352                 var ctx_old = v.ctx
 353                 v.ctx = new CContext
 354
 355                 var ln = 0
 356                 var s = self
 357                 if s.node != null then ln = s.node.line_number
 358                 v.add_decl("struct trace_t trace = \{NULL, NULL, {ln}, LOCATE_{cname}};")
 359                 v.add_instr("trace.prev = tracehead; tracehead = &trace;")
 360                 v.add_instr("trace.file = LOCATE_{module.name};")
 361                 var s = do_compile_inside(v, args)
 362                 v.add_instr("tracehead = trace.prev;")
 363                 if s == null then
 364                         v.add_instr("return;")
 365                 else
 366                         v.add_instr("return {s};")
 367                 end
 368
 369                 v.cfc.generate_var_decls
 370
 371                 ctx_old.append(v.ctx)
 372                 v.ctx = ctx_old
 373                 v.unindent
 374                 v.add_instr("}")
 375         end
 376
 377         # Compile the method body inline
 378         meth do_compile_inside(v: CompilerVisitor, params: Array[String]): String is abstract
 379 end
 380
 381 redef class MMReadImplementationMethod
 382         redef meth do_compile_inside(v, params)
 383         do
 384                 return node.prop.compile_access(v, params[0])
 385         end
 386 end
 387
 388 redef class MMWriteImplementationMethod
 389         redef meth do_compile_inside(v, params)
 390         do
 391                 v.add_assignment(node.prop.compile_access(v, params[0]), params[1])
 392                 return null
 393         end
 394 end
 395
 396 redef class MMMethSrcMethod
 397         redef meth do_compile_inside(v, params)
 398         do
 399                 return node.do_compile_inside(v, self, params)
 400         end
 401 end
 402
 403 redef class MMImplicitInit
 404         redef meth do_compile_inside(v, params)
 405         do
 406                 var f = params.length - unassigned_attributes.length
 407                 var recv = params.first
 408                 for sp in super_inits do
 409                         assert sp isa MMMethod
 410                         var args_recv = [recv]
 411                         if sp == super_init then
 412                                 var args = new Array[String].with_capacity(f)
 413                                 args.add(recv)
 414                                 for i in [1..f[ do
 415                                         args.add(params[i])
 416                                 end
 417                                 sp.compile_call(v, args)
 418                         else
 419                                 sp.compile_call(v, args_recv)
 420                         end
 421                 end
 422                 for i in [f..params.length[ do
 423                         var attribute = unassigned_attributes[i-f]
 424                         v.add_assignment(attribute.compile_access(v, recv), params[i])
 425                 end
 426                 return null
 427         end
 428 end
 429
 430 redef class MMType
 431         # Compile a subtype check to self
 432         # Return a NIT Bool
 433         meth compile_cast(v: CompilerVisitor, recv: String): String
 434         do
 435                 # Fixme: handle formaltypes
 436                 var g = local_class.global
 437                 return "TAG_Bool(({recv}==NIT_NULL) || VAL_ISA({recv}, {g.color_id}, {g.id_id})) /*cast {self}*/"
 438         end
 439
 440         # Compile a cast assertion
 441         meth compile_type_check(v: CompilerVisitor, recv: String, n: PNode)
 442         do
 443                 # Fixme: handle formaltypes
 444                 var g = local_class.global
 445                 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}*/;")
 446         end
 447 end
 448
 449 ###############################################################################
 450
 451 redef class AMethPropdef
 452         # Compile the method body
 453         meth do_compile_inside(v: CompilerVisitor, method: MMSrcMethod, params: Array[String]): String is abstract
 454 end
 455
 456 redef class AConcreteMethPropdef
 457         redef meth do_compile_inside(v, method, params)
 458         do
 459                 var old_nmc = v.nmc
 460                 v.nmc = new NitMethodContext(method)
 461
 462                 var cname = v.cfc.register_variable(self_var)
 463                 v.add_assignment(cname, params[0])
 464                 v.nmc.method_params = [self_var]
 465
 466                 var orig_meth: MMLocalProperty = method.global.intro
 467                 var orig_sig = orig_meth.signature_for(method.signature.recv)
 468                 if n_signature != null then
 469                         var sig = n_signature
 470                         assert sig isa ASignature
 471                         for ap in sig.n_params do
 472                                 var cname = v.cfc.register_variable(ap.variable)
 473                                 v.nmc.method_params.add(ap.variable)
 474                                 var orig_type = orig_sig[ap.position]
 475                                 if not orig_type < ap.variable.stype then
 476                                         # FIXME: do not test always
 477                                         # FIXME: handle formal types
 478                                         v.add_instr("/* check if p<{ap.variable.stype} with p:{orig_type} */")
 479                                         ap.variable.stype.compile_type_check(v, params[ap.position + 1], ap)
 480                                 end
 481                                 v.add_assignment(cname, params[ap.position + 1])
 482                         end
 483                 end
 484
 485                 var itpos: String = null
 486                 if self isa AConcreteInitPropdef then
 487                         itpos = "VAL2OBJ({params[0]})->vft[{method.local_class.global.init_table_pos_id}].i"
 488                         # v.add_instr("printf(\"{method.full_name}: inittable[%d] = %d\\n\", {itpos}, init_table[{itpos}]);")
 489                         v.add_instr("if (init_table[{itpos}]) return;")
 490                 end
 491
 492                 v.nmc.return_label = "return_label{v.new_number}"
 493                 if method.signature.return_type != null then
 494                         v.nmc.return_value = v.cfc.get_var
 495                         v.cfc.free_var(v.nmc.return_value)
 496                 else
 497                         v.nmc.return_value = null
 498                 end
 499                 if self isa AConcreteInitPropdef then
 500                         v.invoke_super_init_calls_after(null)
 501                 end
 502                 if n_block != null then
 503                         v.compile_stmt(n_block)
 504                 end
 505                 if v.nmc.has_return then
 506                         v.add_instr("{v.nmc.return_label}: while(false);")
 507                 end
 508                 if self isa AConcreteInitPropdef then
 509                         v.add_instr("init_table[{itpos}] = 1;")
 510                 end
 511                 var ret = v.nmc.return_value
 512
 513                 v.nmc = old_nmc
 514                 return ret
 515         end
 516 end
 517
 518 redef class ADeferredMethPropdef
 519         redef meth do_compile_inside(v, method, params)
 520         do
 521                 v.add_instr("fprintf(stderr, \"Deferred method called\");")
 522                 v.add_instr(v.printf_locate_error(self))
 523                 v.add_instr("nit_exit(1);")
 524                 if method.signature.return_type != null then
 525                         return("NIT_NULL")
 526                 else
 527                         return null
 528                 end
 529         end
 530 end
 531
 532 redef class AExternMethPropdef
 533         redef meth do_compile_inside(v, method, params)
 534         do
 535                 var ename = "{method.module.name}_{method.local_class.name}_{method.local_class.name}_{method.name}_{method.signature.arity}"
 536                 if n_extern != null then
 537                         ename = n_extern.text
 538                         ename = ename.substring(1, ename.length-2)
 539                 end
 540                 var sig = method.signature
 541                 if params.length != sig.arity + 1 then
 542                         printl("par:{params.length} sig:{sig.arity}")
 543                 end
 544                 var args = new Array[String]
 545                 args.add(sig.recv.unboxtype(params[0]))
 546                 for i in [0..sig.arity[ do
 547                         args.add(sig[i].unboxtype(params[i+1]))
 548                 end
 549                 var s = "{ename}({args.join(", ")})"
 550                 if sig.return_type != null then
 551                         return sig.return_type.boxtype(s)
 552                 else
 553                         v.add_instr("{s};")
 554                         return null
 555                 end
 556         end
 557 end
 558
 559 redef class AInternMethPropdef
 560         redef meth do_compile_inside(v, method, p)
 561         do
 562                 var c = method.local_class.name
 563                 var n = method.name
 564                 var s: String = null
 565                 if c == once "Int".to_symbol then
 566                         if n == once "object_id".to_symbol then
 567                                 s = "{p[0]}"
 568                         else if n == once "unary -".to_symbol then
 569                                 s = "TAG_Int(-UNTAG_Int({p[0]}))"
 570                         else if n == once "output".to_symbol then
 571                                 v.add_instr("printf(\"%ld\\n\", UNTAG_Int({p[0]}));")
 572                         else if n == once "ascii".to_symbol then
 573                                 s = "TAG_Char(UNTAG_Int({p[0]}))"
 574                         else if n == once "succ".to_symbol then
 575                                 s = "TAG_Int(UNTAG_Int({p[0]})+1)"
 576                         else if n == once "prec".to_symbol then
 577                                 s = "TAG_Int(UNTAG_Int({p[0]})-1)"
 578                         else if n == once "to_f".to_symbol then
 579                                 s = "BOX_Float((float)UNTAG_Int({p[0]}))"
 580                         else if n == once "+".to_symbol then
 581                                 s = "TAG_Int(UNTAG_Int({p[0]})+UNTAG_Int({p[1]}))"
 582                         else if n == once "-".to_symbol then
 583                                 s = "TAG_Int(UNTAG_Int({p[0]})-UNTAG_Int({p[1]}))"
 584                         else if n == once "*".to_symbol then
 585                                 s = "TAG_Int(UNTAG_Int({p[0]})*UNTAG_Int({p[1]}))"
 586                         else if n == once "/".to_symbol then
 587                                 s = "TAG_Int(UNTAG_Int({p[0]})/UNTAG_Int({p[1]}))"
 588                         else if n == once "%".to_symbol then
 589                                 s = "TAG_Int(UNTAG_Int({p[0]})%UNTAG_Int({p[1]}))"
 590                         else if n == once "<".to_symbol then
 591                                 s = "TAG_Bool(UNTAG_Int({p[0]})<UNTAG_Int({p[1]}))"
 592                         else if n == once ">".to_symbol then
 593                                 s = "TAG_Bool(UNTAG_Int({p[0]})>UNTAG_Int({p[1]}))"
 594                         else if n == once "<=".to_symbol then
 595                                 s = "TAG_Bool(UNTAG_Int({p[0]})<=UNTAG_Int({p[1]}))"
 596                         else if n == once ">=".to_symbol then
 597                                 s = "TAG_Bool(UNTAG_Int({p[0]})>=UNTAG_Int({p[1]}))"
 598                         else if n == once "lshift".to_symbol then
 599                                 s = "TAG_Int(UNTAG_Int({p[0]})<<UNTAG_Int({p[1]}))"
 600                         else if n == once "rshift".to_symbol then
 601                                 s = "TAG_Int(UNTAG_Int({p[0]})>>UNTAG_Int({p[1]}))"
 602                         else if n == once "==".to_symbol then
 603                                 s = "TAG_Bool(({p[0]})==({p[1]}))"
 604                         else if n == once "!=".to_symbol then
 605                                 s = "TAG_Bool(({p[0]})!=({p[1]}))"
 606                         end
 607                 else if c == once "Float".to_symbol then
 608                         if n == once "object_id".to_symbol then
 609                                 s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
 610                         else if n == once "unary -".to_symbol then
 611                                 s = "BOX_Float(-UNBOX_Float({p[0]}))"
 612                         else if n == once "output".to_symbol then
 613                                 v.add_instr("printf(\"%f\\n\", UNBOX_Float({p[0]}));")
 614                         else if n == once "to_i".to_symbol then
 615                                 s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
 616                         else if n == once "+".to_symbol then
 617                                 s = "BOX_Float(UNBOX_Float({p[0]})+UNBOX_Float({p[1]}))"
 618                         else if n == once "-".to_symbol then
 619                                 s = "BOX_Float(UNBOX_Float({p[0]})-UNBOX_Float({p[1]}))"
 620                         else if n == once "*".to_symbol then
 621                                 s = "BOX_Float(UNBOX_Float({p[0]})*UNBOX_Float({p[1]}))"
 622                         else if n == once "/".to_symbol then
 623                                 s = "BOX_Float(UNBOX_Float({p[0]})/UNBOX_Float({p[1]}))"
 624                         else if n == once "<".to_symbol then
 625                                 s = "TAG_Bool(UNBOX_Float({p[0]})<UNBOX_Float({p[1]}))"
 626                         else if n == once ">".to_symbol then
 627                                 s = "TAG_Bool(UNBOX_Float({p[0]})>UNBOX_Float({p[1]}))"
 628                         else if n == once "<=".to_symbol then
 629                                 s = "TAG_Bool(UNBOX_Float({p[0]})<=UNBOX_Float({p[1]}))"
 630                         else if n == once ">=".to_symbol then
 631                                 s = "TAG_Bool(UNBOX_Float({p[0]})>=UNBOX_Float({p[1]}))"
 632                         end
 633                 else if c == once "Char".to_symbol then
 634                         if n == once "object_id".to_symbol then
 635                                 s = "TAG_Int(UNTAG_Char({p[0]}))"
 636                         else if n == once "unary -".to_symbol then
 637                                 s = "TAG_Char(-UNTAG_Char({p[0]}))"
 638                         else if n == once "output".to_symbol then
 639                                 v.add_instr("printf(\"%c\", (unsigned char)UNTAG_Char({p[0]}));")
 640                         else if n == once "ascii".to_symbol then
 641                                 s = "TAG_Int((unsigned char)UNTAG_Char({p[0]}))"
 642                         else if n == once "succ".to_symbol then
 643                                 s = "TAG_Char(UNTAG_Char({p[0]})+1)"
 644                         else if n == once "prec".to_symbol then
 645                                 s = "TAG_Char(UNTAG_Char({p[0]})-1)"
 646                         else if n == once "to_i".to_symbol then
 647                                 s = "TAG_Int(UNTAG_Char({p[0]})-'0')"
 648                         else if n == once "+".to_symbol then
 649                                 s = "TAG_Char(UNTAG_Char({p[0]})+UNTAG_Char({p[1]}))"
 650                         else if n == once "-".to_symbol then
 651                                 s = "TAG_Char(UNTAG_Char({p[0]})-UNTAG_Char({p[1]}))"
 652                         else if n == once "*".to_symbol then
 653                                 s = "TAG_Char(UNTAG_Char({p[0]})*UNTAG_Char({p[1]}))"
 654                         else if n == once "/".to_symbol then
 655                                 s = "TAG_Char(UNTAG_Char({p[0]})/UNTAG_Char({p[1]}))"
 656                         else if n == once "%".to_symbol then
 657                                 s = "TAG_Char(UNTAG_Char({p[0]})%UNTAG_Char({p[1]}))"
 658                         else if n == once "<".to_symbol then
 659                                 s = "TAG_Bool(UNTAG_Char({p[0]})<UNTAG_Char({p[1]}))"
 660                         else if n == once ">".to_symbol then
 661                                 s = "TAG_Bool(UNTAG_Char({p[0]})>UNTAG_Char({p[1]}))"
 662                         else if n == once "<=".to_symbol then
 663                                 s = "TAG_Bool(UNTAG_Char({p[0]})<=UNTAG_Char({p[1]}))"
 664                         else if n == once ">=".to_symbol then
 665                                 s = "TAG_Bool(UNTAG_Char({p[0]})>=UNTAG_Char({p[1]}))"
 666                         else if n == once "==".to_symbol then
 667                                 s = "TAG_Bool(({p[0]})==({p[1]}))"
 668                         else if n == once "!=".to_symbol then
 669                                 s = "TAG_Bool(({p[0]})!=({p[1]}))"
 670                         end
 671                 else if c == once "Bool".to_symbol then
 672                         if n == once "object_id".to_symbol then
 673                                 s = "TAG_Int(UNTAG_Bool({p[0]}))"
 674                         else if n == once "unary -".to_symbol then
 675                                 s = "TAG_Bool(-UNTAG_Bool({p[0]}))"
 676                         else if n == once "output".to_symbol then
 677                                 v.add_instr("(void)printf(UNTAG_Bool({p[0]})?\"true\\n\":\"false\\n\");")
 678                         else if n == once "ascii".to_symbol then
 679                                 s = "TAG_Bool(UNTAG_Bool({p[0]}))"
 680                         else if n == once "to_i".to_symbol then
 681                                 s = "TAG_Int(UNTAG_Bool({p[0]}))"
 682                         else if n == once "==".to_symbol then
 683                                 s = "TAG_Bool(({p[0]})==({p[1]}))"
 684                         else if n == once "!=".to_symbol then
 685                                 s = "TAG_Bool(({p[0]})!=({p[1]}))"
 686                         end
 687                 else if c == once "NativeArray".to_symbol then
 688                         if n == once "object_id".to_symbol then
 689                                 s = "TAG_Int(UNBOX_NativeArray({p[0]}))"
 690                         else if n == once "[]".to_symbol then
 691                                 s = "UNBOX_NativeArray({p[0]})[UNTAG_Int({p[1]})]"
 692                         else if n == once "[]=".to_symbol then
 693                                 v.add_instr("UNBOX_NativeArray({p[0]})[UNTAG_Int({p[1]})]={p[2]};")
 694                         else if n == once "copy_to".to_symbol then
 695                                 v.add_instr("(void)memcpy(UNBOX_NativeArray({p[1]}), UNBOX_NativeArray({p[0]}), UNTAG_Int({p[2]})*sizeof(val_t));")
 696                         end
 697                 else if c == once "NativeString".to_symbol then
 698                         if n == once "object_id".to_symbol then
 699                                 s = "TAG_Int(UNBOX_NativeString({p[0]}))"
 700                         else if n == once "atoi".to_symbol then
 701                                 s = "TAG_Int(atoi(UNBOX_NativeString({p[0]})))"
 702                         else if n == once "[]".to_symbol then
 703                                 s = "TAG_Char(UNBOX_NativeString({p[0]})[UNTAG_Int({p[1]})])"
 704                         else if n == once "[]=".to_symbol then
 705                                 v.add_instr("UNBOX_NativeString({p[0]})[UNTAG_Int({p[1]})]=UNTAG_Char({p[2]});")
 706                         else if n == once "copy_to".to_symbol then
 707                                 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]}));")
 708                         end
 709                 else if n == once "object_id".to_symbol then
 710                         s = "TAG_Int((bigint){p[0]})"
 711                 else if n == once "sys".to_symbol then
 712                         s = "(G_sys)"
 713                 else if n == once "is_same_type".to_symbol then
 714                         s = "TAG_Bool((VAL2VFT({p[0]})==VAL2VFT({p[1]})))"
 715                 else if n == once "exit".to_symbol then
 716                         v.add_instr("exit(UNTAG_Int({p[1]}));")
 717                 else if n == once "calloc_array".to_symbol then
 718                         s = "BOX_NativeArray((val_t*)malloc((UNTAG_Int({p[1]}) * sizeof(val_t))))"
 719                 else if n == once "calloc_string".to_symbol then
 720                         s = "BOX_NativeString((char*)malloc((UNTAG_Int({p[1]}) * sizeof(char))))"
 721
 722                 else
 723                         v.add_instr("fprintf(stderr, \"Intern {n}\\n\"); nit_exit(1);")
 724                 end
 725                 if method.signature.return_type != null and s == null then
 726                         s = "NIT_NULL /*stub*/"
 727                 end
 728                 return s
 729         end
 730 end
 731
 732 ###############################################################################
 733
 734 redef class PExpr
 735         # Compile the node as an expression
 736         # Only the visitor should call it
 737         meth compile_expr(v: CompilerVisitor): String is abstract
 738
 739         # Prepare a call of node as a statement
 740         # Only the visitor should call it
 741         # It's used for local variable managment
 742         meth prepare_compile_stmt(v: CompilerVisitor) do end
 743
 744         # Compile the node as a statement
 745         # Only the visitor should call it
 746         meth compile_stmt(v: CompilerVisitor) do printl("Error!")
 747 end
 748
 749 redef class ABlockExpr
 750         redef meth compile_stmt(v)
 751         do
 752                 for n in n_expr do
 753                         v.compile_stmt(n)
 754                 end
 755         end
 756 end
 757
 758 redef class AVardeclExpr
 759         redef meth prepare_compile_stmt(v)
 760         do
 761                 v.cfc.register_variable(variable)
 762         end
 763
 764         redef meth compile_stmt(v)
 765         do
 766                 var cname = v.cfc.varname(variable)
 767                 if n_expr == null then
 768                         var t = variable.stype
 769                         v.add_assignment(cname, "{t.default_cvalue} /*decl variable {variable.name}*/")
 770                 else
 771                         var e = v.compile_expr(n_expr)
 772                         v.add_assignment(cname, e)
 773                 end
 774         end
 775 end
 776
 777 redef class AReturnExpr
 778         redef meth compile_stmt(v)
 779         do
 780                 v.nmc.has_return = true
 781                 if n_expr != null then
 782                         var e = v.compile_expr(n_expr)
 783                         v.add_assignment(v.nmc.return_value, e)
 784                 end
 785                 v.add_instr("goto {v.nmc.return_label};")
 786         end
 787 end
 788
 789 redef class ABreakExpr
 790         redef meth compile_stmt(v)
 791         do
 792                 v.add_instr("goto {v.nmc.break_label};")
 793         end
 794 end
 795
 796 redef class AContinueExpr
 797         redef meth compile_stmt(v)
 798         do
 799                 v.add_instr("goto {v.nmc.continue_label};")
 800         end
 801 end
 802
 803 redef class AAbortExpr
 804         redef meth compile_stmt(v)
 805         do
 806                 v.add_instr("fprintf(stderr, \"Aborted\"); {v.printf_locate_error(self)} nit_exit(1);")
 807         end
 808 end
 809
 810 redef class ADoExpr
 811         redef meth compile_stmt(v)
 812         do
 813                  if n_block != null then
 814                          v.compile_stmt(n_block)
 815                  end
 816         end
 817 end
 818
 819 redef class AIfExpr
 820         redef meth compile_stmt(v)
 821         do
 822                 var e = v.compile_expr(n_expr)
 823                 v.add_instr("if (UNTAG_Bool({e})) \{ /*if*/")
 824                 v.cfc.free_var(e)
 825                 if n_then != null then
 826                         v.indent
 827                         v.compile_stmt(n_then)
 828                         v.unindent
 829                 end
 830                 if n_else != null then
 831                         v.add_instr("} else \{ /*if*/")
 832                         v.indent
 833                         v.compile_stmt(n_else)
 834                         v.unindent
 835                 end
 836                 v.add_instr("}")
 837         end
 838 end
 839
 840 redef class AIfexprExpr
 841         redef meth compile_expr(v)
 842         do
 843                 var e = v.compile_expr(n_expr)
 844                 v.add_instr("if (UNTAG_Bool({e})) \{ /*if*/")
 845                 v.cfc.free_var(e)
 846                 v.indent
 847                 var e = v.ensure_var(v.compile_expr(n_then))
 848                 v.unindent
 849                 v.add_instr("} else \{ /*if*/")
 850                 v.cfc.free_var(e)
 851                 v.indent
 852                 var e2 = v.ensure_var(v.compile_expr(n_else))
 853                 v.add_assignment(e, e2)
 854                 v.unindent
 855                 v.add_instr("}")
 856                 return e
 857         end
 858 end
 859
 860 redef class AControlableBlock
 861         meth compile_inside_block(v: CompilerVisitor) is abstract
 862         redef meth compile_stmt(v)
 863         do
 864                 var old_break_label = v.nmc.break_label
 865                 var old_continue_label = v.nmc.continue_label
 866                 var id = v.new_number
 867                 v.nmc.break_label = "break_{id}"
 868                 v.nmc.continue_label = "continue_{id}"
 869
 870                 compile_inside_block(v)
 871
 872
 873                 v.nmc.break_label = old_break_label
 874                 v.nmc.continue_label = old_continue_label
 875         end
 876 end
 877
 878 redef class AWhileExpr
 879         redef meth compile_inside_block(v)
 880         do
 881                 v.add_instr("while (true) \{ /*while*/")
 882                 v.indent
 883                 var e = v.compile_expr(n_expr)
 884                 v.add_instr("if (!UNTAG_Bool({e})) break; /* while*/")
 885                 v.cfc.free_var(e)
 886                 if n_block != null then
 887                         v.compile_stmt(n_block)
 888                 end
 889                 v.add_instr("{v.nmc.continue_label}: while(0);")
 890                 v.unindent
 891                 v.add_instr("}")
 892                 v.add_instr("{v.nmc.break_label}: while(0);")
 893         end
 894 end
 895
 896 redef class AForExpr
 897         redef meth compile_inside_block(v)
 898         do
 899                 v.compile_stmt(n_vardecl)
 900         end
 901 end
 902
 903 redef class AForVardeclExpr
 904         redef meth compile_stmt(v)
 905         do
 906                 var e = v.compile_expr(n_expr)
 907                 var prop = n_expr.stype.local_class.select_method(once "iterator".to_symbol)
 908                 if prop == null then
 909                         printl("No iterator")
 910                         return
 911                 end
 912                 var ittype = prop.signature.return_type
 913                 v.cfc.free_var(e)
 914                 var iter = v.cfc.get_var
 915                 v.add_assignment(iter, prop.compile_call(v, [e]))
 916                 var prop2 = ittype.local_class.select_method(once "is_ok".to_symbol)
 917                 if prop2 == null then
 918                         printl("No is_ok")
 919                         return
 920                 end
 921                 var prop3 = ittype.local_class.select_method(once "item".to_symbol)
 922                 if prop3 == null then
 923                         printl("No item")
 924                         return
 925                 end
 926                 var prop4 = ittype.local_class.select_method(once "next".to_symbol)
 927                 if prop4 == null then
 928                         printl("No next")
 929                         return
 930                 end
 931                 v.add_instr("while (true) \{ /*for*/")
 932                 v.indent
 933                 var ok = v.cfc.get_var
 934                 v.add_assignment(ok, prop2.compile_call(v, [iter]))
 935                 v.add_instr("if (!UNTAG_Bool({ok})) break; /*for*/")
 936                 v.cfc.free_var(ok)
 937                 var e = prop3.compile_call(v, [iter])
 938                 e = v.ensure_var(e)
 939                 var cname = v.cfc.register_variable(variable)
 940                 v.add_assignment(cname, e)
 941                 var par = parent
 942                 assert par isa AForExpr
 943                 var n_block = par.n_block
 944                 if n_block != null then
 945                         v.compile_stmt(n_block)
 946                 end
 947                 v.add_instr("{v.nmc.continue_label}: while(0);")
 948                 e = prop4.compile_call(v, [iter])
 949                 assert e == null
 950                 v.unindent
 951                 v.add_instr("}")
 952                 v.add_instr("{v.nmc.break_label}: while(0);")
 953         end
 954 end
 955
 956 redef class AAssertExpr
 957         redef meth compile_stmt(v)
 958         do
 959                 var e = v.compile_expr(n_expr)
 960                 var s = ""
 961                 if n_id != null then
 962                         s = " '{n_id.text}' "
 963                 end
 964                 v.add_instr("if (!UNTAG_Bool({e})) \{ fprintf(stderr, \"Assert%s failed\", \"{s}\"); {v.printf_locate_error(self)} nit_exit(1);}")
 965         end
 966 end
 967
 968 redef class AVarExpr
 969         redef meth compile_expr(v)
 970         do
 971                 return " {v.cfc.varname(variable)} /*{variable.name}*/"
 972         end
 973 end
 974
 975 redef class AVarAssignExpr
 976         redef meth compile_stmt(v)
 977         do
 978                 var e = v.compile_expr(n_value)
 979                 v.add_assignment(v.cfc.varname(variable), "{e} /*{variable.name}=*/")
 980         end
 981 end
 982
 983 redef class AVarReassignExpr
 984         redef meth compile_stmt(v)
 985         do
 986                 var e1 = v.cfc.varname(variable)
 987                 var e2 = v.compile_expr(n_value)
 988                 var e3 = assign_method.compile_call(v, [e1, e2])
 989                 v.add_assignment(v.cfc.varname(variable), "{e3} /*{variable.name}*/")
 990         end
 991 end
 992
 993 redef class ASelfExpr
 994         redef meth compile_expr(v)
 995         do
 996                 return v.cfc.varname(v.nmc.method_params[0])
 997         end
 998 end
 999
1000 redef class AOrExpr
1001         redef meth compile_expr(v)
1002         do
1003                 var e = v.ensure_var(v.compile_expr(n_expr))
1004                 v.add_instr("if (!UNTAG_Bool({e})) \{ /* or */")
1005                 v.cfc.free_var(e)
1006                 v.indent
1007                 var e2 = v.compile_expr(n_expr2)
1008                 v.add_assignment(e, e2)
1009                 v.unindent
1010                 v.add_instr("}")
1011                 return e
1012         end
1013 end
1014
1015 redef class AAndExpr
1016         redef meth compile_expr(v)
1017         do
1018                 var e = v.ensure_var(v.compile_expr(n_expr))
1019                 v.add_instr("if (UNTAG_Bool({e})) \{ /* and */")
1020                 v.cfc.free_var(e)
1021                 v.indent
1022                 var e2 = v.compile_expr(n_expr2)
1023                 v.add_assignment(e, e2)
1024                 v.unindent
1025                 v.add_instr("}")
1026                 return e
1027         end
1028 end
1029
1030 redef class ANotExpr
1031         redef meth compile_expr(v)
1032         do
1033                 return " TAG_Bool(!UNTAG_Bool({v.compile_expr(n_expr)}))"
1034         end
1035 end
1036
1037 redef class AEeExpr
1038         redef meth compile_expr(v)
1039         do
1040                 var e = v.compile_expr(n_expr)
1041                 var e2 = v.compile_expr(n_expr2)
1042                 return "TAG_Bool(IS_EQUAL_NN({e},{e2}))"
1043         end
1044 end
1045
1046 redef class AIsaExpr
1047         redef meth compile_expr(v)
1048         do
1049                 var e = v.compile_expr(n_expr)
1050                 return n_type.stype.compile_cast(v, e)
1051         end
1052 end
1053
1054 redef class AAsCastExpr
1055         redef meth compile_expr(v)
1056         do
1057                 var e = v.compile_expr(n_expr)
1058                 n_type.stype.compile_type_check(v, e, self)
1059                 return e
1060         end
1061 end
1062
1063 redef class ATrueExpr
1064         redef meth compile_expr(v)
1065         do
1066                 return " TAG_Bool(true)"
1067         end
1068 end
1069
1070 redef class AFalseExpr
1071         redef meth compile_expr(v)
1072         do
1073                 return " TAG_Bool(false)"
1074         end
1075 end
1076
1077 redef class AIntExpr
1078         redef meth compile_expr(v)
1079         do
1080                 return " TAG_Int({n_number.text})"
1081         end
1082 end
1083
1084 redef class AFloatExpr
1085         redef meth compile_expr(v)
1086         do
1087                 return "BOX_Float({n_float.text})"
1088         end
1089 end
1090
1091 redef class ACharExpr
1092         redef meth compile_expr(v)
1093         do
1094                 return " TAG_Char({n_char.text})"
1095         end
1096 end
1097
1098 redef class AStringFormExpr
1099         redef meth compile_expr(v)
1100         do
1101                 var prop = stype.local_class.select_method(once "with_native".to_symbol)
1102                 compute_string_info
1103                 return prop.compile_constructor_call(v, stype , ["BOX_NativeString(\"{_cstring}\")", "TAG_Int({_cstring_length})"])
1104         end
1105
1106         # The raw string value
1107         protected meth string_text: String is abstract
1108
1109         # The string in a C native format
1110         protected attr _cstring: String
1111
1112         # The string length in bytes
1113         protected attr _cstring_length: Int
1114
1115         # Compute _cstring and _cstring_length using string_text
1116         protected meth compute_string_info
1117         do
1118                 var len = 0
1119                 var str = string_text
1120                 var res = new String
1121                 var i = 0
1122                 while i < str.length do
1123                         var c = str[i]
1124                         if c == '\\' then
1125                                 i = i + 1
1126                                 var c2 = str[i]
1127                                 if c2 != '{' and c2 != '}' then
1128                                         res.add(c)
1129                                 end
1130                                 c = c2
1131                         end
1132                         len = len + 1
1133                         res.add(c)
1134                         i = i + 1
1135                 end
1136                 _cstring = res
1137                 _cstring_length = len
1138         end
1139 end
1140
1141 redef class AStringExpr
1142         redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1143 end
1144 redef class AStartStringExpr
1145         redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1146 end
1147 redef class AMidStringExpr
1148         redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1149 end
1150 redef class AEndStringExpr
1151         redef meth string_text do return n_string.text.substring(1, n_string.text.length - 2)
1152 end
1153
1154 redef class ASuperstringExpr
1155         redef meth compile_expr(v)
1156         do
1157                 var prop = stype.local_class.select_method(once "init".to_symbol)
1158                 var recv = prop.compile_constructor_call(v, stype, new Array[String])
1159
1160                 var prop2 = stype.local_class.select_method(once "append".to_symbol)
1161
1162                 var prop3 = stype.local_class.select_method(once "to_s".to_symbol)
1163                 for ne in n_exprs do
1164                         var e = v.ensure_var(v.compile_expr(ne))
1165                         if ne.stype != stype then
1166                                 v.add_assignment(e, prop3.compile_call(v, [e]))
1167                         end
1168                         prop2.compile_call(v, [recv, e])
1169                 end
1170
1171                 return recv
1172         end
1173 end
1174
1175 redef class ANullExpr
1176         redef meth compile_expr(v)
1177         do
1178                 return " NIT_NULL /*null*/"
1179         end
1180 end
1181
1182 redef class AArrayExpr
1183         redef meth compile_expr(v)
1184         do
1185                 var prop = stype.local_class.select_method(once "with_capacity".to_symbol)
1186                 var recv = prop.compile_constructor_call(v, stype, ["TAG_Int({n_exprs.length})"])
1187
1188                 var prop2 = stype.local_class.select_method(once "add".to_symbol)
1189                 for ne in n_exprs do
1190                         var e = v.compile_expr(ne)
1191                         prop2.compile_call(v, [recv, e])
1192                 end
1193                 return recv
1194         end
1195 end
1196
1197 redef class ARangeExpr
1198         redef meth compile_expr(v)
1199         do
1200                 var prop = stype.local_class.select_method(propname)
1201                 var e = v.compile_expr(n_expr)
1202                 var e2 = v.compile_expr(n_expr2)
1203                 return prop.compile_constructor_call(v, stype, [e, e2])
1204         end
1205         # The constructor that must be used for the range
1206         protected meth propname: Symbol is abstract
1207 end
1208
1209 redef class ACrangeExpr
1210         redef meth propname do return once "init".to_symbol
1211 end
1212 redef class AOrangeExpr
1213         redef meth propname do return once "without_last".to_symbol
1214 end
1215
1216 redef class ASuperExpr
1217         redef meth compile_stmt(v)
1218         do
1219                 var e = compile_expr(v)
1220                 if e != null then v.add_instr("{e};")
1221         end
1222
1223         redef meth compile_expr(v)
1224         do
1225                 var arity = v.nmc.method_params.length - 1
1226                 if init_in_superclass != null then
1227                         arity = init_in_superclass.signature.arity
1228                 end
1229                 var args = new Array[String].with_capacity(arity + 1)
1230                 args.add(v.cfc.varname(v.nmc.method_params[0]))
1231                 if n_args.length != arity then
1232                         for i in [0..arity[ do
1233                                 args.add(v.cfc.varname(v.nmc.method_params[i + 1]))
1234                         end
1235                 else
1236                         for na in n_args do
1237                                 args.add(v.compile_expr(na))
1238                         end
1239                 end
1240                 #return "{prop.cname}({args.join(", ")}) /*super {prop.local_class}::{prop.name}*/"
1241                 if init_in_superclass != null then
1242                         return init_in_superclass.compile_call(v, args)
1243                 else
1244                         if prop.global.is_init then args.add("init_table")
1245                         return prop.compile_super_call(v, args)
1246                 end
1247         end
1248 end
1249
1250 redef class AAttrExpr
1251         redef meth compile_expr(v)
1252         do
1253                 var e = v.compile_expr(n_expr)
1254                 return prop.compile_access(v, e)
1255         end
1256 end
1257
1258 redef class AAttrAssignExpr
1259         redef meth compile_stmt(v)
1260         do
1261                 var e = v.compile_expr(n_expr)
1262                 var e2 = v.compile_expr(n_value)
1263                 v.add_assignment(prop.compile_access(v, e), e2)
1264         end
1265 end
1266 redef class AAttrReassignExpr
1267         redef meth compile_stmt(v)
1268         do
1269                 var e1 = v.compile_expr(n_expr)
1270                 var e2 = prop.compile_access(v, e1)
1271                 var e3 = v.compile_expr(n_value)
1272                 var e4 = assign_method.compile_call(v, [e2, e3])
1273                 v.add_assignment(e2, e4)
1274         end
1275 end
1276
1277 redef class ASendExpr
1278         redef meth compile_expr(v)
1279         do
1280                 var recv = v.compile_expr(n_expr)
1281                 var cargs = new Array[String]
1282                 cargs.add(recv)
1283                 for a in arguments do
1284                         cargs.add(v.compile_expr(a))
1285                 end
1286
1287                 var e = prop.compile_call(v, cargs)
1288                 if prop.global.is_init then
1289                         v.invoke_super_init_calls_after(prop)
1290                 end
1291                 return e
1292         end
1293
1294         redef meth compile_stmt(v)
1295         do
1296                 var e = compile_expr(v)
1297                 if e != null then
1298                         v.add_instr(e + ";")
1299                 end
1300         end
1301 end
1302
1303 redef class ASendReassignExpr
1304         redef meth compile_expr(v)
1305         do
1306                 var recv = v.compile_expr(n_expr)
1307                 var cargs = new Array[String]
1308                 cargs.add(recv)
1309                 for a in arguments do
1310                         cargs.add(v.compile_expr(a))
1311                 end
1312
1313                 var e2 = read_prop.compile_call(v, cargs)
1314                 var e3 = v.compile_expr(n_value)
1315                 var e4 = assign_method.compile_call(v, [e2, e3])
1316                 cargs.add(e4)
1317                 return prop.compile_call(v, cargs)
1318         end
1319 end
1320
1321 redef class ANewExpr
1322         redef meth compile_expr(v)
1323         do
1324                 var cargs = new Array[String]
1325                 for a in arguments do
1326                         cargs.add(v.compile_expr(a))
1327                 end
1328                 return prop.compile_constructor_call(v, stype, cargs)
1329         end
1330 end
1331
1332 redef class AProxyExpr
1333         redef meth compile_expr(v)
1334         do
1335                 return v.compile_expr(n_expr)
1336         end
1337 end
1338
1339 redef class AOnceExpr
1340         redef meth compile_expr(v)
1341         do
1342                 var i = v.new_number
1343                 var cvar = v.cfc.get_var
1344                 v.add_decl("static val_t once_value_{i}; static int once_bool_{i}; /* Once value for {cvar}*/")
1345                 v.add_instr("if (once_bool_{i}) {cvar} = once_value_{i};")
1346                 v.add_instr("else \{")
1347                 v.indent
1348                 v.cfc.free_var(cvar)
1349                 var e = v.compile_expr(n_expr)
1350                 v.add_assignment(cvar, e)
1351                 v.add_instr("once_value_{i} = {cvar};")
1352                 v.add_instr("once_bool_{i} = true;")
1353                 v.unindent
1354                 v.add_instr("}")
1355                 return cvar
1356         end
1357 end