Google
 
Trailing-Edge - PDP-10 Archives - clisp - clisp/upsala/kernel.clisp
There is 1 other file named kernel.clisp in the archive. Click here to see a list.
;;; This is a -*- Lisp -*- file.
;;; This file contains things needed for the kernel such as docstrings
;;;  and exportation of kernel functions.
;;; Written by Dave Steiner.

(in-package 'lisp)

(export '( ; from SEQ.CLISP
	  identity

	  ;from SYMBOL.CLISP
	  get remprop symbol-plist symbol-name make-symbol gensym gentemp
	  symbol-package keywordp makunbound fmakunbound symbol-value
	  symbol-function boundp fboundp set

	  ;from ARITH.CLISP
	  zerop plusp minusp oddp evenp = /= < > <= >= + - * / 1+ 1- abs
	  truncate float boole ash integer-length byte byte-size byte-position
	  dpb gcd

	  ;from EVAL.CLISP
	  eval *eval evalhook applyhook constantp quote eval-when progn
	  prog1 prog2 let let* do progv and or cond if the
	  macro-function special-form-p *macroexpand-hook* macroexpand-1
	  macroexpand block return-from return function setq psetq apply
	  funcall compiler-let flet labels macrolet tagbody go values
	  values-list multiple-value-list multiple-value-call
	  multiple-value-prog1 multiple-value-bind multiple-value-setq catch
	  unwind-protect throw defun
	  declare special macro
	  lambda &optional &rest &key &aux &body &whole &allow-other-keys
	  &environment

	  ;from HASH.CLISP
	  hash-table hash-table-p gethash remhash maphash clrhash
	  hash-table-count sxhash

	  ;from STREAM.CLISP
	  streamp make-synonym-stream make-two-way-stream make-echo-stream
	  make-string-input-stream make-string-output-stream
	  get-output-stream-string stream-element-type input-stream-p
	  output-stream-p read-line read-char
	  unread-char peek-char listen read-char-no-hang clear-input read-byte
	  write-char terpri fresh-line finish-output
	  force-output clear-output write-byte

	  ;from SPIRRAT.CLISP
	  exp log sqrt sin cos tan asin acos atan sinh cosh tanh

	  ;from READER.CLISP
	  readtable readtablep *read-base* read read-preserving-whitespace
	  read-delimited-list

	  ;from PACKAGE.CLISP
	  packagep package-name package-nicknames package-use-list
	  package-used-by-list package-shadowing-symbols intern find-symbol

	  ;from MISC.CLISP
	  room gc

	  ;from FILESYS.CLISP
	  pathnamep truename namestring user-homedir-pathname probe-file
	  rename-file delete-file file-write-date file-author directory

	  ;from ARRAY.CLISP
	  vector aref svref bit sbit

	  ;from LIST.CLISP
	  car cdr cons rplaca rplacd assq

	  ;from PRINT.CLISP
	  *print-gensym* prin1-to-string princ-to-string

	  ;from STRING.CLISP
	  char schar

	  ;from PRED.CLISP
	  null symbolp atom consp listp numberp integerp rationalp floatp
	  characterp stringp bit-vector-p vectorp simple-vector-p
	  simple-string-p simple-bit-vector-p arrayp functionp
	  compiled-function-p commonp eq eql equal not structurep fixnump
	  bignump bitp short-floatp single-floatp long-floatp double-floatp
	  ratiop

	  ;miscellaneous things
	  ^^ ^ $g ok $p bk $s go ? ;; n s m q p b e r g  ;[Victor] removed this
	  %put set-terminal-modes get-terminal-modes save ddt *print-gc-info*
	  *gc-trigger* exit compile compile-file uncompile compiledp
	  *standard-output* *trace-output* *terminal-io* *error-output*
	  *query-io* *read-suppress* *debug-io* *standard-input*
	  get-internal-run-time get-internal-real-time decode-universal-time
	  get-universal-time get-decoded-time
	  inline type ftype notinline optimize declaration ignore
	  file-length file-position scale-float decode-float
	  integer-decode-float float-sign float-radix
	  otherwise
))

;;; Make vars declared in kernel special if not done elsewhere.

(proclaim '(special *gc-trigger* *print-gc-info*
		    right-paren-whitespace t))

;;; These are doc strings for functions and variables in the kernel.

