;; system variables
(*OBARRAY* VARIABLE) "The object hash table"
(*STANDARD-INPUT* VARIABLE) "Default input stream."
(*STANDARD-OUTPUT* VARIABLE) "Default output stream."
(*ERROR-OUTPUT* VARIABLE) "Default error output stream."
(*DEBUG-IO* VARIABLE) "Default break input/output stream."
(*TRACE-OUTPUT* VARIABLE) "Default trace output stream."
(*EVALHOOK* VARIABLE)
"If *EVALHOOK* is not NIL, its value must be a function of arguments: 
a form to evaluate and an environment.  This function does the evaluation
instead of EVAL."
(*APPLYHOOK* VARIABLE) "(Not yet implemented)"
(*TRACELIST* VARIABLE) "List of names of functions and macros to be traced"
(*TRACENABLE* VARIABLE) "Enable backtrace on errors"
(*TRACELIMIT* VARIABLE) "Number of levels of trace back information"
(*BREAKENABLE* VARIABLE) "Flag that controls entering the break loop on errors"
(*READTABLE* VARIABLE) "The current readtable."
(*GC-FLAG* VARIABLE) "Controls printing of GC messages"
(*GC-HOOK* VARIABLE) "If not nil, function of two arguments to be called after GC"
(*PRINT-CASE* VARIABLE) "symbol output case (:upcase or :downcase)"
(*RANDOM-STATE* VARIABLE) "Current state of the random number generator"
(*INPUT-STREAM* VARIABLE) "Stream used for buffering between listener and reader."
(PI VARIABLE)
"The floating-point number that is approximately equal to the ratio of the
circumference of a circle to its diameter."
(-   VARIABLE) "The current input expression"
(+   VARIABLE) "The last expression read"
(++  VARIABLE) "The previous value of +"
(+++ VARIABLE) "The previous value of ++"
(*   VARIABLE) "The result of the last evaluation"
(**  VARIABLE) "The previous value of *"
(*** VARIABLE) "The previous value of **"

;; Built in types
(SUBR TYPE) "Built in function"
(FSUBR TYPE) "Built in special form or macro"
(CONS TYPE) "A list cell"
(SYMBOL TYPE) "A symbol"
(FIXNUM TYPE) "An integer"
(FLONUM TYPE) "A floating point number"
(STRING TYPE) "A string"
(OBJECT TYPE) "An xlisp object"
(FILE-STREAM TYPE) "A file stream"
(VECTOR TYPE) "A vector"
(CLOSURE TYPE) "A function closure or macro"
(CHARACTER TYPE) "A character"
(UNNAMED-STREAM TYPE) "An unnamed stream (string input stream, e. g.)"
(COMPLEX TYPE) "A complex number"
(ARRAY TYPE) "A displaced multidimensional array"

;; built in object prototypes
(*OBJECT* VARIABLE) "The top of the object hierarchy."
(HARDWARE-OBJECT-PROTO VARIABLE) "Internally allocatable object prototype"
(WINDOW-PROTO VARIABLE) "Window prototype"
(EDIT-WINDOW-PROTO VARIABLE) "Edit window prototype"
(LISTENER-PROTO VARIABLE) "Listener window prototype"
(MENU-PROTO VARIABLE) "Menu prototype"
(APPLE-MENU-PROTO VARIABLE) "Apple menu prototype"
(MENU-ITEM-PROTO VARIABLE) "Menu item prototype"
(DIALOG-PROTO VARIABLE) "Dialog prototype"
(DIALOG-ITEM-PROTO VARIABLE) "Dialog item prototype"
(BUTTON-ITEM-PROTO VARIABLE) "Dialog button prototype"
(TOGGLE-ITEM-PROTO VARIABLE) "Dialog toggle item (check box) prototype"
(TEXT-ITEM-PROTO VARIABLE) "Dialog text item prototype (editable or static)"
(CHOICE-ITEM-PROTO VARIABLE) "Dialog choice item (radio button cluster) prototype"
(SCROLL-ITEM-PROTO VARIABLE) "Dialog scroll bar prototype"
(LIST-ITEM-PROTO VARIABLE) "Dialog list item prototype"
(GRAPH-WINDOW-PROTO VARIABLE) "Graphics window prototype"
(GRAPH-PROTO VARIABLE) "Dynamic plot prototype"
(SPIN-PROTO VARIABLE) "Rotating plot prototype"
(SCATMAT-PROTO VARIABLE) "Scatterplot matrix prototype"
(NAME-LIST-PROTO VARIABLE) "Name list prototype"
(HISTOGRAM-PROTO VARIABLE) "Histogram prototype"
(SCATTERPLOT-PROTO VARIABLE) "Scatterplot prototype"
(COMPOUND-DATA-PROTO VARIABLE) "Compound data object prototype"

;; evaluator functions 
EVAL
"Args: (expr)
Evaluates EXPR in a NULL environment and returns the result."
APPLY
"Args: (function &rest args)
Conses all arguments but the last onto the last and applies FUNCTION to 
the resulting argument list. Last argument must be a list."
FUNCALL
"Args: (function &rest arguments)
Applies FUNCTION to the ARGUMENTs"
QUOTE
"Syntax: (quote x)
Returns X without evaluating it. ALso 'x."
FUNCTION
"Syntax: (function x)
If X is a lambda expression, creates and returns a lexical closure of X in
the current lexical environment. If X is a symbol that names a function,
returns that function. ALso #'x."
BACKQUOTE
"Syntax: (backquote template) or `template.
Fills in TEMPLATE by expanding COMMA and COMMA-AT expressions."
LAMBDA
"Syntax: (lambda args {forms}*)
Makes a function closure."

;; symbol functions
SET
"Args: (symbol value)
Assigns the value of VALUE to the dynamic variable named by SYMBOL (i. e.
it changes the global definition of SYMBOL), and returns the value assigned."
SETQ
"Syntax: (setq {var form}*)
VARs are not evaluated and must be symbols.  Assigns the value of the first
FORM to the first VAR, then assigns the value of the second FORM to the second
VAR, and so on.  Returns the last value assigned."
SETF
"Syntax: (setf {place newvalue}*)
Replaces the value in PLACE with the value of NEWVALUE, from left to right.
Returns the value of the last NEWVALUE.  Each PLACE may be any one of the
following:
  * A symbol that names a variable.
  * A function call form whose first element is the name of the following
    functions:
	nth
	aref subarray sublist select elt
	get
	symbol-value
	symbol-plist
	documentation
	slot-value
	c?r	c??r	c???r	c????r
    where '?' stands for either 'a' or 'd'."
DEFUN
"Syntax: (defun name lambda-list [doc] {form}*)
Defines a function as the global definition of the symbol NAME. The
complete syntax of a lambda-list is:
	({var}*
	 [&optional {var}*]
	 [&rest var]
	 [&aux {var}*])
