Provided by: gcl_2.6.12-94_amd64 bug


       gcl - GCL Common Lisp interpreter/compiler, CVS snapshot


       gcl [ options ]


       The  program 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.

       The best documentation is available in texinfo/info form, with there being three groups of
       information.   gcl-si  for  basic common lisp descriptions, and features unique to gcl The
       gcl-tk info refers to the connection with tk window system, allowing all the power of  the
       tcl/tk  interaction system to be used from lisp.  The third info file 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.

       When  gcl is invoked from the shell, the variable si::*command-args* is set to the list of
       command line arguments.  Various options are understood:

       -eval command
               Call read and then eval on the command passed in.

       --      Stop processing arguments, setting si::*command-args* to  a  list  containing  the
              arguments after the --.

       -load pathname
               Load the file whose pathname is specified after -load.

       -f       Open the file following -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  -f.   This  can  be  used  as with the shells to write small shell

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

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

       tutorial% foo billy
       hello world billy

         NOTE:   On many systems (eg SunOs) the first line of an executable script file such as:
       #!/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 /bin/sh script.   In latter case the /bin/sh interpreter would
       get invoked on the file.

       Alternately one could invoke the file foo without making it executable:

       tutorial% gcl -f foo "from bill"
       hello world from bill

       -batch  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.

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

               -libdir /d/wfs/gcl-2.0/

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

                Invoke  the  compiler  on  the  filename  following  -compile  Other flags affect

               If nil follows -o-file then do not produce an .o file.

               If -c-file is specified, leave the intermediate .c file there.

              If -h-file is specified, leave the intermediate .h file there.

              If -data-file is specified, leave the intermediate .data file there.

              If -system-p is specified then invoke compile-file with  the  :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

              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.


              executable shell script wrapper

              executable lisp images


       Common LISP: The Language, Guy L. Steele, Jr., Digital Press, Bedford, MA, 1984.

       Common LISPcraft, Robert Wilensky, W. W. Norton & Co., New York, 1984.


       The  GCL  system  contains  C and Lisp source files to build a Common Lisp system.  CGL is
       derived from Kyoto Common LISP (kcl), 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.

                                          17 March 1997                                   GCL(1L)