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

       -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

               -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

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

               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

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


              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

                                 17 March 1997                         GCL(1L)