The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be
retrieved by (documentation 'NAME 'function)."
DEFMACRO
"Syntax: (defmacro name defmacro-lambda-list [doc] {form}*)
Defines a macro as the global definition of the symbol NAME. The complete
syntax of a lambda-list is:
	({var}*
	 [&optional {var}*]
	 [&rest var]
	 [&aux {var}*])
The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be
retrieved by (documentation 'NAME 'function)."
GENSYM
"Args: (&optional (x nil))
Creates and returns 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 an integer, resets the counter.  If X is a
string, it becomes the new prefix."
MAKE-SYMBOL
"Args: (string)
Create and return new uninterned symbol with print name STRING."
INTERN
"Args: (name)
Returns a symbol having the specified name, creating it if necessary."
SYMBOL-NAME
"Args: (symbol)
Returns the print name of the symbol SYMBOL."
SYMBOL-VALUE
"Args: (symbol)
Returns the current global value of the variable named by SYMBOL."
SYMBOL-FUNCTION
"Args: (symbol)
Returns the current global function definition of the function named by SYMBOL."
SYMBOL-PLIST
"Args: (symbol)
Returns the property list of SYMBOL."
GET
"Args: (symbol indicator)
Looks on the property list of SYMBOL for the specified INDICATOR.  If this
is found, returns the associated value.  Otherwise, returns nil."
PUTPROP
"Args: (symbol value indicator)
Puts property INDICATOR with value VALUE on the property list of SYMBOL.
Returns VALUE."
REMPROP
"Args: (symbol indicator)
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, returns NIL with no side effects.
(This is what it should  return. Actually always returns nil. ***BUG***)"
HASH
" Args (sym n)
Computes the hash index for symbol SYM in a table of size N."
			
;; list functions
CAR
"Args: (list)
Returns the car of LIST.  Returns NIL if LIST is NIL."
CDR
"Args: (list)
Returns the cdr of LIST.  Returns NIL if LIST is NIL."
CAAAAR
"Args: (x)
Equivalent to (CAR (CAR (CAR (CAR X))))."
CAAADR
"Args: (x)
Equivalent to (CAR (CAR (CAR (CDR X))))."
CAAAR
"Args: (x)
Equivalent to (CAR (CAR (CAR X)))."
CAADAR
"Args: (x)
Equivalent to (CAR (CAR (CDR (CAR X))))."
CAADDR
"Args: (x)
Equivalent to (CAR (CAR (CDR (CDR X))))."
CAADR
"Args: (x)
Equivalent to (CAR (CAR (CDR X)))."
CAAR
"Args: (x)
Equivalent to (CAR (CAR X))."
CADAAR
"Args: (x)
Equivalent to (CAR (CDR (CAR (CAR X))))."
CADADR
"Args: (x)
Equivalent to (CAR (CDR (CAR (CDR X))))."
CADAR
"Args: (x)
Equivalent to (CAR (CDR (CAR X)))."
CADDAR
"Args: (x)
Equivalent to (CAR (CDR (CDR (CAR X))))."
CADDDR
"Args: (x)
Equivalent to (CAR (CDR (CDR (CDR X))))."
CADDR
"Args: (x)
Equivalent to (CAR (CDR (CDR X)))."
CADR
"Args: (x)
Equivalent to (CAR (CDR X))."
CDAADR
"Args: (x)
Equivalent to (CDR (CAR (CAR (CDR X))))."
CDAAR
"Args: (x)
Equivalent to (CDR (CAR (CAR X)))."
CDADAR
"Args: (x)
Equivalent to (CDR (CAR (CDR (CAR X))))."
CDADDR
"Args: (x)
Equivalent to (CDR (CAR (CDR (CDR X))))."
CDADR
"Args: (x)
Equivalent to (CDR (CAR (CDR X)))."
CDAR
"Args: (x)
Equivalent to (CDR (CAR X))."
CDDAAR
"Args: (x)
Equivalent to (CDR (CDR (CAR (CAR X))))."
CDDADR
"Args: (x)
Equivalent to (CDR (CDR (CAR (CDR X))))."
CDDAR
"Args: (x)
Equivalent to (CDR (CDR (CAR X)))."
CDDDAR
"Args: (x)
Equivalent to (CDR (CDR (CDR (CAR X))))."
CDDDDR
"Args: (x)
Equivalent to (CDR (CDR (CDR (CDR X))))."
CDDDR
"Args: (x)
Equivalent to (CDR (CDR (CDR X)))."
CDDR
"Args: (x)
Equivalent to (CDR (CDR X))."
CDAAAR
"Args: (x)
Equivalent to (CDR (CAR (CAR (CAR X))))."
FIRST
"Args: (x)
Equivalent to (CAR X)."
SECOND
"Args: (x)
Equivalent to (CAR (CDR X))."
THIRD
"Args: (x)
Equivalent to (CADDR X)."
FOURTH
"Args: (x)
Equivalent to (CADDDR X)."

REST
"Args: (x)
Equivalent to (CDR X)."

CONS
"Args: (x y)
Returns a new cons (list node) whose car and cdr are X and Y, respectively."
LIST
"Args: (&rest args)
Returns a list of its arguments"
APPEND
"Args: (&rest lists)
Constructs a new list by concatenating its arguments."
REVERSE
"Args: (list)
Returns a new list containing the same elements as LIST but in
reverse order."
LAST
"Args: (list)
Returns the last cons in LIST"
NTH
"Args: (n list)
Returns the N-th element of LIST, where the car of LIST is the zero-th
element."
NTHCDR
"Args: (n list)
Returns the result of performing the CDR operation N times on LIST."
MEMBER
"Args: (item list &key (test #'eql) test-not)
Returns the tail of LIST beginning with the first ITEM."
ASSOC
"Args: (item alist &key (test #'eql) test-not)
Returns the first pair in ALIST whose car is equal (in the sense of TEST) to
ITEM."
SUBST
"Args: (new old tree &key (test #'eql) test-not)
Substitutes NEW for subtrees of TREE that match OLD."
SUBLIS
"Args: (alist tree &key (test #'eql) test-not)
Substitutes from ALIST for subtrees of TREE nondestructively."
REMOVE
"Args: (item list &key (test #'eql) test-not)
Returns a copy of LIST with ITEM removed."
LENGTH
"Args: (sequence)
Returns the length of SEQUENCE."
MAPC
"Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs.  Returns the first LIST."
MAPCAR
"Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs and returns the results as a list."
MAPL
"Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs.  Returns the first LIST."
MAPLIST
"Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs and returns the results as a list."
			
