   This is a Texinfo GCL SYSTEM INTERNALS Manual

   Copyright 1994 William F. Schelter

Characters
**********

 - Function: NAME-CHAR (NAME)
     Package:LISP

     Given an argument acceptable to string, Returns a character object
     whose name is NAME if one exists.  Returns NIL otherwise.  NAME
     must be an object that can be coerced to a string.

 - Function: CHAR-NAME (CHAR)
     Package:LISP

     Returns the name for CHAR as a string; NIL if CHAR has no name.
     Only #\Backspace, #\Tab, #\Newline (or #\Linefeed), #\Page,
     #\Return, and #\Rubout have names.

 - Function: BOTH-CASE-P (CHAR)
     Package:LISP

     Returns T if CHAR is an alphabetic character; NIL otherwise.
     Equivalent to ALPHA-CHAR-P.

 - Function: SCHAR (SIMPLE-STRING INDEX)
     Package:LISP

     Returns the character object representing the INDEX-th character
     in STRING.  This is faster than CHAR.

 - Constant: CHAR-SUPER-BIT
     Package:LISP The bit that indicates a super character.

 - Constant: CHAR-FONT-LIMIT
     Package:LISP The upper exclusive bound on values produced by
     CHAR-FONT.

 - Function: CHAR-DOWNCASE (CHAR)
     Package:LISP

     Returns the lower-case equivalent of CHAR, if any.  If not, simply
     returns CHAR.

 - Function: STRING-CHAR-P (CHAR)
     Package:LISP

     Returns T if CHAR can be stored in a string.  In GCL, this
     function always returns T since any character in GCL can be stored
     in a string.

 - Function: CHAR-NOT-LESSP (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly non-increasing
     order; NIL otherwise.  For a lower-case character, the code of its
     upper-case equivalent is used.

 - Function: DISASSEMBLE (THING)
     Package:LISP

     Compiles the form specified by THING and prints the intermediate C
     language code for that form.  But does NOT install the result of
     compilation.  If THING is a symbol that names a not-yet-compiled
     function, the function definition is disassembled.  If THING is a
     lambda expression, it is disassembled as a function definition.
     Otherwise, THING itself is disassembled as a top-level form.

 - Function: LOWER-CASE-P (CHAR)
     Package:LISP

     Returns T if CHAR is a lower-case character; NIL otherwise.

 - Function: CHAR<= (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly non-decreasing
     order; NIL otherwise.

 - Constant: CHAR-HYPER-BIT
     Package:LISP The bit that indicates a hyper character.

 - Function: CODE-CHAR (CODE &optional (BITS 0) (FONT 0))
     Package:LISP

     Returns a character object with the specified code, if any.  If
     not, returns NIL.

 - Function: CHAR-CODE (CHAR)
     Package:LISP

     Returns the code attribute of CHAR.

 - Constant: CHAR-CONTROL-BIT
     Package:LISP The bit that indicates a control character.

 - Function: CHAR-LESSP (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly increasing order;
     NIL otherwise.  For a lower-case character, the code of its
     upper-case equivalent is used.

 - Function: CHAR-FONT (CHAR)
     Package:LISP

     Returns the font attribute of CHAR.

 - Function: CHAR< (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly increasing order;
     NIL otherwise.

 - Function: CHAR>= (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly non-increasing
     order; NIL otherwise.

 - Constant: CHAR-META-BIT
     Package:LISP The bit that indicates a meta character.

 - Function: GRAPHIC-CHAR-P (CHAR)
     Package:LISP

     Returns T if CHAR is a printing character, i.e., #\Space through
     #\~; NIL otherwise.

 - Function: CHAR-NOT-EQUAL (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if no two of CHARs are the same character; NIL otherwise.
     Upper case character and its lower case equivalent are regarded
     the same.

 - Constant: CHAR-BITS-LIMIT
     Package:LISP The upper exclusive bound on values produced by
     CHAR-BITS.

 - Function: CHARACTERP (X)
     Package:LISP

     Returns T if X is a character; NIL otherwise.

 - Function: CHAR= (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if all CHARs are the same character; NIL otherwise.

 - Function: ALPHA-CHAR-P (CHAR)
     Package:LISP

     Returns T if CHAR is an alphabetic character, A-Z or a-z; NIL
     otherwise.

 - Function: UPPER-CASE-P (CHAR)
     Package:LISP

     Returns T if CHAR is an upper-case character; NIL otherwise.

 - Function: CHAR-BIT (CHAR NAME)
     Package:LISP

     Returns T if the named bit is on in the character CHAR; NIL
     otherwise.  In GCL, this function always returns NIL.

 - Function: MAKE-CHAR (CHAR &optional (BITS 0) (FONT 0))
     Package:LISP

     Returns a character object with the same code attribute as CHAR
     and with the specified BITS and FONT attributes.

 - Function: CHARACTER (X)
     Package:LISP

     Coerces X into a character object if possible.

 - Function: CHAR-EQUAL (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if all of its arguments are the same character; NIL
     otherwise.  Upper case character and its lower case equivalent are
     regarded the same.

 - Function: CHAR-NOT-GREATERP (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly non-decreasing
     order; NIL otherwise.  For a lower-case character, the code of its
     upper-case equivalent is used.

 - Function: CHAR> (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly decreasing order;
     NIL otherwise.

 - Function: STANDARD-CHAR-P (CHAR)
     Package:LISP

     Returns T if CHAR is a standard character, i.e., one of the 95
     ASCII printing characters #\Space to #\~ and #Newline; NIL
     otherwise.

 - Function: CHAR-UPCASE (CHAR)
     Package:LISP

     Returns the upper-case equivalent of CHAR, if any.  If not, simply
     returns CHAR.

 - Function: DIGIT-CHAR-P (CHAR &optional (RADIX 10))
     Package:LISP

     If CHAR represents a digit in RADIX, then returns the weight as an
     integer.  Otherwise, returns nil.

 - Function: CHAR/= (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if no two of CHARs are the same character; NIL otherwise.

 - Function: CHAR-GREATERP (CHAR &rest MORE-CHARS)
     Package:LISP

     Returns T if the codes of CHARs are in strictly decreasing order;
     NIL otherwise.  For a lower-case character, the code of its
     upper-case equivalent is used.

 - Function: ALPHANUMERICP (CHAR)
     Package:LISP

     Returns T if CHAR is either numeric or alphabetic; NIL otherwise.

 - Function: CHAR-BITS (CHAR)
     Package:LISP

     Returns the bits attribute (which is always 0 in GCL) of CHAR.

 - Function: DIGIT-CHAR (DIGIT &optional (RADIX 10) (FONT 0))
     Package:LISP

     Returns a character object that represents the DIGIT in the
     specified RADIX.  Returns NIL if no such character exists.

 - Function: SET-CHAR-BIT (CHAR NAME NEWVALUE)
     Package:LISP

     Returns a character just like CHAR except that the named bit is
     set or cleared, according to whether NEWVALUE is non-NIL or NIL.
     This function is useless in GCL.

Lists
*****

 - Function: NINTERSECTION (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the intersection of LIST1 and LIST2.  LIST1 may be
     destroyed.

 - Function: RASSOC-IF (PREDICATE ALIST)
     Package:LISP

     Returns the first cons in ALIST whose cdr satisfies PREDICATE.

 - Function: MAKE-LIST (SIZE &key (INITIAL-ELEMENT NIL))
     Package:LISP

     Creates and returns a list containing SIZE elements, each of which
     is initialized to INITIAL-ELEMENT.

 - Function: NTH (N LIST)
     Package:LISP

     Returns the N-th element of LIST, where the car of LIST is the
     zeroth element.

 - Function: CAAR (X)
     Package:LISP

     Equivalent to (CAR (CAR X)).

 - Function: NULL (X)
     Package:LISP

     Returns T if X is NIL; NIL otherwise.

 - Function: FIFTH (X)
     Package:LISP

     Equivalent to (CAR (CDDDDR X)).

 - Function: NCONC (&rest LISTS)
     Package:LISP

     Concatenates LISTs by destructively modifying them.

 - Function: TAILP (SUBLIST LIST)
     Package:LISP

     Returns T if SUBLIST is one of the conses in LIST; NIL otherwise.

 - Function: CONSP (X)
     Package:LISP

     Returns T if X is a cons; NIL otherwise.

 - Function: TENTH (X)
     Package:LISP

     Equivalent to (CADR (CDDDDR (CDDDDR X))).

 - Function: LISTP (X)
     Package:LISP

     Returns T if X is either a cons or NIL; NIL otherwise.

 - Function: MAPCAN (FUN LIST &rest MORE-LISTS)
     Package:LISP

     Applies FUN to successive cars of LISTs, NCONCs the results, and
     returns it.

 - Function: EIGHTH (X)
     Package:LISP

     Equivalent to (CADDDR (CDDDDR X)).

 - Function: LENGTH (SEQUENCE)
     Package:LISP

     Returns the length of SEQUENCE.

 - Function: RASSOC (ITEM ALIST &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the first cons in ALIST whose cdr is equal to ITEM.

 - Function: NSUBST-IF-NOT (NEW TEST TREE &key (KEY #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees of TREE that do not satisfy TEST.

 - Function: NBUTLAST (LIST &optional (N 1))
     Package:LISP

     Changes the cdr of the N+1 th cons from the end of the list LIST
     to NIL.  Returns the whole list.

 - Function: CDR (LIST)
     Package:LISP

     Returns the cdr of LIST.  Returns NIL if LIST is NIL.

 - Function: MAPC (FUN LIST &rest MORE-LISTS)
     Package:LISP

     Applies FUN to successive cars of LISTs.  Returns the first LIST.

 - Function: MAPL (FUN LIST &rest MORE-LISTS)
     Package:LISP

     Applies FUN to successive cdrs of LISTs.  Returns the first LIST.

 - Function: CONS (X Y)
     Package:LISP

     Returns a new cons whose car and cdr are X and Y, respectively.

 - Function: LIST (&rest ARGS)
     Package:LISP

     Returns a list of its arguments

 - Function: THIRD (X)
     Package:LISP

     Equivalent to (CADDR X).

 - Function: CDDAAR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CAR (CAR X)))).

 - Function: CDADAR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CDR (CAR X)))).

 - Function: CDAADR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CAR (CDR X)))).

 - Function: CADDAR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CDR (CAR X)))).

 - Function: CADADR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CAR (CDR X)))).

 - Function: CAADDR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CDR (CDR X)))).

 - Function: NTHCDR (N LIST)
     Package:LISP

     Returns the result of performing the CDR operation N times on LIST.

 - Function: PAIRLIS (KEYS DATA &optional (ALIST NIL))
     Package:LISP

     Constructs an association list from KEYS and DATA adding to ALIST.

 - Function: SEVENTH (X)
     Package:LISP

     Equivalent to (CADDR (CDDDDR X)).

 - Function: SUBSETP (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns T if every element of LIST1 appears in LIST2; NIL
     otherwise.

 - Function: NSUBST-IF (NEW TEST TREE &key (KEY #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees of TREE that satisfy TEST.

 - Function: COPY-LIST (LIST)
     Package:LISP

     Returns a new copy of LIST.

 - Function: LAST (LIST)
     Package:LISP

     Returns the last cons in LIST

 - Function: CAAAR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CAR X))).

 - Function: LIST-LENGTH (LIST)
     Package:LISP

     Returns the length of LIST, or NIL if LIST is circular.

 - Function: CDDDR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CDR X))).

 - Function: INTERSECTION (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the intersection of List1 and List2.

 - Function: NSUBST (NEW OLD TREE &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees in TREE that match OLD.

 - Function: REVAPPEND (X Y)
     Package:LISP

     Equivalent to (APPEND (REVERSE X) Y)

 - Function: CDAR (X)
     Package:LISP

     Equivalent to (CDR (CAR X)).

 - Function: CADR (X)
     Package:LISP

     Equivalent to (CAR (CDR X)).

 - Function: REST (X)
     Package:LISP

     Equivalent to (CDR X).

 - Function: NSET-EXCLUSIVE-OR (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT
          (KEY #'IDENTITY))
     Package:LISP

     Returns a list with elements which appear but once in LIST1 and
     LIST2.

 - Function: ACONS (KEY DATUM ALIST)
     Package:LISP

     Constructs a new alist by adding the pair (KEY . DATUM) to ALIST.

 - Function: SUBST-IF-NOT (NEW TEST TREE &key (KEY #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees of TREE that do not satisfy TEST.

 - Function: RPLACA (X Y)
     Package:LISP

     Replaces the car of X with Y, and returns the modified X.

 - Function: SECOND (X)
     Package:LISP

     Equivalent to (CADR X).

 - Function: NUNION (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the union of LIST1 and LIST2.  LIST1 and/or LIST2 may be
     destroyed.

 - Function: BUTLAST (LIST &optional (N 1))
     Package:LISP

     Creates and returns a list with the same elements as LIST but
     without the last N elements.

 - Function: COPY-ALIST (ALIST)
     Package:LISP  Returns a new copy of ALIST.

 - Function: SIXTH (X)
     Package:LISP  Equivalent to (CADR (CDDDDR X)).

 - Function: CAAAAR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CAR (CAR X)))).

 - Function: CDDDAR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CDR (CAR X)))).

 - Function: CDDADR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CAR (CDR X)))).

 - Function: CDADDR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CDR (CDR X)))).

 - Function: CADDDR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CDR (CDR X)))).

 - Function: FOURTH (X)
     Package:LISP

     Equivalent to (CADDDR X).

 - Function: NSUBLIS (ALIST TREE &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Substitutes from ALIST for subtrees of TREE.

 - Function: SUBST-IF (NEW TEST TREE &key (KEY #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees of TREE that satisfy TEST.

 - Function: NSET-DIFFERENCE (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT
          (KEY #'IDENTITY))
     Package:LISP

     Returns a list of elements of LIST1 that do not appear in LIST2.
     LIST1 may be destroyed.

 - Special Form: POP
     Package:LISP

     Syntax:
          (pop place)

     Pops one item off the front of the list in PLACE and returns it.

 - Special Form: PUSH
     Package:LISP

     Syntax:
          (push item place)

     Conses ITEM onto the list in PLACE, and returns the new list.

 - Function: CDAAR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CAR X))).

 - Function: CADAR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CAR X))).

 - Function: CAADR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CDR X))).

 - Function: FIRST (X)
     Package:LISP

     Equivalent to (CAR X).

 - Function: SUBST (NEW OLD TREE &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Substitutes NEW for subtrees of TREE that match OLD.

 - Function: ADJOIN (ITEM LIST &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Adds ITEM to LIST unless ITEM is already a member of LIST.

 - Function: MAPCON (FUN LIST &rest MORE-LISTS)
     Package:LISP

     Applies FUN to successive cdrs of LISTs, NCONCs the results, and
     returns it.

 - Macro: PUSHNEW
     Package:LISP

     Syntax:
          (pushnew item place {keyword value}*)

     If ITEM is already in the list stored in PLACE, does nothing.
     Else, conses ITEM onto the list.  Returns NIL.  If no KEYWORDs are
     supplied, each element in the list is compared with ITEM by EQL,
     but the comparison can be controlled by supplying keywords :TEST,
     :TEST-NOT, and/or :KEY.

 - Function: SET-EXCLUSIVE-OR (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT
          (KEY #'IDENTITY))
     Package:LISP

     Returns a list of elements appearing exactly once in LIST1 and
     LIST2.

 - Function: TREE-EQUAL (X Y &key (TEST #'EQL) TEST-NOT)
     Package:LISP

     Returns T if X and Y are isomorphic trees with identical leaves.

 - Function: CDDR (X)
     Package:LISP

     Equivalent to (CDR (CDR X)).

 - Function: GETF (PLACE INDICATOR &optional (DEFAULT NIL))
     Package:LISP

     Searches the property list stored in Place for an indicator EQ to
     Indicator.  If one is found, the corresponding value is returned,
     else the Default is returned.

 - Function: LDIFF (LIST SUBLIST)
     Package:LISP

     Returns a new list, whose elements are those of LIST that appear
     before SUBLIST.  If SUBLIST is not a tail of LIST, a copy of LIST
     is returned.

 - Function: UNION (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the union of LIST1 and LIST2.

 - Function: ASSOC-IF-NOT (TEST ALIST)
     Package:LISP

     Returns the first pair in ALIST whose car does not satisfy TEST.

 - Function: RPLACD (X Y)
     Package:LISP

     Replaces the cdr of X with Y, and returns the modified X.

 - Function: MEMBER-IF-NOT (TEST LIST &key (KEY #'IDENTITY))
     Package:LISP

     Returns the tail of LIST beginning with the first element not
     satisfying TEST.

 - Function: CAR (LIST)
     Package:LISP

     Returns the car of LIST.  Returns NIL if LIST is NIL.

 - Function: ENDP (X)
     Package:LISP

     Returns T if X is NIL.  Returns NIL if X is a cons.  Otherwise,
     signals an error.

 - Function: LIST* (ARG &rest OTHERS)
     Package:LISP

     Returns a list of its arguments with the last cons being a dotted
     pair of the next to the last argument and the last argument.

 - Function: NINTH (X)
     Package:LISP

     Equivalent to (CAR (CDDDDR (CDDDDR X))).

 - Function: CDAAAR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CAR (CAR X)))).

 - Function: CADAAR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CAR (CAR X)))).

 - Function: CAADAR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CDR (CAR X)))).

 - Function: CAAADR (X)
     Package:LISP

     Equivalent to (CAR (CAR (CAR (CDR X)))).

 - Function: CDDDDR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CDR (CDR X)))).

 - Function: SUBLIS (ALIST TREE &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Substitutes from ALIST for subtrees of TREE nondestructively.

 - Function: RASSOC-IF-NOT (PREDICATE ALIST)
     Package:LISP

     Returns the first cons in ALIST whose cdr does not satisfy
     PREDICATE.

 - Function: NRECONC (X Y)
     Package:LISP

     Equivalent to (NCONC (NREVERSE X) Y).

 - Function: MAPLIST (FUN LIST &rest MORE-LISTS)
     Package:LISP

     Applies FUN to successive cdrs of LISTs and returns the results as
     a list.

 - Function: SET-DIFFERENCE (LIST1 LIST2 &key (TEST #'EQL) TEST-NOT
          (KEY #'IDENTITY))
     Package:LISP

     Returns a list of elements of LIST1 that do not appear in LIST2.

 - Function: ASSOC-IF (TEST ALIST)
     Package:LISP

     Returns the first pair in ALIST whose car satisfies TEST.

 - Function: GET-PROPERTIES (PLACE INDICATOR-LIST)
     Package:LISP

     Looks for the elements of INDICATOR-LIST in the property list
     stored in PLACE.  If found, returns the indicator, the value, and
     T as multiple-values.  If not, returns NILs as its three values.

 - Function: MEMBER-IF (TEST LIST &key (KEY #'IDENTITY))
     Package:LISP

     Returns the tail of LIST beginning with the first element
     satisfying TEST.

 - Function: COPY-TREE (OBJECT)
     Package:LISP

     Recursively copies conses in OBJECT and returns the result.

 - Function: ATOM (X)
     Package:LISP

     Returns T if X is not a cons; NIL otherwise.

 - Function: CDDAR (X)
     Package:LISP

     Equivalent to (CDR (CDR (CAR X))).

 - Function: CDADR (X)
     Package:LISP

     Equivalent to (CDR (CAR (CDR X))).

 - Function: CADDR (X)
     Package:LISP

     Equivalent to (CAR (CDR (CDR X))).

 - Function: ASSOC (ITEM ALIST &key (TEST #'EQL) TEST-NOT)
     Package:LISP

     Returns the first pair in ALIST whose car is equal (in the sense
     of TEST) to ITEM.

 - Function: APPEND (&rest LISTS)
     Package:LISP

     Constructs a new list by concatenating its arguments.

 - Function: MEMBER (ITEM LIST &key (TEST #'EQL) TEST-NOT (KEY
          #'IDENTITY))
     Package:LISP

     Returns the tail of LIST beginning with the first ITEM.

Streams and Reading
*******************

 - Function: MAKE-ECHO-STREAM (INPUT-STREAM OUTPUT-STREAM)
     Package:LISP

     Returns a bidirectional stream which gets its input from
     INPUT-STREAM and sends its output to OUTPUT-STREAM.  In addition,
     all input is echoed to OUTPUT-STREAM.

 - Variable: *READTABLE*
     Package:LISP The current readtable.

 - Function: LOAD (FILENAME
     &key (verbose *load-verbose*) (print nil) (if-does-not-exist
     :error)) Package:LISP

     Loads the file named by FILENAME into GCL.

 - Function: OPEN (FILENAME &key (DIRECTION :INPUT) (ELEMENT-TYPE
          'STRING-CHAR)
     (if-exists :error) (if-does-not-exist :error)) Package:LISP

     Opens the file specified by FILENAME, which may be a string, a
     pathname, or a stream.  Returns a stream for the open file.
     DIRECTION is  :INPUT, :OUTPUT, :IO or :PROBE.  ELEMENT-TYPE is
     STRING-CHAR, (UNSIGNED-BYTE n), UNSIGNED-BYTE, (SIGNED-BYTE n),
     SIGNED-BYTE, CHARACTER, BIT, (MOD n), or :DEFAULT.  IF-EXISTS is
     :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, :OVERWRITE,
     :APPEND, :SUPERSEDE, or NIL.  IF-DOES-NOT-EXIST is  :ERROR,
     :CREATE, or NIL.

 - Variable: *PRINT-BASE*
     Package:LISP The radix in which the GCL printer prints integers
     and rationals.  The value must be an integer from 2 to 36,
     inclusive.

 - Function: MAKE-STRING-INPUT-STREAM (STRING &optional (START 0) (END
          (LENGTH STRING)))
     Package:LISP

     Returns an input stream which will supply the characters of String
     between Start and End in order.

 - Function: PPRINT (OBJECT &optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Pretty-prints OBJECT.  Returns OBJECT.  Equivalent to
     (WRITE :STREAM STREAM :PRETTY T) The SI:PRETTY-PRINT-FORMAT
     property N (which must be a non-negative integer) of a symbol
     SYMBOL controls the pretty-printing of form 	(SYMBOL f1 ... fN fN+1
     ... fM) in such a way that the subforms fN+1, ..., fM are regarded
     as the 'body' of the entire form.  For instance, the property
     value of 2 is initially given to the symbol DO.

 - Variable: *READ-DEFAULT-FLOAT-FORMAT*
     Package:LISP The floating-point format the GCL reader uses when
     reading floating-point numbers that have no exponent marker or
     have e or E for an exponent marker.  Must be one of SHORT-FLOAT,
     SINGLE-FLOAT, DOUBLE-FLOAT, and LONG-FLOAT.

 - Function: READ-PRESERVING-WHITESPACE (&optional (STREAM
          *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL)
     (recursive-p nil)) Package:LISP

     Reads an object from STREAM, preserving the whitespace that
     followed the object.

 - Function: STREAMP (X)
     Package:LISP

     Returns T if X is a stream object; NIL otherwise.

 - Function: SET-DISPATCH-MACRO-CHARACTER (DISP-CHAR SUB-CHAR FUNCTION
          &optional (READTABLE *READTABLE*))
     Package:LISP

     Causes FUNCTION to be called when the DISP-CHAR followed by
     SUB-CHAR is read.

 - Macro: WITH-OUTPUT-TO-STRING
     Package:LISP

     Syntax:
          (with-output-to-string (var [string]) {decl}* {form}*)

     Binds VAR to a string output stream that puts characters into
     STRING, which defaults to a new string.  The stream is
     automatically closed on exit and the string is returned.

 - Function: FILE-LENGTH (FILE-STREAM)
     Package:LISP

     Returns the length of the specified file stream.

 - Variable: *PRINT-CASE*
     Package:LISP The case in which the GCL printer should print
     ordinary symbols.  The value must be one of the keywords :UPCASE,
     :DOWNCASE, and :CAPITALIZE.

 - Function: PRINT (OBJECT &optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Outputs a newline character, and then prints OBJECT in the mostly
     readable representation.  Returns OBJECT.  Equivalent to
     (PROGN (TERPRI STREAM) (WRITE OBJECT :STREAM STREAM :ESCAPE T)).

 - Function: SET-MACRO-CHARACTER (CHAR FUNCTION
     &optional (non-terminating-p nil) (readtable *readtable*))
     Package:LISP

     Causes CHAR to be a macro character that, when seen by READ,
     causes FUNCTION to be called.

 - Function: FORCE-OUTPUT (&optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Attempts to force any buffered output to be sent.

 - Variable: *PRINT-ARRAY*
     Package:LISP Whether the GCL printer should print array elements.

 - Function: STREAM-ELEMENT-TYPE (STREAM)
     Package:LISP

     Returns a type specifier for the kind of object returned by STREAM.

 - Function: WRITE-BYTE (INTEGER STREAM)
     Package:LISP

     Outputs INTEGER to the binary stream STREAM.  Returns INTEGER.

 - Function: MAKE-CONCATENATED-STREAM (&rest STREAMS)
     Package:LISP

     Returns a stream which takes its input from each of the STREAMs in
     turn, going on to the next at end of stream.

 - Function: PRIN1 (OBJECT &optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Prints OBJECT in the mostly readable representation.  Returns
     OBJECT.  Equivalent to (WRITE OBJECT :STREAM STREAM :ESCAPE T).

 - Function: PRINC (OBJECT &optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Prints OBJECT without escape characters.  Returns OBJECT.
     Equivalent to 	(WRITE OBJECT :STREAM STREAM :ESCAPE NIL).

 - Function: CLEAR-OUTPUT (&optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Clears the output stream STREAM.

 - Function: TERPRI (&optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Outputs a newline character.

 - Function: FINISH-OUTPUT (&optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Attempts to ensure that all output sent to STREAM has reached its
     destination, and only then returns.

 - Macro: WITH-OPEN-FILE
     Package:LISP

     Syntax:
          (with-open-file (stream filename {options}*) {decl}* {form}*)

     Opens the file whose name is FILENAME, using OPTIONs, and binds
     the variable STREAM to a stream to/from the file.  Then evaluates
     FORMs as a PROGN.  The file is automatically closed on exit.

 - Special Form: DO
     Package:LISP

     Syntax:
          (do ({(var [init [step]])}*) (endtest {result}*)
                    {decl}* {tag | statement}*)

     Creates a NIL block, binds each VAR to the value of the
     corresponding INIT, and then executes STATEMENTs repeatedly until
     ENDTEST is satisfied.  After each iteration, assigns to each VAR
     the value of the corresponding STEP.  When ENDTEST is satisfied,
     evaluates RESULTs as a PROGN and returns the value(s) of the last
     RESULT (or NIL if no RESULTs are supplied).  Performs variable
     bindings and assignments all at once, just like LET and PSETQ do.

 - Function: READ-FROM-STRING (STRING &optional (EOF-ERROR-P T)
          (EOF-VALUE NIL)
     &key (start 0) (end (length string)) (preserve-whitespace nil))
     Package:LISP

     Reads an object from STRING.

 - Function: WRITE-STRING (STRING &optional (STREAM *STANDARD-OUTPUT*)
     &key (start 0) (end (length string))) Package:LISP

     Outputs STRING and returns it.

 - Variable: *PRINT-LEVEL*
     Package:LISP How many levels deep the GCL printer should print.
     Unlimited if NIL.

 - Variable: *PRINT-RADIX*
     Package:LISP Whether the GCL printer should print the radix
     indicator when printing integers and rationals.

 - Function: Y-OR-N-P (&optional (FORMAT-STRING NIL) &rest ARGS)
     Package:LISP

     Asks the user a question whose answer is either 'Y' or 'N'.  If
     FORMAT-STRING is non-NIL, then FRESH-LINE operation is performed,
     a message is printed as if FORMAT-STRING and ARGs were given to
     FORMAT, and then a prompt "(Y or N)" is printed.  Otherwise, no
     prompt will appear.

 - Function: MAKE-BROADCAST-STREAM (&rest STREAMS)
     Package:LISP

     Returns an output stream which sends its output to all of the
     given streams.

 - Function: READ-CHAR (&optional (STREAM *STANDARD-INPUT*)
          (EOF-ERROR-P T)
     (eof-value nil) (recursive-p nil)) Package:LISP

     Reads a character from STREAM.

 - Function: PEEK-CHAR (&optional (PEEK-TYPE NIL) (STREAM
          *STANDARD-INPUT*) (EOF-ERROR-P T)
     (eof-value nil) (recursive-p nil)) Package:LISP

     Peeks at the next character in the input stream STREAM.

 - Function: OUTPUT-STREAM-P (STREAM)
     Package:LISP

     Returns non-nil if STREAM can handle output operations; NIL
     otherwise.

 - Variable: *QUERY-IO*
     Package:LISP The query I/O stream.

 - Variable: *READ-BASE*
     Package:LISP The radix that the GCL reader reads numbers in.

 - Macro: WITH-OPEN-STREAM
     Package:LISP

     Syntax:
          (with-open-stream (var stream) {decl}* {form}*)

     Evaluates FORMs as a PROGN with VAR bound to the value of STREAM.
     The stream is automatically closed on exit.

 - Macro: WITH-INPUT-FROM-STRING
     Package:LISP

     Syntax:
          (with-input-from-string (var string {keyword value}*) {decl}*
          {form}*)

     Binds VAR to an input stream that returns characters from STRING
     and evaluates the FORMs.  The stream is automatically closed on
     exit.  Allowed keywords are :INDEX, :START, and :END.

 - Function: CLEAR-INPUT (&optional (STREAM *STANDARD-INPUT*))
     Package:LISP  Clears the input stream STREAM.

 - Variable: *TERMINAL-IO*
     Package:LISP The terminal I/O stream.

 - Function: LISTEN (&optional (STREAM *STANDARD-INPUT*))
     Package:LISP

     Returns T if a character is available on STREAM; NIL otherwise.
     This function does not correctly work in some versions of GCL
     because of the lack of such mechanism in the underlying operating
     system.

 - Function: MAKE-PATHNAME (&key (DEFAULTS (PARSE-NAMESTRING ""
     (pathname-host *default-pathname-defaults*)))             (host
     (pathname-host defaults))             (device (pathname-device
     defaults))             (directory (pathname-directory defaults))
              (name (pathname-name defaults))             (type
     (pathname-type defaults))             (version (pathname-version
     defaults))) Package:LISP

     Create a pathname from HOST, DEVICE, DIRECTORY, NAME, TYPE and
     VERSION.

 - Function: PATHNAME-TYPE (PATHNAME)
     Package:LISP

     Returns the type slot of PATHNAME.

 - Variable: *PRINT-GENSYM*
     Package:LISP Whether the GCL printer should prefix symbols with no
     home package with "#:".

 - Function: READ-LINE (&optional (STREAM *STANDARD-INPUT*)
          (EOF-ERROR-P T)
     (eof-value nil) (recursive-p nil)) Package:LISP

     Returns a line of text read from STREAM as a string, discarding
     the newline character.

     Note that when using line at a time input under unix, input forms
     will always be followed by a #\newline.   Thus if you do

     >(read-line) "" nil

     the empty string will be returned.  After lisp reads the
     (read-line) it then invokes (read-line).  This happens before it
     does anything else and so happens before the newline character
     immediately following (read-line) has been read.  Thus read-line
     immediately encounters a #\newline and so returns the empty
     string.  If there had been other characters before the #\newline
     it would have been different:

     >(read-line) how are you " how are you" nil

     If you want to throw away "" input, you can do that with the
     following:

     (sloop::sloop while (equal (setq input (read-line)) ""))

     You may also want to use character at a time input, but that makes
     input editing harder.  nicolas% stty cbreak nicolas% gcl GCL (GNU
     Common Lisp)  Version(1.1.2) Mon Jan  9 12:58:22 MET 1995 Licensed
     under GNU Public Library License Contains Enhancements by W.
     Schelter

     >(let ((ifilename nil))     (format t "~%Input file name: ")
     (setq ifilename (read-line))) Input file name: /tmp/myfile
     "/tmp/myfile"

     >(bye)Bye.

 - Function: WRITE-TO-STRING (OBJECT &key (ESCAPE *PRINT-ESCAPE*)
          (RADIX *PRINT-RADIX*)
     (base *print-base*) (circle *print-circle*)
     (pretty *print-pretty*) (level *print-level*)
     (length *print-length*) (case *print-case*)
     (array *print-array*) (gensym *print-gensym*)) Package:LISP

     Returns as a string the printed representation of OBJECT in the
     specified mode.  See the variable docs of *PRINT-...* for the mode.

 - Function: PATHNAMEP (X)
     Package:LISP

     Returns T if X is a pathname object; NIL otherwise.

 - Function: READTABLEP (X)
     Package:LISP

     Returns T if X is a readtable object; NIL otherwise.

 - Function: READ (&optional (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T)
          (EOF-VALUE NIL)
     (recursivep nil)) Package:LISP

     Reads in the next object from STREAM.

 - Function: NAMESTRING (PATHNAME)
     Package:LISP

     Returns the full form of PATHNAME as a string.

 - Function: UNREAD-CHAR (CHARACTER &optional (STREAM *STANDARD-INPUT*))
     Package:LISP

     Puts CHARACTER back on the front of the input stream STREAM.

 - Function: CLOSE (STREAM &key (ABORT NIL))
     Package:LISP

     Closes STREAM.  A non-NIL value of :ABORT indicates an abnormal
     termination.

 - Variable: *PRINT-LENGTH*
     Package:LISP How many elements the GCL printer should print at
     each level of nested data object.  Unlimited if NIL.

 - Function: SET-SYNTAX-FROM-CHAR (TO-CHAR FROM-CHAR
     &optional (to-readtable *readtable*) (from-readtable nil))
     Package:LISP

     Makes the syntax of TO-CHAR in TO-READTABLE be the same as the
     syntax of FROM-CHAR in FROM-READTABLE.

 - Function: INPUT-STREAM-P (STREAM)
     Package:LISP

     Returns non-NIL if STREAM can handle input operations; NIL
     otherwise.

 - Function: PATHNAME (X)
     Package:LISP

     Turns X into a pathname.  X may be a string, symbol, stream, or
     pathname.

 - Function: FILE-NAMESTRING (PATHNAME)
     Package:LISP

     Returns the written representation of PATHNAME as a string.

 - Function: MAKE-DISPATCH-MACRO-CHARACTER (CHAR &optional
          (NON-TERMINATING-P NIL) (READTABLE *READTABLE*))
     Package:LISP

     Causes the character CHAR to be a dispatching macro character in
     READTABLE.

 - Variable: *STANDARD-OUTPUT*
     Package:LISP The default output stream used by the GCL printer.

 - Function: MAKE-TWO-WAY-STREAM (INPUT-STREAM OUTPUT-STREAM)
     Package:LISP

     Returns a bidirectional stream which gets its input from
     INPUT-STREAM and sends its output to OUTPUT-STREAM.

 - Variable: *PRINT-ESCAPE*
     Package:LISP Whether the GCL printer should put escape characters
     whenever appropriate.

 - Function: COPY-READTABLE (&optional (FROM-READTABLE *READTABLE*)
          (TO-READTABLE NIL))
     Package:LISP

     Returns a copy of the readtable FROM-READTABLE.  If TO-READTABLE
     is non-NIL, then copies into TO-READTABLE.  Otherwise, creates a
     new readtable.

 - Function: DIRECTORY-NAMESTRING (PATHNAME)
     Package:LISP

     Returns the directory part of PATHNAME as a string.

 - Function: TRUENAME (PATHNAME)
     Package:LISP

     Returns the pathname for the actual file described by PATHNAME.

 - Variable: *READ-SUPPRESS*
     Package:LISP When the value of this variable is NIL, the GCL
     reader operates normally.  When it is non-NIL, then the reader
     parses input characters but much of what is read is not
     interpreted.

 - Function: GET-DISPATCH-MACRO-CHARACTER (DISP-CHAR SUB-CHAR &optional
          (READTABLE *READTABLE*))
     Package:LISP

     Returns the macro-character function for SUB-CHAR under DISP-CHAR.

 - Function: PATHNAME-DEVICE (PATHNAME)
     Package:LISP

     Returns the device slot of PATHNAME.

 - Function: READ-CHAR-NO-HANG (&optional (STREAM *STANDARD-INPUT*)
          (EOF-ERROR-P T)
     (eof-value nil) (recursive-p nil)) Package:LISP

     Returns the next character from STREAM if one is available; NIL
     otherwise.

 - Function: FRESH-LINE (&optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Outputs a newline if it is not positioned at the beginning of a
     line.  Returns T if it output a newline; NIL otherwise.

 - Function: WRITE-CHAR (CHAR &optional (STREAM *STANDARD-OUTPUT*))
     Package:LISP

     Outputs CHAR and returns it.

 - Function: PARSE-NAMESTRING (THING &optional HOST (DEFAULTS
          *DEFAULT-PATHNAME-DEFAULTS*)
     &key (start 0) (end (length thing)) (junk-allowed nil))
     Package:LISP

     Parses a string representation of a pathname into a pathname.  HOST
     is ignored.

 - Function: PATHNAME-DIRECTORY (PATHNAME)
     Package:LISP

     Returns the directory slot of PATHNAME.

 - Function: GET-MACRO-CHARACTER (CHAR &optional (READTABLE
          *READTABLE*))
     Package:LISP

     Returns the function associated with CHAR and, as a second value,
     returns the non-terminating-p flag.

 - Function: FORMAT (DESTINATION CONTROL-STRING &rest ARGUMENTS)
     Package:LISP

     Provides various facilities for formatting output.  DESTINATION
     controls where the result will go.  If DESTINATION is T, then the
     output is sent to the standard output stream.  If it is NIL, then
     the output is returned in a string as the value of the call.
     Otherwise, DESTINATION must be a stream to which the output will
     be sent.

     CONTROL-STRING is a string to be output, possibly with embedded
     formatting directives, which are flagged with the escape character
     "~".  Directives generally expand into additional text to be
     output, usually consuming one or more of ARGUMENTs in the process.

     A few useful directives are:

          ~A, ~nA, ~n@A	Prints one argument as if by PRINC
          ~S, ~nS, ~n@S	Prints one argument as if by PRIN1
          ~D, ~B, ~O, ~X	Prints one integer in decimal, binary, octal, and hexa
          ~%		Does TERPRI
          ~&		Does FRESH-LINE

     where n is the minimal width of the field in which the object is
     printed.  ~nA and ~nS put padding spaces on the right; ~n@A and
     ~n@S put on the left.

          ~R  is for printing numbers in various formats.

            ~nR   prints arg in radix n.
            ~R    prints arg as a cardinal english number: two
            ~:R   prints arg as an ordinal english number: third
            ~@R   prints arg as an a Roman Numeral: VII
            ~:@R   prints arg as an old Roman Numeral: IIII

          ~C prints a character.
            ~:C represents non printing characters by their pretty names,eg Space
            ~@C uses the #\ syntax to allow the reader to read it.

          ~F prints a floating point number arg.
            The full form is ~w,d,k,overflowchar,padcharF
            w represents the total width of the printed representation (variable if
              not present)
            d the number of fractional digits to display
              (format nil "~,2f" 10010.0314) --> "10010.03"
            k arg is multiplied by 10^k before printing it as a decimal number.
            overflowchar width w characters copies of the overflow character will
              be printed.   eg(format t "X>~5,2,,'?F<X" 100.034) --> X>?????<X
            padchar is the character to pad with
              (format t "X>~10,2,1,'?,'bF<X" 100.03417) -->X>bbb1000.34<X
            @ makes + sign print if the arg is positive

          ~@[print-if-true~]
        if arg is not nil, then it is retained as an arg for further
     printing,    otherwise it is used up

             (format nil "~@[x = ~d~]~a" nil 'bil) --> "BIL"
             (format nil "~@[x = ~d ~]~a" 8) --> "x = 8 BIL"

 - Function: PATHNAME-NAME (PATHNAME)
     Package:LISP

     Returns the name slot of PATHNAME.

 - Function: MAKE-STRING-OUTPUT-STREAM ()
     Package:LISP

     Returns an output stream which will accumulate all output given it
     for the benefit of the function GET-OUTPUT-STREAM-STRING.

 - Function: MAKE-SYNONYM-STREAM (SYMBOL)
     Package:LISP

     Returns a stream which performs its operations on the stream which
     is the value of the dynamic variable named by SYMBOL.

 - Variable: *LOAD-VERBOSE*
     Package:LISP The default for the VERBOSE argument to LOAD.

 - Variable: *PRINT-CIRCLE*
     Package:LISP Whether the GCL printer should take care of circular
     lists.

 - Variable: *PRINT-PRETTY*
     Package:LISP Whether the GCL printer should pretty-print.  See the
     function doc of PPRINT for more information about pretty-printing.

 - Function: FILE-WRITE-DATE (FILE)
     Package:LISP

     Returns the time at which the specified file is written, as an
     integer in universal time format.  FILE may be a string or a
     stream.

 - Function: PRIN1-TO-STRING (OBJECT)
     Package:LISP

     Returns as a string the printed representation of OBJECT in the
     mostly readable representation.  Equivalent to (WRITE-TO-STRING
     OBJECT :ESCAPE T).

 - Function: MERGE-PATHNAMES (PATHNAME
     &optional (defaults *default-pathname-defaults*) default-version)
     Package:LISP

     Fills in unspecified slots of PATHNAME from DEFAULTS.
     DEFAULT-VERSION is ignored in GCL.

 - Function: READ-BYTE (STREAM &optional (EOF-ERROR-P T) (EOF-VALUE
          NIL))
     Package:LISP

     Reads the next byte from STREAM.

 - Function: PRINC-TO-STRING (OBJECT)
     Package:LISP

     Returns as a string the printed representation of OBJECT without
     escape characters.  Equivalent to 	(WRITE-TO-STRING OBJECT :ESCAPE
     NIL).

 - Variable: *STANDARD-INPUT*
     Package:LISP The default input stream used by the GCL reader.

 - Function: PROBE-FILE (FILE)
     Package:LISP

     Returns the truename of file if the file exists.  Returns NIL
     otherwise.

 - Function: PATHNAME-VERSION (PATHNAME)
     Package:LISP

     Returns the version slot of PATHNAME.

 - Function: WRITE-LINE (STRING &optional (STREAM *STANDARD-OUTPUT*)
     &key (start 0) (end (length string))) Package:LISP

     Outputs STRING and then outputs a newline character.  Returns
     STRING.

 - Function: WRITE (OBJECT &key (STREAM *STANDARD-OUTPUT*) (ESCAPE
          *PRINT-ESCAPE*)
     (radix *print-radix*) (base *print-base*)
     (circle *print-circle*) (pretty *print-pretty*)
     (level *print-level*) (length *print-length*)
     (case *print-case*) (array *print-array*)
     (gensym *print-gensym*)) Package:LISP

     Prints OBJECT in the specified mode.  See the variable docs of
     *PRINT-...* for the mode.

 - Function: GET-OUTPUT-STREAM-STRING (STREAM)
     Package:LISP

     Returns a string of all the characters sent to STREAM made by
     MAKE-STRING-OUTPUT-STREAM since the last call to this function.

 - Function: READ-DELIMITED-LIST (CHAR &optional (STREAM
          *STANDARD-INPUT*) (RECURSIVE-P NIL))
     Package:LISP

     Reads objects from STREAM until the next character after an
     object's representation is CHAR.  Returns a list of the objects
     read.