Stack traces: Difference between revisions

 

The provided solution is specific to the [[GNAT]] Ada compiler. Further it is restricted to some platforms. See the description of the package GNAT.Traceback supplied with [[GNAT]]. The switch -g must be used in order to include debug information into the executable.

with GNAT.Traceback;

with GNAT.Traceback.Symbolic;

begin

Outer (2,3,5);

Sample output:

<pre>

ListLines can be turned on or off... with:

<br> ListLines, On|Off

return

msgbox, variable bindings

}

Output:

006: Return,g()

011: ListLines (0.05)

0[1 of 3]: 0

ErrorLevel[1 of 3]: 0

 

=={{header|BASIC}}==

In order to be able to see the symbols, we need to link with an option telling to export symbols names in the dynamic section (for ELF and targets supporting it); for gcc, it means using the option <tt>-rdynamic</tt> (or <tt>-export-dynamic</tt> in the GNU linker). Otherwise we see only addresses. Static functions will always have their names "hidden".

 

#include <stdlib.h>

#include <unistd.h>

outer(2,3,5);

return EXIT_SUCCESS;

 

Sample output on my system:

 

'''==> stack_trace.h <=='''

/* stack_trace.c - macros for hinting/tracing where a program crashed

on a system _without_ any form of debugger.

#define END }

 

'''==> stack_trace.c <=='''

#include <stddef.h>

 

print_indent(); fprintf(stderr, "--- (depth %d) ---\n", stack_trace.stack.depth);

}

 

'''==> stack_trace_test.c <=='''

The following code demonstrates the usage of the macros. Note that the initial and last curly brackets have been changed to BEGIN(procedure_name) and END. This is sometimes called '''macro magic''' and is unfashionable.

 

#include <stdlib.h>

 

stack_trace.on = FALSE;

RETURN(EXIT_SUCCESS);

 

{{out}}

 

=={{header|C sharp|C#}}==

using System.Diagnostics;

 

Outer();

}

Sample output:

at Program.Middle()

at Program.Outer()

 

=={{header|Clojure}}==

[http://docs.oracle.com/javase/8/docs/api/java/lang/management/ThreadMXBean.html ThreadMXBean] can be used to show you the stack of all live threads.

 

(doall

(map println (.dumpAllThreads (java.lang.management.ManagementFactory/getThreadMXBean) false false)))

{{out}}

<pre>

Here we use SWANK, which a component of SLIME, a Common Lisp IDE (it is the library loaded into the target Lisp system to enable interaction and remote debugging), to make use of its portable debugging facilities:

 

(lambda ()

 

Here are a few lines of the result when running under [[SBCL]], the rest is omitted since it's long and boring:

(1 "(SB-INT:SIMPLE-EVAL-IN-LEXENV (SWANK-BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT (LAMBDA () (SWANK:BACKTRACE 0 NIL))) #<NULL-LEXENV>)")

(2 "(SWANK::EVAL-REGION \"(swank-backend:call-with-debugging-environment\\n (lambda ()\\n (swank:backtrace 0 nil)))\\n\\n\")")

 

Note that this is a data structure containing the backtrace, not a format intended for presentation. In [[SBCL]], executing <code>(sb-debug:backtrace 7)</code> produces output like this (run from the SLIME-REPL, which is why it still contains mentions of SWANK):

 

0: (SB-DEBUG::MAP-BACKTRACE

#<CLOSURE (LAMBDA (SB-DEBUG::FRAME)) {1193EFCD}>)[:EXTERNAL]

6: (SWANK::CALL-WITH-RETRY-RESTART

"Retry SLIME REPL evaluation request."

 

SBCL's backtraces consist entirely of lists of the form <code>(<var>function-name</var> <var>args...</var>)</code>.

Compiled with the dmd compiler using the -g switch.

{{trans|Java}}

 

void inner() { defaultTraceHandler.writeln; }

outer;

"After the stack trace.".writeln;

{{out}}

<pre>0x00404FBE in core.sys.windows.stacktrace.StackTrace core.sys.windows.stacktrace.StackTrace.__ctor(uint, core.sys.windows.windows.CONTEXT*) at E:\dmd2\src\druntime\import\core\sys\windows\stacktrace.d(69)

=={{header|DWScript}}==

Stack traces can be obtained from exception objects

begin

try

end;

 

Output:<pre>Inner [line: 4, column: 23]

Middle [line: 13, column: 4]

Outer [line: 18, column: 4]

[line: 21, column: 1]</pre>

 

=={{header|Elixir}}==

{{trans|Erlang}}

def main do

{:ok, a} = outer

end

 

 

{{out}}

{{trans|Java}}

Stack traces only can be obtained inside a catch block. Additionally, it doesn't work for tail calls.

 

-export([main/0]).

 

inner() ->

{{out}}

<pre>[{stack_traces,inner,0,[{file,"stack_traces.erl"},{line,18}]},

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

type myClass() =

let that = new myClass()

that.outer()

Output

<pre> at Rosetta.myClass.inner()

at Rosetta.myClass.outer()

at Rosetta.main(String[] args)</pre>

 

=={{header|Forth}}==

 

{{works with|4tH|3.60.0}}

\ Return stack counterpart of DEPTH

\ Note the STACK-CELLS correction is there to hide RDEPTH itself

BEGIN DUP WHILE ROT DUP . >R 1- REPEAT DROP

THEN ." (TORS) " DROP >R ;

 

=={{header|Fortran}}==

So, Gnash has invoked ATTACK to deal with input commands, as if cards are being read. ATTACK states that it is dealing with some input (possibly from a script file but in this case the keyboard), and invokes XeqACard to do so. It states that it is confronting some text, then invokes the appropriate command handler - which invokes CROAK, which unwinds the stack. Its final act is <code>STOP "I STOP now. Farewell..." !Whatever pit I was in, I'm gone.</code> which of course is not written to the log file and unless you're using a DOS-style session, the window will be closed before you can read it.

 

 

=={{header|Go}}==

 

import (

fmt.Printf("%s\n", stackTrace)

fmt.Printf("(%d bytes)\n", len(stackTrace))

outputs:

<pre>

=={{header|Groovy}}==

Solution:

 

Test: (demonstrates, among other things, continued execution after generating stack trace)

def props = it.properties

def keys = (it.properties.keySet() - (new Object().properties.keySet()))

trace.each {

propNames.eachWithIndex{ name, i -> printf("%-${propWidths[i]}s ", it[name].toString()) }; println ''

 

Output:

{{libheader|Unicon Code Library}}

[http://tapestry.tucson.az.us/unilib/pack_Utils.html the following code for buildStackTrace in Utils is taken verbatim and shown below the main program]

import Utils # for buildStackTrace

 

# Using 1 as argument omits the trace of buildStackTrace itself

every write("\t",!buildStackTrace(1))

 

# Compute the current stack trace. Starting at level <i>n</i> above

# the current procedure. Here, <i>n</i> defaults to 0, which will

}

return L

 

The output of this example is:

 

To enable suspension and record subsequent stack frames:

 

To retrieve a current stack trace:

 

See also: http://www.jsoftware.com/help/dictionary/dx013.htm

Example:

 

g=:13!:13 bind ''

f 7 NB. empty stack trace because debugging has not been enabled

│ │ │ │ │ │││7││ │ │

│ │ │ │ │ ││└─┘│ │ │

 

Technical note: the stack trace is not displayed, here, until after the stack has been discarded. This is because we have returned the stack trace as a result and relied on J's implicit display of the result of an expression to display the stack trace.

=={{header|Java}}==

{{works with|Java|1.5+}}

public static void printStackTrace() {

StackTraceElement[] elems = Thread.currentThread().getStackTrace();

}

}

Demonstration code:

static void inner() {

StackTracer.printStackTrace();

outer();

}

Output:

<pre>Stack trace:

There is no standard way to do this, but some implementations provide it.<br />

{{works with|Firefox}}

throw new Error;

} catch(e) {

alert(e.stack);

 

The following version works in many browsers but it infinitely loops when there is recursion:

var stack = "Stack trace:";

for (var f = arguments.callee // current function

alert(stack);

}

 

=={{header|Kotlin}}==

 

fun myFunc() {

}

 

myFunc()

println("\nContinuing ... ")

 

{{out}}

 

Continuing ...

</pre>

 

By default Lasso tracks the file path, line and column numbers. You can create a trace method to track type and method names illustrated below or use one of the public libraries like L-Debug [https://github.com/zeroloop/l-debug].

 

define trace => {

local(gb) = givenblock

)

return #gb()

 

;Use Trace:

 

public oncreate => trace => { return self }

public inner => trace => { }

}

 

 

{{out}}

 

=={{header|Lua}}==

print( debug.traceback() )

print "Program continues..."

end

 

<pre>stack traceback:

./prog:4: in function 'Inner'

Program continues...</pre>

 

Built-in function Stack does the task, example I:

prints, gives back:

Example II:

prints, gives back:

Related and similar functions are: Trace, TracePrint, TraceScan,TraceDialog, Monitor, StackInhibit, StackBegin, StackComplete. In the manual look for 'guide/SymbolicExecutionHistory'.

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

j_ = j_ + 2

end i_

'''Output:'''

<pre>

RStackTraces.inner

</pre>

 

=={{header|Objective-C}}==

 

void *frames[128];

NSLog(@"%s", symbols[i]);

}

 

Or in Mac OS X 10.6+:

for (NSString *symbol in symbols) {

NSLog(@"%@", symbol);

 

=={{header|OCaml}}==

{{works with|OCaml|3.11+}}

 

let () =

prerr_endline(Printexc.to_string e);

Printexc.print_backtrace stderr;

 

outputs:

 

Then the code doesn't need additional statements:

 

let () =

let _ = div 3 0 in ()

outputs:

Fatal error: exception Division_by_zero

Otherwise no stack trace is available nor printed.

 

Integer method: f2 self f1 ;

: f3 f2 ;

: f4 f3 ;

 

 

{{out}}

 

=={{header|OxygenBasic}}==

'32bit x86

 

0017FE1C 07 00000000

*/

 

