+++ /dev/null
-# This file is part of NIT ( http://www.nitlanguage.org ).
-#
-# Copyright 2013 Lucas Bajolet <lucas.bajolet@gmail.com>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Debugging of a nit program using the NaiveInterpreter
-module debugger
-
-import breakpoint
-intrude import naive_interpreter
-import nitx
-intrude import local_var_init
-intrude import scope
-intrude import toolcontext
-private import parser_util
-
-redef class Model
- # Cleans the model to remove a module and what it defines when semantic analysis fails on injected code
- private fun try_remove_module(m: MModule): Bool
- do
- var index = -1
- for i in [0 .. mmodules.length[ do
- if mmodules[i] == m then
- index = i
- break
- end
- end
- if index == -1 then return false
- var mmodule = mmodules[index]
- mmodules.remove_at(index)
- for classdef in mmodule.mclassdefs do
- var mclass = classdef.mclass
- for i in [0 .. mclass.mclassdefs.length[ do
- if mclass.mclassdefs[i] == classdef then
- index = i
- break
- end
- end
- mclass.mclassdefs.remove_at(index)
- var propdefs = classdef.mpropdefs
- for propdef in propdefs do
- var prop = propdef.mproperty
- for i in [0..prop.mpropdefs.length[ do
- if prop.mpropdefs[i] == propdef then
- index = i
- break
- end
- end
- prop.mpropdefs.remove_at(index)
- end
- end
- return true
- end
-end
-
-redef class ScopeVisitor
-
- redef init(toolcontext)
- do
- super
- if toolcontext.dbg != null then
- var localvars = toolcontext.dbg.frame.map
- for i in localvars.keys do
- scopes.first.variables[i.to_s] = i
- end
- end
- end
-
-end
-
-redef class LocalVarInitVisitor
- redef fun mark_is_unset(node: AExpr, variable: nullable Variable)
- do
- super
- if toolcontext.dbg != null then
- var varname = variable.to_s
- var instmap = toolcontext.dbg.frame.map
- for i in instmap.keys do
- if i.to_s == varname then
- mark_is_set(node, variable)
- end
- end
- end
- end
-
-end
-
-redef class ToolContext
- private var dbg: nullable Debugger = null
-
- private var had_error: Bool = false
-
- redef fun check_errors
- do
- if dbg == null then
- super
- else
- if messages.length > 0 then
- message_sorter.sort(messages)
-
- for m in messages do
- if m.text.search("Warning") == null then had_error = true
- sys.stderr.write("{m.to_color_string}\n")
- end
- end
-
- messages.clear
- end
- end
-
- # -d
- var opt_debugger_mode: OptionBool = new OptionBool("Launches the target program with the debugger attached to it", "-d")
- # -c
- var opt_debugger_autorun: OptionBool = new OptionBool("Launches the target program with the interpreter, such as when the program fails, the debugging prompt is summoned", "-c")
-
- redef init
- do
- super
- self.option_context.add_option(self.opt_debugger_mode)
- self.option_context.add_option(self.opt_debugger_autorun)
- 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
- # REQUIRE that:
- # 1. the AST is fully loaded.
- # 2. the model is fully built.
- # 3. the instructions are fully analysed.
- fun run_debugger(mainmodule: MModule, arguments: Array[String])
- do
- var time0 = get_time
- self.toolcontext.info("*** START INTERPRETING ***", 1)
-
- var interpreter = new Debugger(self, mainmodule, arguments)
-
- init_naive_interpreter(interpreter, mainmodule)
-
- var time1 = get_time
- self.toolcontext.info("*** END INTERPRETING: {time1-time0} ***", 2)
- end
-
- fun run_debugger_autorun(mainmodule: MModule, arguments: Array[String])
- do
- var time0 = get_time
- self.toolcontext.info("*** START INTERPRETING ***", 1)
-
- var interpreter = new Debugger(self, mainmodule, arguments)
- interpreter.autocontinue = true
-
- init_naive_interpreter(interpreter, mainmodule)
-
- var time1 = get_time
- self.toolcontext.info("*** END INTERPRETING: {time1-time0} ***", 2)
- end
-end
-
-# The class extending `NaiveInterpreter` by adding debugging methods
-class Debugger
- super NaiveInterpreter
-
- # Keeps the frame count in memory to find when to stop
- # and launch the command prompt after a step out call
- var step_stack_count = 1
-
- # Triggers a step over an instruction in a nit program
- var stop_after_step_over_trigger = true
-
- # Triggers a step out of an instruction
- var stop_after_step_out_trigger= false
-
- # Triggers a step in a instruction (enters a function
- # if the instruction is a function call)
- var step_in_trigger = false
-
- # HashMap containing the breakpoints bound to a file
- var breakpoints = new HashMap[String, HashSet[Breakpoint]]
-
- # Contains the current file
- var curr_file = ""
-
- # Aliases hashmap (maps an alias to a variable name)
- var aliases = new HashMap[String, String]
-
- # Set containing all the traced variables and their related frame
- private var traces = new HashSet[TraceObject]
-
- # Map containing all the positions for the positions of the arguments traced
- # In a function call
- private var fun_call_arguments_positions = new HashMap[Int, TraceObject]
-
- # Triggers the remapping of a trace object in the local context after a function call
- var aftermath = false
-
- # Used to prevent the case when the body of the function called is empty
- # If it is not, then, the remapping won't be happening
- var frame_count_aftermath = 1
-
- # Auto continues the execution until the end or until an error is encountered
- var autocontinue = false
-
- #######################################################################
- ## Execution of statement function ##
- #######################################################################
-
- # Main loop, every call to a debug command is done here
- redef fun stmt(n: nullable AExpr)
- do
- if n == null then return
-
- var frame = self.frame
- var old = frame.current_node
- frame.current_node = n
-
- if sys.stdin.poll_in then process_debug_command(gets)
-
- if not self.autocontinue then
- if not n isa ABlockExpr then
- steps_fun_call(n)
-
- breakpoint_check(n)
-
- check_funcall_and_traced_args(n)
-
- remap(n)
-
- check_if_vars_are_traced(n)
- end
- end
-
- n.stmt(self)
- frame.current_node = old
- end
-
- # Does the same as an usual send, except it will modify the call chain on the first call when injecting code at Runtime using the debugger.
- # Instead of creating a pristine Frame, it will copy the actual values of the frame, and re-inject them after execution in the current context.
- fun rt_send(mproperty: MMethod, args: Array[Instance]): nullable Instance
- do
- var recv = args.first
- var mtype = recv.mtype
- var ret = send_commons(mproperty, args, mtype)
- if ret != null then return ret
- var propdef = mproperty.lookup_first_definition(self.mainmodule, mtype)
- return self.rt_call(propdef, args)
- end
-
- # Same as a regular call but for a runtime injected module
- #
- fun rt_call(mpropdef: MMethodDef, args: Array[Instance]): nullable Instance
- do
- args = call_commons(mpropdef, args)
- return rt_call_without_varargs(mpropdef, args)
- end
-
- # Common code to call and this function
- #
- # Call only executes the variadic part, this avoids
- # double encapsulation of variadic parameters into an Array
- fun rt_call_without_varargs(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
- 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.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")
- abort
- end
- end
-
- # Evaluates dynamically a snippet of Nit code
- # `nit_code` : Nit code to be executed
- fun eval(nit_code: String)
- do
- var local_toolctx = modelbuilder.toolcontext
- local_toolctx.dbg = self
- var e = local_toolctx.parse_something(nit_code)
- if e isa ABlockExpr then
- nit_code = "module rt_module\n" + nit_code
- e = local_toolctx.parse_something(nit_code)
- end
- if e isa AExpr then
- nit_code = "module rt_module\nprint " + nit_code
- e = local_toolctx.parse_something(nit_code)
- end
- if e isa AModule then
- local_toolctx.had_error = false
- modelbuilder.load_rt_module(self.mainmodule, e, "rt_module")
- local_toolctx.run_phases([e])
- if local_toolctx.had_error then
- modelbuilder.model.try_remove_module(e.mmodule.as(not null))
- local_toolctx.dbg = null
- return
- end
- var mmod = e.mmodule
- if mmod != null then
- self.mainmodule = mmod
- var local_classdefs = mmod.mclassdefs
- var sys_type = mmod.sys_type
- if sys_type == null then
- print "Fatal error, cannot find Class Sys !\nAborting"
- abort
- end
- var mobj = new MutableInstance(sys_type)
- init_instance(mobj)
- var initprop = mmod.try_get_primitive_method("init", sys_type.mclass)
- if initprop != null then
- self.send(initprop, [mobj])
- end
- var mainprop = mmod.try_get_primitive_method("run", sys_type.mclass) or else
- mmod.try_get_primitive_method("main", sys_type.mclass)
- if mainprop != null then
- self.rt_send(mainprop, [mobj])
- end
- else
- print "Error while loading_rt_module"
- end
- else
- print "Error when parsing, e = {e.class_name}"
- end
- local_toolctx.dbg = null
- end
-
- # Encpasulates the behaviour for step over/out
- private fun steps_fun_call(n: AExpr)
- do
- if self.stop_after_step_over_trigger then
- if self.frames.length <= self.step_stack_count then
- n.debug("Execute stmt {n.to_s}")
- while read_cmd do end
- end
- else if self.stop_after_step_out_trigger then
- if frames.length < self.step_stack_count then
- n.debug("Execute stmt {n.to_s}")
- while read_cmd do end
- end
- else if step_in_trigger then
- n.debug("Execute stmt {n.to_s}")
- while read_cmd do end
- end
- end
-
- # Checks if a breakpoint is encountered, and launches the debugging prompt if true
- private fun breakpoint_check(n: AExpr)
- do
- var currFileNameSplit = self.frame.current_node.location.file.filename.to_s.split_with("/")
-
- self.curr_file = currFileNameSplit[currFileNameSplit.length-1]
-
- var breakpoint = find_breakpoint(curr_file, n.location.line_start)
-
- if breakpoints.keys.has(curr_file) and breakpoint != null then
-
- breakpoint.check_in
-
- if not breakpoint.is_valid
- then
- remove_breakpoint(curr_file, n.location.line_start)
- end
-
- n.debug("Execute stmt {n.to_s}")
- while read_cmd do end
- end
- end
-
- # Check if a variable of current expression is traced
- # Then prints and/or breaks for command prompt
- private fun check_if_vars_are_traced(n: AExpr)
- do
- var identifiers_in_instruction = get_identifiers_in_current_instruction(n.location.text)
-
- for i in identifiers_in_instruction do
- var variable = seek_variable(i, frame)
- for j in self.traces do
- if j.is_variable_traced_in_frame(i, frame) then
- n.debug("Traced variable {i} used")
- if j.break_on_encounter then while read_cmd do end
- break
- end
- end
- end
- end
-
- # Function remapping all the traced objects to match their name in the local context
- private fun remap(n: AExpr)
- do
- if self.aftermath then
-
- # Trace every argument variable pre-specified
- if self.frame_count_aftermath < frames.length and fun_call_arguments_positions.length > 0 then
-
- var ids_in_fun_def = get_identifiers_in_current_instruction(get_function_arguments(frame.mpropdef.location.text))
-
- for i in fun_call_arguments_positions.keys do
- self.fun_call_arguments_positions[i].add_frame_variable(frame, ids_in_fun_def[i])
- end
- end
-
- self.aftermath = false
- end
- end
-
- # If the current instruction is a function call
- # We analyse its signature and the position of traced arguments if the call
- # For future remapping when inside the function
- private fun check_funcall_and_traced_args(n: AExpr) do
- # If we have a function call, we need to see if any of the arguments is traced (including the caller)
- # if it is, next time we face an instruction, we'll trace the local version on the traced variable in the next frame
- if n isa ACallExpr then
- self.aftermath = true
- self.frame_count_aftermath = frames.length
- fun_call_arguments_positions.clear
- var fun_arguments = get_identifiers_in_current_instruction(get_function_arguments(n.location.text))
-
- for i in self.traces do
- for j in [0 .. fun_arguments.length - 1] do
- if i.is_variable_traced_in_frame(fun_arguments[j],frame) then
- fun_call_arguments_positions[j] = i
- end
- end
- end
- end
- end
-
- #######################################################################
- ## Processing commands functions ##
- #######################################################################
-
- fun read_cmd: Bool
- do
- printn "> "
- return process_debug_command(gets)
- end
-
- # Takes a user command as a parameter
- #
- # Returns a boolean value, representing whether or not to
- # continue reading commands from the console input
- fun process_debug_command(command:String): Bool
- do
- # Step-out command
- if command == "finish"
- then
- return step_out
- # Step-in command
- else if command == "s"
- then
- return step_in
- # Step-over command
- else if command == "n" then
- return step_over
- # Opens a new NitIndex prompt on current model
- else if command == "nitx" then
- new NitIndex.with_infos(modelbuilder, self.mainmodule).prompt
- return true
- # Continues execution until the end
- else if command == "c" then
- return continue_exec
- else if command == "nit" then
- printn "$~> "
- command = gets
- var nit_buf = new FlatBuffer
- while not command == ":q" do
- nit_buf.append(command)
- nit_buf.append("\n")
- printn "$~> "
- command = gets
- end
- step_in
- eval(nit_buf.to_s)
- else if command == "quit" then
- exit(0)
- else if command == "abort" then
- print stack_trace
- exit(0)
- else
- var parts_of_command = command.split_with(' ')
- # Shows the value of a variable in the current frame
- if parts_of_command[0] == "p" or parts_of_command[0] == "print" then
- print_command(parts_of_command)
- # Places a breakpoint on line x of file y
- else if parts_of_command[0] == "break" or parts_of_command[0] == "b"
- then
- process_place_break_fun(parts_of_command)
- # Places a temporary breakpoint on line x of file y
- else if parts_of_command[0] == "tbreak" and (parts_of_command.length == 2 or parts_of_command.length == 3)
- then
- process_place_tbreak_fun(parts_of_command)
- # Removes a breakpoint on line x of file y
- else if parts_of_command[0] == "d" or parts_of_command[0] == "delete" then
- process_remove_break_fun(parts_of_command)
- # Sets an alias for a variable
- else if parts_of_command.length == 3 and parts_of_command[1] == "as"
- then
- add_alias(parts_of_command[0], parts_of_command[2])
- # Modifies the value of a variable in the current frame
- else if parts_of_command.length >= 3 and parts_of_command[1] == "=" then
- process_mod_function(parts_of_command)
- # Traces the modifications on a variable
- else if parts_of_command.length >= 2 and parts_of_command[0] == "trace" then
- process_trace_command(parts_of_command)
- # Untraces the modifications on a variable
- else if parts_of_command.length == 2 and parts_of_command[0] == "untrace" then
- process_untrace_command(parts_of_command)
- else
- print "Unknown command \"{command}\""
- end
- end
- return true
- end
-
- #######################################################################
- ## Processing specific command functions ##
- #######################################################################
-
- # Sets the flags to step-over an instruction in the current file
- fun step_over: Bool
- do
- self.step_stack_count = frames.length
- self.stop_after_step_over_trigger = true
- self.stop_after_step_out_trigger = false
- self.step_in_trigger = false
- return false
- end
-
- #Sets the flags to step-out of a function
- fun step_out: Bool
- do
- self.stop_after_step_over_trigger = false
- self.stop_after_step_out_trigger = true
- self.step_in_trigger = false
- self.step_stack_count = frames.length
- return false
- end
-
- # Sets the flags to step-in an instruction
- fun step_in: Bool
- do
- self.step_in_trigger = true
- self.stop_after_step_over_trigger = false
- self.stop_after_step_out_trigger = false
- return false
- end
-
- # Sets the flags to continue execution
- fun continue_exec: Bool
- do
- self.stop_after_step_over_trigger = false
- self.stop_after_step_out_trigger = false
- self.step_in_trigger = false
- return false
- end
-
- # Prints the demanded variable in the command
- #
- # The name of the variable in in position 1 of the array 'parts_of_command'
- fun print_command(parts_of_command: Array[String])
- do
- if parts_of_command[1] == "*" then
- var map_of_instances = frame.map
-
- var keys = map_of_instances.iterator
-
- var self_var = seek_variable("self", frame)
- print "self: {self_var.to_s}"
-
- for instance in map_of_instances.keys do
- print "{instance.to_s}: {map_of_instances[instance].to_s}"
- end
- else if parts_of_command[1] == "stack" then
- print self.stack_trace
- else if parts_of_command[1].chars.has('[') and parts_of_command[1].chars.has(']') then
- process_array_command(parts_of_command)
- else
- var instance = seek_variable(get_real_variable_name(parts_of_command[1]), frame)
-
- if instance != null
- then
- print_instance(instance)
- else
- print "Cannot find variable {parts_of_command[1]}"
- end
- end
- end
-
- # Processes the input string to know where to put a breakpoint
- fun process_place_break_fun(parts_of_command: Array[String])
- do
- var bp = get_breakpoint_from_command(parts_of_command)
- if bp != null then
- place_breakpoint(bp)
- end
- end
-
- # Returns a breakpoint containing the informations stored in the command
- fun get_breakpoint_from_command(parts_of_command: Array[String]): nullable Breakpoint
- do
- if parts_of_command[1].is_numeric then
- return new Breakpoint(parts_of_command[1].to_i, curr_file)
- else if parts_of_command.length >= 3 and parts_of_command[2].is_numeric then
- return new Breakpoint(parts_of_command[2].to_i, parts_of_command[1])
- else
- return null
- end
- end
-
- # Processes the command of removing a breakpoint on specified line and file
- fun process_remove_break_fun(parts_of_command: Array[String])
- do
- if parts_of_command[1].is_numeric then
- remove_breakpoint(self.curr_file, parts_of_command[1].to_i)
- else if parts_of_command.length >= 3 and parts_of_command[2].is_numeric then
- remove_breakpoint(parts_of_command[1], parts_of_command[2].to_i)
- end
- end
-
- # Processes an array print command
- fun process_array_command(parts_of_command: Array[String])
- do
- var index_of_first_brace = parts_of_command[1].chars.index_of('[')
- var variable_name = get_real_variable_name(parts_of_command[1].substring(0,index_of_first_brace))
- var braces = parts_of_command[1].substring_from(index_of_first_brace)
-
- var indexes = remove_braces(braces)
-
- var index_array = new Array[Array[Int]]
-
- if indexes != null then
- for index in indexes do
- var temp_indexes_array = process_index(index)
- if temp_indexes_array != null then
- index_array.push(temp_indexes_array)
- #print index_array.last
- end
- end
- end
-
- var instance = seek_variable(variable_name, frame)
-
- if instance != null then
- print_nested_collection(instance, index_array, 0, variable_name, "")
- else
- print "Cannot find variable {variable_name}"
- end
- end
-
- # Processes the modification function to modify a variable dynamically
- #
- # Command of type variable = value
- fun process_mod_function(parts_of_command: Array[String])
- do
- parts_of_command[0] = get_real_variable_name(parts_of_command[0])
- var parts_of_variable = parts_of_command[0].split_with(".")
-
- if parts_of_variable.length > 1 then
- var last_part = parts_of_variable.pop
- var first_part = parts_of_command[0].substring(0,parts_of_command[0].length - last_part.length - 1)
- var papa = seek_variable(first_part, frame)
-
- if papa != null and papa isa MutableInstance then
- var attribute = get_attribute_in_mutable_instance(papa, last_part)
-
- if attribute != null then
- modify_argument_of_complex_type(papa, attribute, parts_of_command[2])
- end
- end
- else
- var target = seek_variable(parts_of_variable[0], frame)
- if target != null then
- modify_in_frame(target, parts_of_command[2])
- end
- end
- end
-
- # Processes the untrace variable command
- #
- # Command pattern : "untrace variable"
- fun process_untrace_command(parts_of_command: Array[String])
- do
- var variable_name = get_real_variable_name(parts_of_command[1])
- if untrace_variable(variable_name) then
- print "Untraced variable {parts_of_command[1]}"
- else
- print "{parts_of_command[1]} is not traced"
- end
- end
-
- # Processes the trace variable command
- #
- # Command pattern : "trace variable [break/print]"
- fun process_trace_command(parts_of_command: Array[String])
- do
- var variable_name = get_real_variable_name(parts_of_command[1])
- var breaker:Bool
-
- if seek_variable(variable_name, frame) == null then
- print "Cannot find a variable called {parts_of_command[1]}"
- return
- end
-
- if parts_of_command.length == 3 then
- if parts_of_command[2] == "break" then
- breaker = true
- else
- breaker = false
- end
- else
- breaker = false
- end
-
- trace_variable(variable_name, breaker)
-
- print "Successfully tracing {parts_of_command[1]}"
- end
-
- #######################################################################
- ## Trace Management functions ##
- #######################################################################
-
- # Effectively untraces the variable called *variable_name*
- #
- # Returns true if the variable exists, false otherwise
- private fun untrace_variable(variable_name: String): Bool
- do
- var to_remove: nullable TraceObject = null
- for i in self.traces do
- if i.is_variable_traced_in_frame(variable_name, frame) then
- to_remove = i
- end
- end
-
- if to_remove != null then
- self.traces.remove(to_remove)
- return true
- else
- return false
- end
- end
-
- # Effectively traces the variable *variable_name* either in print or break mode depending on the value of breaker (break if true, print if false)
- #
- private fun trace_variable(variable_name: String, breaker: Bool)
- do
- for i in self.traces do
- if i.is_variable_traced_in_frame(variable_name, frame) then
- print "This variable is already traced"
- return
- end
- end
-
- var trace_object: TraceObject
-
- if breaker then
- trace_object = new TraceObject(true)
- else
- trace_object = new TraceObject(false)
- end
-
- # We trace the current variable found for the current frame
- trace_object.add_frame_variable(self.frame, variable_name)
-
- var position_of_variable_in_arguments = get_position_of_variable_in_arguments(frame, variable_name)
-
- # Start parsing the frames starting with the parent of the current one, until the highest
- # When the variable traced is declared locally, the loop stops
- for i in [1 .. frames.length-1] do
-
- # If the variable was reported to be an argument of the previous frame
- if position_of_variable_in_arguments != -1 then
-
- var local_name = get_identifiers_in_current_instruction(get_function_arguments(frames[i].current_node.location.text))[position_of_variable_in_arguments]
-
- position_of_variable_in_arguments = get_position_of_variable_in_arguments(frames[i], local_name)
-
- trace_object.add_frame_variable(frames[i], local_name)
- else
- break
- end
- end
-
- self.traces.add(trace_object)
- end
-
- # 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
- do
- var identifiers = get_identifiers_in_current_instruction(get_function_arguments(frame.mpropdef.location.text))
- for i in [0 .. identifiers.length-1] do
- # If the current traced variable is an argument of the current function, we trace its parent (at least)
- if identifiers[i] == variable_name then return i
- end
- return -1
- end
-
- # Gets all the identifiers of an instruction (uses the rules of Nit as of Mar 05 2013)
- #
- fun get_identifiers_in_current_instruction(instruction: Text): Array[String]
- do
- var result_array = new Array[String]
- var instruction_buffer = new FlatBuffer
-
- var trigger_char_escape = false
- var trigger_string_escape = false
- var trigger_concat_in_string = false
-
- for i in instruction.chars do
- if trigger_char_escape then
- if i == '\'' then trigger_char_escape = false
- else if trigger_string_escape then
- if i == '{' then
- trigger_concat_in_string = true
- trigger_string_escape = false
- else if i == '\"' then trigger_string_escape = false
- else
- if i.is_alphanumeric or i == '_' then
- instruction_buffer.add(i)
- else if i == '.' then
- if instruction_buffer.is_numeric or (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then
- instruction_buffer.clear
- else
- result_array.push(instruction_buffer.to_s)
- instruction_buffer.add(i)
- end
- else if i == '\'' then
- trigger_char_escape = true
- else if i == '\"' then
- trigger_string_escape = true
- else if i == '}' then
- trigger_concat_in_string = false
- trigger_string_escape = true
- else
- if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
- instruction_buffer.clear
- end
- end
- end
-
- if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
-
- return result_array
- end
-
- # Takes a function call or declaration and strips all but the arguments
- #
- fun get_function_arguments(function: Text): String
- do
- var buf = new FlatBuffer
- var trigger_copy = false
-
- for i in function.chars do
- if i == ')' then break
- if trigger_copy then buf.add(i)
- if i == '(' then trigger_copy = true
- end
-
- return buf.to_s
- end
-
- #######################################################################
- ## Alias management functions ##
- #######################################################################
-
- # Adds a new alias to the tables
- fun add_alias(var_represented: String, alias: String)
- do
- self.aliases[alias] = var_represented
- end
-
- # Gets the real name of a variable hidden by an alias
- fun get_variable_name_by_alias(alias: String): nullable String
- do
- if self.aliases.keys.has(alias) then
- return self.aliases[alias]
- end
-
- return null
- end
-
- # Gets the variable named by name, whether it is an alias or not
- fun get_real_variable_name(name: String): String
- do
- var explode_string = name.split_with(".")
- var final_string = new FlatBuffer
- for i in explode_string do
- var alias_resolved = get_variable_name_by_alias(i)
- if alias_resolved != null then
- final_string.append(get_real_variable_name(alias_resolved))
- else
- final_string.append(i)
- end
- final_string.append(".")
- end
-
- return final_string.substring(0,final_string.length-1).to_s
- end
-
- #######################################################################
- ## Print functions ##
- #######################################################################
-
- # Prints an object instance and its attributes if it has some
- #
- # If it is a primitive type, its value is directly printed
- fun print_instance(instance: Instance)
- do
- if instance isa MutableInstance then
- print "\{"
- print "\ttype : {instance},"
-
- printn("\t")
-
- print instance.attributes.join(",\n\t"," : ")
-
- print "\}"
- else
- print "{instance}"
- end
- end
-
- # Prints the attributes demanded in a SequenceRead
- # Used recursively to print nested collections
- fun print_nested_collection(instance: Instance, indexes: Array[Array[Int]], depth: Int, variable_name: String, depth_string: String)
- do
- var collection: nullable SequenceRead[Object] = null
- var real_collection_length: nullable Int = null
-
- if instance isa MutableInstance then
- real_collection_length = get_collection_instance_real_length(instance)
- collection = get_primary_collection(instance)
- end
-
- if collection != null and real_collection_length != null then
- for i in indexes[depth] do
- if i >= 0 and i < real_collection_length then
- if depth == indexes.length-1 then
- print "{variable_name}{depth_string}[{i}] = {collection[i]}"
- else
- var item_i = collection[i]
-
- if item_i isa MutableInstance then
- print_nested_collection(item_i, indexes, depth+1, variable_name, depth_string+"[{i}]")
- else
- print "The item at {variable_name}{depth_string}[{i}] is not a collection"
- print item_i
- end
- end
- else
- print "Out of bounds exception : i = {i} and collection_length = {real_collection_length.to_s}"
-
- if i < 0 then
- continue
- else if i >= real_collection_length then
- break
- end
- end
- end
- else
- if collection == null then
- print "Cannot find {variable_name}{depth_string}"
- else if real_collection_length != null then
- print "Cannot find attribute length in {instance}"
- else
- print "Unknown error."
- abort
- end
- end
- end
-
- #######################################################################
- ## Variable Exploration functions ##
- #######################################################################
-
- # 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
- do
- var full_variable = variable_path.split_with(".")
-
- var full_variable_iterator = full_variable.iterator
-
- var first_instance = get_variable_in_frame(full_variable_iterator.item, frame)
-
- if first_instance == null then return null
-
- if full_variable.length <= 1 then return first_instance
-
- full_variable_iterator.next
-
- if not (first_instance isa MutableInstance and full_variable_iterator.is_ok) then return null
-
- return get_variable_in_mutable_instance(first_instance, full_variable_iterator)
- end
-
- # Gets a variable 'variable_name' contained in the frame 'frame'
- 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
- end
-
- var map_of_instances = frame.map
-
- for key in map_of_instances.keys do
- if key.to_s == variable_name then
- return map_of_instances[key]
- end
- end
-
- return null
- end
-
- # Gets an attribute 'attribute_name' contained in variable 'variable'
- fun get_attribute_in_mutable_instance(variable: MutableInstance, attribute_name: String): nullable MAttribute
- do
- var map_of_attributes = variable.attributes
-
- for key in map_of_attributes.keys do
- if key.to_s.substring_from(1) == attribute_name then
- return key
- end
- end
-
- return null
- end
-
- # Recursive function, returns the variable described by 'total_chain'
- fun get_variable_in_mutable_instance(variable: MutableInstance, iterator: Iterator[String]): nullable Instance
- do
- var attribute = get_attribute_in_mutable_instance(variable, iterator.item)
-
- if attribute == null then return null
-
- iterator.next
-
- if iterator.is_ok then
- var new_variable = variable.attributes[attribute]
- if new_variable isa MutableInstance then
- return get_variable_in_mutable_instance(new_variable, iterator)
- else
- return null
- end
- else
- return variable.attributes[attribute]
- end
- end
-
- #######################################################################
- ## Array exploring functions ##
- #######################################################################
-
- # Gets the length of a collection
- # Used by the debugger, else if we call Collection.length, it returns the capacity instead
- fun get_collection_instance_real_length(collection: MutableInstance): nullable Int
- do
- var collection_length_attribute = get_attribute_in_mutable_instance(collection, "length")
-
- var real_collection_length: nullable Int = null
-
- if collection_length_attribute != null then
- var primitive_length_instance = collection.attributes[collection_length_attribute]
- if primitive_length_instance isa PrimitiveInstance[Int] then
- return primitive_length_instance.val
- end
- end
-
- return null
- end
-
- # Processes the indexes of a print array call
- # Returns an array containing all the indexes demanded
- fun process_index(index_string: String): nullable Array[Int]
- do
- var from_end_index = index_string.chars.index_of('.')
- var to_start_index = index_string.chars.last_index_of('.')
-
- if from_end_index != -1 and to_start_index != -1 then
- var index_from_string = index_string.substring(0,from_end_index)
- var index_to_string = index_string.substring_from(to_start_index+1)
-
- if index_from_string.is_numeric and index_to_string.is_numeric then
- var result_array = new Array[Int]
-
- var index_from = index_from_string.to_i
- var index_to = index_to_string.to_i
-
- for i in [index_from..index_to] do
- result_array.push(i)
- end
-
- return result_array
- end
- else
- if index_string.is_numeric
- then
- var result_array = new Array[Int]
-
- result_array.push(index_string.to_i)
-
- return result_array
- else
- return null
- end
- end
-
- return null
- end
-
- # Gets a collection in a MutableInstance
- fun get_primary_collection(container: MutableInstance): nullable SequenceRead[Object]
- do
- var items_of_array = get_attribute_in_mutable_instance(container, "items")
- if items_of_array != null then
- var array = container.attributes[items_of_array]
-
- if array isa PrimitiveInstance[Object] then
- var sequenceRead_final = array.val
- if sequenceRead_final isa SequenceRead[Object] then
- return sequenceRead_final
- end
- end
- end
-
- return null
- end
-
- # Removes the braces '[' ']' in a print array command
- # Returns an array containing their content
- fun remove_braces(braces: String): nullable Array[String]
- do
- var buffer = new FlatBuffer
-
- var result_array = new Array[String]
-
- var number_of_opening_brackets = 0
- var number_of_closing_brackets = 0
-
- var last_was_opening_bracket = false
-
- for i in braces.chars do
- if i == '[' then
- if last_was_opening_bracket then
- return null
- end
-
- number_of_opening_brackets += 1
- last_was_opening_bracket = true
- else if i == ']' then
- if not last_was_opening_bracket then
- return null
- end
-
- result_array.push(buffer.to_s)
- buffer.clear
- number_of_closing_brackets += 1
- last_was_opening_bracket = false
- else if i.is_numeric or i == '.' then
- buffer.append(i.to_s)
- else if not i == ' ' then
- return null
- end
- end
-
- if number_of_opening_brackets != number_of_closing_brackets then
- return null
- end
-
- return result_array
- end
-
- #######################################################################
- ## Breakpoint placing functions ##
- #######################################################################
-
- # Places a breakpoint on line 'line_to_break' for file 'file_to_break'
- fun place_breakpoint(breakpoint: Breakpoint)
- do
- if not self.breakpoints.keys.has(breakpoint.file) then
- self.breakpoints[breakpoint.file] = new HashSet[Breakpoint]
- end
- if find_breakpoint(breakpoint.file, breakpoint.line) == null then
- self.breakpoints[breakpoint.file].add(breakpoint)
- print "Breakpoint added on line {breakpoint.line} for file {breakpoint.file}"
- else
- print "Breakpoint already present on line {breakpoint.line} for file {breakpoint.file}"
- end
- end
-
- #Places a breakpoint that will trigger once and be destroyed afterwards
- fun process_place_tbreak_fun(parts_of_command: Array[String])
- do
- var bp = get_breakpoint_from_command(parts_of_command)
- if bp != null
- then
- bp.set_max_breaks(1)
- place_breakpoint(bp)
- end
- end
-
- #######################################################################
- ## Breakpoint removing functions ##
- #######################################################################
-
- # Removes a breakpoint on line 'line_to_break' for file 'file_to_break'
- fun remove_breakpoint(file_to_break: String, line_to_break: Int)
- do
- if self.breakpoints.keys.has(file_to_break) then
- var bp = find_breakpoint(file_to_break, line_to_break)
-
- if bp != null then
- self.breakpoints[file_to_break].remove(bp)
- print "Breakpoint removed on line {line_to_break} for file {file_to_break}"
- return
- end
- end
-
- print "No breakpoint existing on line {line_to_break} for file {file_to_break}"
- end
-
- #######################################################################
- ## Breakpoint searching functions ##
- #######################################################################
-
- # Finds a breakpoint for 'file' and 'line' in the class HashMap
- fun find_breakpoint(file: String, line: Int): nullable Breakpoint
- do
- if self.breakpoints.keys.has(file)
- then
- for i in self.breakpoints[file]
- do
- if i.line == line
- then
- return i
- end
- end
- end
-
- return null
- end
-
- #######################################################################
- ## Runtime modification functions ##
- #######################################################################
-
- # Modifies the value of a variable contained in a frame
- fun modify_in_frame(variable: Instance, value: String)
- do
- var new_variable = get_variable_of_type_with_value(variable.mtype.to_s, value)
- if new_variable != null
- then
- var keys = frame.map.keys
- for key in keys
- do
- if frame.map[key] == variable
- then
- frame.map[key] = new_variable
- end
- end
- end
- end
-
- # Modifies the value of a variable contained in a MutableInstance
- fun modify_argument_of_complex_type(papa: MutableInstance, attribute: MAttribute, value: String)
- do
- var final_variable = papa.attributes[attribute]
- var type_of_variable = final_variable.mtype.to_s
- var new_variable = get_variable_of_type_with_value(type_of_variable, value)
- if new_variable != null
- then
- papa.attributes[attribute] = new_variable
- end
- end
-
- #######################################################################
- ## Variable generator functions ##
- #######################################################################
-
- # Returns a new variable of the type 'type_of_variable' with a value of 'value'
- fun get_variable_of_type_with_value(type_of_variable: String, value: String): nullable Instance
- do
- if type_of_variable == "Int" then
- return get_int(value)
- else if type_of_variable == "Float" then
- return get_float(value)
- else if type_of_variable == "Bool" then
- return get_bool(value)
- else if type_of_variable == "Char" then
- return get_char(value)
- end
-
- return null
- end
-
- # Returns a new int instance with value 'value'
- fun get_int(value: String): nullable Instance
- do
- if value.is_numeric then
- return int_instance(value.to_i)
- else
- return null
- end
- end
-
- # Returns a new float instance with value 'value'
- fun get_float(value:String): nullable Instance
- do
- if value.is_numeric then
- return float_instance(value.to_f)
- else
- return null
- end
- end
-
- # Returns a new char instance with value 'value'
- fun get_char(value: String): nullable Instance
- do
- if value.length >= 1 then
- return char_instance(value.chars[0])
- else
- return null
- end
- end
-
- # Returns a new bool instance with value 'value'
- fun get_bool(value: String): nullable Instance
- do
- if value.to_lower == "true" then
- return self.true_instance
- else if value.to_lower == "false" then
- return self.false_instance
- else
- print "Invalid value, a boolean must be set at \"true\" or \"false\""
- return null
- end
- end
-
-end
-
-redef class AMethPropdef
-
- # Same as call except it will copy local variables of the parent frame to the frame defined in this call.
- # 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 curr_instances = v.frame.map
- for i in curr_instances.keys do
- f.map[i] = curr_instances[i]
- end
- call_commons(v,mpropdef,args,f)
- var currFra = v.frames.shift
- for i in curr_instances.keys do
- if currFra.map.keys.has(i) then
- curr_instances[i] = currFra.map[i]
- end
- end
- if v.returnmark == f then
- v.returnmark = null
- var res = v.escapevalue
- v.escapevalue = null
- return res
- end
- return null
-
- end
-end
-
-# Traces the modifications of an object linked to a certain frame
-private class TraceObject
-
- # Map of the local names bound to a frame
- var trace_map: 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
- self.trace_map[frame] = variable_name
- end
-
- # Checks if the prompted variable is traced in the specified frame
- fun is_variable_traced_in_frame(variable_name: String, frame: Frame): Bool
- do
- if self.trace_map.has_key(frame) then
- if self.trace_map[frame] == variable_name then
- return true
- end
- end
-
- return false
- end
-
-end
-
-redef class ANode
-
- # Breaks automatically when encountering an error
- # Permits the injunction of commands before crashing
- redef private fun fatal(v: NaiveInterpreter, message: String)
- do
- if v isa Debugger then
- print "An error was encountered, the program will stop now."
- self.debug(message)
- while v.process_debug_command(gets) do end
- end
-
- super
- end
-end
nitlanguage / nit.git / blobdiff
