X-Git-Url: http://nitlanguage.org diff --git a/src/interpreter/naive_interpreter.nit b/src/interpreter/naive_interpreter.nit index 09437fe..eced30f 100644 --- a/src/interpreter/naive_interpreter.nit +++ b/src/interpreter/naive_interpreter.nit @@ -22,6 +22,7 @@ import semantize private import parser::tables import mixin import primitive_types +private import model::serialize_model redef class ToolContext # --discover-call-trace @@ -113,17 +114,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. @@ -317,24 +320,34 @@ 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] = 0u8 + 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 initialized of `length` + fun c_string_instance_len(length: Int): PrimitiveInstance[CString] do - var val = new NativeString(length) + var val = new CString(length) - var t = mainmodule.native_string_type - var instance = new PrimitiveInstance[NativeString](t, val) + var t = mainmodule.c_string_type + var instance = new PrimitiveInstance[CString](t, val) init_instance_primitive(instance) return instance end @@ -342,8 +355,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_full", nat.mtype), [nat, self.int_instance(txt.bytelen), self.int_instance(txt.length)]) + 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 @@ -675,15 +688,25 @@ 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 `self` IS `o` (using the Nit semantic of is) @@ -738,7 +761,7 @@ class MutableInstance 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 @@ -810,6 +833,12 @@ redef class ANode # `v` is used to know if a colored message is displayed or not fun fatal(v: NaiveInterpreter, message: String) do + # 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 == true then sys.stderr.write("Runtime error: {message} ({location.file.filename}:{location.line_start})\n") else @@ -838,10 +867,8 @@ 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 @@ -933,7 +960,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]) @@ -943,6 +970,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 @@ -1138,11 +1167,11 @@ 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]) @@ -1151,8 +1180,8 @@ redef class AMethPropdef recvval[arg1] = args[2].val.as(Byte) 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 @@ -1162,16 +1191,14 @@ redef class AMethPropdef return v.int_instance(recvval.atoi) else if pname == "fast_cstring" then var ns = recvval.fast_cstring(args[1].to_i) - return v.native_string_instance(ns.to_s) + return v.c_string_instance(ns.to_s) else if pname == "fetch_4_chars" then - return v.int_instance(args[0].val.as(NativeString).fetch_4_chars(args[1].to_i)) + 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.int_instance(args[0].val.as(NativeString).fetch_4_hchars(args[1].to_i)) + 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(NativeString).utf8_length(args[1].to_i, args[2].to_i)) + 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) @@ -1460,12 +1487,7 @@ redef class AMethPropdef 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 @@ -1507,7 +1529,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) @@ -1535,10 +1557,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 @@ -1683,19 +1704,6 @@ redef class AEscapeExpr 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 @@ -1744,8 +1752,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 @@ -1963,11 +1987,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 @@ -1983,6 +2067,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