X-Git-Url: http://nitlanguage.org diff --git a/src/interpreter/naive_interpreter.nit b/src/interpreter/naive_interpreter.nit index c8fc863..bbdb30c 100644 --- a/src/interpreter/naive_interpreter.nit +++ b/src/interpreter/naive_interpreter.nit @@ -21,11 +21,12 @@ import literal import semantize private import parser::tables import mixin -import primitive_types +private import model::serialize_model +private import frontend::explain_assert_api redef class ToolContext # --discover-call-trace - var opt_discover_call_trace = new OptionBool("Trace calls of the first invocation of a method", "--discover-call-trace") + var opt_discover_call_trace = new OptionBool("Trace calls of the first invocation of methods", "--discover-call-trace") redef init do @@ -60,7 +61,7 @@ class NaiveInterpreter var modelbuilder: ModelBuilder # The main module of the program (used to lookup method) - var mainmodule: MModule + var mainmodule: MModule is writable # The command line arguments of the interpreted program # arguments.first is the program name @@ -70,6 +71,9 @@ class NaiveInterpreter # The main Sys instance var mainobj: nullable Instance is noinit + # Name of all supported functional names + var routine_types: Set[String] = new HashSet[String] + init do if mainmodule.model.get_mclasses_by_name("Bool") != null then @@ -79,6 +83,15 @@ class NaiveInterpreter init_instance_primitive(self.false_instance) end self.null_instance = new PrimitiveInstance[nullable Object](mainmodule.model.null_type, null) + + routine_types.add("RoutineRef") + for name in ["Proc", "Fun", "ProcRef", "FunRef"] do + # 20 is a magic number = upper limit of the arity of each functional class. + # i.e. Proc0, Proc1, ... Proc19 + for i in [0..20[ do + routine_types.add("{name}{i}") + end + end end # Starts the interpreter on the main module of a program @@ -113,17 +126,19 @@ class NaiveInterpreter return self.modelbuilder.force_get_primitive_method(current_node, name, recv.mclass, self.mainmodule) end - # Is a return executed? - # Set this mark to skip the evaluation until the end of the specified method frame - var returnmark: nullable FRAME = null - - # Is a break or a continue executed? + # Is a return, a break or a continue executed? # Set this mark to skip the evaluation until a labeled statement catch it with `is_escape` var escapemark: nullable EscapeMark = null + # The count of `catch` blocs that have been encountered and can catch an abort + var catch_count = 0 is writable + + # The last error thrown on abort/runtime error where catch_count > 0 + var last_error: nullable FatalError = null + # Is a return or a break or a continue executed? # Use this function to know if you must skip the evaluation of statements - fun is_escaping: Bool do return returnmark != null or escapemark != null + fun is_escaping: Bool do return escapemark != null # The value associated with the current return/break/continue, if any. # Set the value when you set a escapemark. @@ -157,7 +172,7 @@ class NaiveInterpreter n.debug("inconsitance: no value and not escaping.") end var implicit_cast_to = n.implicit_cast_to - if implicit_cast_to != null then + if i != null and implicit_cast_to != null then var mtype = self.unanchor_type(implicit_cast_to) if not self.is_subtype(i.mtype, mtype) then n.fatal(self, "Cast failed. Expected `{implicit_cast_to}`, got `{i.mtype}`") end @@ -216,6 +231,51 @@ class NaiveInterpreter return instance end + # Return the int8 instance associated with `val`. + fun int8_instance(val: Int8): Instance + do + var t = mainmodule.int8_type + var instance = new PrimitiveInstance[Int8](t, val) + init_instance_primitive(instance) + return instance + end + + # Return the int16 instance associated with `val`. + fun int16_instance(val: Int16): Instance + do + var t = mainmodule.int16_type + var instance = new PrimitiveInstance[Int16](t, val) + init_instance_primitive(instance) + return instance + end + + # Return the uint16 instance associated with `val`. + fun uint16_instance(val: UInt16): Instance + do + var t = mainmodule.uint16_type + var instance = new PrimitiveInstance[UInt16](t, val) + init_instance_primitive(instance) + return instance + end + + # Return the int32 instance associated with `val`. + fun int32_instance(val: Int32): Instance + do + var t = mainmodule.int32_type + var instance = new PrimitiveInstance[Int32](t, val) + init_instance_primitive(instance) + return instance + end + + # Return the uint32 instance associated with `val`. + fun uint32_instance(val: UInt32): Instance + do + var t = mainmodule.uint32_type + var instance = new PrimitiveInstance[UInt32](t, val) + init_instance_primitive(instance) + return instance + end + # Return the char instance associated with `val`. fun char_instance(val: Char): Instance do @@ -272,24 +332,46 @@ class NaiveInterpreter end end - # Return a new native string initialized with `txt` - fun native_string_instance(txt: String): Instance + # Return a new C string initialized with `txt` + fun c_string_instance(txt: String): Instance + do + var instance = c_string_instance_len(txt.byte_length+1) + var val = instance.val + val[txt.byte_length] = 0 + txt.to_cstring.copy_to(val, txt.byte_length, 0, 0) + + return instance + end + + # Return a new C string initialized with `txt` + fun c_string_instance_from_ns(txt: CString, len: Int): Instance do - var instance = native_string_instance_len(txt.bytelen+1) + var instance = c_string_instance_len(len) var val = instance.val - val[txt.bytelen] = 0u8 - txt.to_cstring.copy_to(val, txt.bytelen, 0, 0) + txt.copy_to(val, len, 0, 0) return instance end - # Return a new native string initialized of `length` - fun native_string_instance_len(length: Int): PrimitiveInstance[NativeString] + # Return a new C string instance sharing the same data space as `txt` + fun c_string_instance_fast_cstr(txt: CString, from: Int): Instance do - var val = new NativeString(length) + var ncstr = txt.fast_cstring(from) + var t = mainmodule.c_string_type - var t = mainmodule.native_string_type - var instance = new PrimitiveInstance[NativeString](t, val) + var instance = new PrimitiveInstance[CString](t, ncstr) + init_instance_primitive(instance) + + return instance + end + + # Return a new C string initialized of `length` + fun c_string_instance_len(length: Int): PrimitiveInstance[CString] + do + var val = new CString(length) + + var t = mainmodule.c_string_type + var instance = new PrimitiveInstance[CString](t, val) init_instance_primitive(instance) return instance end @@ -297,8 +379,8 @@ class NaiveInterpreter # Return a new String instance for `txt` fun string_instance(txt: String): Instance do - var nat = native_string_instance(txt) - var res = self.send(self.force_get_primitive_method("to_s_with_length", nat.mtype), [nat, self.int_instance(txt.bytelen)]) + var nat = c_string_instance(txt) + var res = self.send(self.force_get_primitive_method("to_s_unsafe", nat.mtype), [nat, self.int_instance(txt.byte_length), self.int_instance(txt.length), self.false_instance, self.false_instance]) assert res != null return res end @@ -386,6 +468,22 @@ class NaiveInterpreter # Store known methods, used to trace methods as they are reached var discover_call_trace: Set[MMethodDef] = new HashSet[MMethodDef] + # Consumes an iterator of expressions and tries to map each element to + # its corresponding Instance. + # + # If any AExprs doesn't resolve to an Instance, then it returns null. + # Otherwise return an array of instances + fun aexprs_to_instances(aexprs: Iterator[AExpr]): nullable Array[Instance] + do + var accumulator = new Array[Instance] + for aexpr in aexprs do + var instance = expr(aexpr) + if instance == null then return null + accumulator.push(instance) + end + return accumulator + end + # Evaluate `args` as expressions in the call of `mpropdef` on `recv`. # This method is used to manage varargs in signatures and returns the real array # of instances to use in the call. @@ -400,22 +498,15 @@ class NaiveInterpreter if map == null then assert args.length == msignature.arity else debug("Expected {msignature.arity} args, got {args.length}") - for ne in args do - var e = self.expr(ne) - if e == null then return null - res.add e - end + var rest_args = aexprs_to_instances(args.iterator) + if rest_args == null then return null + res.append(rest_args) return res end # Eval in order of arguments, not parameters - var exprs = new Array[Instance].with_capacity(args.length) - for ne in args do - var e = self.expr(ne) - if e == null then return null - exprs.add e - end - + var exprs = aexprs_to_instances(args.iterator) + if exprs == null then return null # Fill `res` with the result of the evaluation according to the mapping for i in [0..msignature.arity[ do @@ -426,8 +517,8 @@ class NaiveInterpreter res.add(null_instance) continue end - if param.is_vararg and map.vararg_decl > 0 then - var vararg = exprs.sub(j, map.vararg_decl) + if param.is_vararg and args[i].vararg_decl > 0 then + var vararg = exprs.sub(j, args[i].vararg_decl) var elttype = param.mtype.anchor_to(self.mainmodule, recv.mtype.as(MClassType)) var arg = self.array_instance(vararg, elttype) res.add(arg) @@ -481,10 +572,12 @@ class NaiveInterpreter # Execute type checks of covariant parameters fun parameter_check(node: ANode, mpropdef: MMethodDef, args: Array[Instance]) do - var msignature = mpropdef.msignature + var msignature = mpropdef.msignature.as(not null) for i in [0..msignature.arity[ do + var mp = msignature.mparameters[i] + # skip test for vararg since the array is instantiated with the correct polymorphic type - if msignature.vararg_rank == i then continue + if mp.is_vararg then continue # skip if the cast is not required var origmtype = mpropdef.mproperty.intro.msignature.mparameters[i].mtype @@ -493,7 +586,7 @@ class NaiveInterpreter #print "{mpropdef}: {mpropdef.mproperty.intro.msignature.mparameters[i]}" # get the parameter type - var mtype = msignature.mparameters[i].mtype + var mtype = mp.mtype var anchor = args.first.mtype.as(MClassType) var amtype = mtype.anchor_to(self.mainmodule, anchor) if not args[i+1].mtype.is_subtype(self.mainmodule, anchor, amtype) then @@ -521,6 +614,7 @@ class NaiveInterpreter # Use this method, instead of `send` to execute and control the additional behavior of the call-sites fun callsite(callsite: nullable CallSite, arguments: Array[Instance]): nullable Instance do + if callsite == null then return null var initializers = callsite.mpropdef.initializers if not initializers.is_empty then var recv = arguments.first @@ -627,17 +721,31 @@ class NaiveInterpreter var error_instance = new MutableInstance(modelbuilder.model.null_type) is lazy end +# A runtime error +class FatalError + # The error message + var message: String + + # The problematic node, if any + var node: nullable ANode +end + # An instance represents a value of the executed program. abstract class Instance # The dynamic type of the instance # ASSERT: not self.mtype.is_anchored var mtype: MType - # return true if the instance is the true value. - # return false if the instance is the true value. - # else aborts + # Return `true` if the instance is the `true` value. + # + # Return `false` if the instance is the `false` value. + # Abort if the instance is not a boolean value. fun is_true: Bool do abort + # Return `true` if the instance is null. + # Return `false` otherwise. + fun is_null: Bool do return mtype isa MNullType + # Return true if `self` IS `o` (using the Nit semantic of is) fun eq_is(o: Instance): Bool do return self.is_same_instance(o) @@ -656,6 +764,26 @@ abstract class Instance # else aborts fun to_b: Byte do abort + # Return the integer value if the instance is a int8. + # else aborts + fun to_i8: Int8 do abort + + # Return the integer value if the instance is a int16. + # else aborts + fun to_i16: Int16 do abort + + # Return the integer value if the instance is a uint16. + # else aborts + fun to_u16: UInt16 do abort + + # Return the integer value if the instance is a int32. + # else aborts + fun to_i32: Int32 do abort + + # Return the integer value if the instance is a uint32. + # else aborts + fun to_u32: UInt32 do abort + # The real value encapsulated if the instance is primitive. # Else aborts. fun val: nullable Object do abort @@ -669,8 +797,29 @@ class MutableInstance var attributes: Map[MAttribute, Instance] = new HashMap[MAttribute, Instance] end +# An instance with the original receiver and callsite (for function reference) +class CallrefInstance + super Instance + + # The original receiver + # + # ~~~nitish + # var a = new A + # var f = &a.toto # `a` is the original receiver + # ~~~ + var recv: Instance + + # The original callsite + # + # ~~~nitish + # var a = new A + # var f = &a.toto # `toto` is the original callsite + # ~~~ + var callsite: CallSite +end + # Special instance to handle primitives values (int, bool, etc.) -# The trick it just to encapsulate the <> value +# The trick is just to encapsulate the “real” value. class PrimitiveInstance[E] super Instance @@ -703,6 +852,16 @@ class PrimitiveInstance[E] redef fun to_f do return val.as(Float) redef fun to_b do return val.as(Byte) + + redef fun to_i8 do return val.as(Int8) + + redef fun to_i16 do return val.as(Int16) + + redef fun to_u16 do return val.as(UInt16) + + redef fun to_i32 do return val.as(Int32) + + redef fun to_u32 do return val.as(UInt32) end # Information about local variables in a running method @@ -724,7 +883,7 @@ class InterpreterFrame super Frame # Mapping between a variable and the current value - private var map: Map[Variable, Instance] = new HashMap[Variable, Instance] + var map: Map[Variable, Instance] = new HashMap[Variable, Instance] end redef class ANode @@ -732,7 +891,13 @@ redef class ANode # `v` is used to know if a colored message is displayed or not fun fatal(v: NaiveInterpreter, message: String) do - if v.modelbuilder.toolcontext.opt_no_color.value == true then + # Abort if there is a `catch` block + if v.catch_count > 0 then + v.last_error = new FatalError(message, self) + abort + end + + if v.modelbuilder.toolcontext.opt_no_color.value then sys.stderr.write("Runtime error: {message} ({location.file.filename}:{location.line_start})\n") else sys.stderr.write("{location}: Runtime error: {message}\n{location.colored_line("0;31")}\n") @@ -760,16 +925,17 @@ redef class AMethPropdef var f = v.new_frame(self, mpropdef, args) var res = call_commons(v, mpropdef, args, f) v.frames.shift - if v.returnmark == f then - v.returnmark = null + if v.is_escape(self.return_mark) then res = v.escapevalue - v.escapevalue = null return res end return res end - private fun call_commons(v: NaiveInterpreter, mpropdef: MMethodDef, arguments: Array[Instance], f: Frame): nullable Instance + # Execution of the body of the method + # + # It handle the common special cases: super, intern, extern + fun call_commons(v: NaiveInterpreter, mpropdef: MMethodDef, arguments: Array[Instance], f: Frame): nullable Instance do v.frames.unshift(f) @@ -798,21 +964,27 @@ redef class AMethPropdef v.call(superpd, arguments) end + # First, try intern if mpropdef.is_intern or mpropdef.is_extern then var res = intern_call(v, mpropdef, arguments) if res != v.error_instance then return res end - + # Then, try extern + if mpropdef.is_extern then + var res = call_extern(v, mpropdef, arguments, f) + if res != v.error_instance then return res + end + # Else try block if n_block != null then v.stmt(self.n_block) return null end + # Fail if nothing succeed if mpropdef.is_intern then fatal(v, "NOT YET IMPLEMENTED intern {mpropdef}") else if mpropdef.is_extern then - var res = call_extern(v, mpropdef, arguments, f) - if res != v.error_instance then return res + fatal(v, "NOT YET IMPLEMENTED extern {mpropdef}") else fatal(v, "NOT YET IMPLEMENTED {mpropdef}") end @@ -822,7 +994,6 @@ redef class AMethPropdef # Call this extern method protected fun call_extern(v: NaiveInterpreter, mpropdef: MMethodDef, arguments: Array[Instance], f: Frame): nullable Instance do - fatal(v, "NOT YET IMPLEMENTED extern {mpropdef}") return v.error_instance end @@ -832,6 +1003,19 @@ redef class AMethPropdef do var pname = mpropdef.mproperty.name var cname = mpropdef.mclassdef.mclass.name + + if pname == "call" and v.routine_types.has(cname) then + var routine = args.shift + assert routine isa CallrefInstance + # Swap the receiver position with the original recv of the call form. + args.unshift routine.recv + var res = v.callsite(routine.callsite, args) + # recover the old args state + args.shift + args.unshift routine + return res + end + if pname == "output" then var recv = args.first recv.val.output @@ -850,7 +1034,7 @@ redef class AMethPropdef else if pname == "native_class_name" then var recv = args.first var txt = recv.mtype.to_s - return v.native_string_instance(txt) + return v.c_string_instance(txt) else if pname == "==" then # == is correctly redefined for instances return v.bool_instance(args[0] == args[1]) @@ -860,6 +1044,8 @@ redef class AMethPropdef return v.bool_instance(args[0].mtype == args[1].mtype) else if pname == "is_same_instance" then return v.bool_instance(args[0].eq_is(args[1])) + else if pname == "class_inheritance_metamodel_json" then + return v.c_string_instance(v.mainmodule.flatten_mclass_hierarchy.to_thin_json) else if pname == "exit" then exit(args[1].to_i) abort @@ -897,27 +1083,28 @@ redef class AMethPropdef return v.bool_instance(recvval >= args[1].to_i) else if pname == "<=>" then return v.int_instance(recvval <=> args[1].to_i) - else if pname == "ascii" then - return v.char_instance(recvval.ascii) + else if pname == "&" then + return v.int_instance(recvval & args[1].to_i) + else if pname == "|" then + return v.int_instance(recvval | args[1].to_i) else if pname == "to_f" then return v.float_instance(recvval.to_f) else if pname == "to_b" then return v.byte_instance(recvval.to_b) - else if pname == "lshift" then - return v.int_instance(recvval.lshift(args[1].to_i)) - else if pname == "rshift" then - return v.int_instance(recvval.rshift(args[1].to_i)) - else if pname == "rand" then - var res = recvval.rand - return v.int_instance(res) - else if pname == "bin_and" then - return v.int_instance(recvval.bin_and(args[1].to_i)) - else if pname == "bin_or" then - return v.int_instance(recvval.bin_or(args[1].to_i)) - else if pname == "bin_xor" then - return v.int_instance(recvval.bin_xor(args[1].to_i)) - else if pname == "bin_not" then - return v.int_instance(recvval.bin_not) + else if pname == "<<" then + return v.int_instance(recvval << args[1].to_i) + else if pname == ">>" then + return v.int_instance(recvval >> args[1].to_i) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) end else if cname == "Byte" then var recvval = args[0].to_b @@ -945,22 +1132,34 @@ redef class AMethPropdef return v.bool_instance(recvval >= args[1].to_b) else if pname == "<=>" then return v.int_instance(recvval <=> args[1].to_b) + else if pname == "&" then + return v.byte_instance(recvval & args[1].to_b) + else if pname == "|" then + return v.byte_instance(recvval | args[1].to_b) else if pname == "to_f" then return v.float_instance(recvval.to_f) else if pname == "to_i" then return v.int_instance(recvval.to_i) - else if pname == "lshift" then - return v.byte_instance(recvval.lshift(args[1].to_i)) - else if pname == "rshift" then - return v.byte_instance(recvval.rshift(args[1].to_i)) + else if pname == "<<" then + return v.byte_instance(recvval << args[1].to_i) + else if pname == ">>" then + return v.byte_instance(recvval >> args[1].to_i) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) else if pname == "byte_to_s_len" then return v.int_instance(recvval.to_s.length) end else if cname == "Char" then var recv = args[0].val.as(Char) - if pname == "ascii" then - return v.int_instance(recv.ascii) - else if pname == "successor" then + if pname == "successor" then return v.char_instance(recv.successor(args[1].to_i)) else if pname == "predecessor" then return v.char_instance(recv.predecessor(args[1].to_i)) @@ -1001,6 +1200,16 @@ redef class AMethPropdef return v.int_instance(recv.to_i) else if pname == "to_b" then return v.byte_instance(recv.to_b) + else if pname == "to_i8" then + return v.int8_instance(recv.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recv.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recv.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recv.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recv.to_u32) else if pname == "cos" then return v.float_instance(args[0].to_f.cos) else if pname == "sin" then @@ -1021,8 +1230,6 @@ redef class AMethPropdef return v.float_instance(args[0].to_f.log) else if pname == "pow" then return v.float_instance(args[0].to_f.pow(args[1].to_f)) - else if pname == "rand" then - return v.float_instance(args[0].to_f.rand) else if pname == "abs" then return v.float_instance(args[0].to_f.abs) else if pname == "hypot_with" then @@ -1034,21 +1241,21 @@ redef class AMethPropdef else if pname == "round" then return v.float_instance(args[0].to_f.round) end - else if cname == "NativeString" then + else if cname == "CString" then if pname == "new" then - return v.native_string_instance_len(args[1].to_i) + return v.c_string_instance_len(args[1].to_i) end - var recvval = args.first.val.as(NativeString) + var recvval = args.first.val.as(CString) if pname == "[]" then var arg1 = args[1].to_i - return v.byte_instance(recvval[arg1]) + return v.int_instance(recvval[arg1]) else if pname == "[]=" then var arg1 = args[1].to_i - recvval[arg1] = args[2].val.as(Byte) + recvval[arg1] = args[2].val.as(Int) return null else if pname == "copy_to" then - # sig= copy_to(dest: NativeString, length: Int, from: Int, to: Int) - var destval = args[1].val.as(NativeString) + # sig= copy_to(dest: CString, length: Int, from: Int, to: Int) + var destval = args[1].val.as(CString) var lenval = args[2].to_i var fromval = args[3].to_i var toval = args[4].to_i @@ -1057,11 +1264,14 @@ redef class AMethPropdef else if pname == "atoi" then return v.int_instance(recvval.atoi) else if pname == "fast_cstring" then - var ns = recvval.to_s.substring_from(args[1].to_i) - return v.native_string_instance(ns) + return v.c_string_instance_fast_cstr(args[0].val.as(CString), args[1].to_i) + else if pname == "fetch_4_chars" then + return v.uint32_instance(args[0].val.as(CString).fetch_4_chars(args[1].to_i)) + else if pname == "fetch_4_hchars" then + return v.uint32_instance(args[0].val.as(CString).fetch_4_hchars(args[1].to_i)) + else if pname == "utf8_length" then + return v.int_instance(args[0].val.as(CString).utf8_length(args[1].to_i, args[2].to_i)) end - else if pname == "calloc_string" then - return v.native_string_instance_len(args[1].to_i) else if cname == "NativeArray" then if pname == "new" then var val = new Array[Instance].filled_with(v.null_instance, args[1].to_i) @@ -1081,16 +1291,276 @@ redef class AMethPropdef recvval.copy_to(0, args[2].to_i, args[1].val.as(Array[Instance]), 0) return null end + else if cname == "Int8" then + var recvval = args[0].to_i8 + if pname == "unary -" then + return v.int8_instance(-recvval) + else if pname == "unary +" then + return args[0] + else if pname == "+" then + return v.int8_instance(recvval + args[1].to_i8) + else if pname == "-" then + return v.int8_instance(recvval - args[1].to_i8) + else if pname == "*" then + return v.int8_instance(recvval * args[1].to_i8) + else if pname == "%" then + return v.int8_instance(recvval % args[1].to_i8) + else if pname == "/" then + return v.int8_instance(recvval / args[1].to_i8) + else if pname == "<" then + return v.bool_instance(recvval < args[1].to_i8) + else if pname == ">" then + return v.bool_instance(recvval > args[1].to_i8) + else if pname == "<=" then + return v.bool_instance(recvval <= args[1].to_i8) + else if pname == ">=" then + return v.bool_instance(recvval >= args[1].to_i8) + else if pname == "<=>" then + return v.int_instance(recvval <=> args[1].to_i8) + else if pname == "to_f" then + return v.float_instance(recvval.to_f) + else if pname == "to_i" then + return v.int_instance(recvval.to_i) + else if pname == "to_b" then + return v.byte_instance(recvval.to_b) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) + else if pname == "<<" then + return v.int8_instance(recvval << (args[1].to_i)) + else if pname == ">>" then + return v.int8_instance(recvval >> (args[1].to_i)) + else if pname == "&" then + return v.int8_instance(recvval & args[1].to_i8) + else if pname == "|" then + return v.int8_instance(recvval | args[1].to_i8) + else if pname == "^" then + return v.int8_instance(recvval ^ args[1].to_i8) + else if pname == "unary ~" then + return v.int8_instance(~recvval) + end + else if cname == "Int16" then + var recvval = args[0].to_i16 + if pname == "unary -" then + return v.int16_instance(-recvval) + else if pname == "unary +" then + return args[0] + else if pname == "+" then + return v.int16_instance(recvval + args[1].to_i16) + else if pname == "-" then + return v.int16_instance(recvval - args[1].to_i16) + else if pname == "*" then + return v.int16_instance(recvval * args[1].to_i16) + else if pname == "%" then + return v.int16_instance(recvval % args[1].to_i16) + else if pname == "/" then + return v.int16_instance(recvval / args[1].to_i16) + else if pname == "<" then + return v.bool_instance(recvval < args[1].to_i16) + else if pname == ">" then + return v.bool_instance(recvval > args[1].to_i16) + else if pname == "<=" then + return v.bool_instance(recvval <= args[1].to_i16) + else if pname == ">=" then + return v.bool_instance(recvval >= args[1].to_i16) + else if pname == "<=>" then + return v.int_instance(recvval <=> args[1].to_i16) + else if pname == "to_f" then + return v.float_instance(recvval.to_f) + else if pname == "to_i" then + return v.int_instance(recvval.to_i) + else if pname == "to_b" then + return v.byte_instance(recvval.to_b) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) + else if pname == "<<" then + return v.int16_instance(recvval << (args[1].to_i)) + else if pname == ">>" then + return v.int16_instance(recvval >> (args[1].to_i)) + else if pname == "&" then + return v.int16_instance(recvval & args[1].to_i16) + else if pname == "|" then + return v.int16_instance(recvval | args[1].to_i16) + else if pname == "^" then + return v.int16_instance(recvval ^ args[1].to_i16) + else if pname == "unary ~" then + return v.int16_instance(~recvval) + end + else if cname == "UInt16" then + var recvval = args[0].to_u16 + if pname == "unary -" then + return v.uint16_instance(-recvval) + else if pname == "unary +" then + return args[0] + else if pname == "+" then + return v.uint16_instance(recvval + args[1].to_u16) + else if pname == "-" then + return v.uint16_instance(recvval - args[1].to_u16) + else if pname == "*" then + return v.uint16_instance(recvval * args[1].to_u16) + else if pname == "%" then + return v.uint16_instance(recvval % args[1].to_u16) + else if pname == "/" then + return v.uint16_instance(recvval / args[1].to_u16) + else if pname == "<" then + return v.bool_instance(recvval < args[1].to_u16) + else if pname == ">" then + return v.bool_instance(recvval > args[1].to_u16) + else if pname == "<=" then + return v.bool_instance(recvval <= args[1].to_u16) + else if pname == ">=" then + return v.bool_instance(recvval >= args[1].to_u16) + else if pname == "<=>" then + return v.int_instance(recvval <=> args[1].to_u16) + else if pname == "to_f" then + return v.float_instance(recvval.to_f) + else if pname == "to_i" then + return v.int_instance(recvval.to_i) + else if pname == "to_b" then + return v.byte_instance(recvval.to_b) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) + else if pname == "<<" then + return v.uint16_instance(recvval << (args[1].to_i)) + else if pname == ">>" then + return v.uint16_instance(recvval >> (args[1].to_i)) + else if pname == "&" then + return v.uint16_instance(recvval & args[1].to_u16) + else if pname == "|" then + return v.uint16_instance(recvval | args[1].to_u16) + else if pname == "^" then + return v.uint16_instance(recvval ^ args[1].to_u16) + else if pname == "unary ~" then + return v.uint16_instance(~recvval) + end + else if cname == "Int32" then + var recvval = args[0].to_i32 + if pname == "unary -" then + return v.int32_instance(-recvval) + else if pname == "unary +" then + return args[0] + else if pname == "+" then + return v.int32_instance(recvval + args[1].to_i32) + else if pname == "-" then + return v.int32_instance(recvval - args[1].to_i32) + else if pname == "*" then + return v.int32_instance(recvval * args[1].to_i32) + else if pname == "%" then + return v.int32_instance(recvval % args[1].to_i32) + else if pname == "/" then + return v.int32_instance(recvval / args[1].to_i32) + else if pname == "<" then + return v.bool_instance(recvval < args[1].to_i32) + else if pname == ">" then + return v.bool_instance(recvval > args[1].to_i32) + else if pname == "<=" then + return v.bool_instance(recvval <= args[1].to_i32) + else if pname == ">=" then + return v.bool_instance(recvval >= args[1].to_i32) + else if pname == "<=>" then + return v.int_instance(recvval <=> args[1].to_i32) + else if pname == "to_f" then + return v.float_instance(recvval.to_f) + else if pname == "to_i" then + return v.int_instance(recvval.to_i) + else if pname == "to_b" then + return v.byte_instance(recvval.to_b) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_u32" then + return v.uint32_instance(recvval.to_u32) + else if pname == "<<" then + return v.int32_instance(recvval << (args[1].to_i)) + else if pname == ">>" then + return v.int32_instance(recvval >> (args[1].to_i)) + else if pname == "&" then + return v.int32_instance(recvval & args[1].to_i32) + else if pname == "|" then + return v.int32_instance(recvval | args[1].to_i32) + else if pname == "^" then + return v.int32_instance(recvval ^ args[1].to_i32) + else if pname == "unary ~" then + return v.int32_instance(~recvval) + end + else if cname == "UInt32" then + var recvval = args[0].to_u32 + if pname == "unary -" then + return v.uint32_instance(-recvval) + else if pname == "unary +" then + return args[0] + else if pname == "+" then + return v.uint32_instance(recvval + args[1].to_u32) + else if pname == "-" then + return v.uint32_instance(recvval - args[1].to_u32) + else if pname == "*" then + return v.uint32_instance(recvval * args[1].to_u32) + else if pname == "%" then + return v.uint32_instance(recvval % args[1].to_u32) + else if pname == "/" then + return v.uint32_instance(recvval / args[1].to_u32) + else if pname == "<" then + return v.bool_instance(recvval < args[1].to_u32) + else if pname == ">" then + return v.bool_instance(recvval > args[1].to_u32) + else if pname == "<=" then + return v.bool_instance(recvval <= args[1].to_u32) + else if pname == ">=" then + return v.bool_instance(recvval >= args[1].to_u32) + else if pname == "<=>" then + return v.int_instance(recvval <=> args[1].to_u32) + else if pname == "to_f" then + return v.float_instance(recvval.to_f) + else if pname == "to_i" then + return v.int_instance(recvval.to_i) + else if pname == "to_b" then + return v.byte_instance(recvval.to_b) + else if pname == "to_i8" then + return v.int8_instance(recvval.to_i8) + else if pname == "to_i16" then + return v.int16_instance(recvval.to_i16) + else if pname == "to_u16" then + return v.uint16_instance(recvval.to_u16) + else if pname == "to_i32" then + return v.int32_instance(recvval.to_i32) + else if pname == "<<" then + return v.uint32_instance(recvval << (args[1].to_i)) + else if pname == ">>" then + return v.uint32_instance(recvval >> (args[1].to_i)) + else if pname == "&" then + return v.uint32_instance(recvval & args[1].to_u32) + else if pname == "|" then + return v.uint32_instance(recvval | args[1].to_u32) + else if pname == "^" then + return v.uint32_instance(recvval ^ args[1].to_u32) + else if pname == "unary ~" then + return v.uint32_instance(~recvval) + end else if pname == "native_argc" then return v.int_instance(v.arguments.length) else if pname == "native_argv" then var txt = v.arguments[args[1].to_i] - return v.native_string_instance(txt) - else if pname == "native_argc" then - return v.int_instance(v.arguments.length) - else if pname == "native_argv" then - var txt = v.arguments[args[1].to_i] - return v.native_string_instance(txt) + return v.c_string_instance(txt) else if pname == "lexer_goto" then return v.int_instance(lexer_goto(args[1].to_i, args[2].to_i)) else if pname == "lexer_accept" then @@ -1117,7 +1587,12 @@ redef class AAttrPropdef return evaluate_expr(v, recv, f) else if mpropdef == mwritepropdef then assert args.length == 2 - v.write_attribute(attr, recv, args[1]) + var arg = args[1] + if is_optional and arg.is_null then + var f = v.new_frame(self, mpropdef, args) + arg = evaluate_expr(v, recv, f) + end + v.write_attribute(attr, recv, arg) return null else abort @@ -1127,7 +1602,7 @@ redef class AAttrPropdef # Evaluate and set the default value of the attribute in `recv` private fun init_expr(v: NaiveInterpreter, recv: Instance) do - if is_lazy then return + if is_lazy or is_optional then return if has_value then var f = v.new_frame(self, mreadpropdef.as(not null), [recv]) evaluate_expr(v, recv, f) @@ -1155,10 +1630,9 @@ redef class AAttrPropdef val = v.expr(nexpr) else if nblock != null then v.stmt(nblock) - assert v.returnmark == f + assert v.escapemark == return_mark val = v.escapevalue - v.returnmark = null - v.escapevalue = null + v.escapemark = null else abort end @@ -1173,14 +1647,14 @@ end redef class AClassdef # Execute an implicit `mpropdef` associated with the current node. - private fun call(v: NaiveInterpreter, mpropdef: MMethodDef, args: Array[Instance]): nullable Instance + private fun call(v: NaiveInterpreter, mpropdef: MMethodDef, arguments: Array[Instance]): nullable Instance do if mpropdef.mproperty.is_root_init then - assert args.length == 1 + assert arguments.length == 1 if not mpropdef.is_intro then # standard call-next-method - var superpd = mpropdef.lookup_next_definition(v.mainmodule, args.first.mtype) - v.call(superpd, args) + var superpd = mpropdef.lookup_next_definition(v.mainmodule, arguments.first.mtype) + v.call(superpd, arguments) end return null else @@ -1298,24 +1772,13 @@ redef class AEscapeExpr var i = v.expr(ne) if i == null then return v.escapevalue = i + else + v.escapevalue = null end v.escapemark = self.escapemark end end -redef class AReturnExpr - redef fun stmt(v) - do - var ne = self.n_expr - if ne != null then - var i = v.expr(ne) - if i == null then return - v.escapevalue = i - end - v.returnmark = v.frame - end -end - redef class AAbortExpr redef fun stmt(v) do @@ -1364,8 +1827,24 @@ end redef class ADoExpr redef fun stmt(v) do - v.stmt(self.n_block) - v.is_escape(self.break_mark) # Clear the break (if any) + # If this bloc has a catch, handle it with a do ... catch ... end + if self.n_catch != null then + var frame = v.frame + v.catch_count += 1 + do + v.stmt(self.n_block) + v.is_escape(self.break_mark) # Clear the break (if any) + v.catch_count -= 1 + catch + # Restore the current frame if needed + while v.frame != frame do v.frames.shift + v.catch_count -= 1 + v.stmt(self.n_catch) + end + else + v.stmt(self.n_block) + v.is_escape(self.break_mark) + end end end @@ -1399,37 +1878,47 @@ end redef class AForExpr redef fun stmt(v) do - var col = v.expr(self.n_expr) - if col == null then return - if col.mtype isa MNullType then fatal(v, "Receiver is null") + var iters = new Array[Instance] + + for g in n_groups do + var col = v.expr(g.n_expr) + if col == null then return + if col.is_null then fatal(v, "Receiver is null") + + var iter = v.callsite(g.method_iterator, [col]).as(not null) + iters.add iter + end - #self.debug("col {col}") - var iter = v.callsite(method_iterator, [col]).as(not null) - #self.debug("iter {iter}") loop - var isok = v.callsite(method_is_ok, [iter]).as(not null) - if not isok.is_true then break - if self.variables.length == 1 then - var item = v.callsite(method_item, [iter]).as(not null) - #self.debug("item {item}") - v.write_variable(self.variables.first, item) - else if self.variables.length == 2 then - var key = v.callsite(method_key, [iter]).as(not null) - v.write_variable(self.variables[0], key) - var item = v.callsite(method_item, [iter]).as(not null) - v.write_variable(self.variables[1], item) - else - abort + for g in n_groups, iter in iters do + var isok = v.callsite(g.method_is_ok, [iter]).as(not null) + if not isok.is_true then break label + if g.variables.length == 1 then + var item = v.callsite(g.method_item, [iter]).as(not null) + #self.debug("item {item}") + v.write_variable(g.variables.first, item) + else if g.variables.length == 2 then + var key = v.callsite(g.method_key, [iter]).as(not null) + v.write_variable(g.variables[0], key) + var item = v.callsite(g.method_item, [iter]).as(not null) + v.write_variable(g.variables[1], item) + else + abort + end end v.stmt(self.n_block) if v.is_escape(self.break_mark) then break v.is_escape(self.continue_mark) # Clear the break if v.is_escaping then break - v.callsite(method_next, [iter]) - end - var method_finish = self.method_finish - if method_finish != null then - v.callsite(method_finish, [iter]) + for g in n_groups, iter in iters do + v.callsite(g.method_next, [iter]) + end + end label + for g in n_groups, iter in iters do + var method_finish = g.method_finish + if method_finish != null then + v.callsite(method_finish, [iter]) + end end end end @@ -1443,7 +1932,13 @@ redef class AWithExpr v.callsite(method_start, [expr]) v.stmt(self.n_block) v.is_escape(self.break_mark) # Clear the break + + # Execute the finally without an escape + var old_mark = v.escapemark + v.escapemark = null v.callsite(method_finish, [expr]) + # Restore the escape unless another escape was provided + if v.escapemark == null then v.escapemark = old_mark end end @@ -1455,6 +1950,22 @@ redef class AAssertExpr if not cond.is_true then v.stmt(self.n_else) if v.is_escaping then return + + # Explain assert if it fails + var explain_assert_str = explain_assert_str + if explain_assert_str != null then + var i = v.expr(explain_assert_str) + if i isa MutableInstance then + var res = v.send(v.force_get_primitive_method("to_cstring", i.mtype), [i]) + if res != null then + var val = res.val + if val != null then + print_error "Runtime assert: {val.to_s}" + end + end + end + end + var nid = self.n_id if nid != null then fatal(v, "Assert '{nid.text}' failed") @@ -1520,6 +2031,11 @@ redef class AIntegerExpr do if value isa Int then return v.int_instance(value.as(Int)) if value isa Byte then return v.byte_instance(value.as(Byte)) + if value isa Int8 then return v.int8_instance(value.as(Int8)) + if value isa Int16 then return v.int16_instance(value.as(Int16)) + if value isa UInt16 then return v.uint16_instance(value.as(UInt16)) + if value isa Int32 then return v.int32_instance(value.as(Int32)) + if value isa UInt32 then return v.uint32_instance(value.as(UInt32)) return null end end @@ -1534,6 +2050,9 @@ end redef class ACharExpr redef fun expr(v) do + if is_code_point then + return v.int_instance(self.value.as(not null).code_point) + end return v.char_instance(self.value.as(not null)) end end @@ -1560,11 +2079,71 @@ redef class AArrayExpr end end +redef class AugmentedStringFormExpr + # Factorize the making of a `Regex` object from a literal prefixed string + fun make_re(v: NaiveInterpreter, rs: Instance): nullable Instance do + var tore = to_re + assert tore != null + var res = v.callsite(tore, [rs]) + if res == null then + print "Cannot call property `to_re` on {self}" + abort + end + for j in suffix.chars do + if j == 'i' then + var prop = ignore_case + assert prop != null + v.callsite(prop, [res, v.bool_instance(true)]) + continue + end + if j == 'm' then + var prop = newline + assert prop != null + v.callsite(prop, [res, v.bool_instance(true)]) + continue + end + if j == 'b' then + var prop = extended + assert prop != null + v.callsite(prop, [res, v.bool_instance(false)]) + continue + end + # Should not happen, this needs to be updated + # along with the addition of new suffixes + abort + end + return res + end +end + redef class AStringFormExpr - redef fun expr(v) - do - var txt = self.value.as(not null) - return v.string_instance(txt) + redef fun expr(v) do return v.string_instance(value) +end + +redef class AStringExpr + redef fun expr(v) do + var s = v.string_instance(value) + if is_string then return s + if is_bytestring then + var ns = v.c_string_instance_from_ns(bytes.items, bytes.length) + var ln = v.int_instance(bytes.length) + var prop = to_bytes_with_copy + assert prop != null + var res = v.callsite(prop, [ns, ln]) + if res == null then + print "Cannot call property `to_bytes` on {self}" + abort + end + s = res + else if is_re then + var res = make_re(v, s) + assert res != null + s = res + else + print "Unimplemented prefix or suffix for {self}" + abort + end + return s end end @@ -1580,6 +2159,7 @@ redef class ASuperstringExpr var i = v.array_instance(array, v.mainmodule.object_type) var res = v.send(v.force_get_primitive_method("plain_to_s", i.mtype), [i]) assert res != null + if is_re then res = make_re(v, res) return res end end @@ -1664,7 +2244,7 @@ redef class AAsNotnullExpr do var i = v.expr(self.n_expr) if i == null then return null - if i.mtype isa MNullType then + if i.is_null then fatal(v, "Cast failed") end return i @@ -1697,14 +2277,30 @@ redef class ASendExpr do var recv = v.expr(self.n_expr) if recv == null then return null + + # Safe call shortcut if recv is null + if is_safe and recv.is_null then + return recv + end + var args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, self.raw_arguments) if args == null then return null - var res = v.callsite(callsite, args) return res end end +redef class ACallrefExpr + redef fun expr(v) + do + var recv = v.expr(self.n_expr) + if recv == null then return null + assert mtype != null + var inst = new CallrefInstance(mtype.as(not null), recv, callsite.as(not null)) + return inst + end +end + redef class ASendReassignFormExpr redef fun stmt(v) do @@ -1793,7 +2389,7 @@ redef class AAttrExpr do var recv = v.expr(self.n_expr) if recv == null then return null - if recv.mtype isa MNullType then fatal(v, "Receiver is null") + if recv.is_null then fatal(v, "Receiver is null") var mproperty = self.mproperty.as(not null) return v.read_attribute(mproperty, recv) end @@ -1804,7 +2400,7 @@ redef class AAttrAssignExpr do var recv = v.expr(self.n_expr) if recv == null then return - if recv.mtype isa MNullType then fatal(v, "Receiver is null") + if recv.is_null then fatal(v, "Receiver is null") var i = v.expr(self.n_value) if i == null then return var mproperty = self.mproperty.as(not null) @@ -1817,7 +2413,7 @@ redef class AAttrReassignExpr do var recv = v.expr(self.n_expr) if recv == null then return - if recv.mtype isa MNullType then fatal(v, "Receiver is null") + if recv.is_null then fatal(v, "Receiver is null") var value = v.expr(self.n_value) if value == null then return var mproperty = self.mproperty.as(not null) @@ -1833,7 +2429,7 @@ redef class AIssetAttrExpr do var recv = v.expr(self.n_expr) if recv == null then return null - if recv.mtype isa MNullType then fatal(v, "Receiver is null") + if recv.is_null then fatal(v, "Receiver is null") var mproperty = self.mproperty.as(not null) return v.bool_instance(v.isset_attribute(mproperty, recv)) end @@ -1846,6 +2442,13 @@ redef class AVarargExpr end end +redef class ASafeExpr + redef fun expr(v) + do + return v.expr(self.n_expr) + end +end + redef class ANamedargExpr redef fun expr(v) do