by Robert MacLachlan, Skef Wholey, Bill Chiles and William Lott
CMUCL attempts to make the full power of the underlying
environment available to the Lisp programmer. This is done using
combination of hand-coded interfaces and foreign function calls to C
libraries. Although the techniques differ, the style of interface is
similar. This chapter provides an overview of the facilities available
and general rules for using them, as well as describing specific
features in detail. It is assumed that the reader has a working
familiarity with Unix and X11, as well as access to the standard
system documentation.
| 6.1 |
Reading the Command Line |
|
The shell parses the command line with which Lisp is invoked, and
passes a data structure containing the parsed information to Lisp.
This information is then extracted from that data structure and put
into a set of Lisp data structures.
[Variable]
extensions:*command-line-strings*
[Variable]
extensions:*command-line-utility-name*
[Variable]
extensions:*command-line-words*
[Variable]
extensions:*command-line-switches*
The value of *command-line-words* is a list of strings that
make up the command line, one word per string. The first word on
the command line, i.e. the name of the program invoked (usually
lisp) is stored in *command-line-utility-name*. The
value of *command-line-switches* is a list of
command-line-switch structures, with a structure for each
word on the command line starting with a hyphen. All the command
line words between the program name and the first switch are stored
in *command-line-words*.
The following functions may be used to examine command-line-switch
structures.
[Function]
extensions:cmd-switch-name switch
Returns the name of the switch, less the preceding hyphen and
trailing equal sign (if any).
[Function]
extensions:cmd-switch-value switch
Returns the value designated using an embedded equal sign, if any.
If the switch has no equal sign, then this is null.
[Function]
extensions:cmd-switch-words switch
Returns a list of the words between this switch and the next switch
or the end of the command line.
[Function]
extensions:cmd-switch-arg switch
Returns the first non-null value from cmd-switch-value, the
first element in cmd-switch-words, or the first word in
command-line-words.
[Function]
extensions:get-command-line-switch sname
This function takes the name of a switch as a string and returns the
value of the switch given on the command line. If no value was
specified, then any following words are returned. If there are no
following words, then t is returned. If the switch was not
specified, then nil is returned.
[Macro]
extensions:defswitch name &optional function
This macro causes function to be called when the switch
name appears in the command line. Name is a simple-string
that does not begin with a hyphen (unless the switch name really
does begin with one.)
If function is not supplied, then the switch is parsed into
command-line-switches, but otherwise ignored. This suppresses
the undefined switch warning which would otherwise take place. The
warning can also be globally suppressed by
complain-about-illegal-switches.
[Variable]
system:*stdin*
[Variable]
system:*stdout*
[Variable]
system:*stderr*
Streams connected to the standard input, output and error file
descriptors.
[Variable]
system:*tty*
A stream connected to /dev/tty.
[Variable]
extensions:*environment-list*
The environment variables inherited by the current process, as a
keyword-indexed alist. For example, to access the DISPLAY
environment variable, you could use
(cdr (assoc :display ext:*environment-list*))
Note that the case of the variable name is preserved when converting
to a keyword. Therefore, you need to specify the keyword properly for
variable names containing lower-case letters,
| 6.3 |
Lisp Equivalents for C Routines |
|
The UNIX documentation describes the system interface in terms of C
procedure headers. The corresponding Lisp function will have a somewhat
different interface, since Lisp argument passing conventions and
datatypes are different.
The main difference in the argument passing conventions is that Lisp does not
support passing values by reference. In Lisp, all argument and results are
passed by value. Interface functions take some fixed number of arguments and
return some fixed number of values. A given ``parameter'' in the C
specification will appear as an argument, return value, or both, depending on
whether it is an In parameter, Out parameter, or In/Out parameter. The basic
transformation one makes to come up with the Lisp equivalent of a C routine is
to remove the Out parameters from the call, and treat them as extra return
values. In/Out parameters appear both as arguments and return values. Since
Out and In/Out parameters are only conventions in C, you must determine the
usage from the documentation.
Thus, the C routine declared as
kern_return_t lookup(servport, portsname, portsid)
port servport;
char *portsname;
int *portsid; /* out */
...
*portsid = <expression to compute portsid field>
return(KERN_SUCCESS);
has as its Lisp equivalent something like
(defun lookup (ServPort PortsName)
...
(values
success
<expression to compute portsid field>))
If there are multiple out or in-out arguments, then there are multiple
additional returns values.
Fortunately, CMUCL programmers rarely have to worry about the
nuances of this translation process, since the names of the arguments and
return values are documented in a way so that the describe function
(and the Hemlock Describe Function Call command, invoked with
C-M-Shift-A) will list this information. Since the names of arguments
and return values are usually descriptive, the information that
describe prints is usually all one needs to write a
call. Most programmers use this on-line documentation nearly
all of the time, and thereby avoid the need to handle bulky
manuals and perform the translation from barbarous tongues.
Lisp data types have very different representations from those used by
conventional languages such as C. Since the system interfaces are
designed for conventional languages, Lisp must translate objects to and
from the Lisp representations. Many simple objects have a direct
translation: integers, characters, strings and floating point numbers
are translated to the corresponding Lisp object. A number of types,
however, are implemented differently in Lisp for reasons of clarity and
efficiency.
Instances of enumerated types are expressed as keywords in Lisp.
Records, arrays, and pointer types are implemented with the Alien
facility (see section 8). Access functions are defined
for these types which convert fields of records, elements of arrays,
or data referenced by pointers into Lisp objects (possibly another
object to be referenced with another access function).
One should dispose of Alien objects created by constructor
functions or returned from remote procedure calls when they are no
longer of any use, freeing the virtual memory associated with that
object. Since Aliens contain pointers to non-Lisp data, the
garbage collector cannot do this itself. If the memory
was obtained from make-alien or from a foreign function call
to a routine that used malloc, then free-alien should
be used.
Note that in some cases an address is represented by a Lisp integer, and in
other cases it is represented by a real pointer. Pointers are usually used
when an object in the current address space is being referred to. The MACH
virtual memory manipulation calls must use integers, since in principle the
address could be in any process, and Lisp cannot abide random pointers.
Because these types are represented differently in Lisp, one must explicitly
coerce between these representations.
System Area Pointers (SAPs) provide a mechanism that bypasses the
Alien type system and accesses virtual memory directly. A SAP is a
raw byte pointer into the lisp process address space. SAPs are
represented with a pointer descriptor, so SAP creation can cause
consing. However, the compiler uses a non-descriptor representation
for SAPs when possible, so the consing overhead is generally minimal.
See section 5.11.2.
[Function]
system:sap-int sap
[Function]
system:int-sap int
The function sap-int is used to generate an integer
corresponding to the system area pointer, suitable for passing to
the kernel interfaces (which want all addresses specified as
integers). The function int-sap is used to do the opposite
conversion. The integer representation of a SAP is the byte offset
of the SAP from the start of the address space.
[Function]
system:sap+ sap offset
This function adds a byte offset to sap, returning a new
SAP.
[Function]
system:sap-ref-8 sap offset
[Function]
system:sap-ref-16 sap offset
[Function]
system:sap-ref-32 sap offset
These functions return the 8, 16 or 32 bit unsigned integer at
offset from sap. The offset is always a byte
offset, regardless of the number of bits accessed. setf may
be used with the these functions to deposit values into virtual
memory.
[Function]
system:signed-sap-ref-8 sap offset
[Function]
system:signed-sap-ref-16 sap offset
[Function]
system:signed-sap-ref-32 sap offset
These functions are the same as the above unsigned operations,
except that they sign-extend, returning a negative number if the
high bit is set.
You probably won't have much cause to use them, but all the Unix system
calls are available. The Unix system call functions are in the
Unix package. The name of the interface for a particular system
call is the name of the system call prepended with unix-. The
system usually defines the associated constants without any prefix name.
To find out how to use a particular system call, try using
describe on it. If that is unhelpful, look at the source in
unix.lisp or consult your system maintainer.
The Unix system calls indicate an error by returning nil as the
first value and the Unix error number as the second value. If the call
succeeds, then the first value will always be non-nil, often t.
For example, to use the chdir syscall:
(multiple-value-bind (success errno)
(unix:unix-chdir "/tmp")
(unless success
(error "Can't change working directory: ~a"
(unix:get-unix-error-msg errno))))
[Function]
Unix:get-unix-error-msg error
This function returns a string describing the Unix error number
error (this is similar to the Unix function perror).
| 6.7 |
File Descriptor Streams |
|
Many of the UNIX system calls return file descriptors. Instead of using other
UNIX system calls to perform I/O on them, you can create a stream around them.
For this purpose, fd-streams exist. See also read-n-bytes.
[Function]
system:make-fd-stream descriptor &key :input :output
:element-type
:buffering :name
:file :original
:delete-original
:auto-close
:timeout :pathname
This function creates a file descriptor stream using
descriptor. If :input is non-nil, input operations are
allowed. If :output is non-nil, output operations are
allowed. The default is input only. These keywords are defined:
-
:element-type
- is the type of the unit of transaction for
the stream, which defaults to string-char. See the Common Lisp
description of open for valid values.
- :buffering
- is the kind of output buffering desired for
the stream. Legal values are :none for no buffering,
:line for buffering up to each newline, and :full for
full buffering.
- :name
- is a simple-string name to use for descriptive
purposes when the system prints an fd-stream. When printing
fd-streams, the system prepends the streams name with Stream
for . If name is unspecified, it defaults to a string
containing file or descriptor, in order of preference.
- :file, :original
- file specifies the defaulted
namestring of the associated file when creating a file stream
(must be a simple-string). original is the
simple-string name of a backup file containing the original
contents of file while writing file.
When you abort the stream by passing t to close as
the second argument, if you supplied both file and
original, close will rename the original name
to the file name. When you close the stream
normally, if you supplied original, and
delete-original is non-nil, close deletes
original. If auto-close is true (the default), then
descriptor will be closed when the stream is garbage
collected.
- :pathname
- : The original pathname passed to open and
returned by pathname; not defaulted or translated.
- :timeout
- if non-null, then timeout is an integer
number of seconds after which an input wait should time out. If a
read does time out, then the system:io-timeout condition is
signalled.
[Function]
system:fd-stream-p object
This function returns t if object is an fd-stream, and
nil if not. Obsolete: use the portable (typep x
'file-stream).
[Function]
system:fd-stream-fd stream
This returns the file descriptor associated with stream.
CMUCL allows access to all the Unix signals that can be generated
under Unix. It should be noted that if this capability is abused, it is
possible to completely destroy the running Lisp. The following macros and
functions allow access to the Unix interrupt system. The signal names as
specified in section 2 of the Unix Programmer's Manual are exported
from the Unix package.
| 6.8.1 |
Changing Signal Handlers |
|
[Macro]
system:with-enabled-interrupts
specs &rest body
This macro should be called with a list of signal specifications,
specs. Each element of specs should be a list of
two elements: the first should be the Unix signal
for which a handler should be established, the second should be a
function to be called when the signal is received One or more signal handlers can be
established in this way. with-enabled-interrupts establishes
the correct signal handlers and then executes the forms in
body. The forms are executed in an unwind-protect so that the
state of the signal handlers will be restored to what it was before
the with-enabled-interrupts was entered. A signal handler
function specified as NIL will set the Unix signal handler to the
default which is normally either to ignore the signal or to cause a
core dump depending on the particular signal.
[Macro]
system:without-interrupts &rest body
It is sometimes necessary to execute a piece a code that can not be
interrupted. This macro the forms in body with interrupts
disabled. Note that the Unix interrupts are not actually disabled,
rather they are queued until after body has finished
executing.
[Macro]
system:with-interrupts &rest body
When executing an interrupt handler, the system disables interrupts,
as if the handler was wrapped in in a without-interrupts.
The macro with-interrupts can be used to enable interrupts
while the forms in body are evaluated. This is useful if
body is going to enter a break loop or do some long
computation that might need to be interrupted.
[Macro]
system:without-hemlock &rest body
For some interrupts, such as SIGTSTP (suspend the Lisp process and
return to the Unix shell) it is necessary to leave Hemlock and then
return to it. This macro executes the forms in body after
exiting Hemlock. When body has been executed, control is
returned to Hemlock.
[Function]
system:enable-interrupt signal function
This function establishes function as the handler for
signal.
Unless you want to establish a global signal handler, you should use
the macro with-enabled-interrupts to temporarily establish a
signal handler.
enable-interrupt returns the old function associated with the
signal.
[Function]
system:ignore-interrupt signal
Ignore-interrupt sets the Unix signal mechanism to ignore
signal which means that the Lisp process will never see the
signal. Ignore-interrupt returns the old function associated with
the signal or nil if none is currently defined.
[Function]
system:default-interrupt signal
Default-interrupt can be used to tell the Unix signal mechanism to
perform the default action for signal. For details on what
the default action for a signal is, see section 2 of the Unix
Programmer's Manual. In general, it is likely to ignore the
signal or to cause a core dump.
| 6.8.2 |
Examples of Signal Handlers |
|
The following code is the signal handler used by the Lisp system for the
SIGINT signal.
(defun ih-sigint (signal code scp)
(declare (ignore signal code scp))
(without-hemlock
(with-interrupts
(break "Software Interrupt" t))))
The without-hemlock form is used to make sure that Hemlock is exited before
a break loop is entered. The with-interrupts form is used to enable
interrupts because the user may want to generate an interrupt while in the
break loop. Finally, break is called to enter a break loop, so the user
can look at the current state of the computation. If the user proceeds
from the break loop, the computation will be restarted from where it was
interrupted.
The following function is the Lisp signal handler for the SIGTSTP signal
which suspends a process and returns to the Unix shell.
(defun ih-sigtstp (signal code scp)
(declare (ignore signal code scp))
(without-hemlock
(Unix:unix-kill (Unix:unix-getpid) Unix:sigstop)))
Lisp uses this interrupt handler to catch the SIGTSTP signal because it is
necessary to get out of Hemlock in a clean way before returning to the shell.
To set up these interrupt handlers, the following is recommended:
(with-enabled-interrupts ((Unix:SIGINT #'ih-sigint)
(Unix:SIGTSTP #'ih-sigtstp))
<user code to execute with the above signal handlers enabled.>
)