;; destructive list functions
RPLACA
"Args: (x y)
Replaces the car of X with Y, and returns the modified X."
RPLACD
"Args: (x y)
Replaces the cdr of X with Y, and returns the modified X."
NCONC
"Args: (&rest lists)
Concatenates LISTs by destructively modifying them."
DELETE
"Args: (item list &key (test #'eql) test-not)
Returns a list formed by removing the specified ITEM destructively from
LIST."

;; predicate functions
ATOM
"Args: (x)
Returns T if X is not a cons; NIL otherwise."
SYMBOLP
"Args: (x)
Returns T if X is a symbol; NIL otherwise."
NUMBERP
"Args: (x)
Returns T if X is any kind of number; NIL otherwise."
BOUNDP
"Args: (symbol)
Returns T if the global variable named by SYMBOL has a value; NIL otherwise."
NULL
"Args: (x)
Returns T if X is NIL; NIL otherwise."
LISTP
"Args: (x)
Returns T if X is either a cons or NIL; NIL otherwise."
CONSP
"Args: (x)
Returns T if X is a cons; NIL otherwise."
EQ
"Args: (x y)
Returns T if X and Y are the same identical object; NIL otherwise."
EQL
"Args: (x y)
Returns T if X and Y are EQ, or if they are numbers of the same type with
the same value, or if they are identical strings.  Returns NIL otherwise."
EQUAL
"Args: (x y)
Returns T if X and Y are EQL or if they are of the same type and corresponding
components are EQUAL.  Returns NIL otherwise. Arrays must be EQ to be EQUAL."
NOT
"Args: (x)
Returns T if X is NIL; NIL otherwise."

;; special forms
COND
"Syntax: (cond {(test {form}*)}*)
Evaluates each TEST in order until one evaluates to a non-NIL value.  Then
evaluates the associated FORMs in order and returns the value of the last
FORM.  If no forms follow the TEST, then returns the value of the TEST.
Returns NIL, if all TESTs evaluate to NIL."
CASE
"Syntax: (case keyform {({key | ({key}*)} {form}*)}*)
Evaluates KEYFORM and tries to find the KEY that is EQL to the value of
KEYFORM.  If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM.  If not, simply returns NIL."
AND
"Syntax: (and {form}*)
Evaluates FORMs in order from left to right.  If any FORM evaluates to NIL,
returns immediately with the value NIL.  Else, returns the value of the
last FORM."
OR
"Syntax: (or {form}*)
Evaluates FORMs in order from left to right.  If any FORM evaluates to
non-NIL, quits and returns that value.  If the last FORM is reached,
returns whatever value it returns."
LET
"Syntax: (let ({var | (var [value])}*) {form}*)
Initializes VARs, binding them to the values of VALUEs (which defaults to NIL)
all at once, then evaluates FORMs as a PROGN."
LET*
"Syntax: (let* ({var | (var [value])}*) {form}*)
Initializes VARs, binding them to the values of VALUEs (which defaults to NIL)
from left to right, then evaluates FORMs as a PROGN."
IF
"Syntax: (if test then [else])
If TEST evaluates to non-NIL, then evaluates THEN and returns the result.
If not, evaluates ELSE (which defaults to NIL) and returns the result."
PROG
"Syntax: (prog ({var | (var [init])}*) {tag | statement}*)
Binds VARs in parallel, and then executes STATEMENTs."
PROG*
"Syntax: (prog* ({var | (var [init])}*) {tag | statement}*)
Binds VARs sequentially, and then executes STATEMENTs."
PROG1
"Syntax: (prog1 first {form}*)
Evaluates FIRST and FORMs in order, and returns the value of FIRST."
PROG2
"Syntax: (prog2 first second {forms}*)
Evaluates FIRST, SECOND, and FORMs in order, and returns the value
of SECOND."
PROGN
"Syntax: (progn {form}*)
Evaluates FORMs in order, and returns whatever the last FORM returns."
PROGV
"Syntax: (progv symbols values {form}*)
Evaluates FORMs in order, with SYMBOLS dynamically bound to VALUES, and 
returns whatever the last FORM returns."
GO
"Syntax: (go tag)
Jumps to the specified TAG established by a lexically surrounding PROG
construct."
RETURN
"Syntax: (return [result])
Returns from the lexically surrounding PROG construct.  The value of RESULT,
which defaults to NIL, is returned as the value of the PROG construct."
DO
"Syntax: (do ({(var [init [step]])}*) (endtest {result}*) {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 of
the last RESULT (or NIL if no RESULTs are supplied).  Performs variable
bindings and assignments all at once, just like LET does."
DO*
"Syntax: (do* ({(var [init [step]])}*) (endtest {result}*) {tag | statement}*)
Just like DO, but performs variable bindings and assignments in serial, just
like LET* and SETQ do."
DOLIST
"Syntax: (dolist (var listform [result]) {tag | statement}*)
Executes STATEMENTs, with VAR bound to each member of the list value of
LISTFORM.  Then returns the value of RESULT (which defaults to NIL)."
DOTIMES
"Syntax: (dotimes (var countform [result]) {tag | statement}*)
Executes STATEMENTs, with VAR bound to each number between 0 (inclusive) and
the value of COUNTFORM (exclusive).  Then returns the value of RESULT
(which defaults to NIL)."
CATCH
"Syntax: (catch tag {form}*)
Sets up a catcher with that value TAG.  Then evaluates FORMs as a PROGN, but
may possibly abort the evaluation by a THROW form that specifies the value
EQ to the catcher tag."
THROW
"Syntax: (throw tag result)
Evaluates TAG and aborts the execution of the most recent CATCH form that sets
up a catcher with the same tag value.  The CATCH form returns whatever RESULT
returned."
	
;; debugging and error handling functions
ERROR
"Args: (message-string arg)
Signals a fatal error. ARG is printed after the MESSAGE-STRING."
CERROR
"Args: (continue-message-string error-message-string args)
Signals a correctable error. Returns NIL when continued from the break loop."
BREAK
CLEAN-UP
"Args: ()
Cleans up after an error and moves to next lower break loop level."
TOP-LEVEL
"Args: ()
Returns to the top level."
CONTINUE
"Args: ()
Continues after a correctable error"
ERRSET
"Args: (expr [pflag])
Traps errors occurring during the evaluation of EXPR. PFLAG controls printing
of the error message. Returns the value of the last expression consed with
NIL or NIL. "
"Args: (number)
Prints NUMBER levels of trace back information. Returns NIL."
BAKTRACE
"Args: (&optional number)
Prints NUMBER levels of trace back information. Returns NIL."
EVALHOOK
"Args: (form evalhookfn applyhookfn &optional (env nil))
Evaluates FORM with *EVALHOOK* bound to EVALHOOKFN and *APPLYHOOK* bound
to APPLYHOOKFN.  Ignores these hooks once, for the top-level evaluation
of FORM.(Note: *APPPLYHOOK* is not yet implemented, and is thus ignored.)"
			
