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]

{{trans|C#}}

ELENA 5.0 :

public singleton program

program.outer()

}

{{out}}

<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()

=={{header|Factor}}==

This stack trace shows the listener — Factor's Read-Eval-Print-Loop. The current execution point in each call frame is indicated by <code>=></code>. Press ctrl+w in the listener to walk through the call stack one step at a time and watch how it affects the data stack. You can even step backward in most cases. This is handy for debugging.

{{out}}

<pre>

{{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}}==

=={{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|Julia}}==

{{works with|Julia|0.6}}

g() = println.(stacktrace())

{{out}}

=={{header|Kotlin}}==

fun myFunc() {

myFunc()

println("\nContinuing ... ")

{{out}}

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'

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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|Nanoquery}}==

__calls__ contains a list that represents a trace of calls that have been made.

global __calls__

println

{{out}}

<pre>stack trace:

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

j_ = j_ + 2

end i_

'''Output:'''

<pre>

=={{header|Nim}}==

In (normal) debug builds stacktraces are enabled, while in release builds stacktraces are disabled by default, but can be enabled like this: <code>nim c -d:release --stacktrace:on --linetrace:on file.nim</code>

# Writes the current stack trace to stderr.

writeStackTrace()

g()

{{out}}

For a release build:

=={{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:

=={{header|Perl}}==

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

sub f {g;}

This prints:

=={{header|Phix}}==

There no standard method of obtaining a stack trace mid-run (as yet, non-fatally that is), but we can quickly cobble something together:

<span style="color: #008080;">constant</span> <span style="color: #000000;">W</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">machine_word</span><span style="color: #0000FF;">(),</span>

<span style="color: #0000FF;">{</span><span style="color: #000000;">RTN</span><span style="color: #0000FF;">,</span><span style="color: #000000;">PREVEBP</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">W</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span><span style="color: #0000FF;">?{</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">}:{</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">40</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"dummy"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- see note below</span>

<span style="color: #000000;">one</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

During compilation, the symbol table entries hold an integer ternary tree index rather than a string name, and normally

things are left like that during interpretation (the proper string names are always written out when an executable is

Alternatively, but only when interpreting (whereas the above works as shown both when interpreting and pre-compiled), the debugger is

started with the much saner

<span style="color: #008080;">trace</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

though as yet it offers no means of examining the stack trace (resume-ably), the above suggests it should be relative easy to add.

=={{header|PHP}}==

class StackTraceDemo {

static function inner() {

StackTraceDemo::outer();

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

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'

=={{header|PL/I}}==

/* The SNAP option in the ON statement is sufficient to obtain */

/* a traceback. The SYSTEM option specifies that standard */

...

signal condition(traceback);

=={{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:

=={{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

=={{header|Racket}}==

#lang racket

(when (car s) (printf "~s: ~s\n" i (car s)))))

(foo)

Output:

(formerly Perl 6)

{{works with|Rakudo|2013-03-03}}

sub f { g }

{{out}}

<pre> in sub g at bt:1

=={{header|Raven}}==

{{out}}

<pre>hash (4 items)

=={{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}}

=={{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:

However, it is not possible to continue execution of the script afterwards. Whilst one can 'catch' such an error using Fiber.try() this will only allow you to inspect the error itself, not the chain of function calls that led up to it.

Fiber.abort("Forced error.")

}

}

{{out}}

=={{header|zkl}}==

{{out}}

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