=={{header|Oz}}==

System exceptions contain the current stack at the nested feature <code>debug.stack</code>. For example:

proc {Test}

_ = 1 div 0

catch E then

{Inspect E}

Output:

[[File:Oz_stacktrace1.png|center|Stack trace of a system exception in Oz.]]

 

To access the stack trace directly, you can use the undocumented internal Debug module. Its <code>getTaskStack</code> function takes a thread, a depth value and a boolean "verbose" flag. It returns a list of stack frames. Example:

\switch +controlflowinfo

 

end

in

 

Output:

[[File:Oz_stacktrace2.png|center|Stack trace created by the Debug module.]]

 

=={{header|Perl}}==

 

sub g {cluck 'Hello from &g';}

sub f {g;}

 

 

This prints:

main::g() called at Print a Stack Trace line 4

main::f() called at Print a Stack Trace line 6</pre>

 

=={{header|PHP}}==

class StackTraceDemo {

static function inner() {

 

StackTraceDemo::outer();

 

<pre>#0 StackTraceDemo::inner() called at [/home/cweiske/Dev/cvs/test/php-stacktrace.php:7]

#1 StackTraceDemo::middle() called at [/home/cweiske/Dev/cvs/test/php-stacktrace.php:10]

#2 StackTraceDemo::outer() called at [/home/cweiske/Dev/cvs/test/php-stacktrace.php:14]</pre>

 

=={{header|PicoLisp}}==

 

As this mechanism uses 'let' to hold the stack frames, it is robust also across catch/throw, coroutines and error handling.

 

(de $$ "Prg"

(de dumpStack ()

(more (reverse (cdr "Stack")))

Test:

(let C 3

(bar (inc 'A) (inc 'B) (inc 'C)) ) )

(! println A B C) ) ) # Set a breakpoint before (println A B C)

 

<pre>: (foo 1 2) # Call 'foo'

(println A B C) # Stopped at breakpoint in 'bar'

-> 9

:</pre>

 

=={{header|PureBasic}}==

The [http://www.purebasic.com/documentation/debugger/showcallstack.html ShowCallstack()]command opens a interactive display allowing viewing of the procedures in the calling path an all their local variables.

a=7

ShowCallstack()

EndProcedure

 

 

=={{header|Python}}==

 

See the [http://docs.python.org/library/traceback.html traceback] module

 

def f(): return g()

def g(): traceback.print_stack()

 

 

Sample output from a session in the Idle IDE:

def g(): traceback.print_stack()

</pre>

 

=={{header|R}}==

{

bar <- function()

}

 

<nowiki>[[1]]</nowiki>

foo()

 

You can also see the stack trace when a function is called (or as it exits) using the trace function.

<pre>

Tracing foo() on entry

Selection:

</pre>

 

=={{header|REXX}}==

{{works with|Regina}}

say 'Call A'

call A '123'

say format(line, 3) ':' left(func, 9) ': source "' || sourceline(line) || '"'

end

 

{{out}}

Regina will also dump a call stack during certain error conditions. For instance, if the code listing above raised an unhandled signal (simulated here with "signal noname" in routine C). This is not a recoverable scenario though, and the program will not continue.

 

signal noname

call callstack

 

{{out}}

9 +++ call B '456'

3 +++ call A '123'

Error 16.1: Label "NONAME" not found</pre>

 

=={{header|Ruby}}==

middle a+b, b+c

end

end

 

<pre>$ ruby stacktrace.rb

stacktrace.rb:10:in `inner'

 

Exceptions caught in a rescue clause contain the trace information:

middle a+b, b+c

end

puts e.backtrace

end

<pre>stacktrace.rb:10:in `inner'

stacktrace.rb:6:in `middle'

continuing after the rescue...</pre>

Thread has a backtrace method:

 

=={{header|Scala}}==

the way, could be used from Java as well, with minor modifications.

 

 

 

Usage example:

The following #printCurrentStack is already defined in the base slate image but it is replicated here.

 

[

d clone `>> [baseFramePointer: (d interpreter framePointerOf: #printCurrentStack).

].

Defining function 'printCurrentStack' on: 'Debugger traits'

 

The output from calling the function:

 

Backtrace (method @ source):

frame: 0 [printCurrentStack &limit: &stream: &showLocation:] @ stdin:0

frame: 9 [start &resource:] @ src/lib/repl.slate:185

frame: 10 [start] @ src/mobius/prelude.slate:38

 

=={{header|Smalltalk}}==

A backtrace is normally sent when some error occurs; however, it can be "forced":

 

Container class >> outer: a and: b and: c [

self middle: (a+b) and: (b+c)

Container outer: 2 and: 3 and: 5.

 

 

Output:

 

=={{header|Tcl}}==

puts "Stack trace:"

for {set i 1} {$i < [info level]} {incr i} {

puts [string repeat " " $i][info level $i]

}

Demonstration code:

middle [expr {$a+$b}] [expr {$b+$c}]

}

printStackTrace

}

Produces this output:

<pre>Stack trace:

middle 5 8

inner 40</pre>

 

=={{header|zkl}}==

{{out}}

stackTrace just returns a string. You don't get to futz with the stack.