module debugger
intrude import naive_interpreter
-import nitx
intrude import semantize::local_var_init
intrude import semantize::scope
intrude import toolcontext
redef class ScopeVisitor
- redef init(toolcontext)
+ redef init
do
super
if toolcontext.dbg != null then
redef fun check_errors
do
if dbg == null then
- super
+ return super
else
if messages.length > 0 then
message_sorter.sort(messages)
messages.clear
end
+ return not had_error
end
# -d
# Auto continues the execution until the end or until an error is encountered
var autocontinue = false
+ redef type FRAME: InterpreterFrame
+
#######################################################################
## Execution of statement function ##
#######################################################################
assert args.length == mpropdef.msignature.arity + 1 else debug("Invalid arity for {mpropdef}. {args.length} arguments given.")
# Look for the AST node that implements the property
- var mproperty = mpropdef.mproperty
- if self.modelbuilder.mpropdef2npropdef.has_key(mpropdef) then
- var npropdef = self.modelbuilder.mpropdef2npropdef[mpropdef]
- self.parameter_check(npropdef, mpropdef, args)
- if npropdef isa AMethPropdef then
- return npropdef.rt_call(self, mpropdef, args)
- else
- print "Error, invalid propdef to call at runtime !"
- return null
- end
- else if mproperty.is_root_init then
- var nclassdef = self.modelbuilder.mclassdef2nclassdef[mpropdef.mclassdef]
- self.parameter_check(nclassdef, mpropdef, args)
- return nclassdef.call(self, mpropdef, args)
+ var node = modelbuilder.mpropdef2node(mpropdef)
+ if node isa AMethPropdef then
+ self.parameter_check(node, mpropdef, args)
+ return node.rt_call(self, mpropdef, args)
+ else if node isa AClassdef then
+ self.parameter_check(node, mpropdef, args)
+ return node.call(self, mpropdef, args)
else
fatal("Fatal Error: method {mpropdef} not found in the AST")
abort
else if command == "help" then
help
return true
- # Opens a new NitIndex prompt on current model
- else if command == "nitx" then
- new NitIndex.with_infos(modelbuilder, self.mainmodule).prompt
- return true
else if command == "bt" or command == "backtrack" then
print stack_trace
return true
# If the variable *variable_name* is an argument of the function being executed in the frame *frame*
# The function returns its position in the arguments
# Else, it returns -1
- private fun get_position_of_variable_in_arguments(frame: Frame, variable_name: String): Int
+ private fun get_position_of_variable_in_arguments(frame: FRAME, variable_name: String): Int
do
var identifiers = get_identifiers_in_current_instruction(get_function_arguments(frame.mpropdef.location.text))
for i in [0 .. identifiers.length-1] do
#######################################################################
# Seeks a variable from the current frame called 'variable_path', can introspect complex objects using function get_variable_in_mutable_instance
- private fun seek_variable(variable_path: String, frame: Frame): nullable Instance
+ private fun seek_variable(variable_path: String, frame: FRAME): nullable Instance
do
var full_variable = variable_path.split_with(".")
end
# Gets a variable 'variable_name' contained in the frame 'frame'
- private fun get_variable_in_frame(variable_name: String, frame: Frame): nullable Instance
+ private fun get_variable_in_frame(variable_name: String, frame: FRAME): nullable Instance
do
if variable_name == "self" then
if frame.arguments.length >= 1 then return frame.arguments.first
# Not supposed to be used by anyone else than the Debugger.
private fun rt_call(v: Debugger, mpropdef: MMethodDef, args: Array[Instance]): nullable Instance
do
- var f = new Frame(self, self.mpropdef.as(not null), args)
+ var f = new InterpreterFrame(self, self.mpropdef.as(not null), args)
var curr_instances = v.frame.map
for i in curr_instances.keys do
f.map[i] = curr_instances[i]
private class TraceObject
# Map of the local names bound to a frame
- var trace_map: HashMap[Frame, String]
+ var trace_map = new HashMap[Frame, String]
+
# Decides if breaking or printing statement when the variable is encountered
var break_on_encounter: Bool
- init(break_on_encounter: Bool)
- do
- trace_map = new HashMap[Frame, String]
- self.break_on_encounter = break_on_encounter
- end
-
# Adds the local alias for a variable and the frame bound to it
fun add_frame_variable(frame: Frame, variable_name: String)
do