7.5.1 Repl

(require 'repl)

Here is a read-eval-print-loop which, given an eval, evaluates forms.

Procedure: repl:top-level repl:eval ¶

reads, repl:evals and writes expressions from (current-input-port) to (current-output-port) until an end-of-file is encountered. load, slib:eval, slib:error, and repl:quit dynamically bound during repl:top-level.

Procedure: repl:quit ¶

Exits from the invocation of repl:top-level.

The repl: procedures establish, as much as is possible to do portably, a top level environment supporting macros. repl:top-level uses dynamic-wind to catch error conditions and interrupts. If your implementation supports this you are all set.

Otherwise, if there is some way your implementation can catch error conditions and interrupts, then have them call slib:error. It will display its arguments and reenter repl:top-level. slib:error dynamically bound by repl:top-level.

To have your top level loop always use macros, add any interrupt catching lines and the following lines to your Scheme init file:

(require 'macro)
(require 'repl)
(repl:top-level macro:eval)

7.5.2 Quick Print

(require 'qp)

When displaying error messages and warnings, it is paramount that the output generated for circular lists and large data structures be limited. This section supplies a procedure to do this. It could be much improved.

Notice that the neccessity for truncating output eliminates Common-Lisp’s Format (version 3.1) from consideration; even when variables *print-level* and *print-level* are set, huge strings and bit-vectors are not limited.

Procedure: qp arg1 … ¶

Procedure: qpn arg1 … ¶

Procedure: qpr arg1 … ¶

qp writes its arguments, separated by spaces, to (current-output-port). qp compresses printing by substituting ‘...’ for substructure it does not have sufficient room to print. qpn is like qp but outputs a newline before returning. qpr is like qpn except that it returns its last argument.

Variable: *qp-width* ¶

*qp-width* is the largest number of characters that qp should use. If *qp-width* is #f, then all items will be writen. If *qp-width* is 0, then all items except procedures will be writen; procedures will be indicated by ‘#[proc]’.

7.5.3 Debug

(require 'debug)

Requiring debug automatically requires trace and break.

An application with its own datatypes may want to substitute its own printer for qp. This example shows how to do this:

(define qpn (lambda args) …)
(provide 'qp)
(require 'debug)

Procedure: trace-all file … ¶

Traces (see Tracing) all procedures defined at top-level in file ….

Procedure: track-all file … ¶

Tracks (see Tracing) all procedures defined at top-level in file ….

Procedure: stack-all file … ¶

Stacks (see Tracing) all procedures defined at top-level in file ….

Procedure: break-all file … ¶

Breakpoints (see Breakpoints) all procedures defined at top-level in file ….

7.5.4 Breakpoints

(require 'break)

Function: init-debug ¶

If your Scheme implementation does not support break or abort, a message will appear when you (require 'break) or (require 'debug) telling you to type (init-debug). This is in order to establish a top-level continuation. Typing (init-debug) at top level sets up a continuation for break.

Function: breakpoint arg1 … ¶

Returns from the top level continuation and pushes the continuation from which it was called on a continuation stack.

Function: continue ¶

Pops the topmost continuation off of the continuation stack and returns an unspecified value to it.

Function: continue arg1 … ¶

Pops the topmost continuation off of the continuation stack and returns arg1 … to it.

Macro: break proc1 … ¶

Redefines the top-level named procedures given as arguments so that breakpoint is called before calling proc1 ….

Macro: break ¶

With no arguments, makes sure that all the currently broken identifiers are broken (even if those identifiers have been redefined) and returns a list of the broken identifiers.

Macro: unbreak proc1 … ¶

Turns breakpoints off for its arguments.

Macro: unbreak ¶

With no arguments, unbreaks all currently broken identifiers and returns a list of these formerly broken identifiers.

These are procedures for breaking. If defmacros are not natively supported by your implementation, these might be more convenient to use.

Function: breakf proc ¶

Function: breakf proc name ¶

To break, type

(set! symbol (breakf symbol))

or

(set! symbol (breakf symbol 'symbol))

or

(define symbol (breakf function))

or

(define symbol (breakf function 'symbol))

Function: unbreakf proc ¶

To unbreak, type

(set! symbol (unbreakf symbol))

7.5.5 Tracing

(require 'trace)

This feature provides three ways to monitor procedure invocations:

stack

Pushes the procedure-name when the procedure is called; pops when it returns.

track

Pushes the procedure-name and arguments when the procedure is called; pops when it returns.

trace

Pushes the procedure-name and prints ‘CALL procedure-name arg1 …’ when the procdure is called; pops and prints ‘RETN procedure-name value’ when the procedure returns.

Variable: debug:max-count ¶

If a traced procedure calls itself or untraced procedures which call it, stack, track, and trace will limit the number of stack pushes to debug:max-count.

Function: print-call-stack ¶

Function: print-call-stack port ¶

Prints the call-stack to port or the current-error-port.

Macro: trace proc1 … ¶

Traces the top-level named procedures given as arguments.

Macro: trace ¶

With no arguments, makes sure that all the currently traced identifiers are traced (even if those identifiers have been redefined) and returns a list of the traced identifiers.

Macro: track proc1 … ¶

Traces the top-level named procedures given as arguments.

Macro: track ¶

With no arguments, makes sure that all the currently tracked identifiers are tracked (even if those identifiers have been redefined) and returns a list of the tracked identifiers.

Macro: stack proc1 … ¶

Traces the top-level named procedures given as arguments.

Macro: stack ¶

With no arguments, makes sure that all the currently stacked identifiers are stacked (even if those identifiers have been redefined) and returns a list of the stacked identifiers.

Macro: untrace proc1 … ¶

Turns tracing, tracking, and off for its arguments.

Macro: untrace ¶

With no arguments, untraces all currently traced identifiers and returns a list of these formerly traced identifiers.

Macro: untrack proc1 … ¶

Turns tracing, tracking, and off for its arguments.

Macro: untrack ¶

With no arguments, untracks all currently tracked identifiers and returns a list of these formerly tracked identifiers.

Macro: unstack proc1 … ¶

Turns tracing, stacking, and off for its arguments.

Macro: unstack ¶

With no arguments, unstacks all currently stacked identifiers and returns a list of these formerly stacked identifiers.

These are procedures for tracing. If defmacros are not natively supported by your implementation, these might be more convenient to use.

Function: tracef proc ¶

Function: tracef proc name ¶

Function: trackf proc ¶

Function: trackf proc name ¶

Function: stackf proc ¶

Function: stackf proc name ¶

To trace, type

(set! symbol (tracef symbol))

or

(set! symbol (tracef symbol 'symbol))

or

(define symbol (tracef function))

or

(define symbol (tracef function 'symbol))

Function: untracef proc ¶

Removes tracing, tracking, or stacking for proc. To untrace, type

(set! symbol (untracef symbol))