;; string functions
STRCAT
" Args: ({string}*)
Concatenates the STRINGs and returns the result."
SUBSEQ
"Args: (string start &optional end)
Extracts and returns the substring of STRING starting at START and ending at
END, if supplied, or the end of STRING."
STRING
"
Args: (sym)
Returns print-name of SYM if SYM is a symbol, or SYM if SYM is a."
CHAR
"Args: (string index)
Returns the INDEX-th character in STRING."

;; I/O functions
READ
"Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursivep nil))
Reads and returns the next object from STREAM."
PRINT
"Args: (object &optional (stream *standard-output*))
Outputs a newline character, and then prints OBJECT in the most readable
representation.  Returns OBJECT."
PRIN1
"Args: (object &optional (stream *standard-output*))
Prints OBJECT in the most readable representation.  Returns OBJECT."
PRINC
"Args: (object &optional (stream *standard-output*))
Prints OBJECT without escape characters.  Returns OBJECT."
TERPRI
"Args: (&optional (stream *standard-output*))
Outputs a newline character."
FLATSIZE
"Args: (object)
Returns length of printed representation of OBJECT using PRIN1"
FLATC
"Args: (object)
Returns length of printed representation of OBJECT using PRINC"
			
;; file I/O functions
OPEN
"Args: (fname &key (direction :input))
Opens file named by string or symbol FNAME. DIRECTION is :INPUT or :OUTPUT."
CLOSE
"Args: (stream)
Close file stream STREAM."
READ-CHAR
"Args: (&optional (stream *standard-input*) (eof-value nil) (recursive-p nil))
Reads a character from STREAM."
PEEK-CHAR
"Args: (&optional (peek-type nil) (stream *standard-input*) (eof-value nil) (recursive-p nil))
Peeks at the next character in the input stream STREAM."
WRITE-CHAR
"Args: (char &optional (stream *standard-output*))
Outputs CHAR and returns it."
READ-LINE
"Args: (&optional (stream *standard-input*) (eof-value nil) (recursive-p nil))
Returns line of text read from STREAM as a string without the newline character."

;; system functions
LOAD
"Args: (filename &key (verbose t) (print nil))
Loads the file named by FILENAME into XLISP. Returns T if load succeeds,
NIL if file does not exist."
DRIBBLE
"Args: (&optional file)
If string or symbol FILE is supplied creates a transcript file with this name.
If FILE is missing closes the transcript file."
SYSTEM
"Args: (string)
Runs the operating system command specified by string. Not available on
all implementations."
DYN-LOAD
"Args: (file &key verbose libflags fortran)
Links the object file FILE with standard C libraries and loads into
the running XLISP-STAT process. If FORTRAN is not NIL also searches
standard FORTRAN libraries. LIBFLAGS can be a string used to specify
additional libraries, for example "-lcmlib". Not available on all
implementations."
CALL-CFUN
"Args: (cfun &rest args)
CFUN is a string naming a C function. The remaining arguments must be
integers, sequences of integers, reals or sequences of reals.  CFUN is
called with the remaining arguments and a list of the lists of the
values of the arguments after the call is returned. Arguments in the
call will be pointers to ints or pointers to doubles.  Not available
on all implementations."
CALL-FSUB
"Args: (fsub &rest args)
FSUB is a string naming a FORTRAN subroutine. The remaining arguments
must be integers, sequences of integers, reals or sequences of reals.
FSUB is called with the remaining arguments and a list of the lists of
the values of the arguments after the call is returned. Arguments in
the call will be (arrays of) integers or double precision numbers. Not
available on all implementations."
CALL-LFUN
"Args: (lfun &rest args)
LFUN is a C function written to conform to internal XLISP argument
reading and value returning conventions. Applies LFUN to ARGS and
returns the result."

GC
"Args: ()
Forces garbage collection. Returns nil."
EXPAND
"Args: (number)
Expand memory by adding NUMBER segments. Returns the number of segments."
ALLOC
"Args: (number)
Changes number of nodes to allocate in each segment to NUMBER. Returns
old number of nodes to allocate."
ROOM
"Args: ()
Shows memory allocation statistics. Returns nil."
SAVE
"Args: (file)
Saves current memory image in FILE.wks. Does not work right with allocated objects."
RESTORE
"Args: (file)
Restores memory image from FILE.wks. Does not work right with allocated objects."

TYPE-OF
"Args: (x)
Returns the type of X."
EXIT
"Args: ()
Exits from XLISP."
PEEK
"Args (address)
Peek at an ADDRESS in memory."
POKE
"Args: (address value)
Poke VALUE into ADDRESS in memory."
ADDRESS-OF
"Args (x)
Get the address of an XLISP node."
X11-OPTIONS
"Args: (&key (fast-lines t) (fast-symbols t) (motion-sync t)
Sets performance options for X11 window system."

;; new functions and special forms
VECTOR
"Args: (&rest items)
Returns a vector with ITEMS as elements."
BLOCK
"Syntax: (block name {form}*)
The FORMs are evaluated in order, but it is possible to exit the block
using (RETURN-FROM name value).  The RETURN-FROM must be lexically contained
within the block."
RETURN-FROM
"Syntax: (return-from name [result])
Returns from the lexically surrounding block whose name is NAME.  The value
of RESULT, which defaults to NIL, is returned as the value of the block."
TAGBODY
"Syntax: (tagbody {tag | statement}*)
Executes STATEMENTs and returns NIL if it falls off the end."
PSETQ
"Syntax: (psetq {var form}*)
Similar to SETQ, but evaluates all FORMs first, and then assigns each value to
the corresponding VAR.  Returns NIL always."
FLET
"Syntax: (flet ({(name lambda-list {decl | doc}* {form}*)}*) . body)
Evaluates BODY as a PROGN, with local function definitions in effect.  BODY is
the scope of each local function definition.  Since the scope does not include
the function definitions themselves, the local function can reference
externally defined functions of the same name.  See the doc of DEFUN for the
complete syntax of a lambda-list.  Doc-strings for local functions are simply
ignored."
LABELS
"Syntax: (labels ({(name lambda-list {decl | doc}* {form}*)}*) . body)
Evaluates BODY as a PROGN, with the local function definitions in effect.
The scope of the locally defined functions include the function definitions
themselves, so they can reference externally defined functions of the same
name.  See the doc of DEFUN for the complete syntax of a lambda-list.
Doc-strings for local functions are simply ignored."
MACROLET
"Syntax: (macrolet ({(name defmacro-lambda-list {decl | doc}* . body)}*)
          {form}*)
