X-Git-Url: http://nitlanguage.org diff --git a/src/naive_interpreter.nit b/src/naive_interpreter.nit index 9cb327e..4818e57 100644 --- a/src/naive_interpreter.nit +++ b/src/naive_interpreter.nit @@ -21,6 +21,17 @@ import literal import typing import auto_super_init +redef class ToolContext + # --discover-call-trace + var opt_discover_call_trace: OptionBool = new OptionBool("Trace calls of the first invocation of a method", "--discover-call-trace") + + redef init + do + super + self.option_context.add_option(self.opt_discover_call_trace) + end +end + redef class ModelBuilder # Execute the program from the entry point (Sys::main) of the `mainmodule' # `arguments' are the command-line arguments in order @@ -89,6 +100,11 @@ private class NaiveInterpreter return sub.is_subtype(self.mainmodule, self.frame.arguments.first.mtype.as(MClassType), sup) end + fun force_get_primitive_method(name: String, recv: MType): MMethod + do + return self.modelbuilder.force_get_primitive_method(self.frame.current_node, name, recv, 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 @@ -149,6 +165,12 @@ private class NaiveInterpreter if i == null and not self.is_escaping then n.debug("inconsitance: no value and not escaping.") end + var implicit_cast_to = n.implicit_cast_to + if 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") + end + #n.debug("OUT Execute expr: value is {i}") #if not is_subtype(i.mtype, n.mtype.as(not null)) then n.debug("Expected {n.mtype.as(not null)} got {i}") frame.current_node = old @@ -218,7 +240,7 @@ private class NaiveInterpreter var mtype = self.mainmodule.get_primitive_class("Array").get_mtype([elttype]) var res = new MutableInstance(mtype) self.init_instance(res) - self.send(self.mainmodule.force_get_primitive_method("with_native", mtype), [res, nat, self.int_instance(values.length)]) + self.send(self.force_get_primitive_method("with_native", mtype), [res, nat, self.int_instance(values.length)]) self.check_init_instance(res) return res end @@ -261,11 +283,28 @@ private class NaiveInterpreter exit(1) end + # Debug on the current node + fun debug(message: String) + do + if frames.is_empty then + print message + else + self.frame.current_node.debug(message) + end + end + + # Store known method, used to trace methods as thez are reached + var discover_call_trace: Set[MMethodDef] = new HashSet[MMethodDef] + # Execute `mpropdef' for a `args' (where args[0] is the receiver). # Return a falue if `mpropdef' is a function, or null if it is a procedure. # The call is direct/static. There is no message-seding/late-bindng. fun call(mpropdef: MMethodDef, args: Array[Instance]): nullable Instance do + if self.modelbuilder.toolcontext.opt_discover_call_trace.value and not self.discover_call_trace.has(mpropdef) then + self.discover_call_trace.add mpropdef + self.debug("Discovered {mpropdef}") + end var vararg_rank = mpropdef.msignature.vararg_rank if vararg_rank >= 0 then assert args.length >= mpropdef.msignature.arity + 1 # because of self @@ -291,8 +330,9 @@ private class NaiveInterpreter args.add(rawargs[i+1]) end end - assert args.length >= mpropdef.msignature.arity + 1 # because of self - assert args.length <= mpropdef.msignature.arity + 1 + mpropdef.msignature.mclosures.length + if args.length < mpropdef.msignature.arity + 1 or args.length > mpropdef.msignature.arity + 1 + mpropdef.msignature.mclosures.length then + fatal("NOT YET IMPLEMENTED: Invalid arity for {mpropdef}. {args.length} arguments given.") + end if args.length < mpropdef.msignature.arity + 1 + mpropdef.msignature.mclosures.length then fatal("NOT YET IMPLEMENTED: default closures") end @@ -301,9 +341,11 @@ private class NaiveInterpreter var mproperty = mpropdef.mproperty if self.modelbuilder.mpropdef2npropdef.has_key(mpropdef) then var npropdef = self.modelbuilder.mpropdef2npropdef[mpropdef] + self.parameter_check(npropdef, mpropdef, args) return npropdef.call(self, mpropdef, args) else if mproperty.name == "init" then var nclassdef = self.modelbuilder.mclassdef2nclassdef[mpropdef.mclassdef] + self.parameter_check(nclassdef, mpropdef, args) return nclassdef.call(self, mpropdef, args) else fatal("Fatal Error: method {mpropdef} not found in the AST") @@ -311,6 +353,28 @@ private class NaiveInterpreter end end + # Generate type checks in the C code to check covariant parameters + fun parameter_check(node: ANode, mpropdef: MMethodDef, args: Array[Instance]) + do + var msignature = mpropdef.msignature + for i in [0..msignature.arity[ do + # skip test for vararg since the array is instantiated with the correct polymorphic type + if msignature.vararg_rank == i then continue + + # skip if the cast is not required + var origmtype = mpropdef.mproperty.intro.msignature.mparameters[i].mtype + if not origmtype.need_anchor then continue + + # get the parameter type + var mtype = msignature.mparameters[i].mtype + var anchor = args.first.mtype.as(MClassType) + mtype = mtype.anchor_to(self.mainmodule, anchor) + if not args[i+1].mtype.is_subtype(self.mainmodule, anchor, mtype) then + node.fatal(self, "Cast failed") + end + end + end + fun call_closure(closure: ClosureInstance, args: Array[Instance]): nullable Instance do var nclosuredef = closure.nclosuredef @@ -351,16 +415,7 @@ private class NaiveInterpreter fatal("Reciever is null") abort end - var propdefs = mproperty.lookup_definitions(self.mainmodule, mtype) - if propdefs.length > 1 then - fatal("NOT YET IMPLEMETED ERROR: Property conflict: {propdefs.join(", ")}") - abort - end - assert propdefs.length == 1 else - fatal("Fatal Error: No property '{mproperty}' for '{recv}'") - abort - end - var propdef = propdefs.first + var propdef = mproperty.lookup_first_definition(self.mainmodule, mtype) return self.call(propdef, args) end @@ -444,12 +499,16 @@ abstract class Instance fun eq_is(o: Instance): Bool do return self is o # Human readable object identity "Type#number" - redef fun to_s do return "{mtype}#{object_id}" + redef fun to_s do return "{mtype}" - # Return the integer valur is the instance is an integer. + # Return the integer value if the instance is an integer. # else aborts fun to_i: Int do abort + # Return the integer value if the instance is a float. + # else aborts + fun to_f: Float do abort + # The real value encapsulated if the instance is primitive. # Else aborts. fun val: Object do abort @@ -499,6 +558,8 @@ class PrimitiveInstance[E: Object] redef fun to_s do return "{mtype}#{val.object_id}({val})" redef fun to_i do return val.as(Int) + + redef fun to_f do return val.as(Float) end private class ClosureInstance @@ -536,10 +597,11 @@ redef class ANode private fun fatal(v: NaiveInterpreter, message: String) do if v.modelbuilder.toolcontext.opt_no_color.value == true then - print("Runtime error: {message} ({location.file.filename}:{location.line_start})") + stderr.write("Runtime error: {message} ({location.file.filename}:{location.line_start})\n") else - print("{location}: Runtime error: {message}\n{location.colored_line("0;31")}") - print(v.stack_trace) + stderr.write("{location}: Runtime error: {message}\n{location.colored_line("0;31")}\n") + stderr.write(v.stack_trace) + stderr.write("\n") end exit(1) end @@ -615,11 +677,11 @@ redef class AInternMethPropdef end else if pname == "output_class_name" then var recv = args.first - print recv.mtype.as(MClassType).mclass + print recv.mtype return null else if pname == "native_class_name" then var recv = args.first - var txt = recv.mtype.as(MClassType).mclass.to_s + var txt = recv.mtype.to_s return v.native_string_instance(txt) else if pname == "==" then # == is correclt redefined for instances @@ -689,16 +751,18 @@ redef class AInternMethPropdef return v.int_instance(recv <=> args[1].val.as(Char)) end else if cname == "Float" then - if pname == "+" then - return v.float_instance(args[0].val.as(Float) + args[1].val.as(Float)) + if pname == "unary -" then + return v.float_instance(-args[0].to_f) + else if pname == "+" then + return v.float_instance(args[0].to_f + args[1].to_f) else if pname == "-" then - return v.float_instance(args[0].val.as(Float) - args[1].val.as(Float)) + return v.float_instance(args[0].to_f - args[1].to_f) else if pname == "*" then - return v.float_instance(args[0].val.as(Float) * args[1].val.as(Float)) + return v.float_instance(args[0].to_f * args[1].to_f) else if pname == "/" then - return v.float_instance(args[0].val.as(Float) / args[1].val.as(Float)) + return v.float_instance(args[0].to_f / args[1].to_f) else if pname == "to_i" then - return v.int_instance(args[0].val.as(Float).to_i) + return v.int_instance(args[0].to_f.to_i) end else if cname == "NativeString" then var recvval = args.first.val.as(Buffer) @@ -756,8 +820,9 @@ redef class AInternMethPropdef end else if pname == "calloc_array" then var recvtype = args.first.mtype.as(MClassType) - var mtype: MType = recvtype.supertype_to(v.mainmodule, recvtype, v.mainmodule.get_primitive_class("ArrayCapable")) - mtype = mtype.as(MGenericType).arguments.first + var mtype: MType + mtype = recvtype.supertype_to(v.mainmodule, recvtype, v.mainmodule.get_primitive_class("ArrayCapable")) + mtype = mtype.arguments.first var val = new Array[Instance].filled_with(v.null_instance, args[1].to_i) return new PrimitiveInstance[Array[Instance]](v.mainmodule.get_primitive_class("NativeArray").get_mtype([mtype]), val) end @@ -837,6 +902,16 @@ redef class AExternMethPropdef var res = sys.system(recvval.to_s) return v.int_instance(res) end + else if cname == "Int" then + if pname == "rand" then + return v.int_instance(args[0].to_i.rand) + end + else if cname == "Float" then + if pname == "cos" then + return v.float_instance(args[0].to_f.cos) + else if pname == "sin" then + return v.float_instance(args[0].to_f.sin) + end else if pname == "native_argc" then return v.int_instance(v.arguments.length) else if pname == "native_argv" then @@ -844,6 +919,10 @@ redef class AExternMethPropdef return v.native_string_instance(txt) else if pname == "get_time" then return v.int_instance(get_time) + else if pname == "atan2" then + return v.float_instance(atan2(args[1].to_f, args[2].to_f)) + else if pname == "pi" then + return v.float_instance(pi) 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 @@ -1123,19 +1202,19 @@ redef class AForExpr var col = v.expr(self.n_expr) if col == null then return #self.debug("col {col}") - var iter = v.send(v.mainmodule.force_get_primitive_method("iterator", col.mtype), [col]).as(not null) + var iter = v.send(v.force_get_primitive_method("iterator", col.mtype), [col]).as(not null) #self.debug("iter {iter}") loop - var isok = v.send(v.mainmodule.force_get_primitive_method("is_ok", iter.mtype), [iter]).as(not null) + var isok = v.send(v.force_get_primitive_method("is_ok", iter.mtype), [iter]).as(not null) if not isok.is_true then return if self.variables.length == 1 then - var item = v.send(v.mainmodule.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) + var item = v.send(v.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) #self.debug("item {item}") v.frame.map[self.variables.first] = item else if self.variables.length == 2 then - var key = v.send(v.mainmodule.force_get_primitive_method("key", iter.mtype), [iter]).as(not null) + var key = v.send(v.force_get_primitive_method("key", iter.mtype), [iter]).as(not null) v.frame.map[self.variables[0]] = key - var item = v.send(v.mainmodule.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) + var item = v.send(v.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) v.frame.map[self.variables[1]] = item else abort @@ -1144,7 +1223,7 @@ redef class AForExpr if v.is_break(self.escapemark) then return v.is_continue(self.escapemark) # Clear the break if v.is_escaping then return - v.send(v.mainmodule.force_get_primitive_method("next", iter.mtype), [iter]) + v.send(v.force_get_primitive_method("next", iter.mtype), [iter]) end end end @@ -1248,7 +1327,7 @@ redef class AArrayExpr if i == null then return null val.add(i) end - var mtype = v.unanchor_type(self.mtype.as(not null)).as(MGenericType) + var mtype = v.unanchor_type(self.mtype.as(not null)).as(MClassType) var elttype = mtype.arguments.first return v.array_instance(val, elttype) end @@ -1261,7 +1340,7 @@ redef class AStringFormExpr var nat = v.native_string_instance(txt) var res = new MutableInstance(v.mainmodule.get_primitive_class("String").mclass_type) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("from_cstring", res.mtype), [res, nat]) + v.send(v.force_get_primitive_method("from_cstring", res.mtype), [res, nat]) v.check_init_instance(res) return res end @@ -1277,7 +1356,7 @@ redef class ASuperstringExpr array.add(i) end var i = v.array_instance(array, v.mainmodule.get_primitive_class("Object").mclass_type) - var res = v.send(v.mainmodule.force_get_primitive_method("to_s", i.mtype), [i]) + var res = v.send(v.force_get_primitive_method("to_s", i.mtype), [i]) assert res != null return res end @@ -1293,7 +1372,7 @@ redef class ACrangeExpr var mtype = v.unanchor_type(self.mtype.as(not null)) var res = new MutableInstance(mtype) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("init", mtype), [res, e1, e2]) + v.send(v.force_get_primitive_method("init", mtype), [res, e1, e2]) v.check_init_instance(res) return res end @@ -1309,7 +1388,7 @@ redef class AOrangeExpr var mtype = v.unanchor_type(self.mtype.as(not null)) var res = new MutableInstance(mtype) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("without_last", mtype), [res, e1, e2]) + v.send(v.force_get_primitive_method("without_last", mtype), [res, e1, e2]) v.check_init_instance(res) return res end @@ -1514,6 +1593,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, "Reciever is null") var mproperty = self.mproperty.as(not null) return v.read_attribute(mproperty, recv) end @@ -1524,6 +1604,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, "Reciever is null") var i = v.expr(self.n_value) if i == null then return var mproperty = self.mproperty.as(not null) @@ -1537,6 +1618,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, "Reciever is null") var value = v.expr(self.n_value) if value == null then return var mproperty = self.mproperty.as(not null) @@ -1553,6 +1635,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, "Reciever is null") var mproperty = self.mproperty.as(not null) assert recv isa MutableInstance return v.bool_instance(recv.attributes.has_key(mproperty))