Provided by: gcl_2.6.10-2_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.

       Open the file following
              -fforinput,skipthefirstline,and  then  read  and  eval the rest of the forms in the
              file.  Replaces si::*command-args* by the the list  starting  after  -f.Thiscan  be
              used as with the shells to write small shell programs:

       #!/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  sytem.   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)