Evaluates FORMs as a PROGN, with the local macro definitions in effect.
See the doc of DEFMACRO for the complete syntax of a defmacro-lambda-list.
Doc-strings for local macros are simply ignored."
UNWIND-PROTECT
"Syntax: (unwind-protect protected-form {cleanup-form}*)
Evaluates PROTECTED-FORM and returns whatever it returned.  Guarantees that
CLEANUP-FORMs be always evaluated before exiting from the UNWIND-PROTECT
form."
PPRINT
"Args: (object &optional (stream *standard-output*))
Pretty-prints OBJECT.  Returns OBJECT."
STRING<
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
If STRING1 is lexicographically less than STRING2, then returns the longest
common prefix of the strings.  Otherwise, returns NIL."
STRING<=
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
If STRING1 is lexicographically less than or equal to STRING2, then returns
the longest common prefix of the two strings.  Otherwise, returns NIL."
STRING=
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Returns T if the two strings are character-wise CHAR=; NIL otherwise."
STRING/=
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Returns NIL if STRING1 and STRING2 are character-wise CHAR=.  Otherwise,
returns the index to the longest common prefix of the strings."
STRING>=
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
If STRING1 is lexicographically greater than or equal to STRING2, then returns
the longest common prefix of the strings.  Otherwise, returns NIL."
STRING>
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
If STRING1 is lexicographically greater than STRING2, then returns the
longest common prefix of the strings.  Otherwise, returns NIL."
STRING-LESSP
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Similar to STRING<, but ignores cases."
STRING-NOT-GREATERP
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Similar to STRING<=, but ignores cases."
STRING-EQUAL
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Given two strings (string1 and string2), and optional integers start1,
start2, end1 and end2, compares characters in string1 to characters in
string2 (using char-equal)."
STRING-NOT-EQUAL
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Similar to STRING=, but ignores cases."
STRING-NOT-LESSP
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Similar to STRING>=, but ignores cases."
STRING-GREATERP
"Args: (string1 string2
       &key (start1 0) (end1 (length string1))
            (start2 0) (end2 (length string2)))
Similar to STRING>, but ignores cases."
INTEGERP
"Args: (x)
Returns T if X is an integer (fixnum or bignum); NIL otherwise."
FLOATP
"Args: (x)
Returns T if X is a floating-point number; NIL otherwise."
STRINGP
"Args: (x)
Returns T if X is a string; NIL otherwise."
ARRAYP
"Args: (x)
Returns T if X is an array; NIL otherwise."
STREAMP
"Args: (x)
Returns T if X is a stream object; NIL otherwise."
OBJECTP
"Args: (x)
Returns T if X is an object, NIL otherwise."
STRING-UPCASE
"Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all lower case characters converted to
uppercase."
STRING-DOWNCASE
"Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all upper case characters converted to
lowercase."
NSTRING-UPCASE
"Args: (string &key (start 0) (end (length string)))
Returns STRING with all lower case characters converted to uppercase."
NSTRING-DOWNCASE
"Args: (string &key (start 0) (end (length string)))
Returns STRING with all upper case characters converted to lowercase."
STRING-TRIM
"Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from both
ends."
STRING-LEFT-TRIM
"Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
left end."
STRING-RIGHT-TRIM
"Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
right end."
WHEN
"Syntax: (when test {form}*)
If TEST evaluates to non-NIL evaluates FORMs as a PROGN.  If not, returns NIL."
UNLESS
"Syntax: (unless test {form}*)
If TEST evaluates to NIL evaluates FORMs as a PROGN.  If not, returns NIL."
LOOP
"Syntax: (loop {form}*)
Executes FORMs repeatedly until exited by a THROW or RETURN.  The FORMs are
surrounded by an implicit NIL block."
FBOUNDP
"Args: (symbol)
Returns T if SYMBOL has a global function definition or if SYMBOL names a
special form or a macro; NIL otherwise."
PROGV
"Syntax: (progv symbols values {form}*)
SYMBOLS must evaluate to a list of symbols. VALUES must evaluate to a list
of initial values. Evaluates FORMs as a PROGN, with each variable bound
dynamically to the corresponding value."
CHARACTERP
"Args: (x)
Returns T if X is a character; NIL otherwise."
CHAR-INT
"Args: (char)
Returns the ASCII code of CHAR. Equivalent to CHAR-CODE in XLISP."
INT-CHAR
"Args: (integer)
Performs the inverse of CHAR-INT. Equivalent to CODE-CHAR in XLISP."
READ-BYTE
"Args: (&optional stream)
Reads the next byte from STREAM."
WRITE-BYTE
"Args: (integer &optional stream)
Outputs INTEGER to the binary stream STREAM.  Returns INTEGER."
MAKE-STRING-INPUT-STREAM
"Args: (string &optional (start 0) (end (length string)))
Returns an input stream which will supply the characters of String between
Start and End in order."
MAKE-STRING-OUTPUT-STREAM
"Args: ()
Returns an output stream which will accumulate all output given it for
the benefit of the function GET-OUTPUT-STREAM-STRING."
GET-OUTPUT-STREAM-STRING
"Args: (stream)
Returns a string of all the characters sent to STREAM made by
MAKE-STRING-OUTPUT-STREAM since the last call to this function."
GET-OUTPUT-STREAM-LIST
"Args: (stream)
Returns list of elements in stream."
GCD
"Args: (&rest integers)
Returns the greatest common divisor of INTEGERs."
GET-LAMBDA-EXPRESSION
"Args (closure)
Extracts lambda expression from CLOSURE."
MACROEXPAND
"Args: (form)
If FORM is a macro form expands it repeatedly until it is not a macro."
MACROEXPAND-1
"Args: (form)
If FORM is a macro form, then expands it once."
CHAR<
"Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly increasing order; NIL
otherwise."
CHAR<=
"Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-decreasing order; NIL
otherwise."
CHAR=
"Args: (char &rest more-chars)
Returns T if all CHARs are the same character; NIL otherwise."
CHAR/=
"Args: (char &rest more-chars)
Returns T if no two of CHARs are the same character; NIL otherwise."
CHAR>=
"Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-increasing order; NIL
otherwise."
CHAR>
"Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly decreasing order; NIL
otherwise."
CHAR-LESSP
"Args: (char &rest more-chars)
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."
CHAR-NOT-GREATERP
"Args: (char &rest more-chars)
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."
CHAR-EQUAL
"Args: (char &rest more-chars)
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."
CHAR-NOT-EQUAL
"Args: (char &rest more-chars)
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."
CHAR-NOT-LESSP
"Args: (char &rest more-chars)
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."
CHAR-GREATERP
"Args: (char &rest more-chars)
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."
UPPER-CASE-P
"Args: (char)
Returns T if CHAR is an upper-case character; NIL otherwise."
LOWER-CASE-P
"Args: (char)
Returns T if CHAR is a lower-case character; NIL otherwise."
BOTH-CASE-P
"Args: (char)
Returns T if CHAR is an alphabetic character; NIL otherwise."
DIGIT-CHAR-P
"Args: (char &optional (radix 10))
If CHAR represents a digit returns the weight as an integer.
Otherwise, returns nil."
ALPHANUMERICP
"Args: (char)
Returns T if CHAR is either numeric or alphabetic; NIL otherwise."
CHAR-UPCASE
"Args: (char)
Returns the upper-case equivalent of CHAR, if any, or CHAR."
CHAR-DOWNCASE
"Args: (char)
Returns the lower-case equivalent of CHAR, if any, or CHAR."
DIGIT-CHAR
"Args: (digit)
Returns a character object that represents the DIGIT, or NIL."
CHAR-CODE
"Args: (char)
Returns ASCII code of CHAR."
CODE-CHAR
"Args: (code)
Returns character object with the specified ASCII code, or NIL."
ENDP
"Args: (x)
Returns T if X is NIL.  Returns NIL if X is a cons.  Otherwise, signals an
error."
REMOVE-IF
"Args: (test list)
Returns a copy of LIST with elements satisfying TEST removed."
REMOVE-IF-NOT
"Args: (test list)
Returns a copy of LIST with elements not satisfying TEST removed."
DELETE-IF
"Args: (test list)
Returns result of destructively removing the elements satisfying TEST from LIST."
DELETE-IF-NOT
"Args: (test list)
Returns result of destructively removing the elements not satisfying TEST from LIST."
TRACE
"Syntax: (trace {function-name}*)
Traces the specified functions.  With no FUNCTION-NAMEs, returns a list of
functions currently being traced."
UNTRACE
"Syntax: (untrace {function-name}*)
Removes tracing from the specified functions.  With no FUNCTION-NAMEs,
untraces all functions."
SORT
"Args: (list predicate)
Destructively sorts LIST.  PREDICATE should return non-NIL if its first
argument is to precede its second argument."

