701 lines
24 KiB
TeX
701 lines
24 KiB
TeX
%----------------------------------------------------------------------------
|
|
% Magic tutorial number S-1
|
|
%----------------------------------------------------------------------------
|
|
|
|
\NeedsTeXFormat{LaTeX2e}[1994/12/01]
|
|
\documentclass[letterpaper,twoside,12pt]{article}
|
|
\usepackage{epsfig,times}
|
|
|
|
\setlength{\textwidth}{8.5in}
|
|
\addtolength{\textwidth}{-2.0in}
|
|
\setlength{\textheight}{11.0in}
|
|
\addtolength{\textheight}{-2.0in}
|
|
\setlength{\oddsidemargin}{0in}
|
|
\setlength{\evensidemargin}{0pt}
|
|
\setlength{\topmargin}{-0.5in}
|
|
\setlength{\headheight}{0.2in}
|
|
\setlength{\headsep}{0.3in}
|
|
\setlength{\topskip}{0pt}
|
|
|
|
\def\hinch{\hspace*{0.5in}}
|
|
\def\starti{\begin{center}\begin{tabbing}\hinch\=\hinch\=\hinch\=hinch\hinch\=\kill}
|
|
\def\endi{\end{tabbing}\end{center}}
|
|
\def\ii{\>\>\>}
|
|
\def\q{\special{ps:(") show}\hspace*{0.6em}}
|
|
\def\mytitle{Magic Tutorial \#S-1: The scheme command-line interpreter}
|
|
\def\bk{\special{ps:/bksp 2 string def bksp 0 92 put bksp show}\hspace*{0.4em}}
|
|
|
|
%----------------------------------------------------------------------------
|
|
|
|
\begin{document}
|
|
|
|
\makeatletter
|
|
\newcommand{\ps@magic}{%
|
|
\renewcommand{\@oddhead}{\mytitle\hfil\today}%
|
|
\renewcommand{\@evenhead}{\today\hfil\mytitle}%
|
|
\renewcommand{\@evenfoot}{\hfil\textrm{--{\thepage}--}\hfil}%
|
|
\renewcommand{\@oddfoot}{\@evenfoot}}
|
|
\newcommand{\ps@mplain}{%
|
|
\renewcommand{\@oddhead}{}%
|
|
\renewcommand{\@evenhead}{}%
|
|
\renewcommand{\@evenfoot}{\hfil\textrm{--{\thepage}--}\hfil}%
|
|
\renewcommand{\@oddfoot}{\@evenfoot}}
|
|
\makeatother
|
|
\pagestyle{magic}
|
|
\thispagestyle{mplain}
|
|
|
|
|
|
\begin{center}
|
|
{\bfseries \Large \mytitle} \\
|
|
\vspace*{0.5in}
|
|
{\itshape Rajit Manohar} \\
|
|
\vspace*{0.5in}
|
|
Department of Computer Science \\
|
|
California Institute of Technology \\
|
|
Pasadena, CA 91125 \\
|
|
\vspace*{0.25in}
|
|
This tutorial corresponds to Magic version 7. \\
|
|
\end{center}
|
|
\vspace*{0.5in}
|
|
|
|
{\noindent\bfseries\large Tutorials to read first:}
|
|
\starti
|
|
\> Read reference \cite{sussman}
|
|
\endi
|
|
|
|
{\noindent\bfseries\large Commands introduced in this tutorial:}
|
|
\starti
|
|
\> :scm-echo-result, :eval, lots of scheme functions
|
|
\endi
|
|
|
|
{\noindent\bfseries\large Macros introduced in this tutorial:}
|
|
|
|
\starti
|
|
\> {\itshape (None)}
|
|
\endi
|
|
|
|
\vspace*{0.75in}
|
|
\section{Introduction}
|
|
|
|
Magic's original command-line interpreter has some limitations. Some of
|
|
these include the absence of definitions with arguments, block structure,
|
|
the ability to define complex functions. We describe an extension which
|
|
is almost completely backward compatible with the existing magic
|
|
command-line syntax, but permits the use of Scheme on the command-line.
|
|
|
|
\section{Backward compatibility}
|
|
|
|
To permit existing magic source files to work within the scheme interpreter,
|
|
we have had to sacrifice one feature of the magic command-line syntax. Single
|
|
quotes can only be used to quote a single character. The reason for this
|
|
limitation is that {\itshape unmatched} quotes are used by scheme to stop
|
|
evaluation of the next input symbol.
|
|
|
|
Parentheses are used by the scheme interpreter. If you use parentheses
|
|
outside single or double quotes in your magic source files, you might
|
|
find that the source files don't work properly. To circumvent this
|
|
problem, simply put your parentheses in double quotes. You can also
|
|
use backslashes to quote parentheses as in:
|
|
|
|
\starti
|
|
\ii {\bfseries :macro {\bk}( {\q}echo hello{\q}}
|
|
\endi
|
|
|
|
Another thing
|
|
you may notice is that floating-point numbers are parsed as such, and
|
|
therefore a command such as
|
|
|
|
\starti
|
|
\ii {\bfseries :echo 5.3}
|
|
\endi
|
|
|
|
would display the string {\bfseries 5.300000}. If you really want the string
|
|
{\bfseries 5.3}, use:
|
|
|
|
\starti
|
|
\ii {\bfseries :echo {\q}5.3{\q}}
|
|
\endi
|
|
|
|
If this difference is undesirable, the scheme interpreter can be
|
|
turned off at compile-time. Talk to your local magic maintainer if you
|
|
want this done. We feel that the minor trouble taken in modifying
|
|
existing magic source files will be outweighed by the advantage of
|
|
using a more powerful layout language.
|
|
|
|
|
|
\section{The scheme interpreter}
|
|
|
|
The interpreter supports a subset of the scheme language. The features
|
|
of scheme that are missing include character types,
|
|
vector types, file input/output, complex numbers, the distinction
|
|
between exact and inexact arithmetic, quasi-quotations, and
|
|
continuations.
|
|
|
|
\subsection{Command-line interaction}
|
|
|
|
When
|
|
interacting with the command-line of magic, the interpreter implicitly
|
|
parenthesizes its input. For example, the command
|
|
|
|
\starti
|
|
\ii {\bfseries :paint poly}
|
|
\endi
|
|
|
|
would be interpreted as the scheme expression
|
|
|
|
\starti
|
|
\ii {\bfseries (paint poly)}
|
|
\endi
|
|
|
|
This has exactly the same effect as the original expression, because
|
|
all existing magic command-line functions are also scheme functions.
|
|
Since the valid magic commands vary from window to window, the return
|
|
value of the function is a boolean that indicates whether the command
|
|
was valid for the current window.
|
|
|
|
The boolean {\bfseries scm-echo-result} controls whether or not the result
|
|
of the evaluation is displayed. If the variable does not exist, or the
|
|
variable is not boolean-valued, the result of evaluation is not
|
|
echoed. Since the input is implicitly parenthesized, typing in
|
|
|
|
\starti
|
|
\ii {\bfseries :scm-echo-result}
|
|
\endi
|
|
|
|
would not display the value of the variable, since it would be
|
|
evaluated as:
|
|
|
|
\starti
|
|
\ii {\bfseries (scm-echo-result)}
|
|
\endi
|
|
|
|
To display the value of a variable, use the built-in procedure
|
|
{\bfseries eval} as follows:
|
|
|
|
\starti
|
|
\ii {\bfseries :eval scm-echo-result}
|
|
\endi
|
|
|
|
This would result in the expression:
|
|
|
|
\starti
|
|
\ii {\bfseries (eval scm-echo-result)}
|
|
\endi
|
|
|
|
which would have the desired effect (note that for this to actually
|
|
display anything, the value of {\bfseries scm-echo-result} must be {\bfseries \#t},
|
|
and so examining its value is really a futile exercise---which is why
|
|
it is an example, of course!).
|
|
|
|
\subsection{Types of arguments}
|
|
|
|
Since scheme expressions are typed, we may need to examine the
|
|
type of a particular expression. The following functions return
|
|
booleans, and can be used to determine the type of an object.
|
|
|
|
{\bfseries \#t} and {\bfseries \#f} are constants representing the booleans true and
|
|
false. A standard scheme convention is to name functions that return
|
|
booleans with a name ending with ``?''. The built-in functions conform
|
|
to this convention.
|
|
|
|
The expression {\itshape expr} is evaluated, and the type of the result of
|
|
evaluation is checked.
|
|
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (boolean?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a boolean \\ \hline
|
|
{\bfseries (symbol?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a symbol \\ \hline
|
|
{\bfseries (list?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a list \\ \hline
|
|
{\bfseries (pair?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a pair \\ \hline
|
|
{\bfseries (number?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a number \\ \hline
|
|
{\bfseries (string?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a string \\ \hline
|
|
{\bfseries (procedure?} {\itshape expr}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape expr} is a procedure \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
For example,
|
|
|
|
\starti
|
|
\ii {\bfseries (boolean? \#t)}{\itshape $=>$ \#t} \\
|
|
\ii {\bfseries (number? \#t)}{\itshape $=>$ \#f}
|
|
\endi
|
|
|
|
\subsection{Lists and pairs}
|
|
|
|
A pair is a record structure with two fields, called the car and cdr
|
|
fields (for historical reasons). Pairs are used primarily to represent
|
|
lists. A list can be defined recursively as either the empty list, or
|
|
a pair whose cdr field is a list. The following functions are used to
|
|
extract these fields and to construct new pairs and lists.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (car} {\itshape pair}{\bfseries )} &
|
|
the car field of {\itshape pair} \\ \hline
|
|
{\bfseries (cdr} {\itshape pair}{\bfseries )}&
|
|
the cdr field {\itshape pair} \\ \hline
|
|
{\bfseries (cons} {\itshape obj1 obj2}{\bfseries )} &
|
|
a new pair whose car field is
|
|
{\itshape obj1} and cdr field is {\itshape obj2} \\ \hline
|
|
{\bfseries (list} {\itshape arg1 \dots}{\bfseries )} &
|
|
a new list consisting of its arguments \\ \hline
|
|
{\bfseries (null?} {\itshape list}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape list} is the empty list \\ \hline
|
|
{\bfseries (length} {\itshape list}{\bfseries )} &
|
|
the number of elements in {\itshape list} \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
For example,
|
|
|
|
\starti
|
|
\ii {\bfseries (car '(a b c))}{\itshape =$>$ a} \\
|
|
\ii {\bfseries (cdr '(a b c))}{\itshape =$>$ (b c)} \\
|
|
\ii {\bfseries (cons 'a '(b c))}{\itshape =$>$ (a b c)} \\
|
|
\ii {\bfseries (list 'a 'b 'c)}{\itshape =$>$ (a b c)} \\
|
|
\ii {\bfseries (null? '(a b))}{\itshape =$>$ \#f} \\
|
|
\ii {\bfseries (null? ())}{\itshape =$>$ \#t}
|
|
\endi
|
|
|
|
The car field and cdr field of a pair can be set using the following two
|
|
functions.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (set-car!} {\itshape pair obj}{\bfseries )} &
|
|
sets the car field of {\itshape pair} to
|
|
{\itshape obj}. It returns the new pair \\ \hline
|
|
{\bfseries (set-cdr!} {\itshape pair obj}{\bfseries )} &
|
|
sets the cdr field of {\itshape pair} to
|
|
{\itshape obj}. It returns the new pair \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
These two functions have {\itshape side-effects}, another feature that
|
|
distinguishes scheme from pure lisp. Another naming convention
|
|
followed is that functions that have side-effects end in ``!''.
|
|
|
|
Try the following sequence in magic:
|
|
|
|
\starti
|
|
\ii {\bfseries (define x '(a b))}{\itshape =$>$ (a b)} \\
|
|
\ii {\bfseries (set-car! x 'c)}{\itshape =$>$ (c b)} \\
|
|
\ii {\bfseries (set-cdr! x '(q))}{\itshape =$>$ (c q)} \\
|
|
\ii {\bfseries (set-cdr! x 'q)}{\itshape =$>$ (c . q)} \\
|
|
\endi
|
|
|
|
After the last statement, the value of x is no longer a list but a
|
|
pair.
|
|
|
|
\subsection{Arithmetic}
|
|
|
|
The interpreter supports both floating-point and integer
|
|
arithmetic. The basic arithmetic functions are supported.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (+ }{\itshape num1 num2}{\bfseries )} &
|
|
the sum {\itshape num1}+{\itshape num2} \\ \hline
|
|
{\bfseries (- }{\itshape num1 num2}{\bfseries )} &
|
|
the difference {\itshape num1}-{\itshape num2} \\ \hline
|
|
{\bfseries (* }{\itshape num1 num2}{\bfseries )} &
|
|
the product {\itshape num1}*{\itshape num2} \\ \hline
|
|
{\bfseries (/ }{\itshape num1 num2}{\bfseries )} &
|
|
the quotient {\itshape num1}/{\itshape num2} \\ \hline
|
|
{\bfseries (truncate }{\itshape num}{\bfseries )} &
|
|
the integer part of {\itshape num} \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The division operator checks for division by zero, and promotes
|
|
integers to floating-point if deemed necessary. Floating-point numbers
|
|
can be converted into integers by truncation. The range of a number
|
|
can be checked using the following predicates:
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (zero? }{\itshape num}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape num} is zero \\ \hline
|
|
{\bfseries (positive? }{\itshape num}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape num} is positive \\ \hline
|
|
{\bfseries (negative? }{\itshape num}{\bfseries )} &
|
|
{\bfseries \#t} if {\itshape num} is negative \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\subsection{Strings}
|
|
|
|
The interpreter supports string manipulation. String manipulation can
|
|
be useful for interaction with the user as well as constructing names
|
|
for labels.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|p{0.6\columnwidth}|} \hline
|
|
{\bfseries (string-append }{\itshape str1 str2}{\bfseries )} &
|
|
the string formed by concatenating
|
|
{\itshape str1} and {\itshape str2} \\ \hline
|
|
{\bfseries (string-length }{\itshape str}{\bfseries )} &
|
|
the length of string {\itshape str} \\ \hline
|
|
{\bfseries (string-compare }{\itshape str1 str2}{\bfseries )} &
|
|
a positive, zero, or negative number depending on whether
|
|
{\itshape str1} is lexicographically greater, equal to,
|
|
or less than {\itshape str2} \\ \hline
|
|
{\bfseries (string-ref }{\itshape str int}{\bfseries )} &
|
|
the numerical value of the character stored at position
|
|
{\itshape int} in {\itshape str} (The first character
|
|
is at position 0.) \\ \hline
|
|
{\bfseries (string-set! }{\itshape str int1 int2}{\bfseries )} &
|
|
sets character in string {\itshape str} at position
|
|
{\itshape int1} to {\itshape int2} \\ \hline
|
|
{\bfseries (substring }{\itshape str int1 int2}{\bfseries )} &
|
|
returns substring of {\itshape str} from position
|
|
{\itshape int1} (inclusive) to {\itshape int2} (exclusive) \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
Strings can be used to convert to and from various types.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (number-$>$string }{\itshape num}{\bfseries )} &
|
|
the string corresponding to the representation of
|
|
{\itshape num} \\ \hline
|
|
{\bfseries (string-$>$number }{\itshape str}{\bfseries )} &
|
|
the number corresponding to {\itshape str} \\ \hline
|
|
{\bfseries (string-$>$symbol }{\itshape str}{\bfseries )} &
|
|
a symbol named {\itshape str} \\ \hline
|
|
{\bfseries (symbol$->$string }{\itshape sym}{\bfseries )} &
|
|
the string corresponding to the name of {\itshape sym} \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\subsection{Bindings and functions}
|
|
|
|
An object (more accurately, the {\itshape location} where the object is
|
|
stored) can be bound to a symbol using the following two functions:
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (define }{\itshape sym expr}{\bfseries )} &
|
|
bind {\itshape expr} to {\itshape sym}, creating
|
|
a new symbol if necessary and return {\itshape expr} \\ \hline
|
|
{\bfseries (set! }{\itshape sym expr}{\bfseries )} &
|
|
bind {\itshape expr} to an existing symbol {\itshape sym}
|
|
and return {\itshape expr} \\ \hline
|
|
\end{tabular} \\
|
|
(Note: these functions do not evaluate their first argument.)
|
|
\end{center}
|
|
|
|
The difference between the two is that {\bfseries define} introduces a new
|
|
binding, whereas {\bfseries set!} modifies an existing binding. In both
|
|
cases, {\itshape expr} is evaluated, and the result is bound to the symbol
|
|
{\itshape sym}. The result of the evaluation is also returned.
|
|
|
|
\starti
|
|
\ii {\bfseries (define x 4)}{\itshape $=>$ 4}
|
|
\endi
|
|
|
|
Functions can be defined using lambda expressions. Typically a
|
|
function is bound to a variable. If required, a lambda expression or
|
|
built-in function can be applied to a list.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (lambda }{\itshape list obj}{\bfseries )} &
|
|
a new function \\ \hline
|
|
\end{tabular} \\
|
|
(Note: a lambda does not evaluate its arguments.)
|
|
\end{center}
|
|
|
|
{\itshape list} is a list of symbol names, and {\itshape obj} is the expression
|
|
that corresponds to the body of the function. For example,
|
|
|
|
\starti
|
|
\ii {\bfseries (lambda (x y z) (+ (+ x y) z))}{\itshape $=>$ \#proc}
|
|
\endi
|
|
|
|
is a function that takes three arguments and returns their sum. It can
|
|
be bound to a symbol using {\bfseries define}.
|
|
|
|
\starti
|
|
\ii {\bfseries (define sum3 (lambda (x y z) (+ (+ x y) z)))}{\itshape $=>$ \#proc}
|
|
\endi
|
|
|
|
Now, we can use {\bfseries sum3} like any other function.
|
|
|
|
\starti
|
|
\ii {\bfseries (sum3 5 3 8)}{\itshape $=>$ 16}
|
|
\endi
|
|
|
|
A function can be applied to a list using {\bfseries apply}.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (apply }{\itshape proc list}{\bfseries )} &
|
|
apply {\itshape proc} to {\itshape list} \\ \hline
|
|
\end{tabular} \\
|
|
(Note: both {\itshape proc} and {\itshape list} are evaluated before
|
|
application.)
|
|
\end{center}
|
|
|
|
{\itshape list} is used as the list of arguments for the function. For
|
|
instance, an alternative way to sum the three numbers in the example
|
|
above is:
|
|
|
|
\starti
|
|
\ii {\bfseries (apply sum3 '(3 5 8))}{\itshape $=>$ 16}
|
|
\endi
|
|
|
|
An alternative method for creating bindings is provided by the
|
|
{\bfseries let} mechanism.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (let }{\itshape binding-list expr}{\bfseries )} &
|
|
evaluate {\itshape expr} after the bindings have
|
|
been performed \\ \hline
|
|
{\bfseries (let* }{\itshape binding-list expr}{\bfseries )} &
|
|
evaluate {\itshape expr} after the bindings have
|
|
been performed \\ \hline
|
|
{\bfseries (letrec }{\itshape binding-list expr}{\bfseries )} &
|
|
evaluate {\itshape expr} after the bindings have
|
|
been performed \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The {\itshape binding-list} is a list of bindings. Each binding is a list
|
|
containing a symbol and an expression. The expression is evaluated and
|
|
bound to the symbol. In the case of {\bfseries let}, all the expressions are
|
|
evaluated before binding them to any symbol; {\bfseries let*}, on the other
|
|
hand, evaluates an expression and binds it to the symbol before
|
|
evaluating the next expression. {\bfseries letrec} permits bindings to refer
|
|
to each other, permitting mutually recursive function definitions.
|
|
The evaluation order is defined to be from left to right in all
|
|
cases. After performing the bindings, {\itshape expr} is evaluated with the
|
|
new bindings in effect and the result is returned.
|
|
|
|
{\bfseries let} bindings can be used in interesting ways. An example of
|
|
their use is provided later.
|
|
|
|
Scheme is an eager language, and only a few functions do not evaluate
|
|
all their arguments (definitions and conditionals). Evaluation can be
|
|
controlled to some degree using the following two functions:
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (quote }{\itshape obj}{\bfseries )} &
|
|
the unevaluated object {\itshape obj} \\ \hline
|
|
{\bfseries (eval }{\itshape obj}{\bfseries )} &
|
|
evaluates object {\itshape obj} \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
|
|
\subsection{Control structures}
|
|
|
|
Since scheme is a functional programming language, functions that are
|
|
usually written using loops are written using recursion. Conditional
|
|
constructs are used to terminate the recursion. These constructs are
|
|
slightly different in that they do not evaluate all their arguments
|
|
(otherwise recursive functions would not terminate!).
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (if }{\itshape expr arg1 arg2}{\bfseries )} &
|
|
evaluate {\itshape expr} and evaluate one
|
|
of {\itshape arg1} or {\itshape arg2} \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The {\bfseries if} construct evaluates its first argument (which must result
|
|
in a boolean), and if the result is {\bfseries \#t} evaluates {\itshape arg1} and
|
|
returns the result; otherwise {\itshape arg2} is evaluated and returned.
|
|
|
|
For instance, the standard factorial function might be written as:
|
|
|
|
\starti
|
|
\ii {\bfseries (define fact (lambda (x) (if (positive? x)
|
|
(* x (fact (- x 1))) 1)))}
|
|
\endi
|
|
|
|
A more complicated form of conditional behavior is provided by {\bfseries cond}.
|
|
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (cond }{\itshape arg1 arg2 ...}{\bfseries )} &
|
|
generalized conditional \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
Each argument consists of a list which contains two expressions. The
|
|
first expression is evaluated (and must evaluate to a boolean), and if
|
|
it is true the second expression is evaluated and returned as the
|
|
result of the entire expression. If the result was false, the next
|
|
argument is examined and the above procedure is repeated. If all
|
|
arguments evaluate to false, the result is undefined.
|
|
|
|
For instance if {\bfseries x} was a list, the expression
|
|
|
|
\starti
|
|
\ii {\bfseries (cond ((null? x) x) ((list? x) (car x)) (\#t (echo {\q}error{\q})))}
|
|
\endi
|
|
|
|
would return the empty list if {\bfseries x} was the empty list and the
|
|
first element from the list otherwise. When {\bfseries x} is not a list, an
|
|
error message is displayed. Note that {\bfseries echo} is a standard magic
|
|
command.
|
|
|
|
Often one needs to evaluate a number of expressions in
|
|
sequence (since the language has side-effects). The {\bfseries begin}
|
|
construct can be used for this purpose.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (begin }{\itshape arg1 arg2 \dots}{\bfseries )} &
|
|
sequencing construct \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
{\bfseries begin} evaluates each of its arguments in sequence, and returns
|
|
the result of evaluating its last argument.
|
|
|
|
\subsection{Interaction with layout}
|
|
|
|
All standard magic commands are also scheme functions. This permits
|
|
one to write scheme functions that interact with the layout
|
|
directly. Apart from the standard magic commands, the following scheme
|
|
functions are provided so as to enable the user to edit layout.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|p{0.6\columnwidth}|} \hline
|
|
{\bfseries (getbox)} &
|
|
a list containing four members (llx lly urx ury) \\ \hline
|
|
{\bfseries (getpaint }{\itshape str}{\bfseries )} &
|
|
a list containing the boxes from layer {\itshape str}
|
|
under the current box that have paint in them \\ \hline
|
|
{\bfseries (getlabel }{\itshape str}{\bfseries )} &
|
|
a list containing the labels under the current box that
|
|
match {\itshape str} \\ \hline
|
|
{\bfseries (magic }{\itshape sym}{\bfseries )} &
|
|
forces {\itshape sym} to be interpreted as a
|
|
magic command \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The pairs (llx,lly) and (urx,ury) correspond to magic coordinates for
|
|
the lower left and upper right corner of the current
|
|
box. {\bfseries getpaint} returns a list of boxes (llx lly urx ury), and
|
|
{\bfseries getlabel} returns a list of tagged boxes (label llx lly urx ury)
|
|
which contain the label string. {\bfseries magic} can be used to force the
|
|
scheme interpreter to interpret a symbol as a magic procedure. The
|
|
evaluation returns the specified magic command.
|
|
|
|
|
|
\subsection{Miscellaneous}
|
|
|
|
Some additional functions are provided to enable the user to debug
|
|
functions.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (showframe)} &
|
|
display the current list of bindings \\ \hline
|
|
{\bfseries (display-object }{\itshape obj}{\bfseries )} &
|
|
display the type and value of {\itshape obj} \\ \hline
|
|
{\bfseries (error }{\itshape str}{\bfseries )} &
|
|
display error message and abort evaluation \\ \hline
|
|
{\bfseries (eqv? }{\itshape obj1 obj2}{\bfseries )} &
|
|
checks if two objects are equal \\ \hline
|
|
{\bfseries (collect-garbage)} &
|
|
force garbage collection \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The following is a complete list of the built-in scheme variables that
|
|
can be used to control the interpreter.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|p{0.6\columnwidth}|} \hline
|
|
{\bfseries scm-library-path} &
|
|
a colon-separated path string \\ \hline
|
|
{\bfseries scm-echo-result} &
|
|
a boolean used to determine if the result of evaluation
|
|
should be displayed \\ \hline
|
|
{\bfseries scm-trace-magic} &
|
|
controls display of actual magic commands \\ \hline
|
|
{\bfseries scm-echo-parser-input} &
|
|
controls display of the string sent to the scheme parser \\ \hline
|
|
{\bfseries scm-echo-parser-output} &
|
|
controls display of the result of parsing \\ \hline
|
|
{\bfseries scm-stack-display-depth} &
|
|
controls the number of frames displayed in the stack trace
|
|
output when an error occurs during evaluation \\ \hline
|
|
{\bfseries scm-gc-frequency} &
|
|
controls the frequency of garbage collection \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\subsection{Libraries}
|
|
|
|
The following function loads in a file and evaluates its contents in order.
|
|
|
|
\begin{center}
|
|
\begin{tabular}{|l|l|} \hline
|
|
{\bfseries (load-scm }{\itshape str}{\bfseries )} &
|
|
reads scheme commands in from the named file \\ \hline
|
|
{\bfseries (save-scm }{\itshape str obj}{\bfseries )} &
|
|
appends {\itshape obj} to the file {\itshape str},
|
|
creating a new file if necessary \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The file can be in the current directory, or in any of the
|
|
locations specified by a string containing a colon-separated list of
|
|
directory names stored in {\bfseries scm-library-path}.
|
|
|
|
The format of these files differs from standard magic source files
|
|
because the contents of a line are not implicitly
|
|
parenthesized. In addition, semicolons are used as a comment
|
|
character; everything following a semicolon to the end of the current
|
|
line is treated as a comment.
|
|
|
|
For instance,
|
|
|
|
\starti
|
|
\ii {\bfseries define f (lambda (x) x)}
|
|
\endi
|
|
|
|
would define {\bfseries f} to be the identity function when placed in a
|
|
magic source file (so as to provide backward compatibility). The same
|
|
definition would result in an error if placed in a scheme source
|
|
file.
|
|
|
|
\starti
|
|
\ii {\bfseries (define f (lambda (x) x))}
|
|
\endi
|
|
|
|
The above expression should be used in the scheme file to achieve the
|
|
same effect.
|
|
|
|
\begin{thebibliography}{2}
|
|
|
|
\bibitem{sussman}
|
|
H. Abelson and G.J. Sussman,
|
|
\newblock {\itshape Structure and Interpretation of Computer Programs}.
|
|
|
|
\bibitem{abelson}
|
|
H. Abelson {\itshape et al.},
|
|
\newblock {\itshape Revised Report on the Algorithmic Language Scheme}.
|
|
\end{thebibliography}
|
|
|
|
\end{document}
|