Print debugging statement: Difference between revisions

=={{header|Applesoft BASIC}}==

Debugging commands TRACE and NOTRACE turn on and off showing line numbers as the program runs. The LIST command can be embedded in the program to display lines of the program. The RUN command can used to start the program at a specific line number. The STOP command stops the program and displays an error message. The CLEAR and RUN commands clear all variables.

1 IF DEBUG THEN LIST 1: PRINT "TEST"

2 IF DEBUG THEN LIST 2: TRACE

4 IF DEBUG THEN LIST 4, 6: PRINT "ALPHA" : RUN 4

5 NOTRACE

{{out}}

<pre>

END

</pre>

{{out}}

<pre>

C doesn't have a built-in print debugging statement. However, it can be defined by users as a macro.

#define DEBUG_INT(x) printf( #x " at line %d\nresult: %d\n\n", __LINE__, x)

add(2, 7);

return 0;

{{out}}

=={{header|C++}}==

// requires support for variadic macros in this form

return 0;

=={{header|COBOL}}==

Explicit debug usually just uses DISPLAY, and usually directed at SYSERR. Compiler Directing Facility debug is supported with <code>>>D</code> directive statements. GnuCOBOL also supports full on line step tracing, controlled by both compile time switch, <code>-ftraceall</code>, and a truthy setting in a `COB_SET_TRACE` environment variable (so program step logging can be switched on and off without a recompile (for tracking down pesky production run mysteries)).

*> steptrace.cob

*> Tectonics: cobc -xj -fdebugging-line -ftraceall steptrace.cob

display "from " FUNCTION MODULE-ID " in " FUNCTION MODULE-SOURCE

goback.

That is fixed form COBOL, columns 1 through 6 ignored by the preprocessor (historical format, from the days of punch card input) with column 7 being a special indicator column, star for comments, dash for continuations, and D is supported by GnuCOBOL for Debug lines. The <code>>>D</code> form is a newer addition to the Compiler Directing Facility, and can float anywhere on a free format compile line.

Using templates and default arguments provides options for specifying a debug function.

The file and line could be included as either template arguments or function arguments.

void debugln(string file = __FILE__, size_t line = __LINE__, S...)(S args) {

debugWrite("Goodbye", ' ', "world", '!');

}

{{out}}

<pre>[debug.d@12]

{{libheader| System.sysutils}}

Delphi has a "OutputDebugString" for debug, but not give lines and filename of source.

program DebugApp;

writeln(Add(2, 7));

readln;

