X-Git-Url: http://nitlanguage.org

diff --git a/src/debugger.nit b/src/debugger.nit
index 04c2ec6..0f211e6 100644
--- a/src/debugger.nit
+++ b/src/debugger.nit
@@ -19,21 +19,122 @@ 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
+	# 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.
@@ -50,9 +151,23 @@ redef class ModelBuilder
 		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
+# The class extending `NaiveInterpreter` by adding debugging methods
 class Debugger
 	super NaiveInterpreter
 
@@ -70,8 +185,32 @@ class Debugger
 	# 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                  ##
 	#######################################################################
@@ -85,28 +224,230 @@ class Debugger
 		var old = frame.current_node
 		frame.current_node = n
 
-		steps_fun_call(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 process_debug_command(gets) do end
+				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 process_debug_command(gets) do end
+				while read_cmd do end
 			end
 		else if step_in_trigger then
 			n.debug("Execute stmt {n.to_s}")
-			while process_debug_command(gets) do end
+			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
 
@@ -114,20 +455,20 @@ class Debugger
 	##                   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
-		# For lisibility
-		print "\n"
-
-		# Kills the current program
-		if command == "kill" then
-			abort
 		# Step-out command
-		else if command == "finish"
+		if command == "finish"
 		then
 			return step_out
 		# Step-in command
@@ -137,14 +478,61 @@ class Debugger
 		# 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
@@ -202,23 +590,341 @@ class Debugger
 
 			var keys = map_of_instances.iterator
 
-			print "Variables collection : \n"
+			var self_var = seek_variable("self", frame)
+			print "self: {self_var.to_s}"
 
 			for instance in map_of_instances.keys do
-				print "Variable {instance.to_s}, Instance {map_of_instances[instance].to_s}"
+				print "{instance.to_s}: {map_of_instances[instance].to_s}"
 			end
-
-			print "\nEnd of current instruction \n"
+		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(parts_of_command[1], frame)
+			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                           ##
 	#######################################################################
@@ -229,14 +935,65 @@ class Debugger
 	fun print_instance(instance: Instance)
 	do
 		if instance isa MutableInstance then
-			var attributes = instance.attributes
-			print "Object : {instance}"
+			print "\{"
+			print "\ttype : {instance},"
+
+			printn("\t")
+
+			print instance.attributes.join(",\n\t"," : ")
 
-			for current_attribute in attributes.keys do
-				print "Attribute : {current_attribute.to_s} \nValeur : {attributes[current_attribute].to_s}"
+			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
-			print "Found variable {instance}"
+			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
 
@@ -318,6 +1075,178 @@ class Debugger
 	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                   ##
 	#######################################################################
 
@@ -338,4 +1267,179 @@ class Debugger
 		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