# 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

intrude import naive_interpreter
import nitx
intrude import semantize::local_var_init
intrude import semantize::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
	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
			return 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
		return not had_error
	end

	# -d
	var opt_debugger_mode = new OptionBool("Launches the target program with the debugger attached to it", "-d")
	# -c
	var opt_debugger_autorun = 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)

		interpreter.start(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

		interpreter.start(mainmodule)

		var time1 = get_time
		self.toolcontext.info("*** END INTERPRETING: {time1-time0} ***", 2)
	end
end

# Contains all the informations of a Breakpoint for the Debugger
class Breakpoint

	# Line to break on
	var line: Int

	# File concerned by the breakpoint
	var file: String

	redef init do
		if not file.has_suffix(".nit") then file += ".nit"
	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

	redef type FRAME: InterpreterFrame

	#######################################################################
	##                  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
		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 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
		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 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
			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
			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
		# Shows help
		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
		# 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 = command.split_with(' ')
			var cname = parts.first
			# Shows the value of a variable in the current frame
			if cname == "p" or cname == "print" then
				print_command(parts)
			# Places a breakpoint on line x of file y
			else if cname == "break" or cname == "b" then
				process_place_break_fun(parts)
			# Removes a breakpoint on line x of file y
			else if cname == "d" or cname == "delete" then
				process_remove_break_fun(parts)
			# Sets an alias for a variable
			else if parts.length == 2 and parts[1] == "as" then
				process_alias(parts)
			# Modifies the value of a variable in the current frame
			else if parts.length == 3 and parts[1] == "=" then
				process_mod_function(parts)
			# Traces the modifications on a variable
			else if cname == "trace" then
				process_trace_command(parts)
			# Untraces the modifications on a variable
			else if cname == "untrace" then
				process_untrace_command(parts)
			else
				bad_command(command)
			end
		end
		return true
	end

	# Produces help for the commands of the debugger
	fun help do
		print ""
		print "Help :"
		print "-----------------------------------"
		print ""
		print "Variables"
		print " * Modification: var_name = value (Warning: var_name must be primitive)"
		print " * Alias: var_name as alias"
		print ""
		print "Printing"
		print " * Variables: p(rint) var_name (Use * to print all local variables)"
		print " * Collections: p(rint) var_name '[' start_index (.. end_index) ']'"
		print ""
		print "Breakpoints"
		print " * File/line: b(reak) file_name line_number"
		print " * Remove: d(elete) id"
		print ""
		print "Tracepoints"
		print " * Variable: trace var_name break/print"
		print " * Untrace variable: untrace var_name"
		print ""
		print "Flow control"
		print " * Next instruction (same-level): n"
		print " * Next instruction: s"
		print " * Finish current method: finish"
		print " * Continue until next breakpoint or end: c"
		print ""
		print "General commands"
		print " * quit: Quits the debugger"
		print " * abort: Aborts the interpretation, prints the stack trace before leaving"
		print " * nitx: Ask questions to the model about its entities (classes, methods, etc.)"
		print " * nit: Inject dynamic code for interpretation"
		print ""
	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

	fun bad_command(cmd: String) do
		print "Unrecognized command {cmd}. Use 'help' to show help."
	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: Array[String])
	do
		if parts.length != 2 then
			bad_command(parts.join(" "))
			return
		end
		if parts[1] == "*" then
			var map_of_instances = frame.map

			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[1].chars.has('[') and parts[1].chars.has(']') then
			process_array_command(parts)
		else
			var instance = seek_variable(get_real_variable_name(parts[1]), frame)

			if instance != null
			then
				print_instance(instance)
			else
				print "Cannot find variable {parts[1]}"
			end
		end
	end

	# Process the input command to set an alias for a variable
	fun process_alias(parts: Array[String]) do
		if parts.length != 3 then
			bad_command(parts.join(" "))
			return
		end
		add_alias(parts.first, parts.last)
	end

	# Processes the input string to know where to put a breakpoint
	fun process_place_break_fun(parts: Array[String])
	do
		if parts.length != 3 then
			bad_command(parts.join(" "))
			return
		end
		var bp = get_breakpoint_from_command(parts)
		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: Array[String]): nullable Breakpoint
	do
		if parts[1].is_numeric then
			return new Breakpoint(parts[1].to_i, curr_file)
		else if parts.length >= 3 and parts[2].is_numeric then
			return new Breakpoint(parts[2].to_i, parts[1])
		else
			return null
		end
	end

	# Processes the command of removing a breakpoint on specified line and file
	fun process_remove_break_fun(parts: Array[String])
	do
		if parts.length != 2 then
			bad_command(parts.join(" "))
			return
		end
		if parts[1].is_numeric then
			remove_breakpoint(self.curr_file, parts[1].to_i)
		else if parts.length >= 3 and parts[2].is_numeric then
			remove_breakpoint(parts[1], parts[2].to_i)
		end
	end

	# Processes an array print command
	fun process_array_command(parts: Array[String])
	do
		var index_of_first_brace = parts[1].chars.index_of('[')
		var variable_name = get_real_variable_name(parts[1].substring(0,index_of_first_brace))
		var braces = parts[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: Array[String])
	do
		if parts.length != 3 then
			bad_command(parts.join(" "))
			return
		end
		var p0 = parts[0]
		p0 = get_real_variable_name(p0)
		var parts_of_variable = p0.split_with(".")

		if parts_of_variable.length > 1 then
			var last_part = parts_of_variable.pop
			var first_part = p0.substring(0,p0.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[2])
				end
			end
		else
			var target = seek_variable(parts_of_variable[0], frame)
			if target != null then
				modify_in_frame(target, parts[2])
			end
		end
	end

	# Processes the untrace variable command
	#
	# Command pattern : "untrace variable"
	fun process_untrace_command(parts: Array[String])
	do
		if parts.length != 2 then
			bad_command(parts.join(" "))
			return
		end
		var variable_name = get_real_variable_name(parts[1])
		if untrace_variable(variable_name) then
			print "Untraced variable {parts[1]}"
		else
			print "{parts[1]} is not traced"
		end
	end

	# Processes the trace variable command
	#
	# Command pattern : "trace variable [break/print]"
	fun process_trace_command(parts: Array[String])
	do
		if parts.length != 3 then
			bad_command(parts.join(" "))
			return
		end
		var variable_name = get_real_variable_name(parts[1])
		var breaker:Bool

		if seek_variable(variable_name, frame) == null then
			print "Cannot find a variable called {parts[1]}"
			return
		end

		if parts[2] == "break" then
			breaker = true
		else
			breaker = false
		end

		trace_variable(variable_name, breaker)

		print "Successfully tracing {parts[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

		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_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_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")

		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

	#######################################################################
	##                  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 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]
		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 = new HashMap[Frame, String]

	# Decides if breaking or printing statement when the variable is encountered
	var break_on_encounter: Bool

	# 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 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