Print debugging statement
From Wikipedia:
Print debugging (or tracing) is the act of watching (live or recorded) trace statements, or print statements, that indicate the flow of execution of a process. This is sometimes called printf debugging, due to the use of the printf function in C.
- Task
- Show the print debugging statements in the language.
- Demonstrate their ability to track provenance by displaying information about source code (e.g., code fragment, line and column number).
C
C doesn't have a built-in print debugging statement. However, it can be defined by users as a macro.
<lang C>#include <stdio.h>
- define DEBUG_INT(x) printf( #x " at line %d\nresult: %d\n\n", __LINE__, x)
int add(int x, int y) {
int result = x + y; DEBUG_INT(x); DEBUG_INT(y); DEBUG_INT(result); DEBUG_INT(result+1); return result;
}
int main() {
add(2, 7); return 0;
}</lang>
- Output:
x at line 7 result: 2 y at line 8 result: 7 result at line 9 result: 9 result+1 at line 10 result: 10
Go
Go doesn't have a built-in print debugging statement as such. Nor does it have macros.
However, as the following example shows, it is easy enough to mimic a C-like approach by writing a short 'debug' function which can show the value of an expression and its type at the appropriate line number in the program's source code.
Note that a label for the expression (whether it's a simple variable or not) must be passed to the 'debug' function as there is no way to deduce it otherwise. <lang go>package main
import (
"fmt" "runtime"
)
type point struct {
x, y float64
}
func add(x, y int) int {
result := x + y
debug("x", x)
debug("y", y)
debug("result", result)
debug("result+1", result+1)
return result
}
func debug(s string, x interface{}) {
_, _, lineNo, _ := runtime.Caller(1)
fmt.Printf("%q at line %d type '%T'\nvalue: %#v\n\n", s, lineNo, x, x)
}
func main() {
add(2, 7)
b := true
debug("b", b)
s := "Hello"
debug("s", s)
p := point{2, 3}
debug("p", p)
q := &p
debug("q", q)
}</lang>
- Output:
"x" at line 14 type 'int'
value: 2
"y" at line 15 type 'int'
value: 7
"result" at line 16 type 'int'
value: 9
"result+1" at line 17 type 'int'
value: 10
"b" at line 29 type 'bool'
value: true
"s" at line 31 type 'string'
value: "Hello"
"p" at line 33 type 'main.point'
value: main.point{x:2, y:3}
"q" at line 35 type '*main.point'
value: &main.point{x:2, y:3}
Perl 6
There isn't anything built-in to do this in Rakudo Perl 6, though is pretty easy to cobble something together piggybacking off of the exception system. It would probably be better to instantiate a specific "DEBUG" exception to avoid interfering with other user instantiated ad-hoc exceptions, but for a quick-and-dirty demo, this should suffice.
This example will report any payload contents passed to the exception. If you want specific information, it will need to be passed in, though some of it may be determinable through introspection. Reports the file-name and line number where the "debug" call originated and unwinds the call stack to trace through the subroutine calls leading up to it. Will follow the call chain into included files and modules, though calls to the CORE setting and dispatcher are filtered out here to reduce noise.
Comments with the files line numbers are added here to make it easier to match up the debug output with the file. Typically you would be editing the file in an editor that provides line numbering so that wouldn't be necessary/helpful.
<lang perl6>my &pdb = ¨
CATCH {
when X::AdHoc {
my @frames = .backtrace[*];
say .payload;
for @frames {
# Filter out exception handing and dispatcher frames
next if .file.contains: 'SETTING' or .subname.chars < 1;
printf "%sfrom file: %s,%s line: %s\n",
(' ' x $++), .file,
(my $s = .subname) eq '<unit>' ?? !! " sub: $s,", .line;
}
say ;
.resume;
}
default {}
}
- Testing / demonstration
- helper subs #line 22
sub alpha ($a) { #line 23
pdb ('a =>', $a + 3); #line 24
pdb 'string'; #line 25
beta(7); #line 26
} #line 27 sub beta ($b) { pdb $b } #line 28 sub gamma ($c) { beta $c } #line 29 sub delta ($d) { gamma $d } #line 30
#line 31
my $a = 10; #line 32 pdb (.VAR.name, $_) with $a; #line 33 alpha($a); #line 34 delta("Δ"); #line 35 .&beta for ^3; #line 36</lang>
- Output:
($a 10) from file: debug.p6, line: 33 (a => 13) from file: debug.p6, sub: alpha, line: 24 from file: debug.p6, line: 34 string from file: debug.p6, sub: alpha, line: 25 from file: debug.p6, line: 34 7 from file: debug.p6, sub: beta, line: 28 from file: debug.p6, sub: alpha, line: 26 from file: debug.p6, line: 34 Δ from file: debug.p6, sub: beta, line: 28 from file: debug.p6, sub: gamma, line: 29 from file: debug.p6, sub: delta, line: 30 from file: debug.p6, line: 35 0 from file: debug.p6, sub: beta, line: 28 from file: debug.p6, line: 36 1 from file: debug.p6, sub: beta, line: 28 from file: debug.p6, line: 36 2 from file: debug.p6, sub: beta, line: 28 from file: debug.p6, line: 36
Pyret
Pyret has the spy expression. The expression can print the value of an identifier, using the identifier itself as a label if it's not already given. It could also print the value of an arbitrary expression, but it needs an explicit label in this case.
<lang pyret>fun add(x, y):
result = x + y spy "in add": x, y, result, result-plus-one: result + 1 end result
end
add(2, 7)</lang>
- Output:
Spying "in add" (at file:///spies.arr:3:2-8:5) x: 2 y: 7 result: 9 result-plus-one: 10 9
Racket
Racket doesn't have a built-in print debugging statement. However, it can be defined by users as a macro.
<lang racket>#lang racket
(require syntax/parse/define)
(define (debug:core line col code val #:label [label #f])
;; if label exists, use it instead of the code fragment (printf "~a at line ~a column ~a\n" (or label code) line col) (printf "result: ~a\n\n" val) ;; return the value itself, so that we can wrap macro around an expression ;; without restructuring any code val)
(define-simple-macro (debug <x> option ...)
#:with line (datum->syntax this-syntax (syntax-line #'<x>)) #:with col (datum->syntax this-syntax (syntax-column #'<x>)) (debug:core line col (quote <x>) <x> option ...))
(define (add x y)
(define result (+ x y)) (debug x) (debug y) (debug (if #t (+ x y) (error 'impossible))) (debug (add1 result) #:label "result plus one") (debug result))
(add 2 7)</lang>
- Output:
x at line 20 column 9 result: 2 y at line 21 column 9 result: 7 (if #t (+ x y) (error 'impossible)) at line 22 column 9 result: 9 result plus one at line 23 column 9 result: 10 result at line 24 column 9 result: 9 9
REXX
There are other options for the REXX's trace instruction, but the i is the most informative and
shows intermediate results within a REXX statement as it's being evaluated.
The first number (for the trace output) is the line number for the REXX program.
Blank lines are not traced.
This particular output is from the Regina REXX interpreter. <lang rexx>/*REXX program to demonstrate debugging (TRACE) information while executing a program*/ /*────────────────────────────────────────────── (below) the I is for information. */ trace i parse arg maxDiv . if maxDiv== | maxDiv=="," then maxDiv= 1000 /*obtain optional argument from the CL.*/ say 'maximum random divisor is:' maxDiv /*display the max divisor being used. */ total= 0
do j=1 to 100
total= total + j/random(maxDiv)
end /*j*/
say 'total=' total /*stick a fork in it, we're all done. */</lang>
- output when using the input of: 9
4 *-* parse arg maxDiv .
>>> "9"
>.> ""
5 *-* if maxDiv=='' | maxDiv=="," then maxDiv= 1000 /*obtain optional argument from the CL.*/
>V> "9"
>L> ","
>O> "0"
>V> "9"
>L> ""
>O> "0"
>U> "0"
6 *-* say 'maximum random divisor is:' maxDiv /*display the max divisor being used. */
>L> "maximum random divisor is:"
>V> "9"
>O> "maximum random divisor is: 9"
maximum random divisor is: 9
7 *-* total= 0
>L> "0"
9 *-* do j=1 to 100
>L> "1"
>L> "100"
>V> "1"
10 *-* total= total + j/random(maxDiv)
>V> "0"
>V> "1"
>V> "9"
>F> "3"
>O> "0.333333333"
>O> "0.333333333"
11 *-* end /*j*/
9 *-* do j=1 to 100
>V> "1"
>V> "2"
10 *-* total= total + j/random(maxDiv)
>V> "0.333333333"
>V> "2"
>V> "9"
>F> "0"
10 +++ total= total + j/random(maxDiv)
Error 42 running "c:\debuggin.rex", line 10: Arithmetic overflow/underflow
Error 42.3: Arithmetic overflow; divisor must not be zero