;; *OBJECT*
(*OBJECT* OBJECT PROTO) "The root object."
(*OBJECT*  OBJECT :GET-METHOD)
"Method args: (selector)
Returns method for SELECTOR symbol from object's precedence list."
(*OBJECT*  OBJECT :HAS-SLOT)
"Method args: (slot &optional own)
Returns T if slot SLOT exists, NIL if not. If OWN is not NIL
only checks the object; otherwise check the entire precedence list."
(*OBJECT*  OBJECT :HAS-METHOD)
"Method args: (selector &optional own)
Returns T if method for SELECTOR exists, NIL if not. If OWN is not NIL
only checks the object; otherwise check the entire precedence list."
(*OBJECT*  OBJECT :ADD-SLOT)
"Method args: (slot &optional value)
Installs slot SLOT in object, if it does not already exist, and
sets its value to VLAUE."
(*OBJECT*  OBJECT :ADD-METHOD)
"Method args: (selector method)
Installs METHOD for SELECTOR in object."
(*OBJECT*  OBJECT :DELETE-SLOT)
"Method args: (slot)
Deletes slot SLOT from object if it exists."
(*OBJECT*  OBJECT :DELETE-METHOD)
"Method args: (selector)
Deletes method for SELECTOR in object if it exists."
(*OBJECT*  OBJECT :SHOW)
"Method Args: ()
Prints object's internal data."
(*OBJECT*  OBJECT :ISNEW)
"Method args: (&rest args)
Checks ARGS for keyword arguments matching slots and uses them to
initialize slots."
(*OBJECT*  OBJECT :PARENTS)
"Method args: ()
Returns copy of parents list."
(*OBJECT*  OBJECT :PRECEDENCE-LIST)
"Method args: ()
Returns copy of the precedence list."
(*OBJECT*  OBJECT :OWN-SLOTS)
"Method args: ()
Returns list of names of slots owned by object."
(*OBJECT*  OBJECT :OWN-METHODS)
"Method args ()
Returns copy of selectors for methods owned by object."
(*OBJECT*  OBJECT :INTERNAL-DOC)
"Method args (topic &optional value)
Retrieves or installs documentation for topic."
(*OBJECT* OBJECT :REPARENT)
"Method args: (&rest parents)
Changes precedence list to correspond to PARENTS. Does not change descendants."

;; compound data objects
(COMPOUND-DATA-PROTO OBJECT :SELECT-DATA)
"Sets or retrieves subset of data. Arguments depend on the object."
(COMPOUND-DATA-PROTO OBJECT :MAKE-DATA)
"Methos args: (data)
Make object like self with new data."
(COMPOUND-DATA-PROTO OBJECT :DATA-SEQ)
"Methos args: ()
Return sequence of object's data."
(COMPOUND-DATA-PROTO OBJECT :DATA-LENGTH)
"Methos args: ()
Return length of object's data."

;; WINDOW-PROTO
(WINDOW-PROTO  OBJECT PROTO)
"Instance variables: (title location size go-away)
Basic window prototype. Instance variables used at allocation; can set with
keywords to :ISNEW."
(WINDOW-PROTO  OBJECT :SHOW-WINDOW)
"Method args: ()
Makes window visible and moves it to the front. Returns NIL."
(WINDOW-PROTO  OBJECT :HIDE-WINDOW)
"Method args: ()
Hides the window without deallocating it. Returns NIL."
(WINDOW-PROTO  OBJECT :CLOSE)
"Method args: ()
Closes the window without deallocating it. Returns NIL."
(WINDOW-PROTO  OBJECT :TITLE)
"Method args: (&optional title)
Sets window title to TITLE if supplied. Returns current title."
(WINDOW-PROTO  OBJECT :LOCATION)
"Method args: (&optional left top)
Moves window content to (LEFT TOP) if supplied. Returns list of 
current left, top. Adjusts for the menu bar."
(WINDOW-PROTO  OBJECT :SIZE)
"Method args: (&optional width height)
Sets window content width and size to WIDTH and SIZE if supplied.
Returns list of current WIDTH HEIGHT. Adjusts for the menu bar."
(WINDOW-PROTO  OBJECT :FRAME-LOCATION)
"Method args: (&optional left top)
Moves window frame to (LEFT TOP) if supplied. Returns list of 
current left, top. Adjusts for the menu bar."
(WINDOW-PROTO  OBJECT :FRAME-SIZE)
"Method args: (&optional width height)
Sets window frame width and size to WIDTH and SIZE if supplied. 
Returns list of current WIDTH and HEIGHT. Adjusts for the menu bar."
(WINDOW-PROTO  OBJECT :UNDO)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :CUT-TO-CLIP)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :COPY-TO-CLIP)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :PASTE-FROM-CLIP)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :CLEAR)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :PASTE-STREAM)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :PASTE-STRING)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :SELECTION-STREAM)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :ACTIVATE)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :UPDATE)
"Method args: ()
Does nothing."
(WINDOW-PROTO  OBJECT :FIND)
"Method args: ()
Does nothing."