In next we have a workaround using a idea from '''user3989283'''[[https://stackoverflow.com/questions/7214213/how-to-get-line-number-at-runtime]]. This code override the default assert function to gain access to line and file name.

Obs.: In this example default action of assert is disabled, but you can enable calling in HookAssert (at end).

program DebugApp;

ReleaseDebug;

{{out}}

Example log:

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.

import (

q := &p

debug("q", q)

{{out}}

=={{header|J}}==

3 3

$'a' dump i.3 3

3 4 5

6 7 8

2 5 10 17

' sum'&dump@+/@('list'&dump)\2 3 5 7

sum: 15

sum: 17

if.#d=.13!:13'' do.

echo (,:': ',~;:inv":&.>0 2{1{d) ,&.|:1 1}._1 _1}.":<y

end.

y

Here, we get debugging output only if debugging is enabled. And we're annotating each value with the name of the routine, and the line within that routine. Thus:

j=. 1

dump r=. 2

example''

example 1: 2

=={{header|Java}}==

public class PrintDebugStatement {

oops.run();

}

{{out}}

<pre>[DEBUG][PrintDebugStatement.java PrintDebugStatement.main#30] Hello world.

The '''debug''' built-in is a 0-arity filter which behaves somewhat like `tee /dev/stderr` in *ix -- that is, it prints its input as a message to '''stderr''' and also passes it along to the next filter, as illustrated by this transcript:

jq -n '"abc" | debug | length'

["DEBUG:","abc"]

3

'''$__loc__'''

=={{header|Julia}}==

Julia has native print logging type functions, including a core Logging module. In addition, there are several additional downloadable modules, such as Memento, with extended logging functionality. Julia's builtin logging has defined macros for logging levels: @error, @warn, @info, and @debug. By default, debug level statements in code are not printed unless the logging level is set to allow debug statements to print, which can be enabled by setting the JULIA_DEBUG environment variable.

@info "starting test()"

a = [1, 2]

test()

<pre>

[ Info: starting test()

=={{header|Kotlin}}==

val exception = RuntimeException()

val stackTrace = exception.stackTrace

}

nested()

{{out}}

<pre>[DEBUG][PrintDebuggingStatement.kt PrintDebuggingStatementKt.main#18] Hello world.

=={{header|Ksh}}==

#!/bin/ksh

(( result = x + y ))

exit

{{out}}<pre>

Line 33: Command: 'typeset -li x y result'

Together with data functors like <code>$module</code>, <code>$pred</code>, <code>$line</code>, trace goals can be used for debugging print statements as in the following example. Together with the [https://mercurylang.org/information/doc-latest/mercury_library/require.html require] module's utilities, trace goals can be used for assert() statements or pre/post assertions.

:- interface.

:- import_module io.

main(!IO) :-

2 `add` 7 = N,

{{out}} (with a non-debug grade)

The conditional activation is done using a “when” statement. Here is an example:

When compiling, if nothing is specified, no code is generated to display the debugging information. If we want to generate the debug statements, we have to specify <code>-d:debug</code> when compiling, for instance if the file is named “example.nim”: <code>nim c -d:debug example.nim</code>. Note that the name “debug” has been chosen as an example but maybe any valid Nim identifier not already used. This allows to use different flags according to what we want to debug.

If is also possible to use existing flags instead of defining new ones:

In this case, by default (debug build), the code for the statement is generated. But if we produce a release build (<code>-d:release</code> option), the debugging code will not be generated.

Last, but not least, Nim provides a simple and efficient log module. Using logger objects, this module allows to write log data to the console or into a file. As expected of a logging module, it provides several levels for debugging:

lvlAll, ## All levels active

lvlDebug, ## Debug level and above are active

lvlError, ## Error level and above are active

lvlFatal, ## Fatal level and above are active

These levels are mapped to the following names: "DEBUG", "DEBUG", "INFO", "NOTICE", "WARN","ERROR", "FATAL", "NONE".

Logging debugging data is then a simple as writing:

=={{header|Perl}}==

<code>Carp</code> is a core module, always available.

$str = 'Resistance'; carp "'$str' is futile."; print "\n";

sub fiddle { faddle(2*shift) }

sub faddle { fuddle(3*shift) }

{{out}}

<pre>'Resistance' is futile. at printf_debug.pl line 11.

to the language, albeit as yet undocumented.

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

<span style="color: #000080;font-style:italic;">-- use throw to convert a return address and routine number

<span style="color: #008080;">return</span> <span style="color: #000000;">_debug_info</span><span style="color: #0000FF;">()[</span><span style="color: #000000;">E_PATH</span><span style="color: #0000FF;">]</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

This can be used as follows (0.8.1+)

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">reflections</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

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

{{out}}

{{libheader|logging}}

Python's builtin [https://docs.python.org/3.8/library/logging.html logging module] allows extensive customization of output format and destination.

LOG_FILENAME = "logdemo.log"

print_cubes(10)

{{out}}<b>Contents of logdemo.log</b>

<pre>

Pyret has the [https://www.pyret.org/docs/latest/s_spies.html <code>spy</code> 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.

result = x + y

spy "in add":

end

{{out}}

Racket doesn't have a built-in print debugging statement. However, it can be defined by users as a macro.

(require syntax/parse/define)

(debug result))

{{out}}

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.

CATCH {

alpha($a); #line 34

delta("Δ"); #line 35

{{out}}

The following output is from the Regina REXX interpreter.

/*────────────────────────────────────────────── (below) the I is for information. */

trace i

end /*j*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 9 </tt>}}

<pre>

What is generally done in practice is to hard-code some location indicator (such as the line number itself) at which a variable's value is being obtained. The Go example code then looks like this when translated to Wren.

class Point {

debug.call("p", p, 32)

var l = [1, "two", 3]

{{out}}

Print debugging is similar to C. The _debug_ keyword conditionally compiles

code (ie the debug code isn't compiled unless debugging is turned on).

println("This is line %d of file %s compiled on %s"

.fmt(line,__FILE__,__DATE__));

ds(__LINE__); println("Debug level is ",__DEBUG__);

vm.stackTrace().println();

{{out}}

<pre>