benchs: use NIT_GC_OPTION instead of -DNOBOEHM

[nit.git] / src / debugger.nit

diff --git a/src/debugger.nit b/src/debugger.nit
index 9807917..87c9a17 100644 (file)
--- a/src/debugger.nit
+++ b/src/debugger.nit
@@ -23,11 +23,14 @@ intrude import naive_interpreter
 redef class ToolContext
        # -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
 
@@ -50,6 +53,20 @@ 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
@@ -93,6 +110,9 @@ class Debugger
        # 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                  ##
        #######################################################################
@@ -106,16 +126,18 @@ class Debugger
                var old = frame.current_node
                frame.current_node = n
 
-               if not n isa ABlockExpr then
-                       steps_fun_call(n)
+               if not self.autocontinue then
+                       if not n isa ABlockExpr then
+                               steps_fun_call(n)
 
-                       breakpoint_check(n)
+                               breakpoint_check(n)
 
-                       check_funcall_and_traced_args(n)
+                               check_funcall_and_traced_args(n)
 
-                       remap(n)
+                               remap(n)
 
-                       check_if_vars_are_traced(n)
+                               check_if_vars_are_traced(n)
+                       end
                end
 
                n.stmt(self)
@@ -349,6 +371,8 @@ class Debugger
                        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].has('[') and parts_of_command[1].has(']') then
                        process_array_command(parts_of_command)
                else
@@ -456,6 +480,9 @@ class Debugger
                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])
@@ -498,6 +525,9 @@ class Debugger
        ##                    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
@@ -515,6 +545,8 @@ class Debugger
                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
@@ -1124,6 +1156,7 @@ class Debugger
                print "[p/print] variable : [p/print] * shows the status of all the variables\n"
                print "[p/print] variable[i] : Prints the value of the variable contained at position *i* in SequenceRead collection *variable*\n"
                print "[p/print] variable[i..j]: Prints the value of all the variables contained between positions *i* and *j* in SequenceRead collection *variable*\n"
+               print "[p/print] stack: Prints a stack trace at current instruction\n"
                print "Note : The arrays can be multi-dimensional (Ex : variable[i..j][k] will print all the values at position *k* of all the SequenceRead collections contained between positions *i* and *j* in SequenceRead collection *variable*)\n"
                print "s : steps in on the current function\n"
                print "n : steps-over the current instruction\n"