.TH GCL 1L "17 March 1997"
.SH NAME
gcl \- GCL Common Lisp interpreter/compiler, CVS snapshot
.SH SYNOPSIS
.B gcl
[
.B options
]

.SH DESCRIPTION

The program
.I gcl
is an implementation of a subset of the Common Lisp Ansi standard.
It is written in C and in Common Lisp, and is highly portable.   It
includes those features in the original definition of Common Lisp,
(Guy Steele version 1.), as well as some features from the proposed
new standard.
.LP
The best documentation is available in
.I texinfo/info
form, with there being three groups of information.
.I gcl\-si
for basic common lisp descriptions, and features unique to
.I gcl
The
.I gcl\-tk
info refers to the connection with
.I tk
window system, allowing all the power of the
.I tcl/tk
interaction system to be used from lisp.
The third info file
.I gcl
details the Ansi standard for common lisp, to which this subset
tries to adhere.   It is highly recommended to write programs,
which will be in the intersection of gcl and ansi common lisp.
Unfortunately the Ansi standard is huge, and will require a substantial
effort, and increase in the size of gcl, to include all of it.
.LP
When
.I gcl
is invoked from the shell, the variable
.I si::*command\-args*
is set to the list of command line arguments.
Various
.I options
are understood:
.TP
.BR \-eval\ command 
.RB
Call read and then eval on the
.I command passed in.
.TP
.B \-\-
.RB
Stop processing arguments, setting si::*command\-args* to a list
containing the arguments after the
.BR \-\- .
.TP
.BR \-load\ pathname
.RB
Load the file whose
.I pathname
is specified after
.BR \-load .
.TP
.BR \-f
.RB
Open the file following
.BR \-f
for input, skip the first line, and
then read and eval the rest of the forms in the file.
Replaces si::*command\-args* by the the list starting after
.BR \-f .
This can be used as with the shells to write small shell programs:

.LP
.br
#!/usr/local/bin/gcl.exe \-f
.br
(format t "hello world ~a~%" (nth 1 si::*command\-args*))

.BR
The value
.I si::*command\-args*
will have the appropriate value.
Thus if the above 2 line file is made executable and called
.I foo
then

.LP
.LP
.br
tutorial% foo billy
.br
hello world billy

.BR
NOTE:  On many systems (eg SunOs) the first line of an executable
script file such as:
.BR
#!/usr/local/bin/gcl.exe \-f
only reads the first 32 characters!   So if your pathname where
the executable together with the '\-f' amount to more than 32
characters the file will not be recognized.   Also the executable
must be the actual large binary file, [or a link to it], and not
just a
.I /bin/sh
script.   In latter case the
.I /bin/sh
interpreter would get invoked on the file.

Alternately one could invoke the file
.I foo
without making it
executable:
.LP
.LP
.br
tutorial% gcl \-f foo "from bill"
.br
hello world from bill

.TP
.B \-batch
.RB
Do not enter the command print loop.  Useful if the other command
line arguments do something.  Do not print the License and
acknowledgement information.  Note if your program does print any
License information, it must print the GCL header information also.

.TP
.B \-dir
.RB
Directory where the executable binary that is running is located.
Needed by save and friends.  This gets set as
si::*system\-directory*

.TP
.B \-libdir
.RB
.BR \-libdir
.I /d/wfs/gcl\-2.0/
.RB

would mean that the files like gcl\-tk/tk.o would be found by
concatting the path to the libdir path, ie in
.RB /d/wfs/gcl\-2.0/gcl\-tk/tk.o

.TP
.B \-compile
.RB
Invoke the compiler on the filename following
.BR \-compile
.
Other flags affect compilation.

.TP
.B \-o\-file
.RB
If nil follows
.BR \-o\-file
then do not produce an
.I .o
file.

.TP
.B \-c\-file
.RB
If
.BR \-c\-file
is specified, leave the intermediate
.I .c
file there.

.TP
.B \-h\-file
.RB     If
.BR \-h\-file
is specified, leave the intermediate
.I .h
file there.

.TP
.B \-data\-file
.RB     If
.BR \-data\-file
is specified, leave the intermediate
.I .data
file
there.

.TP
.B \-system\-p
.RB     If
.BR \-system\-p
is specified then invoke
.I compile\-file
with the
.I :system\-p t
keyword argument, meaning that the C init function
will bear a name based on the name of the file, so that it may be
invoked by name by C code.

This GNU package should not be confused with the proprietary program
distributed by FRANZ, Inc.  Nor should it be confused with any public
domain or proprietary lisp system.  

For anything other than program development, use of the lisp compiler
is strongly recommended in preference to use of the interpreter, due
to much higher speed.
.\".LP
.\"This program may be used in conjunction with the UCSF
.\".I batchqueue
.\"system.
.\".SH "LOCAL ACCESS"
.\"Locally, access to all LISP systems is made through a shared
.\"interactive front\-end which assumes that the job is be run in batch mode
.\"unless the \fB\-i\fP option is activated, which starts an interactive session.
.\"Interactive sessions are limited to 30 cpu minutes.
.SH FILES
.TP
\fI/usr/bin/gcl
executable shell script wrapper
.TP
\fI/usr/lib/gcl\-version/unixport/saved[_flavor]_gcl
executable lisp images
.SH "SEE ALSO"
.sp
\fICommon LISP: The Language\fP, Guy L. Steele, Jr., Digital Press, Bedford, MA,
1984.
.sp
\fICommon LISPcraft\fP, Robert Wilensky, W. W. Norton & Co., New York, 1984.
.SH AUTHORS

The GCL system contains C and Lisp source files to build a Common Lisp
system.  
CGL is derived from Kyoto Common LISP (\fIkcl\fP),
which was written in 1984 by T. Yuasa and M. Hagiya
(working under Professor R. Nakajima at the Research
Institute for Mathematical Sciences, Kyoto University).
The AKCL system work was begun in 1987 by
William Schelter at the University of Texas, Austin,  and continued through 1994.  
In 1994 AKCL was released as GCL (GNU Common Lisp) under the
GNU public library license.
.\"