trusty (1) gcl.1L.gz

NAME

       gcl - GCL Common Lisp interpreter/compiler, CVS snapshot

SYNOPSIS

       gcl [ options ]

DESCRIPTION

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

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

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

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

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

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

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

FILES

       /usr/bin/gcl
              executable shell script wrapper

       /usr/lib/gcl-version/unixport/saved[_flavor]_gcl
              executable lisp images

SEE ALSO

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

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

AUTHORS

       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)