(%PUT (QUOTE LISP::*) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the product of its arguments.  With no args, returns 1."))

(%PUT (QUOTE LISP::+) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the sum of its arguments.  With no args, returns 0."))

(%PUT (QUOTE LISP::-) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Subtracts the second and all subsequent arguments from the first.
  With one arg, negates it."))

(%PUT (QUOTE LISP::/) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Divides the first arg by each of the following arguments, in turn.
  With one arg, returns reciprocal."))

(%PUT (QUOTE LISP::/=) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if no two of its arguments are numerically equal,
   NIL otherwise."))

(%PUT (QUOTE LISP::1+) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns NUMBER + 1."))

(%PUT (QUOTE LISP::1-) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns NUMBER - 1."))

(%PUT (QUOTE LISP::<) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if its arguments are in strictly increasing order,
   NIL otherwise."))

(%PUT (QUOTE LISP::<=) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if arguments are in strictly non-decreasing order,
   NIL otherwise."))

(%PUT (QUOTE LISP::=) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if all of its arguments are numerically equal,
   NIL otherwise."))

(%PUT (QUOTE LISP::>) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if its arguments are in strictly decreasing order,
   NIL otherwise."))

(%PUT (QUOTE LISP::>=) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if arguments are in strictly non-increasing order,
   NIL otherwise."))

(%PUT (QUOTE LISP::ABS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the absolute value of the number."))

(%PUT (QUOTE LISP::ACOS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the arc cosine of the argument."))

(%PUT (QUOTE LISP::AND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluate the sub-forms in order, left to right.  If any eval to
  nil, quit and return nil.  Else, return the value(s) of the last
  sub-form."))

(%PUT (QUOTE LISP::APPLY) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Applies FUNCTION to a list of arguments produced by evaluating ARGS in
  the manner of LIST*.  That is, a list is made of the values of all but the
  last argument, appended to the value of the last argument, which must be a
  list."))

(%PUT (QUOTE LISP::APPLYHOOK) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Applies Function to Args, with *Evalhook* bound to Evalhookfn and with
  *Applyhook* bound to Applyhookfn.  Ignores the hook function once, for the
  top-level application of Function to Args."))

(%PUT (QUOTE LISP::AREF) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the element of the Array specified by the Subscripts."))

(%PUT (QUOTE LISP::ARRAYP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the argument is any kind of array, else returns NIL."))

(%PUT (QUOTE LISP::ASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Shifts integer left by count places preserving sign.  - count
   shifts right."))

(%PUT (QUOTE LISP::ASIN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the arc sine of the argument."))

(%PUT (QUOTE LISP::ASSQ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return the first pair of a-list where item EQ the key of pair"))

(%PUT (QUOTE LISP::ATAN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the arc tangent of the argument."))

(%PUT (QUOTE LISP::ATOM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is not a cons, else returns NIL.
  Note that (ATOM NIL) => T."))

(%PUT (QUOTE LISP::BIGNUMP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a bignum, else returns NIL."))

(%PUT (QUOTE LISP::BIT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The element of Bit-String specified by the integer Index is
   returned."))

(%PUT (QUOTE LISP::BITP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a bit, else returns NIL."))

(%PUT (QUOTE LISP::BIT-VECTOR-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a bit vector, else returns NIL."))

(%PUT (QUOTE LISP::BLOCK) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Syntax is (BLOCK name . body).  The body is evaluated as a PROGN,
  but it is possible to exit the block using (RETURN-FROM name
  value).  The RETURN-FROM must be lexically contained within the
  block."))

(%PUT (QUOTE LISP::BOOLE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Bit-wise boolean function on two integers.  Function chosen by OP
   (see manual)"))

(%PUT (QUOTE LISP::BOUNDP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  Return () if this symbol is
  unbound, T if it has a value."))

(%PUT (QUOTE LISP::BYTE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a byte specifier which may be used by other byte functions."))

(%PUT (QUOTE LISP::BYTE-POSITION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the position part of the byte specifier bytespec."))

(%PUT (QUOTE LISP::BYTE-SIZE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the size part of the byte specifier bytespec."))

(%PUT (QUOTE LISP::CATCH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Used to set up dynamic gotos.  See manual for details."))

(%PUT (QUOTE LISP::CHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Given a string and a non-negative integer index less than the
  length of the string, returns the character object representing the
  character at that position in the string."))

(%PUT (QUOTE LISP::CHARACTERP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a character, else returns NIL."))

(%PUT (QUOTE LISP::CHARPOS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the number of characters on the current line of output of
  the given Stream, or Nil if that information is not availible."))

(%PUT (QUOTE LISP::CLEAR-INPUT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Clears any buffered input associated with the Stream."))

(%PUT (QUOTE LISP::CLEAR-OUTPUT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Clears the given output Stream."))

(%PUT (QUOTE LISP::CLRHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Removes all entries of HASH-TABLE and returns the hash table
   itself."))

(%PUT (QUOTE LISP::COMMONP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if object is a legal Common-Lisp type, NIL if object is any
  sort of implementation-dependent or internal type."))

(%PUT (QUOTE LISP::COMPILED-FUNCTION-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a compiled function object, else
   returns NIL."))

(%PUT (QUOTE LISP::COMPILER-LET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "In the interpreter, works just like a LET with all variables
  implicitly declared special.  In the compiler, processes the forms
  in the body with the variables rebound in the compiler environment.
  No declarations are allowed."))

(%PUT (QUOTE LISP::COND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Syntax is (COND (pred1 forms) (pred2 forms) ...)
  Evaluate each predicate in order until one evaluates to non-nil.
  Then evaluate the associated forms in order returning the value
  of the last one.  If no predicate wins, return nil."))

(%PUT (QUOTE LISP::CONSP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a cons cell, else returns NIL.
  Note that (CONSP NIL) => NIL."))

(%PUT (QUOTE LISP::CONSTANTP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "True of any Lisp object that has a constant value: types that eval to
  themselves, keywords, constants, and list whose car is QUOTE."))

(%PUT (QUOTE LISP::COS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the cosine of the argument."))

(%PUT (QUOTE LISP::COSH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the hyperbolic cosine of the argument."))

(%PUT (QUOTE LISP::DDT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Go into DDT.  To exit, type IRET$X."))

(%PUT (QUOTE LISP::DECLARE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "A DECLARE special form is known as a declaration.  Declarations may
   occur only at the beginning of the bodies of lambda-expressions and certain
   special forms.  All statements preceding it (if any) must also be DECLARE
   forms (or possibly documentation strings, in some cases).  See manual
   for more details."))

(%PUT (QUOTE LISP::DECODE-FLOAT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Takes a floating-point number and returns three values.  The first
   value is a new floating-point number of the same format representing
   the significand; the second value is an integer representing the exponent;
   and the third value is a floating-point number of the same format
   indicating the sign."))

(%PUT (QUOTE LISP::DECODE-UNIVERSAL-TIME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The time specified by UNIVERSAL-TIME in Universal Time format is
   converted to Decoded Time format."))

(%PUT (QUOTE LISP::DEFUN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Used to create a new function as the global functional definition of
  some symbol.  Format is (DEFUN name varlist . body)."))

(%PUT (QUOTE LISP::DELETE-FILE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Delete the specified file."))

(%PUT (QUOTE LISP::DIRECTORY) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Prints out a list of files that matches NAME.  NAME may be a string,
   a pathname of a file stream."))

(%PUT (QUOTE LISP::DO) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Iteration construct. Does inits and steps in parallel."))

(%PUT (QUOTE LISP::DOUBLE-FLOATP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a double floating-point number, else
   returns NIL."))

(%PUT (QUOTE LISP::DPB) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns new integer with newbyte in specified position, newbyte
   is right justified."))

(%PUT (QUOTE LISP::EQ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if X and Y are the same object, else returns NIL."))

(%PUT (QUOTE LISP::EQL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if X and Y are EQ, or if they are numbers of the same
  type and precisely equal value, or if they are characters and
  are CHAR=, else returns NIL."))

(%PUT (QUOTE LISP::EQUAL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if X and Y are EQL or if they are structured components
  whose elements are EQUAL.  Strings and bit-vectors are EQUAL if they
  are the same length and have indentical components.  Other arrays must be
  EQ to be EQUAL."))

(%PUT (QUOTE LISP::EVAL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates its single arg in a null lexical environment, returns the
  result or results."))

(%PUT (QUOTE LISP::%EVAL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Internal evaluation routine.  Gets its lexical environment from the
  special variables %VENV%, etc.  Evaluates its single arg and returns
  the result or results."))

(%PUT (QUOTE LISP::*EVAL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates EXP and returns the result or results.  The additional
  arguments supply the lexical environment for the evaluation."))

(%PUT (QUOTE LISP::EVALHOOK) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates Form with *Evalhook* bound to Evalhookfn and *Applyhook*
  bound to applyhookfn.  Ignores these hooks once, for the top-level evaluation
  of Form."))

(%PUT (QUOTE LISP::EVAL-WHEN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Syntax is (EVAL-WHEN control-list forms).  If the control list
  contains the symbol EVAL, the forms are evaluated by the interpreter.  If the
  control list contains COMPILE, the forms are evaluated within the compiler.
  If the control list contains LOAD, the compiler arranges for the forms to
  be evaluated when the compiled file is loaded."))

(%PUT (QUOTE LISP::EVENP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if number is even, NIL otherwise."))

(%PUT (QUOTE LISP::EXIT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Exits CLisp and returns to Exec."))

(%PUT (QUOTE LISP::EXP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Calculates e to the given power, where e is the base of natural
   logarithms."))

(%PUT (QUOTE LISP::FBOUNDP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  Return () if this symbol is
  undefined, T if it has a definition."))

(%PUT (QUOTE LISP::FILE-AUTHOR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the author of the file."))

(%PUT (QUOTE LISP::FILE-POSITION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "With one argument returns the current position within the file
  File-Stream is open to.  If the second argument is supplied, then
  this becomes the new file position.  The second argument may also
  be :start or :end for the start and end of the file, respectively."))

(%PUT (QUOTE LISP::FILE-LENGTH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "This function returns the length of the file that File-Stream is
    open to."))

(%PUT (QUOTE LISP::FILE-WRITE-DATE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return file's creation date, or NIL if it doesn't exist."))

(%PUT (QUOTE LISP::FIND-SYMBOL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Search for a symbol named string in package, does the same
  as intern but will never create a symbol."))

(%PUT (QUOTE LISP::FINISH-OUTPUT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Attempts to ensure that all output sent to the the Stream has
   reached its destination, and only then returns."))

(%PUT (QUOTE LISP::FIXNUMP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a fixnum, else returns NIL."))

(%PUT (QUOTE LISP::FLET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First arg is list of function definitions in form (name
  lambda-list . body).  This list is followed any number of
  additional forms to be evaluated as a Progn with the local function
  definitions in effect.  The scope of the locally defined functions
  does not include the function definitions themselves, so they can
  reference externally defined functions of the same name."))

(%PUT (QUOTE LISP::FLOAT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Converts a number of any type to floating point.
  If OTHER is not provided, it returns a SINGLE-FLOAT if NUMBER
  is not already a FLOAT. If OTHER is provided, the result is
  the same float format as OTHER."))

(%PUT (QUOTE LISP::FLOAT-RADIX) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns (as an integer) the radix B of the floating-point argument."))

(%PUT (QUOTE LISP::FLOAT-SIGN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a floating-point number Z such that Z and argument1 have the
   same sign and also such that Z and argument2 (if included) have the
   same absolute value."))

(%PUT (QUOTE LISP::FLOATP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a floating-point number, else
   returns NIL."))

(%PUT (QUOTE LISP::FMAKUNBOUND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol is made undefined,
  removing any definition it may currently have."))

(%PUT (QUOTE LISP::FORCE-OUTPUT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Attempts to force any buffered output to be sent."))

(%PUT (QUOTE LISP::FRESH-LINE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Outputs a new line to the Stream if it is not positioned at the
   begining of a line.  Returns T if it output a new line, nil otherwise."))

(%PUT (QUOTE LISP::FSET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol's definition cell is
  set to the specified new definition."))

(%PUT (QUOTE LISP::FUNCALL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Calls Function with the given Arguments."))

(%PUT (QUOTE LISP::FUNCTION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "If argument is a lambda expression, create a closure of it in the
  current lexical environment.  If it is a symbol that names a function,
  return that function."))

(%PUT (QUOTE LISP::FUNCTIONP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a function, suitable for use by FUNCALL
  or APPLY, else returns NIL."))

(%PUT (QUOTE LISP::GC) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Initiates a garbage collection.  If Blah-P is T, the amount of storage
  reclaimed is printed, otherwise it is returned."))

(%PUT (QUOTE LISP::*GC-TRIGGER*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "This variable controls how often garbage collection will be done.  See
   Tops-20 Common Lisp Red Pages for more info."))

(%PUT (QUOTE LISP::GCD) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the greatest common divisor of the arguments, which must be
    integers.  Gcd with no arguments is defined to be 0."))

(%PUT (QUOTE LISP::GENSYM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Creates a new uninterned symbol whose name is a prefix string
  (defaults to \"G\", followed by a decimal number).  The number is
  incremented by each call to GENSYM.  X, if supplied and an integer,
  resets the counter.  If X is a string, it becomes the new prefix."))

(%PUT (QUOTE LISP::GENTEMP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Creates a new symbol interned in package Package with the
   given Prefix."))

(%PUT (QUOTE LISP::GET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Look on the property list of SYMBOL for the specified INDICATOR.
  If this is found, return the associated value, else return DEFAULT."))

(%PUT (QUOTE LISP::GET-DECODED-TIME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The current time is returned in Decoded Time format."))

(%PUT (QUOTE LISP::GET-INTERNAL-REAL-TIME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return the real time in the internal time format.  This is useful
  for finding elapsed time.  See Internal-Time-Units-Per-Second."))

(%PUT (QUOTE LISP::GET-INTERNAL-RUN-TIME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return the run time in the internal time format.  This is useful
  for finding CPU usage.  Since this calls the process-manager,
  taking about 2.3 units, you are better off using
  Get-Internal-Real-Time for small intervals."))

(%PUT (QUOTE LISP::GET-OUTPUT-STREAM-STRING) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string of all the characters sent to a stream made by
   Make-String-Output-Stream since the last call to this function."))

(%PUT (QUOTE LISP::GET-TERMINAL-MODES) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a list of terminal parameters."))

(%PUT (QUOTE LISP::GET-UNIVERSAL-TIME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The current time of day is returned as a single integer in 
   Universal Time format."))

(%PUT (QUOTE LISP::GETHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Finds the entry in Hash-Table whose key is Key and returns the
   associated value and T as multiple values, or returns Default and Nil if 
   there is no such entry."))

(%PUT (QUOTE LISP::GO) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Go to the specified tag in the lexically surrounding tagbody."))

(%PUT (QUOTE LISP::HASH-TABLE-COUNT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the number of entries in the given Hash-Table."))

(%PUT (QUOTE LISP::HASH-TABLE-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a hash-table, else returns NIL."))

(%PUT (QUOTE LISP::IDENTITY) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns what was passed to it.  Default for :key options."))

(%PUT (QUOTE LISP::IF) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Syntax is (IF predicate then [else]).  If the predicate
  evaluates to non-null, eval the Then clause and return the result.
  If not, eval and return the Else clause, which defaults to Nil."))

(%PUT (QUOTE LISP::INPUT-STREAM-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns non-nil if the given Stream can perform input operations."))

(%PUT (QUOTE LISP::INTEGER-DECODE-FLOAT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Similar to DECODE-FLOAT but for its first value returns, as an
   integer, the significand scaled so as to be an integer."))

(%PUT (QUOTE LISP::INTEGER-LENGTH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the number of significant bits in the absolute value
   of integer."))

(%PUT (QUOTE LISP::INTEGERP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is an integer (fixnum or bignum), else 
  returns NIL."))

(%PUT (QUOTE LISP::INTERN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Intern looks for a symbol with the given name, and creates a new
  one if it doesn't exist."))

(%PUT (QUOTE LISP::KEYWORDP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the Symbol belongs to the Keyword package, Nil
   otherwise."))

(%PUT (QUOTE LISP::LABELS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First arg is list of function definitions in form (name
  lambda-list . body).  This list is followed any number of
  additional forms to be evaluated as a Progn with the local function
  definitions in effect.  The scope of the locally defined functions
  includes the function definitions themselves, so they can reference
  one another."))

(%PUT (QUOTE LISP::LDB) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Extract the specified byte from integer, and right justify result."))

(%PUT (QUOTE LISP::LET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First sub-form is a list of (variable initialization) pairs.
  Initializes the variables, binding them to new values all at once,
  then executes the remaining forms as in a PROGN."))

(%PUT (QUOTE LISP::LET*) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First sub-form is a list of (variable initialization) pairs.
  Initializes the variables left to right, then executes the
  remaining forms as in a PROGN."))

;;Actually only defined in compiler package.  Not needed in lisp package.
;(%PUT (QUOTE LISP::%LEXICAL-ENVIRONMENT%) (QUOTE LISP::%VAR-DOCUMENTATION)
; (QUOTE "Holds the lexical environment sturcture during execution of a
;  compiled lexical closure."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::LISP-IMPLEMENTATION-TYPE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the generic name of the Common
   Lisp implementation."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::LISP-IMPLEMENTATION-VERSION)
 (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the version of the particular
   Common Lisp implementation."))

(%PUT (QUOTE LISP::LISTEN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if a character is availible on the given Stream."))

(%PUT (QUOTE LISP::LISTP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a cons cell or NIL, else returns NIL."))

(%PUT (QUOTE LISP::LOG) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the logarithm of NUMBER in the base BASE, which defaults
   to e, the base of the natural logarithms."))

(%PUT (QUOTE LISP::LONG-FLOATP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a long floating-point number, else
   returns NIL."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::LONG-SITE-NAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the site (in long form)."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::MACHINE-INSTANCE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the particular instance of the 
   computer hardare."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::MACHINE-TYPE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the generic name of the computer
   hardware."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::MACHINE-VERSION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the version of the computer
   hardware."))

(%PUT (QUOTE LISP::MACRO) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Internal form used to define new macros.  Syntax like DEFUN, but
  takes only one arg which is bound to the entire calling form.  For
  better style use DEFMACRO instead of MACRO."))

(%PUT (QUOTE LISP::MACRO-FUNCTION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "If the symbol globally names a macro, returns the expansion function,
  else returns NIL."))

(%PUT (QUOTE LISP::MACROEXPAND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "If form is a macro, expands it repeatedly until it is not a macro
  any more.  Returns two values: the expanded form and a T-or-NIL
  flag that indicates whether the original form was a macro."))

(%PUT (QUOTE LISP::%MACROEXPAND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Does a macroexpand in the current lexical environment."))

(%PUT (QUOTE LISP::MACROEXPAND-1) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "If form is a macro, expands it once.  Returns two values, the
  expanded form and a T-or-NIL flag indicating whether the form was,
  in fact, a macro."))

(%PUT (QUOTE LISP::%MACROEXPAND-1) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Does Macroexpand-1 in the current lexical environment."))

(%PUT (QUOTE LISP::*MACROEXPAND-HOOK*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "The value of this variable must be a function that can take two
  arguments, a macro expander function and the macro form to be expanded,
  returning the expanded form.  This function is called by MACROEXPAND-1
  whenever a runtime expansion is needed.  Initially this is set to
  FUNCALL.  To turn memoization on, set it to MEMOIZE-MACRO-CALL."))

(%PUT (QUOTE LISP::MACROLET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First arg is list of macro definitions in form (name varlist .
  body), analogous to the varlist and body of a defmacro.  This list
  of definitions is followed by the Macrolet form's body.  This is
  evaluated as a progn, but with the local macro definitions in
  effect."))

(%PUT (QUOTE LISP::MAKE-ECHO-STREAM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a bidirectional stream that gets its input from INPUT-STREAM
   and sends its output to OUTPUT-STREAM.  In addition, all input taken from
   INPUT-STREAM is echoed to OUTPUT-STREAM."))

(%PUT (QUOTE LISP::MAKE-STRING-INPUT-STREAM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns an input stream which will supply the characters of String
  between Start and End in order."))

(%PUT (QUOTE LISP::MAKE-STRING-OUTPUT-STREAM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns an output stream that will accumulate all output given it for
   the benefit of the function GET-OUTPUT-STREAM-STRING."))

(%PUT (QUOTE LISP::MAKE-SYMBOL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Make and return a new symbol with the STRING as its print name."))

(%PUT (QUOTE LISP::MAKE-SYNONYM-STREAM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Creates and returns a 'synonym-stream'.  Any operations on the new
   stream will be preformed on the stream that is then the value of the 
   dynamic variable name by the SYMBOL.  If the value of the variable should
   change or be bound, then the synonym stream will operate on the new
   stream."))

(%PUT (QUOTE LISP::MAKE-TWO-WAY-STREAM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "This returns a bidirectional stream that gets its input from 
   INPUT-STREAM and sends its output to OUTPUT-STREAM."))

(%PUT (QUOTE LISP::MAKUNBOUND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol is made unbound,
  removing any value it may currently have."))

(%PUT (QUOTE LISP::MAPHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "For each entry in HASH-TABLE, calls FUNCTION on the key and value
   of the entry; returns T."))

(%PUT (QUOTE LISP::MASK-FIELD) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Extract the specified byte from integer,  but do not right justify
   result."))

(%PUT (QUOTE LISP::MASK-FIELD) (QUOTE LISP::%SETF-DOCUMENTATION)
 (QUOTE "The first argument is a byte specifier.  The second is any place form
  acceptable to SETF.  Replaces the specified byte of the number in this place
  with bits from the corresponding position in the new value."))

(%PUT (QUOTE LISP::MINUSP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if number < 0, NIL otherwise."))

(%PUT (QUOTE LISP::MOD) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns second result of FLOOR."))

(%PUT (QUOTE LISP::MULTIPLE-VALUE-BIND) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Form is (MULTIPLE-VALUE-BIND var-list values-form . body).
  Binds the variables in Var-List to the results of the Values-Form,
  in order (defaulting to nil) and evaluates each form in the Body."))

(%PUT (QUOTE LISP::MULTIPLE-VALUE-CALL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Calls Function with the values of all of the Forms as arguments."))

(%PUT (QUOTE LISP::MULTIPLE-VALUE-LIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates Form, and returns a list of multiple values it returned."))

(%PUT (QUOTE LISP::MULTIPLE-VALUE-PROG1) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates the first Form, saves the values returned, then evaluates
   the rest of the forms, discarding their values.  Returns the results of the
   first form."))

(%PUT (QUOTE LISP::MULTIPLE-VALUE-SETQ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Sets each variable in the list of Variables to the corresponding
  value of the Form."))

(%PUT (QUOTE LISP::NAMESTRING) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the full form of PATHNAME as a string."))

(%PUT (QUOTE LISP::NIL) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "The value of NIL is always NIL.  This object represents the logical
   false value and also the empty list.  It can also be written ()."))

(%PUT (QUOTE LISP::NOT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is NIL, else returns NIL."))

(%PUT (QUOTE LISP::NULL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is NIL, else returns NIL."))

(%PUT (QUOTE LISP::NUMBERP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is any kind of number."))

(%PUT (QUOTE LISP::ODDP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if number is odd, NIL otherwise."))

(%PUT (QUOTE LISP::OR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluate the sub-forms in order, left to right.  If any eval to
  non-nil, quit and return that (single) value.  If the last form
  is reached, return whatever value(s) it returns."))

(%PUT (QUOTE LISP::OUTPUT-OBJECT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Outputs a string which is the printed representation of the given
   object."))

(%PUT (QUOTE LISP::OUTPUT-STREAM-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns non-nil if the given Stream can perform output operations."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGE-NAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the string that names the given package.  The argument must
   be a package."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGE-NICKNAMES) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the list of nickname strings for the given package, not
   including the primary name.  The argument must be a package."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGE-SHADOWING-SYMBOLS) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a list of symbols that have been declared as shadowing symbols
   in the package by SHADOW or SHADOWING-IMPORT."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGE-USE-LIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a list of other packages used by the argument package."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGE-USED-BY-LIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a list of other packages that use the argument package."))

;;Function defined by a structure in PACKAGE.CLISP
(%PUT (QUOTE LISP::PACKAGEP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the argument is a package, otherwise returns NIL."))

;;Function defined by a structure in READER.CLISP
(%PUT (QUOTE LISP::PATHNAMEP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the argument is a pathname, else returns NIL."))

(%PUT (QUOTE LISP::PEEK-CHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Peeks at the next character in the input Stream.  See manual
   for details."))

(%PUT (QUOTE LISP::PLUSP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if number > 0, NIL otherwise."))

(%PUT (QUOTE LISP::PRIMEP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if X is prime, otherwise Nil."))

(%PUT (QUOTE LISP::PRIN1-TO-STRING) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the printed representation of OBJECT as a string with 
   slashification on."))

(%PUT (QUOTE LISP::PRINC-TO-STRING) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the printed representation of OBJECT as a string with
  slashification off."))

(%PUT (QUOTE LISP::*PRINT-ESCAPE*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "Flag which indicates that slashification is on.  See the manual"))

(%PUT (QUOTE LISP::*PRINT-GC-INFO*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "If non-NIL, the garbage collector will print a message showing the
   total amount of free space before and after the garbage collection."))

(%PUT (QUOTE LISP::*PRINT-GENSYM*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "If true, symbols with no home package are printed with a #:
  prefix.  If false, no prefix is printed."))

(%PUT (QUOTE LISP::*PRINT-PRETTY*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "Flag which indicates that pretty printing is to be used"))

(%PUT (QUOTE LISP::PROG) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Prog binds local variables in parallel, creates a block with name NIL,
  and then evaluates the body as in a tagbody.  Therefore, GO and RETURN
  work within a PROG."))

(%PUT (QUOTE LISP::PROG*) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Prog* is like Prog, but binds its variables sequentially."))

(%PUT (QUOTE LISP::PROGN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates the forms in order, returning the value(s) of the last
   one."))

(%PUT (QUOTE LISP::PROGV) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "First arg evaluates to a list of variables.  Second arg evaluates to a
  list of initial values.  Everything after that is body.  Evaluate the
  body with the variables bound (as specials) to the corresponding values."))

(%PUT (QUOTE LISP::PROG1) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evlautes the forms in order, returning the value(s) of the first
   one."))

(%PUT (QUOTE LISP::PROG2) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Evaluates the forms in order, returning the value(s) of the second
   one."))

(%PUT (QUOTE LISP::PROBE-FILE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return a pathname which is the truename of the file if it exists,
  NIL otherwise.  Returns NIL for directories and other non-file
  entries."))

(%PUT (QUOTE LISP::PSETQ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Parallel SETQ.  Takes any number of symbols and values like a
  SETQ, but evaluates all the values first, then sets all of the
  symbols to new values at once.  Returns NIL."))

(%PUT (QUOTE LISP::%PUT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The VALUE is added as a property of SYMBOL under the specified
  INDICATOR.  Returns VALUE."))

(%PUT (QUOTE LISP::%PUTHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Create an entry in HASH-TABLE associating KEY with VALUE; if there
   already is an entry for KEY, replace it.  Returns VALUE."))

(%PUT (QUOTE LISP::QUOTE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns its single argument without evaluating it."))

;;Function defined by a structure in RAND.CLISP
(%PUT (QUOTE LISP::RANDOM-STATE-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the argument is a random-state object, else
   returns NIL."))

(%PUT (QUOTE LISP::RATIOP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a ratio, else returns NIL."))

(%PUT (QUOTE LISP::RATIONAL) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Converts any non-complex number to be a rational number.  Assumes
   that a floating-point number is completely accurate and returns a rational
   number mathematically equal to the precise value of the floating-point 
   number."))

(%PUT (QUOTE LISP::RATIONALP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is an integer or a ratio, else returns NIL."))

(%PUT (QUOTE LISP::READ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Reads in the next object in the stream, which defaults to
  *standard-input*. For details see the I/O chapter of
  the manual."))

(%PUT (QUOTE LISP::*READ-BASE*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "The radix that Lisp reads numbers in."))

(%PUT (QUOTE LISP::READ-BYTE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the next byte of the Stream."))

(%PUT (QUOTE LISP::READ-CHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Inputs a character from Stream and returns it."))

(%PUT (QUOTE LISP::READ-CHAR-NO-HANG) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the next character from the Stream if one is availible,
   or nil."))

(%PUT (QUOTE LISP::READ-DELIMITED-LIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Reads objects from STREAM until the next character after an object's
   representation (ignoring whitespace characters and comments) is CHAR. (The
   CHAR should not have whitespace syntax in the current readtable.)  A list
   of the objects read is returned."))

(%PUT (QUOTE LISP::READ-LINE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a line of text read from the Stream as a string, discarding
   the newline character."))

(%PUT (QUOTE LISP::READ-PRESERVING-WHITESPACE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Reads from stream and returns the object read, preserving the
  whitespace that followed the object."))

(%PUT (QUOTE LISP::*READ-SUPPRESS*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "When the value of *READ-SUPPRESS* is NIL, the Lisp reader operates
   normally.  When it is not NIL, then most of the interesting operations of
   the reader are suppressed; input characters are parsed, but much of what
   is read is not interpreted.  See manual for details."))

;;Function defined by a structure in READER.CLISP
(%PUT (QUOTE LISP::READTABLEP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the argument is a readtable object, else returns NIL."))

(%PUT (QUOTE LISP::*REAL-EOF-ERRORP*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "Value checked by reader if recursivep is true."))

(%PUT (QUOTE LISP::REMHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Remove any entry for KEY in HASH-TABLE.  Returns T if such an entry
   existed; () otherwise."))

(%PUT (QUOTE LISP::REMPROP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Look on property list of SYMBOL for property with specified
  INDICATOR.  If found, splice this indicator and its value out of
  the plist, and return the tail of the original list starting with
  INDICATOR.  If not found, return () with no side effects."))

(%PUT (QUOTE LISP::RENAME-FILE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Rename File to have the specified New-Name.  If file is a stream
  open to a file, then the associated file is renamed.  If the file
  does not yet exist then the file is created with the New-Name when
  the stream is closed."))

(%PUT (QUOTE LISP::RETURN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Equivalent to RETURN-FROM with a block-name of NIL."))

(%PUT (QUOTE LISP::RETURN-FROM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The first argument names a lexically surrounding block, perhaps
  implicitly created by a defun.  The second argument is a form to
  be evaluated and returned as the value of this block."))

(%PUT (QUOTE LISP::RIGHT-PAREN-WHITESPACE) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "Flag that READ uses to tell when it's ok to treat right parens as
  whitespace."))

(%PUT (QUOTE LISP::ROOM) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Displays information about storage allocation.
  If X is true then information is displayed broken down by types.
  If Object is supplied then just display information for objects of
  that type."))

(%PUT (QUOTE LISP::SAVE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Save an image of core in the specified file."))

(%PUT (QUOTE LISP::SBIT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the bit from the Simple-Bit-Array at the specified
  Subscripts."))

(%PUT (QUOTE LISP::SCALE-FLOAT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Takes a floating-point number F and an integer K, and returns
   (* f (expt (float b f) k)), where B is the radix."))

(%PUT (QUOTE LISP::SCHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The given INDEX must be a non-negative integer less than the length
   string, which must be a simple-string.  The character at position INDEX
   of the string is returns as a character object."))

(%PUT (QUOTE LISP::SEQUENCEP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if object is a sequence, NIL otherwise."))

(%PUT (QUOTE LISP::SET) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol's special value
  cell is set to the specified new value."))

(%PUT (QUOTE LISP::SET-MACRO-CHARACTER) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Causes CHAR to be a macro character that when seen by READ causes
   FUNCTION to be called.  If NON-TERMINATING-P is not NIL, then it will
   be a non-terminating macro character: it may be embedded within extended
   tokens.  Returns T."))

(%PUT (QUOTE LISP::SET-TERMINAL-MODES) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "This function allows you to control the way Lisp will handle the
  terminal.  See Tops-20 Common Lisp Red Pages for more info."))

(%PUT (QUOTE LISP::SETQ) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The first arg is not evaluated and must be a symbol.  The second
  arg is an expression which is evaluated to get a new value for that
  symbol.  Additional alternating symbols and values may be present.
  These are evaluated left-to-right.  The final value is returned
  from the SETQ."))

(%PUT (QUOTE LISP::SHORT-FLOATP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a short floating-point number, else
   returns NIL."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::SHORT-SITE-NAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the site (in short form)."))

(%PUT (QUOTE LISP::SIMPLE-BIT-VECTOR-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a simple bit vector, else returns NIL."))

(%PUT (QUOTE LISP::SIMPLE-STRING-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a simple string, else returns NIL."))

(%PUT (QUOTE LISP::SIMPLE-VECTOR-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a simple vector, else returns NIL."))

(%PUT (QUOTE LISP::SIN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the sine of the argument."))

(%PUT (QUOTE LISP::SINGLE-FLOATP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a single floating-point number, else
   returns NIL."))

(%PUT (QUOTE LISP::SINH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the hyperbolic sine of the argument."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::SOFTWARE-TYPE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the generic name of the supporting
   software."))

;;Function defined in MISC.CLISP
(%PUT (QUOTE LISP::SOFTWARE-VERSION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a string that identifies the version of the supporting
   software."))

(%PUT (QUOTE LISP::SPECIAL-FORM-P) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "If the symbol globally names a special form, returns the definition
   in a mysterious internal format (a FEXPR), else returns NIL."))

(%PUT (QUOTE LISP::SQRT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the principal square root of NUMBER."))

(%PUT (QUOTE LISP::STREAM-ELEMENT-TYPE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns a type specifier for the kind of object returned by
   the Stream."))

(%PUT (QUOTE LISP::STREAMP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a stream, else returns NIL."))

(%PUT (QUOTE LISP::STRINGP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a string, else returns NIL."))

(%PUT (QUOTE LISP::STRUCTUREP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a structure, else returns NIL."))

(%PUT (QUOTE LISP::SVREF) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the Subscriptth element of the simple vector Object."))

(%PUT (QUOTE LISP::SXHASH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Computes a hash code for S-EXPR and returns it as an integer."))

(%PUT (QUOTE LISP::SYMBOL-FUNCTION) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol's current definition
  is returned."))

(%PUT (QUOTE LISP::SYMBOL-NAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  Return its print name."))

(%PUT (QUOTE LISP::SYMBOL-PACKAGE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  Return its package."))

(%PUT (QUOTE LISP::SYMBOL-PLIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  Return its property list."))

(%PUT (QUOTE LISP::SYMBOL-VALUE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "VARIABLE must evaluate to a symbol.  This symbol's current special
  value is returned."))

(%PUT (QUOTE LISP::SYMBOLP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is a symbol, else returns NIL."))

(%PUT (QUOTE LISP::T) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "The value of T is always T."))

(%PUT (QUOTE LISP::TAGBODY) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "The body is executed and returns NIL if it falls off the end."))

(%PUT (QUOTE LISP::TAN) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the tangent of the argument."))

(%PUT (QUOTE LISP::TANH) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the hyperbolic tangent of the argument."))

(%PUT (QUOTE LISP::*TERMINAL-IO*) (QUOTE LISP::%VAR-DOCUMENTATION)
 (QUOTE "Terminal I/O stream."))

(%PUT (QUOTE LISP::TERPRI) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Outputs a new line to the Stream."))

(%PUT (QUOTE LISP::THE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Declares that Object must be of specified Type, complains if this
  is not the case."))

(%PUT (QUOTE LISP::THROW) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Initiates a non-local goto.  See manual for details."))

(%PUT (QUOTE LISP::TRUENAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Return the pathname for the actual file described by the pathname
  An error is signalled if no such file exists."))

(%PUT (QUOTE LISP::TRUNCATE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns number (or number/divisor) as an integer, rounded toward 0.
  The second returned value is the remainder."))

(%PUT (QUOTE LISP::UNREAD-CHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Puts the Character back on the front of the input Stream."))

(%PUT (QUOTE LISP::UNWIND-PROTECT) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "UNWIND-PROTECT guarantees to execute the cleanup-forms before
   exiting, whether it terminates normally or is aborted by a throw of some
   kind.  See manual for details."))

(%PUT (QUOTE LISP::USER-HOMEDIR-PATHNAME) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns the home directory of the logged in user as a pathname."))

(%PUT (QUOTE LISP::VALUES) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns all of its arguments, in order, as values."))

(%PUT (QUOTE LISP::VALUES-LIST) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns all of the elements of List, in order, as values."))

(%PUT (QUOTE LISP::VECTOR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Constructs a Simple-Vector from the given objects."))

(%PUT (QUOTE LISP::VECTORP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if the object is any kind of vector, else returns NIL."))

(%PUT (QUOTE LISP::WRITE-BYTE) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Outputs the Integer to the binary Stream."))

(%PUT (QUOTE LISP::WRITE-CHAR) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Outputs the Character to the Stream."))

(%PUT (QUOTE LISP::ZEROP) (QUOTE LISP::%FUN-DOCUMENTATION)
 (QUOTE "Returns T if number = 0, NIL otherwise."))