Merge branch 'master' into teh/fix_161

Author: KristofferC

Project.toml

@@ -1,6 +1,6 @@
 name = "JuliaInterpreter"
 uuid = "aa1ae85d-cabe-5617-a682-6adf51b2e16a"
-version = "0.1.1"
+version = "0.2.0"
 
 [deps]
 CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2"

docs/src/dev_reference.md

@@ -60,6 +60,8 @@ breakpoint
 enable
 disable
 remove
+break_on
+break_off
 JuliaInterpreter.dummy_breakpoint
 ```
 

src/JuliaInterpreter.jl

@@ -14,7 +14,7 @@ using CodeTracking
 
 export @interpret, Compiled, Frame, root, leaf,
        BreakpointRef, breakpoint, @breakpoint, breakpoints, enable, disable, remove,
-       debug_command, @bp
+       debug_command, @bp, break_on, break_off
 
 module CompiledCalls
 # This module is for handling intrinsics that must be compiled (llvmcall)

src/breakpoints.jl

@@ -129,6 +129,40 @@ function remove()
     return nothing
 end
 
+"""
+    break_on(states...)
+
+Turn on automatic breakpoints when any of the conditions described in `states` occurs.
+The supported states are:
+
+- `:error`: trigger a breakpoint any time an uncaught exception is thrown
+"""
+function break_on(states::Vararg{Symbol})
+    for state in states
+        if state == :error
+            break_on_error[] = true
+        else
+            throw(ArgumentError(string("unsupported state :", state)))
+        end
+    end
+end
+
+"""
+    break_off(states...)
+
+Turn off automatic breakpoints when any of the conditions described in `states` occurs.
+See [`break_on`](@ref) for a description of valid states.
+"""
+function break_off(states::Vararg{Symbol})
+    for state in states
+        if state == :error
+            break_on_error[] = false
+        else
+            throw(ArgumentError(string("unsupported state :", state)))
+        end
+    end
+end
+
 """
     breakpoint(f, sig)
     breakpoint(f, sig, line)

src/commands.jl

@@ -297,38 +297,38 @@ end
 
 Perform one "debugger" command. `cmd` should be one of:
 
-- "n": advance to the next line
-- "s": step into the next call
-- "c": continue execution until termination or reaching a breakpoint
-- "finish": finish the current frame and return to the parent
+- `:n`: advance to the next line
+- `:s`: step into the next call
+- `:c`: continue execution until termination or reaching a breakpoint
+- `:finish`: finish the current frame and return to the parent
 
 or one of the 'advanced' commands
 
-- "nc": step forward to the next call
-- "se": execute a single statement
-- "si": execute a single statement, stepping in if it's a call
-- "sg": step into the generator of a generated function
+- `:nc`: step forward to the next call
+- `:se`: execute a single statement
+- `:si`: execute a single statement, stepping in if it's a call
+- `:sg`: step into the generator of a generated function
 
 `rootistoplevel` and `ret` are as described for [`JuliaInterpreter.maybe_reset_frame!`](@ref).
 """
-function debug_command(@nospecialize(recurse), frame::Frame, cmd::AbstractString, rootistoplevel::Bool=false)
+function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootistoplevel::Bool=false)
     istoplevel = rootistoplevel && frame.caller === nothing
     cmd0 = cmd
-    if cmd == "si"
+    if cmd == :si
         stmt = pc_expr(frame)
-        cmd = is_call(stmt) ? "s" : "se"
+        cmd = is_call(stmt) ? :s : :se
     end
     try
-        cmd == "nc" && return maybe_reset_frame!(recurse, frame, next_call!(recurse, frame, istoplevel), rootistoplevel)
-        cmd == "n" && return maybe_reset_frame!(recurse, frame, next_line!(recurse, frame, istoplevel), rootistoplevel)
-        cmd == "se" && return maybe_reset_frame!(recurse, frame, step_expr!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == :nc && return maybe_reset_frame!(recurse, frame, next_call!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == :n && return maybe_reset_frame!(recurse, frame, next_line!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == :se && return maybe_reset_frame!(recurse, frame, step_expr!(recurse, frame, istoplevel), rootistoplevel)
 
         enter_generated = false
-        if cmd == "sg"
+        if cmd == :sg
             enter_generated = true
-            cmd = "s"
+            cmd = :s
         end
-        if cmd == "s"
+        if cmd == :s
             pc = maybe_next_call!(recurse, frame, istoplevel)
             (isa(pc, BreakpointRef) || pc === nothing) && return maybe_reset_frame!(recurse, frame, pc, rootistoplevel)
             stmt0 = stmt = pc_expr(frame, pc)
@@ -345,7 +345,7 @@ function debug_command(@nospecialize(recurse), frame::Frame, cmd::AbstractString
             end
             if isa(ret, BreakpointRef)
                 newframe = leaf(frame)
-                cmd0 == "si" && return newframe, ret
+                cmd0 == :si && return newframe, ret
                 newframe = maybe_step_through_wrapper!(recurse, newframe)
                 return newframe, BreakpointRef(newframe.framecode, 0)
             end
@@ -354,21 +354,21 @@ function debug_command(@nospecialize(recurse), frame::Frame, cmd::AbstractString
             frame.pc += 1
             return frame, frame.pc
         end
-        if cmd == "c"
+        if cmd == :c
             r = root(frame)
             ret = finish_stack!(recurse, r, rootistoplevel)
             return isa(ret, BreakpointRef) ? (leaf(r), ret) : nothing
         end
-        cmd == "finish" && return maybe_reset_frame!(recurse, frame, finish!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == :finish && return maybe_reset_frame!(recurse, frame, finish!(recurse, frame, istoplevel), rootistoplevel)
     catch err
         frame = unwind_exception(frame, err)
-        if cmd == "c"
-            return debug_command(recurse, frame, "c", istoplevel)
+        if cmd == :c
+            return debug_command(recurse, frame, :c, istoplevel)
         else
-            return debug_command(recurse, frame, "nc", istoplevel)
+            return debug_command(recurse, frame, :nc, istoplevel)
         end
     end
     throw(ArgumentError("command $cmd not recognized"))
 end
-debug_command(frame::Frame, cmd::AbstractString, rootistoplevel::Bool=false) =
+debug_command(frame::Frame, cmd::Symbol, rootistoplevel::Bool=false) =
     debug_command(finish_and_return!, frame, cmd, rootistoplevel)

test/breakpoints.jl

@@ -130,7 +130,8 @@ end
 
     # break on error
     try
-        JuliaInterpreter.break_on_error[] = true
+        @test_throws ArgumentError("unsupported state :missing") break_on(:missing)
+        break_on(:error)
 
         inner(x) = error("oops")
         outer() = inner(1)
@@ -158,7 +159,7 @@ end
         @test v isa ErrorException
         @test stacklength(frame) == 1
     finally
-        JuliaInterpreter.break_on_error[] = false
+        break_off(:error)
     end
 
     # Breakpoint display