Initial working commit

REQUIRE

@@ -1 +1,2 @@
 julia 0.4
+Compat

src/DebuggingUtilities.jl

@@ -1,5 +1,150 @@
+__precompile__()
+
 module DebuggingUtilities
 
-# package code goes here
+using Compat
+
+export @showln, test_showline, time_showline
+
+"""
+DebuggingUtilities contains a few tools that may help debug julia code. The
+exported tools are:
+
+- `@showln`: a macro for displaying variables and corresponding function, file, and line number information
+- `test_showline`: a function that displays progress as it executes a file
+- `time_showline`: a function that displays execution time for each expression in a file
+"""
+DebuggingUtilities
+
+## @showln
+
+btvalid(lkup) = !isempty(lkup)
+btfrom_c(lkup) = lkup[length(lkup)-1]
+
+if VERSION < v"0.5.0-dev"
+    function print_btinfo(io, lkup)
+        funcname, file, line = lkup
+        print(io, "in ", funcname, " at ", file, ", line ", line)
+    end
+else
+    function print_btinfo(io, lkup)
+        funcname = lkup[1]
+        print(io, "in ", funcname)
+        for i = 2:2:length(lkup)-3
+            print(io, " at ", lkup[i], ":", lkup[i+1])
+        end
+    end
+end
+
+function show_backtrace1(io, bt)
+    for t in bt
+        lkup = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Int32), t, 0)
+        if btvalid(lkup) && !btfrom_c(lkup)
+            funcname = lkup[1]
+            if funcname != :backtrace
+                print_btinfo(io, lkup)
+                break
+            end
+        end
+    end
+end
+
+const showlnio = Ref{IO}(STDOUT)
+
+"""
+`@showln x` prints "x = val", where `val` is the value of `x`, along
+with information about the function, file, and line number at which
+this statement was executed. For example:
+
+    function foo()
+        x = 5
+        @showln x
+        x = 7
+        @showln x
+        nothing
+    end
+
+might produce output like
+
+            x = 5
+            (in foo at ./error.jl:26 at /tmp/showln_test.jl:52)
+            x = 7
+            (in foo at ./error.jl:26 at /tmp/showln_test.jl:54)
+
+This macro causes a backtrace to be taken, and looking up the
+corresponding code information is relatively expensive, so using
+`@showln` can have a substantial performance cost.
+
+The indentation of the line is proportional to the length of the
+backtrace, and consequently is an indication of recursion depth.
+
+Line numbers are not typically correct on julia-0.4.
+"""
+macro showln(exs...)
+    blk = Expr(:block)
+    for ex in exs
+        push!(blk.args, :(println(showlnio[], " "^indent, sprint(Base.show_unquoted,$(Expr(:quote, ex)),indent)*" = ", repr(begin value=$(esc(ex)) end))))
+    end
+    if !isempty(exs); push!(blk.args, :value); end
+    quote
+        local bt = backtrace()
+        local indent = length(bt)  # to mark recursion
+        $blk
+        print(showlnio[], " "^indent*"(")
+        show_backtrace1(showlnio[], bt)
+        println(showlnio[], ")")
+    end
+end
+
+"""
+`test_showline(filename)` is equivalent to `include(filename)`, except
+that it also displays the expression and file-offset (in characters) for
+each expression it executes. This can be useful for debugging errors,
+especially those that cause a segfault.
+"""
+function test_showline(filename)
+    str = @compat readstring(filename)
+    eval(Main, parse("using Base.Test"))
+    idx = 1
+    while idx < length(str)
+        ex, idx = parse(str, idx)
+        try
+            println(idx, ": ", ex)
+        end
+        eval(Main,ex)
+    end
+    println("done")
+end
+
+"""
+`time_showline(filename)` is equivalent to `include(filename)`, except
+that it also analyzes the time expended on each expression within the
+file. Once finished, it displays the file-offset (in characters),
+elapsed time, and expression in order of increasing duration.  This
+can help you identify bottlenecks in execution.
+
+This is less useful now that julia has package precompilation, but can
+still be handy on occasion.
+"""
+function time_showline(filename)
+    str = @compat readstring(filename)
+    idx = 1
+    exprs = Array(Any, 0)
+    t = Array(Float64, 0)
+    pos = Array(Int, 0)
+    while idx < length(str)
+        ex, idx = parse(str, idx)
+        push!(exprs, ex)
+        push!(t, (tic(); eval(Main,ex); toq()))
+        push!(pos, idx)
+    end
+    perm = sortperm(t)
+    for p in perm
+        print(pos[p], " ", t[p], ": ")
+        str = string(exprs[p])
+        println(split(str, '\n')[1])
+    end
+    println("done")
+end
 
 end # module

test/error.jl

@@ -0,0 +1,2 @@
+# The next line is a deliberate error
+sqrt(-3)

test/noerror.jl

@@ -0,0 +1,2 @@
+x = 5
+sqrt(x)

test/runtests.jl

@@ -1,5 +1,30 @@
 using DebuggingUtilities
 using Base.Test
 
-# write your own tests here
-@test 1 == 1
+io = IOBuffer()
+DebuggingUtilities.showlnio[] = io
+
+function foo()
+    x = 5
+    @showln x
+    x = 7
+    @showln x
+    nothing
+end
+
+foo()
+
+str = chomp(takebuf_string(io))
+target = ("x = 5", "(in foo at", "x = 7", "(in foo at")
+for (i,ln) in enumerate(split(str, '\n'))
+    ln = lstrip(ln)
+    @test startswith(ln, target[i])
+end
+
+DebuggingUtilities.showlnio[] = STDOUT
+nothing
+
+# Just make sure these run
+test_showline("noerror.jl")
+@test_throws DomainError test_showline("error.jl")
+time_showline("noerror.jl")