;; EDIT-WINDOW-PROTO
(EDIT-WINDOW-PROTO  OBJECT PROTO)
"Instance variables: (input-enabled output-stream bind-to-file)
Edit window prototype. Instance variables used at allocation; can set with
:SINEW keywords. Inherits from WINDOW-PROTO"
(EDIT-WINDOW-PROTO  OBJECT :ISNEW)
"Method args: (&key title location size go-away input-enabled
                    output-stream bind-to-file)
Initializes instance variables and sends itself the :ALLOCATE message.
Instance variables are used on allocation. GO-AWAY says whether window has a
close box, OUTPUT-STREAM can be used to write to the window, and BIND-TO-FILE
will cause a get-file-dialog to appear when the window is allocated."
(EDIT-WINDOW-PROTO  OBJECT :ALLOCATE)
"Method args: ()
Allocates and opens the window. Obtains file with get-file-dialog if slot
BIND-TO-FILE is true."
(EDIT-WINDOW-PROTO  OBJECT :CUT-TO-CLIP)
"Method args: ()
Cut selection to clip board."
(EDIT-WINDOW-PROTO  OBJECT :COPY-TO-CLIP)
"Method args: ()
Copy selection to clip board."
(EDIT-WINDOW-PROTO  OBJECT :PASTE-FROM-CLIP)
"Method args: ()
Paste selection to clip board."
(EDIT-WINDOW-PROTO  OBJECT :REVERT)
"Method args: ()
Reverts to file on disk; opens dialog to check first."
(EDIT-WINDOW-PROTO  OBJECT :SAVE)
"Method args: ()
Save file. Use save-file dialog to get a name if not bound to file."
(EDIT-WINDOW-PROTO  OBJECT :SAVE-AS)
"Method args: ()
Save file under name obtained by save-file-dialog and bind window to the file."
(EDIT-WINDOW-PROTO  OBJECT :SAVE-COPY)
"Method args: ()
Save copy of file under name obtained by save-file-dialog; don't change file binding."
(EDIT-WINDOW-PROTO  OBJECT :PASTE-STREAM)
"Method args: (string)
Inserts the characters in STRING at the current insertion point, replacing any
current selection."
(EDIT-WINDOW-PROTO  OBJECT :PASTE-STRING)
"Method args: (stream)
Inserts the characters in STREAM at the current insertion point, replacing any
current selection."
(EDIT-WINDOW-PROTO  OBJECT :FLUSH-WINDOW)
"Method args: (&optional count)
Flushes the first COUNT characters from the window. Flushes all characters if
COUNT is not supplied."
(EDIT-WINDOW-PROTO  OBJECT :SELECTION-STREAM)
"Method args: ()
Returns a stream containing the characters of the current selection."
(EDIT-WINDOW-PROTO  OBJECT :CLOSE)
"Method args: ()
Closes and deallocates the window. Asks about saving the file if necessary."
(EDIT-WINDOW-PROTO  OBJECT :REMOVE)
"Method args: ()
Closes and deallocates the window. Asks about saving the file if necessary."
(EDIT-WINDOW-PROTO  OBJECT :DISPOSE)
"Method args: ()
Closes and deallocates the window. Asks about saving the file if necessary."
(EDIT-WINDOW-PROTO  OBJECT :ACTIVATE)
"Method args: ()
Does nothing."
(EDIT-WINDOW-PROTO  OBJECT :UPDATE)
"Method args: ()
Does nothing."
(EDIT-WINDOW-PROTO  OBJECT :FIND-STRING)
"Method args: (string)
Finds and selects STRING if it is in the file. Returns T if found, NIL if not.
Search is case insensitive."

;; LISTENER-PROTO
(LISTENER-PROTO  OBJECT :ISNEW)
"Method args: ()
Initializes new listener object."
(LISTENER-PROTO  OBJECT :ALLOCATE)
"Method args: ()
Connects object to internal listener window."

;; MENU-PROTO
(MENU-PROTO  OBJECT PROTO)
"Instance variables: (title items enabled id)
Basic menu prototype. Instance variables used internally."
(MENU-PROTO  OBJECT :ISNEW)
"Method args: (title)
Sets menu title to TITLE and sends it the itself :ALLOCATE message."
(MENU-PROTO  OBJECT :ALLOCATE)
"Method args: ()
Allocates an internal menu for the object."
(MENU-PROTO  OBJECT :DISPOSE)
"Method args: ()
Disposes of the internal menu."
(MENU-PROTO  OBJECT :INSTALL)
"Method args ()
Installs the menu in the menu bar (Macintosh only)."
(MENU-PROTO  OBJECT :REMOVE)
"Method args: ()
Removes the menu from the menu bar (Macintosh only)."
(MENU-PROTO  OBJECT :ENABLED)
"Method args: (&optional enabled)
If ENABLED is supplied enables or disables the menu if ENABLED is true or
NIL. Returns T if menu is enabled, NIL otherwise."
(MENU-PROTO  OBJECT :UPDATE)
"Method args: ()
Sends each menu item the :UPTADE message."
(MENU-PROTO  OBJECT :ALLOCATED-P)
"Method args: ()
Returns true if menu is allocated, NIL otherwise."
(MENU-PROTO  OBJECT :TITLE) 
"Method args: (&optional TITLE)
If TITLE is supplied sets menu title to TITLE. Returns menu title."
(MENU-PROTO  OBJECT :ITEMS)
"Method args: ()
Returns list of menu items."
(MENU-PROTO  OBJECT :INSTALLED-P)
"Method args: ()
Returns true if menu is in the menu bar, NIL otherwise."
(MENU-PROTO  OBJECT :APPEND-ITEMS)
"Method args: (&rest items)
adds ITEMS to the menu and Returns NIL."
(MENU-PROTO  OBJECT :DELETE-ITEMS)
"Method args: (&rest items)
Removes ITEMS from menu and returns NIL. Signals an error if an
item is not in the menu"
(MENU-PROTO  OBJECT :SELECT)
"Method args: (index)
Sends item (elt items (- INDEX 1)) the :DO-ACTION message."
(MENU-PROTO  OBJECT :POPUP)
"Method args: (x y)
Waits for a mouse click if mouse is not already down at call time, then
pops up menu at screen coordinates (X Y)."

;; APPLE-MENU-PROTO
(APPLE-MENU-PROTO  OBJECT :ISNEW)
"Method args: (title)
Sets menu title to TITLE and sends it the itself :ALLOCATE message."
(APPLE-MENU-PROTO  OBJECT :SELECT)
"Method args: (index)
Sends item (elt items (- INDEX 1)) the :DO-ACTION message or opens the
desk accessory."

