diff options
Diffstat (limited to 'doc/ref/scheme-debugging.texi')
-rw-r--r-- | doc/ref/scheme-debugging.texi | 123 |
1 files changed, 0 insertions, 123 deletions
diff --git a/doc/ref/scheme-debugging.texi b/doc/ref/scheme-debugging.texi deleted file mode 100644 index dd49dd3a3..000000000 --- a/doc/ref/scheme-debugging.texi +++ /dev/null @@ -1,123 +0,0 @@ -@c -*-texinfo-*- -@c This is part of the GNU Guile Reference Manual. -@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2006 -@c Free Software Foundation, Inc. -@c See the file guile.texi for copying conditions. - -@node Tracing -@section Tracing - -The @code{(ice-9 debug)} module implements tracing of procedure -applications. When a procedure is @dfn{traced}, it means that every -call to that procedure is reported to the user during a program run. -The idea is that you can mark a collection of procedures for tracing, -and Guile will subsequently print out a line of the form - -@lisp -| | [@var{procedure} @var{args} @dots{}] -@end lisp - -whenever a marked procedure is about to be applied to its arguments. -This can help a programmer determine whether a function is being called -at the wrong time or with the wrong set of arguments. - -In addition, the indentation of the output is useful for demonstrating -how the traced applications are or are not tail recursive with respect -to each other. Thus, a trace of a non-tail recursive factorial -implementation looks like this: - -@lisp -[fact1 4] -| [fact1 3] -| | [fact1 2] -| | | [fact1 1] -| | | | [fact1 0] -| | | | 1 -| | | 1 -| | 2 -| 6 -24 -@end lisp - -While a typical tail recursive implementation would look more like this: - -@lisp -[fact2 4] -[facti 1 4] -[facti 4 3] -[facti 12 2] -[facti 24 1] -[facti 24 0] -24 -@end lisp - -@deffn {Scheme Procedure} trace procedure -Enable tracing for @code{procedure}. While a program is being run, -Guile will print a brief report at each call to a traced procedure, -advising the user which procedure was called and the arguments that were -passed to it. -@end deffn - -@deffn {Scheme Procedure} untrace procedure -Disable tracing for @code{procedure}. -@end deffn - -Here is another example: - -@lisp -(define (rev ls) - (if (null? ls) - '() - (append (rev (cdr ls)) - (cons (car ls) '())))) @result{} rev - -(trace rev) @result{} (rev) - -(rev '(a b c d e)) -@result{} [rev (a b c d e)] - | [rev (b c d e)] - | | [rev (c d e)] - | | | [rev (d e)] - | | | | [rev (e)] - | | | | | [rev ()] - | | | | | () - | | | | (e) - | | | (e d) - | | (e d c) - | (e d c b) - (e d c b a) - (e d c b a) -@end lisp - -Note the way Guile indents the output, illustrating the depth of -execution at each procedure call. This can be used to demonstrate, for -example, that Guile implements self-tail-recursion properly: - -@lisp -(define (rev ls sl) - (if (null? ls) - sl - (rev (cdr ls) - (cons (car ls) sl)))) @result{} rev - -(trace rev) @result{} (rev) - -(rev '(a b c d e) '()) -@result{} [rev (a b c d e) ()] - [rev (b c d e) (a)] - [rev (c d e) (b a)] - [rev (d e) (c b a)] - [rev (e) (d c b a)] - [rev () (e d c b a)] - (e d c b a) - (e d c b a) -@end lisp - -Since the tail call is effectively optimized to a @code{goto} statement, -there is no need for Guile to create a new stack frame for each -iteration. Tracing reveals this optimization in operation. - - -@c Local Variables: -@c TeX-master: "guile.texi" -@c End: |