;; MENU-ITEM-PROTO
(MENU-ITEM-PROTO  OBJECT PROTO)
"Instance variables: (title key mark style action enabled menu)
Menu item. Instance variables used on installation; can set using
keywords to :ISNEW."
(MENU-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (title &key key mark style action (enabled t))
Initializes a new menu item object."
(MENU-ITEM-PROTO  OBJECT :TITLE)
"Method args: (&optional title)
Sets item title to TITLE if supplied and returns title."
(MENU-ITEM-PROTO  OBJECT :KEY)
"Method args: (&optional char)
Sets item keyboard equivalent to CHAR, if supplied, and returns current key
(Macintosh only)."
(MENU-ITEM-PROTO  OBJECT :MARK)
"Method args: (&optional MARK)
Sets item mark to MARK if MARK is a character, to a check if MARK is T
and to no mark if MARK is NIL. Returns current mark (Macintosh only)."
(MENU-ITEM-PROTO  OBJECT :STYLE)
"Method args: (&optional style)
Sets and returns item style. STYLE can be a symbol or list of symbols from
BOLD, ITALIC, UNDERLINE, SHADOW, CONDENSE, EXTEND (Macintosh only)."
(MENU-ITEM-PROTO  OBJECT :ACTION)
"Method args: (&optional FCN)
Sets ACTION slot to FCN if supplied; returns current ACTION value."
(MENU-ITEM-PROTO  OBJECT :ENABLED)
"Method args: (&optional enable)
Enables or disables item if ENABLED is supplied; returns T if enabled,
NIL if not."
(MENU-ITEM-PROTO  OBJECT :INSTALLED-P)
"Method args: ()
Returns T if item is installed in a menu, NIL if not."
(MENU-ITEM-PROTO  OBJECT :UPDATE)
"Method args: ()
Does nothing."
(MENU-ITEM-PROTO  OBJECT :DO-ACTION)
"Method args: ()
Funcalls the value of the ACTION slot."

;; DIALOG-PROTO
(DIALOG-PROTO  OBJECT PROTO)
"Dialog window prototype."
(DIALOG-PROTO  OBJECT :ISNEW) 
"Method args: (items &key title location size go-away type default-button)
Initializes and allocates a dialog. ITEMS is a list of dialog items; type
should be MODAL or MODELESS. Default is MODAL. Type only affect window
appearance, not the dialog's behavior."
(DIALOG-PROTO  OBJECT :ALLOCATE)
"Method args: ()
Allocates and opens a dialog window."
(DIALOG-PROTO  OBJECT :REMOVE)
"Method args: ()
Closes and deallocates the dialog window."
(DIALOG-PROTO  OBJECT :DISPOSE)
"Method args: ()
Closes and deallocates the dialog window."
(DIALOG-PROTO  OBJECT :CLOSE)
"Method args: ()
Closes and deallocates the dialog window."
(DIALOG-PROTO  OBJECT :ALLOCATED-P)
"Method args: ()
Returns T if dialog is allocated, NIL if not."
(DIALOG-PROTO  OBJECT :DEFAULT-BUTTON)
"Message args: (button)
Makes BUTTON the default button."
(DIALOG-PROTO  OBJECT :MODAL-DIALOG)
"Method args: ()
Puts dialog into modal mode, waits for a dialog event, and returns the item
in which the event occurred."
(DIALOG-PROTO :ITEMS)
"Method args: ()
Returns list of dialog items."

;; DIALOG-ITEM-PROTO
(DIALOG-ITEM-PROTO  OBJECT PROTO)
"Dialog item prototype."
(DIALOG-ITEM-PROTO  OBJECT :DO-ACTION)
"Method args: ()
Funcalls value of ACTION slot if it is not NIL."
(DIALOG-ITEM-PROTO  OBJECT :ACTION)
"Method args (&optional fcn)
Sets or returns value of ACTION slot."

;; BUTTON-ITEM-PROTO
(BUTTON-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (text &key location size action)
Initializes a button item."

;; TOGGLE-ITEM-PROTO
(TOGGLE-ITEM-PROTO  OBJECT PROTO)
"Toggle item prototype."
(TOGGLE-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (text &key location size action value)
Initializes a toggle (check box) item."
(TOGGLE-ITEM-PROTO  OBJECT :VALUE)
"Method args: (value)
Sets or gets toggle item value. Value is T or NIL."

;; TEXT-ITEM-PROTO
(TEXT-ITEM-PROTO  OBJECT PROTO)
"Text item prototype."
(TEXT-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (text &key location size action (editable nil))
Initializes a text item (editable or static)."
(TEXT-ITEM-PROTO  OBJECT :TEXT)
"Method args: (string)
Sets or gets text item's text."
  
;; CHOICE-ITEM-PROTO
(CHOICE-ITEM-PROTO  OBJECT PROTO)
"Choice (radio button cluster) item prototype."
(CHOICE-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (strings &key location size action value)
Initializes a choice (radio button cluster) item. STRINGS is a list of strings."
(CHOICE-ITEM-PROTO  OBJECT :VALUE)
"Method args: (value)
Sets or gets choice item value. Value is the zero-based index of the selected item."

;; SCROLL-ITEM-PROTO
(SCROLL-ITEM-PROTO  OBJECT PROTO)
"Scroll bar item."
(SCROLL-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (&key location size action (min-value 0) (max-value 100) (page-increment 5) 
value)
Initializes a scroll bar item. Orientation is determined by SIZE; default is horizontal."
(SCROLL-ITEM-PROTO  OBJECT :VALUE)
"Method args: (value)
Sets or gets scroll item value. Value is truncated to [min-value, max-value]."
(SCROLL-ITEM-PROTO  OBJECT :MAX-VALUE)
"Method args: (value)
Sets or gets scroll item minimum value."
(SCROLL-ITEM-PROTO  OBJECT :MIN-VALUE)
"Method args: (value)
Sets or gets scroll item maximum value."
(SCROLL-ITEM-PROTO  OBJECT :SCROLL-ACTION)
"Method args: ()
Funcalls ACTION slot value if it is not NIL."

;; LIST-ITEM-PROTO
(LIST-ITEM-PROTO  OBJECT PROTO)
"List item."
(LIST-ITEM-PROTO  OBJECT :ISNEW)
"Method args: (strings &key location size action (columns 1))
Initializes a list item. STRINGS should be a sequence of two dimensional array
of strings. COLUMNS is the number of columns visible in the display."
(LIST-ITEM-PROTO  OBJECT :DO-ACTION)
"Method args: (&optional (double nil))
Funcalls value of ACTION slot, if it is not NIL, with argument DOUBLE."
(LIST-ITEM-PROTO  OBJECT :SET-TEXT)
"Method args: (index string)
Sets text at INDEX to STRING. INDEX should be a number or a list of two numbers,
depending