home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / xl21hos2.zip / GLOS.TXT < prev    next >
Text File  |  1995-12-27  |  146KB  |  3,072 lines
  1. .nil -  represents empty list  and the boolean  value for "false".  The
  2.      value of NIL is  NIL, and cannot be changed  (it is a constant).  (car
  3.      NIL) and (cdr NIL) are also defined to be NIL.
  4.  
  5. .t - boolean value "true" is constant with value t.
  6.  
  7. .self -  within a method  context, the  current object
  8.      otherwise initially unbound.
  9.  
  10. .object - constant, value is the class 'Object.'
  11.  
  12. .class - constant, value is the class 'Class'.
  13.  
  14. .internal-time-units-per-second  - integer constant  to divide returned
  15.      times by to get time in seconds.
  16.  
  17. .pi - floating  point aproximation  of pi (constant  defined when  math
  18.      extension is compiled).
  19.  
  20. .*obarray* - the  object hash table. Length  of array is  a compilation
  21.      option. Objects are hashed using the hash function and are placed on a
  22.      list in the appropriate array slot. This variable does note exist when
  23.      the package feature is compiled in.
  24.  
  25. .*package*  - the current  package. Do not  alter. Part of  the package
  26.      feature.
  27.  
  28. .*terminal-io* - stream bound to keyboard and display. Do not alter.
  29.  
  30. .*standard-input*  - the  standard  input stream,  initially stdin.  If
  31.      stdin is not  redirected on  the command line,  then *terminal-io*  is
  32.      used so that all interactive i/o uses the same stream.
  33.  
  34. .*standard-output* -  the standard output stream,  initially stdout. If
  35.      stdout is not  redirected on  the command line  then *terminal-io*  is
  36.      used so that all interactive i/o uses the same stream.
  37.  
  38. .*error-output* - the error output stream (used by all error messages),
  39.      initially same as *terminal-io*.
  40.  
  41. .*trace-output* - the trace output stream (used by the trace function),
  42.      initially same as *terminal-io*.
  43.  
  44. .*debug-io*   -  the  break   loop  i/o   stream,  initially   same  as
  45.      *terminal-io*. System messages  (other than error messages) also print
  46.      out on this stream.
  47.  
  48. .*breakenable* -  flag controlling entering  break loop on  errors.
  49.  
  50. .*tracelist* -  list of names  of functions to  trace, as set  by trace
  51.      function.
  52.  
  53. .*tracenable* - enable trace back printout on errors.
  54.  
  55. .*tracelimit*  - number of levels  of trace back  information.
  56.  
  57. .*evalhook* - user substitute  for the evaluator function
  58.  
  59. .*applyhook* -  user substitute for  function application
  60.  
  61. .*readtable* - the current readtable
  62.  
  63. .*gc-flag*  - controls  the printing  of gc  messages. When  non-NIL, a
  64.      message  is printed  after each  garbage collection  giving  the total
  65.      number of nodes and the number of nodes free.
  66.  
  67. .*gc-hook* - function to call after garbage collection
  68.  
  69. .*integer-format* - format for  printing integers (when not bound  to a
  70.      string,  defaults  to  "%d"  or "%ld"  depending  on  implementation).
  71.      Variable not used when bignum extension installed.
  72.  
  73. .*float-format*  -  format for  printing floats  (when  not bound  to a
  74.      string, defaults to "%g")
  75.  
  76. .*readtable-case*  - symbol  read  and output  case.
  77.  
  78. .*read-base*  - When  bound to  a  fixnum in  the range  2 through  36,
  79.      determines the default radix used when reading  rational numbers. Part
  80.      of bignum extension.
  81.  
  82. .*print-base*  - When  bound to  a fixnum  in the  range 2  through 36,
  83.      determines the  radix used when  printing rational numbers  with prin1
  84.      and princ. Part of bignum extension.
  85.  
  86. .*print-case*  -  symbol output  case when  printing.
  87.  
  88. .*print-level* - When bound to a number, list  levels beyond this value
  89.      are printed as '#'. Used by all printing functions. Good precaution to
  90.      avoid getting caught in circular lists.
  91.  
  92. .*print-length* - When  bound to a number, lists longer than this value
  93.      are  printed as '...'. Used by all printing functions. Good precaution
  94.      to avoid getting caught in circular lists.
  95.  
  96. .*dos-input* - When not NIL, uses dos line input function for read
  97.  
  98. .*displace-macros* -  When  not  NIL,  macros  are  replaced  by  their
  99.      expansions when exectuted
  100.  
  101. .*random-state* - the default random-state used by the random function.
  102.  
  103. .*features* - list of features, initially (:xlisp), used  for #+ and #-
  104.      reader macros.
  105.  
  106. .*startup-functions* -  list of functions to be executed when workspace
  107.      started
  108.  
  109. .*command-line*  - the  xlisp command line,  in the  form of  a list of
  110.      strings, one string per argument.
  111.  
  112. .*load-file-arguments*  - When not  NIL, file arguements  are loaded at
  113.      startup.
  114.  
  115. .*top-level-loop* - Top  level loop to utilize,  defaults to TOP-LEVEL-
  116.      LOOP. Note that this  function can only be restarted by executing TOP-
  117.      LEVEL, and it never exits.
  118.  
  119. .*read-suppress*  - When  not NIL,  inhibits certain parts  of reading.
  120.      Used by the #+ and #- macroes.
  121.  
  122. .+ 
  123. .++ 
  124. .+++ 
  125. .* 
  126. .** 
  127. .*** 
  128. There  are several  symbols  maintained by  the  read/eval/print loop.  The
  129. symbols  '+', '++',  and '+++'  are bound  to the  most recent  three input
  130. expressions.  The symbols '*', '**' and '***'  are bound to the most recent
  131. three results.  The symbol '-'  is bound to the  expression currently being
  132. evaluated. It becomes the value of '+' at the end of the evaluation.
  133.  
  134. (eval <expr>)                                  EVALUATE AN XLISP EXPRESSION
  135.      <expr>    the expression to be evaluated
  136.      returns   the result of evaluating the expression
  137.  
  138. (apply <fun> <arg>...<args>)        APPLY A FUNCTION TO A LIST OF ARGUMENTS
  139.      <fun>     the function to apply (or function symbol). May not be macro
  140.                or fsubr.
  141.      <arg>     initial arguments, which are CONSed to...
  142.      <args>    the argument list
  143.      returns   the result of applying the function to the arguments
  144.  
  145. (funcall <fun> <arg>...)                     CALL A FUNCTION WITH ARGUMENTS
  146.      <fun>     the  function to call (or function symbol). May not be macro
  147.                or fsubr.
  148.      <arg>     arguments to pass to the function
  149.      returns   the result of calling the function with the arguments
  150.  
  151. (quote <expr>)                             RETURN AN EXPRESSION UNEVALUATED
  152.      fsubr
  153.      <expr>    the expression to be quoted (quoted)
  154.      returns   <expr> unevaluated
  155.  
  156. (function <expr>)                         GET THE FUNCTIONAL INTERPRETATION
  157.      fsubr
  158.      <expr>    the symbol or lambda expression (quoted)
  159.      returns   the functional interpretation
  160.  
  161. (complement <fun>)                            MAKE A COMPLEMENTARY FUNCTION
  162.      This  function is intended to eliminate the need for -IF-NOT functions
  163.      and :TEST-NOT keys by providing a way to make complementary functions.
  164.      <fun>     the function or closure (not macro or fsubr)
  165.      returns   a new function closure that returns NOT of the result of the
  166.                original function.
  167.  
  168. (identity <expr>)                                     RETURN THE EXPRESSION
  169.      <expr>    the expression
  170.      returns   the expression
  171.  
  172. (backquote <expr>)                                       FILL IN A TEMPLATE
  173.      fsubr. Note: an improved backquote facility, which works properly when
  174.      nested, is available by loading the file backquot.lsp.
  175.      <expr>    the template (quoted)
  176.      returns   a copy  of the template with comma  and comma-at expressions
  177.                expanded.
  178.  
  179. (comma <expr>)                                             COMMA EXPRESSION
  180.      (Never  executed)  As  the  object  of  a  backquote   expansion,  the
  181.      expression is evaluated and becomes an object in the enclosing list.
  182.  
  183. (comma-at <expr>)                                       COMMA-AT EXPRESSION
  184.      (Never  executed)   As  the  object  of  a  backquote  expansion,  the
  185.      expression is  evaluated (and  must evaluate  to a  list) and is  then
  186.      spliced into the enclosing list.
  187.  
  188. (lambda <args> <expr>...)                           MAKE A FUNCTION CLOSURE
  189.      fsubr
  190.      <args>    formal argument list (lambda list) (quoted)
  191.      <expr>    expressions of the function body (quoted)
  192.      returns   the function closure
  193.  
  194. (get-lambda-expression <closure>)                 GET THE LAMBDA EXPRESSION
  195.      <closure> the closure
  196.      returns   the original  lambda expression, or  NIL if  not a  closure.
  197.                Second return  value  is  T  if  closure  has  a  non-global
  198.                environment, and the third  return value is the name  of the
  199.                closure.
  200.  
  201. (macroexpand <form>)                         RECURSIVELY EXPAND MACRO CALLS
  202.      <form>    the form to expand
  203.      returns   the macro expansion
  204.  
  205. (macroexpand-1 <form>)                                  EXPAND A MACRO CALL
  206.      <form>    the macro call form
  207.      returns   the macro expansion
  208.  
  209. (multiple-value-bind <varlist> <vform> [<form>...])
  210.                                       BIND RETURN VALUES INTO LOCAL CONTEXT
  211.      defined as macro in common.lsp
  212.      <vform>   form to be evaluated
  213.      <varlist> list of variables to bind to return values of vform
  214.      <form>    forms  evaluated   sequentially,  as  in  LET,  using  local
  215.                bindings
  216.      returns   values of last form evaluated, or NIL if no forms
  217.  
  218. (multiple-value-call <fun> <form> ...)    COLLECT VALUES AND APPLY FUNCTION
  219.      fsubr
  220.      <fun>     function to apply
  221.      <form>    forms, which are evaluated, with result values collected
  222.      returns   result of applying fun to all of  the returned values of the
  223.                forms
  224.  
  225. (multiple-value-list <form>)   COLLECT MULTIPLE RETURNED VALUES INTO A LIST
  226.      defined as macro in common.lsp
  227.      <form>    form to be evaluated
  228.      returns   list of returned values
  229.  
  230. (multiple-value-prog1 <form> [<form> ...])      RETURN VALUES OF FIRST FORM
  231.      fsubr
  232.      <form>    one or more forms, which are evaluated sequentially
  233.      returns   the result values of the first form
  234.  
  235. (multiple-value-setq <varlist> <form>)      BIND RETURN VALUES TO VARIABLES
  236.      defined as macro in common.lsp
  237.      <form>    form to be evaluated
  238.      <varlist> list of variables to bind to return values of form
  239.      returns   (undefined, implementation dependent)
  240.  
  241. (nth-value <index> <form>)                           EXTRACT A RETURN VALUE
  242.      fsubr
  243.      <index>   index into return values
  244.      <form>    form which gets evaluated
  245.      returns   the nth result value of exectuing the form
  246.  
  247. (values [<expr>])                                    RETURN MULTIPLE VALUES
  248.      <expr>    expression(s) to be evaluated
  249.      returns   each argument as a separate value
  250.  
  251. (values-list <list>)                       RETURN MULTIPLE VALUES FROM LIST
  252.      defined in common.lsp
  253.      <list>    a list
  254.      returns   each list element as a separate value
  255.  
  256. (set <sym> <expr>)                         SET THE GLOBAL VALUE OF A SYMBOL
  257.      You can also use (setf (symbol-value <sym>) <expr>)
  258.      <sym>     the symbol being set
  259.      <expr>    the new value
  260.      returns   the new value
  261.  
  262. (setq [<sym> <expr>]...)                          SET THE VALUE OF A SYMBOL
  263.      fsubr. You can also use (setf <sym> <expr>)
  264.      <sym>     the symbol being set (quoted)
  265.      <expr>    the new value
  266.      returns   the last new value or NIL if no arguments
  267.  
  268. (psetq [<sym> <expr>]...)                          PARALLEL VERSION OF SETQ
  269.      fsubr. All  expressions are evaluated before  any assignments are
  270.      made.
  271.      <sym>     the symbol being set (quoted)
  272.      <expr>    the new value
  273.      returns   NIL
  274.  
  275. (defun <sym> <fargs> <expr>...)                           DEFINE A FUNCTION
  276. (defmacro <sym> <fargs> <expr>...)                           DEFINE A MACRO
  277.      fsubr
  278.      <sym>     symbol being defined (quoted)
  279.      <fargs>   formal argument list (lambda list) (quoted)
  280.      <expr>    expressions constituting the body of the function (quoted)
  281.      returns   the function symbol
  282.  
  283. (gensym [<tag>])                                          GENERATE A SYMBOL
  284.      <tag>     string or number
  285.      returns   the new symbol, uninterned
  286.  
  287. (intern <pname> [<package>])                        MAKE AN INTERNED SYMBOL
  288.      <pname>   the symbol's print name string
  289.      <package> the package (defaults to current package)
  290.      returns   the new symbol. A second  value is returned which is NIL  if
  291.                the symbol did not pre-exist, :internal if it is an internal
  292.                symbol, :external if it is an external symbol, or :inherited
  293.                if it inherited via USE-PACKAGE.
  294.  
  295. (make-symbol <pname>)                             MAKE AN UNINTERNED SYMBOL
  296.      <pname>   the symbol's print name string
  297.      returns   the new symbol
  298.  
  299. (symbol-name <sym>)                          GET THE PRINT NAME OF A SYMBOL
  300.      <sym>     the symbol
  301.      returns   the symbol's print name
  302.  
  303. (symbol-value <sym>)                              GET THE VALUE OF A SYMBOL
  304.      May be used as a place form.
  305.      <sym>     the symbol
  306.      returns   the symbol's value
  307.  
  308. (symbol-function <sym>)                GET THE FUNCTIONAL VALUE OF A SYMBOL
  309.      May be used as a place form.
  310.      <sym>     the symbol
  311.      returns   the symbol's functional value
  312.  
  313. (symbol-plist <sym>)                      GET THE PROPERTY LIST OF A SYMBOL
  314.      May be used as a place form.
  315.      <sym>     the symbol
  316.      returns   the symbol's property list
  317.  
  318. (hash <expr> <n>)                                    COMPUTE THE HASH INDEX
  319.      <expr>    the object to hash
  320.      <n>       the table size (positive fixnum less than 32768)
  321.      returns   the hash index (fixnum 0 to n-1)
  322.  
  323. (makunbound <sym>)                           MAKE A SYMBOL VALUE BE UNBOUND
  324.      You cannot unbind constants.
  325.      <sym>     the symbol
  326.      returns   the symbol
  327.  
  328. (fmakunbound <sym>)                       MAKE A SYMBOL FUNCTION BE UNBOUND
  329.      <sym>     the symbol
  330.      returns   the symbol
  331.  
  332. (unintern <sym> [<package>])                              UNINTERN A SYMBOL
  333.      Defined in common.lsp if package extension not compiled.
  334.      <sym>     the symbol
  335.      <package> the package to look in for the symbol
  336.      returns   t if successful, NIL if symbol not interned
  337.  
  338. (defconstant <sym> <val> [<comment>])                     DEFINE A CONSTANT
  339.      fsubr.
  340.      <sym>     the symbol
  341.      <val>     the value
  342.      <comment> optional comment string (ignored)
  343.      returns   the value
  344.  
  345. (defparameter <sym> <val> [<comment>])                   DEFINE A PARAMETER
  346.      fsubr.
  347.      <sym>     the symbol (will be marked "special")
  348.      <val>     the value
  349.      <comment> optional comment string (ignored)
  350.      returns   the value
  351.  
  352. (defvar <sym> [<val> [<comment>]])                        DEFINE A VARIABLE
  353.      fsubr. Variable only initialized if not previously defined.
  354.      <sym>     the symbol (will be marked "special")
  355.      <val>     the initial value, or NIL if absent.
  356.      <comment> optional comment string (ignored)
  357.      returns   the current value
  358.  
  359. (mark-as-special <sym> [<flag>])                      SET SPECIAL ATTRIBUTE
  360.      Also see definition of PROCLAIM and DECLARE.
  361.      <sym>     symbol to mark
  362.      <flag>    non-nil to make into a constant
  363.      returns   nil,  with  symbol  marked  as  special  and  possibly as  a
  364.                constant.
  365.  
  366. (declare [<declaration> ...])                   DECLARE ARGUMENT ATTRIBUTES
  367.      Macro  in  common.lsp  provided  to  assist  in  porting  Common  Lisp
  368.      applications to XLISP-PLUS.
  369.      <declaration>       list of local variable and attributes
  370.      returns   nil, produces an error message if attribute SPECIAL is used.
  371.  
  372. (proclaim <proc>)                         PROCLAIM GLOBAL SYMBOL ATTRIBUTES
  373.      Function in  common.lsp  provided to  assist  in porting  Common  Lisp
  374.      applications to XLISP-PLUS.
  375.      <proc>    a list of  symbols. If the CAR of the  list is SPECIAL, then
  376.                the remaining symbols are marked as special variables.
  377.  
  378. (copy-symbol <sym> [<flag>])                        MAKE A COPY OF A SYMBOL
  379.      Function in common2.lsp
  380.      <sym>     symbol to copy
  381.      <flag>    if present  and non-nil,  copy value, function  binding, and
  382.                property list.
  383.      returns   un-interned copy of <sym>
  384.  
  385. (setf [<place> <expr>]...)                         SET THE VALUE OF A FIELD
  386.      fsubr
  387.      <place> the field specifier
  388.      <expr>  the new value
  389.      returns the last new value, or NIL if no arguments
  390.  
  391. (psetf [<place> <expr>]...)                        PARALLEL VERSION OF SETF
  392.      fsubr. All  expressions are evaluated  and macro place  forms expanded
  393.      before any assignments are made.
  394.      <place>   the field specifier
  395.      <expr>    the new value
  396.      returns   NIL
  397.  
  398. (defsetf <sym> <fcn>)                         DEFINE A SETF FIELD SPECIFIER
  399. (defsetf <sym> <fargs> (<value>) <expr>...)
  400.      Defined  as macro  in common.lsp.  Convenient, Common  Lisp compatible
  401.      alternative to setting *setf* or *setf-lambda* property directly.
  402.      <sym>     field specifier symbol (quoted)
  403.      <fcn>     function  to  use  (quoted  symbol)  which  takes  the  same
  404.                arguments as the field specifier plus an additional argument
  405.                for the value. The value must be returned.
  406.      <fargs>   formal  argument list of unevaluated arguments (lambda list)
  407.                (quoted)
  408.      <value>   symbol bound to value to store (quoted).
  409.      <expr>    The last expression  must an expression  to evaluate in  the
  410.                setf  context.In this  respect, defsetf  works like  a macro
  411.                definition.
  412.      returns   the field specifier symbol
  413.  
  414. (push  <expr> <place>)                                      CONS TO A FIELD
  415.      Defined as macro  in common.lsp. Only  evaluates place form  arguments
  416.      one time. It is recommended that *displace-macros* be non-NIL for best
  417.      performance.
  418.      <place>   field specifier being modified (see setf)
  419.      <expr>    value to cons to field
  420.      returns   the new value which is (CONS <expr> <place>)
  421.  
  422. (pushnew <expr> <place> &key :test :test-not :key)      CONS NEW TO A FIELD
  423.      Defined  as macro in  common.lsp. Only evaluates  place form arguments
  424.      one time. It is recommended that *displace-macros* be non-NIL for best
  425.      performance.
  426.      <place>   field specifier being modified (see setf)
  427.      <expr>    value to cons to field, if not already MEMBER of field
  428.      :test     the test function (defaults to eql)
  429.      :test-not the test function (sense inverted)
  430.      :key      function to  apply to test function  list argument (defaults
  431.                to identity)
  432.      returns   the new value which is (CONS <expr> <place>) or <place>
  433.  
  434. (pop <place>)                               REMOVE FIRST ELEMENT OF A FIELD
  435.      Defined as  macro in common.lsp.  Only evaluates place  form arguments
  436.      one time. It is recommended that *displace-macros* be non-NIL for best
  437.      performance.
  438.      <place>   the field being modified (see setf)
  439.      returns   (CAR <place>), field changed to (CDR <place>)
  440.  
  441. (incf <place> [<value>])                                  INCREMENT A FIELD
  442. (decf <place> [<value>])                                  DECREMENT A FIELD
  443.      Defined as macro  in common.lsp. Only  evaluates place form  arguments
  444.      one time. It is recommended that *displace-macros* be non-NIL for best
  445.      performance.
  446.      <place>   field specifier being modified (see setf)
  447.      <value>   Numeric value (default 1)
  448.      returns   the new value  which is  (+ <place> <value>)  or (-  <place>
  449.                <value>)
  450.  
  451. (apropos <string> [<package>])                SEARCH SYMBOLS FOR NAME MATCH
  452. (apropos-list <string> [<package>])
  453.      Functions in common.lsp.
  454.      <string>  find symbols which contain this string as substring of print
  455.                name
  456.      <package> package to search, if absent, or NIL, search all packages
  457.      returns   apropos-list  returns list of  symbols, apropos prints them,
  458.                along with some information, and returns nothing.
  459.  
  460. (defpackage <package> [<option>...])                   (RE)DEFINE A PACKAGE
  461.      Macro in common.lsp. Use to define a package, or redefine a package.
  462.      <package> the name of the package to (re)define
  463.      <option>  any one or more of the following, none evaluated, applied in
  464.                this order:
  465.      (:shadow <symbol>...)
  466.                one or more symbols to shadow, as in function SHADOW
  467.      (:shadowing-import-from <symbol>...)
  468.                one   or   more   symbols   to  shadow,   as   in   function
  469.                SHADOWING-IMPORT
  470.      (:use <package>...)
  471.                one or more packages to "use", as in function USE-PACKAGE
  472.      (:import-from <package> <symbol>...)
  473.                one  or more  symbols  to import  from  the package,  as  in
  474.                function IMPORT
  475.      (:intern <symbol>...)
  476.                one  or  more  symbols to  be  located  or  created in  this
  477.                package, as in function INTERN
  478.      (:export <symbol>...)
  479.                one or more symbols to be exported  from this package, as in
  480.                function EXPORT
  481.      returns   the new or redefined package
  482.  
  483. (delete-package <package>)                                 DELETE A PACKAGE
  484.      Deletes  a package  by uninterning  all its  symbols and  removing the
  485.      package.
  486.      <package> package to delete
  487.      returns   T if successful
  488.  
  489. (do-symbols (<var> [<package> [<result>]]) <expr>...)) ITERATE OVER SYMBOLS
  490. (do-external-symbols (<var> [<package> [<result>]]) <expr>...)
  491. (do-all-symbols (<var> [<result>]) <expr>...)
  492.      Implemented  as macros  in  common.lsp. DO-SYMBOLS  iterates over  all
  493.      symbols in  a single  package, DO-EXTERNAL-SYMBOLS iterates  only over
  494.      the  external symbols, and DO-ALL-SYMBOLS iterates over all symbols in
  495.      all packages.
  496.      <var>     variable to bind to symbol
  497.      <package> the package to search
  498.      <result>  a single result form
  499.      <expr>    expressions to evaluate (implicit tag-body)
  500.      returns   result of result form, or NIL if not specified
  501.  
  502. (export <symbols> [<package>])                     DECLARE EXTERNAL SYMBOLS
  503.      <symbols> symbols to declare as external
  504.      <package> package symbol is in
  505.      returns   T
  506.  
  507. (find-all-symbols <string>)                FIND SYMBOLS WITH SPECIFIED NAME
  508.      <string>  string or symbol (if latter, print name string is used)
  509.      returns   list of all symbols having that print-name
  510.  
  511. (find-package <package>)                   FIND PACKAGE WITH SPECIFIED NAME
  512.      <package> package to find
  513.      returns   package with name or nickname <package>, or NIL if not found
  514.  
  515. (find-symbol <string> [<package>])                         LOOK UP A SYMBOL
  516.      <string>  print name to search for
  517.      <package> package to search in
  518.      returns   two values, the first being the symbol, and the second being
  519.                :internal  if  the  symbol   is  internal  in  the  package,
  520.                :external  if  it  is  external,  or  :inherited  if  it  is
  521.                inherited via USE-PACKAGE. If the symbol was not found, then
  522.                both return values are NIL.
  523.  
  524. (import <symbols> [<package>])                IMPORT SYMBOLS INTO A PACKAGE
  525.      <symbols> symbols to import (fully qualified names)
  526.      <package> package to import symbols into
  527.      returns   T
  528.  
  529. (in-package <package>)                                  SET CURRENT PACKAGE
  530.      FSUBR which sets the current package until next call or end of current
  531.      LOAD.
  532.      <package> the package to enter
  533.      returns   the package
  534.  
  535. (list-all-packages)                                   GET ALL PACKAGE NAMES
  536.      returns   list of all currently existing packages
  537.  
  538. (make-package <package> &key :nicknames :use)            MAKE A NEW PACKAGE
  539.      <package> name of new package to create
  540.      :nicknames          list of package nicknames
  541.      :use      list of packages to use (as in USE-PACKAGE)
  542.      returns   the new package
  543.  
  544. (package-name <package>)                            GET PACKAGE NAME STRING
  545.      <package> package name
  546.      returns   package name string
  547.  
  548. (package-nicknames <package>)                  GET PACKAGE NICKNAME STRINGS
  549.      <package> package name
  550.      returns   list of package nickname strings
  551.  
  552. (package-obarray <package> [<external>])                     GET AN OBARRAY
  553.      <package> package to use
  554.      <external>          non-nil  for  external   obarray,  else   internal
  555.                          obarray (default)
  556.      returns   the obarray (array of lists of symbols in package)
  557.  
  558. (package-shadowing-symbols <package>)         GET LIST OF SHADOWING SYMBOLS
  559.      <package> the package
  560.      returns   list of shadowing symbols in package
  561.  
  562. (package-use-list <package>)                 GET PACKAGES USED BY A PACKAGE
  563.      <package> the package
  564.      returns   list of packages used by this package (as in USE-PACKAGE)
  565.  
  566. (package-used-by-list <package>)         GET PACKAGES THAT USE THIS PACKAGE
  567.      <package> the package
  568.      returns   list of packages that use this package (as in USE-PACKAGE)
  569.  
  570. (package-valid-p <package>)                         IS THIS A GOOD PACKAGE?
  571.      <package> object to check
  572.      returns   T if a valid package, else NIL
  573.  
  574. (rename-package <package> <new> [<nick>])                  RENAME A PACKAGE
  575.      <package> original package
  576.      <new>     new package name (may be same as original name)
  577.      <nick>    list of new package nicknames
  578.      returns   the new package
  579.  
  580. (shadow <symbols> [<package>])                       MAKE SHADOWING SYMBOLS
  581.      If a symbol is not already in  the package, it is interned. The symbol
  582.      is placed in the shadowing symbols list for the package.
  583.      <symbols> the symbol or symbols to shadow
  584.      <package> package to put symbols in
  585.      returns   T
  586.  
  587. (shadowing-import <symbols> [<package>])          IMPORT SYMBOLS AND SHADOW
  588.      If a  symbol exists in the package, it is first uninterned. The symbol
  589.      is imported, and then made shadowing.
  590.      <symbols> the symbol or symbols to import and shadow
  591.      <package> package to put symbols in
  592.      returns   T
  593.  
  594. (symbol-package <symbol>)                      FIND THE PACKAGE OF A SYMBOL
  595.      <symbol>  the symbol
  596.      returns   the home package of the symbol, or NIL if none
  597.  
  598. (unexport <symbols> [<package>])           MAKE SYMBOLS INTERNAL TO PACKAGE
  599.      <symbols> symbol or symbols to make internal
  600.      <package> package for symbols
  601.      returns   T
  602.  
  603. (unuse-package <pkgs> [<package>])            REMOVE PACKAGES FROM USE LIST
  604.      <pkgs>    A single package or list of packages
  605.      <package> Package  in which  to  un-use packages  (default is  current
  606.                package)
  607.      returns   T
  608.  
  609. (use-package <pkgs> [<package>])                   ADD PACKAGES TO USE LIST
  610.      <pkgs>    A single package or list of packages
  611.      <package> Package  in which  to  use packages  in (default  is current
  612.                package)
  613.      returns   T
  614.  
  615. (get <sym> <prop> [<dflt>])            GET THE VALUE OF A SYMBOL'S PROPERTY
  616.      Use as a place form (with SETF) to add or change properties.
  617.      <sym>     the symbol
  618.      <prop>    the property name
  619.      <dflt>    value to return if property not found, default is NIL
  620.      returns   the property value or <dflt> if property doesn't exist.
  621.  
  622. (getf <place> <prop> [<dflt>])                  GET THE VALUE OF A PROPERTY
  623.      Use GETF as a place form with SETF to add or change properties. (NOTE-
  624.      -when used  with SETF,  <place> must  be a valid  place form.  It gets
  625.      executed twice, contrary to Common Lisp standard.)
  626.      <place>   where the property list is stored
  627.      <prop>    the property name
  628.      <dflt>    value to return if property not found, default is NIL
  629.      returns   the property value or <dflt> if property doesn't exist.
  630.  
  631. (putprop <sym> <val> <prop>)            PUT A PROPERTY ONTO A PROPERTY LIST
  632.      Modern practice is to use (SETF (GET...)...) rather than PUTPROP.
  633.      <sym>     the symbol
  634.      <val>     the property value
  635.      <prop>    the property name
  636.      returns   the property value
  637.  
  638. (remf <place> <prop>)                                     DELETE A PROPERTY
  639.      Defined as a macro in COMMON.LSP
  640.      <place>   where the property list is stored
  641.      <prop>    the property name
  642.      returns   T if property existed, else NIL
  643.  
  644. (remprop <sym> <prop>)                           DELETE A SYMBOL'S PROPERTY
  645.      <sym>     the symbol
  646.      <prop>    the property name
  647.      returns   NIL
  648.  
  649. (make-hash-table &key :size :test)                        MAKE A HASH TABLE
  650.      :size     fixnum  size  of hash  table --  should  be a  prime number.
  651.                Default is 31.
  652.      :test     comparison function. Defaults to eql.
  653.      returns   the hash table
  654.  
  655. (gethash <key> <table> [<def>])                     EXTRACT FROM HASH TABLE
  656.      May be used as place form.
  657.      <key>     hash key
  658.      <table>   hash table
  659.      <def>     value to return on no match (default is NIL)
  660.      returns   associated data, if found, or <def> if not found.
  661.  
  662. (remhash <key> <table>)                              DELETE FROM HASH TABLE
  663.      <key>     hash key
  664.      <table>   hash table
  665.      returns   T if deleted, NIL if not in table
  666.  
  667. (clrhash <table>)                                      CLEAR THE HASH TABLE
  668.      <table>   hash table
  669.      returns   NIL, all entries cleared from table
  670.  
  671. (hash-table-count <table>)                  NUMBER OF ENTRIES IN HASH TABLE
  672.      <table>   hash table
  673.      returns   integer number of entries in table
  674.  
  675. (maphash <fcn> <table>)                     MAP FUNCTION OVER TABLE ENTRIES
  676.      <fcn>     the function or function name, a function of two  arguments,
  677.                the first is  bound to the key, and the  second the value of
  678.                each table entry in turn.
  679.      <table>   hash table
  680.      returns   NIL
  681.  
  682. (aref <array> <n>)                          GET THE NTH ELEMENT OF AN ARRAY
  683.      May be used as a place form
  684.      <array>   the array (or string)
  685.      <n>       the array index (fixnum, zero based)
  686.      returns   the value of the array element
  687.  
  688. (make-array <size> &key :initial-element :initial-contents)  MAKE A NEW ARRAY
  689.      <size>    the size of the new array (fixnum)
  690.      :initial-element
  691.                value to initialize all array elements, default NIL
  692.      :initial-contents
  693.                sequence used to initialize  all array elements, consecutive
  694.                sequence  elements  are used  for  each  array element.  The
  695.                length  of the sequence must be the  same as the size of the
  696.                array
  697.      returns   the new array
  698.  
  699. (vector <expr>...)                               MAKE AN INITIALIZED VECTOR
  700.      <expr>    the vector elements
  701.      returns   the new vector
  702.  
  703. (concatenate <type> <expr> ...)                       CONCATENATE SEQUENCES
  704.      If result type is string, sequences must contain only characters.
  705.      <type>    result type, one of CONS, LIST, ARRAY, or STRING
  706.      <expr>    zero or more sequences to concatenate
  707.      returns   a  sequence  which is  the  concatenation  of the  arguement
  708.                sequences
  709.  
  710. (elt <expr> <n>)                          GET THE NTH ELEMENT OF A SEQUENCE
  711.      May be used as a place form
  712.      <expr>    the sequence
  713.      <n>       the index of element to return
  714.      returns   the element if the index is in bounds, otherwise error
  715.  
  716. (map <type> <fcn> <expr> ...)         APPLY FUNCTION TO SUCCESSIVE ELEMENTS
  717. (map-into <target> <fcn> [<expr> ...])
  718.      <type>    result type, one of CONS, LIST, ARRAY, STRING, or NIL
  719.      <target>  destination sequence to modify
  720.      <fcn>     the function or function name
  721.      <expr>    a sequence for each argument of the function
  722.      returns   a  new sequence  of type  <type> for  MAP, and  <target> for
  723.                MAP-INTO.
  724.  
  725. (every <fcn> <expr> ...)             APPLY FUNCTION TO ELEMENTS UNTIL FALSE
  726. (notevery <fcn> <expr> ...)
  727.      <fcn>     the function or function name
  728.      <expr>    a sequence for each argument of the function
  729.      returns   every returns last evaluated function result
  730.                notevery returns T if  there is a NIL function  result, else
  731.                NIL
  732.  
  733. (some <fcn> <expr> ...)               APPLY FUNCTION TO ELEMENTS UNTIL TRUE
  734. (notany <fcn> <expr> ...)
  735.      <fcn>     the function or function name
  736.      <expr>    a sequence for each argument of the function
  737.      returns   some returns first non-NIL function result, or NIL
  738.                notany returns  NIL if there  is a non-NIL  function result,
  739.                else T
  740.  
  741. (length <expr>)                               FIND THE LENGTH OF A SEQUENCE
  742.      Note that  a circular list causes an error. To detect a circular list,
  743.      use LIST-LENGTH.
  744.      <expr>    the list, vector or string
  745.      returns   the length of the list, vector or string
  746.  
  747. (reverse <expr>)                                         REVERSE A SEQUENCE
  748. (nreverse <expr>)                          DESTRUCTIVELY REVERSE A SEQUENCE
  749.      <expr>    the sequence to reverse
  750.      returns   a new sequence in the reverse order
  751.  
  752. (subseq <seq> <start> [<end>])                        EXTRACT A SUBSEQUENCE
  753.      <seq>     the sequence
  754.      <start>   the starting position (zero origin)
  755.      <end>     the ending position + 1 (defaults to end) or NIL  for end of
  756.                sequence
  757.      returns   the sequence between <start> and <end>
  758.  
  759. (sort <seq> <test> &key :key)                 DESTRUCTIVELY SORT A SEQUENCE
  760. (stable-sort <seq> <test> &key :key)                STABLE DESTRUCTIVE SORT
  761.      <seq>     the sequence to sort
  762.      <test>    the comparison  function,  must return  T only  if its first
  763.                argument is strictly to the left of its second argument.
  764.      :key      function to apply to comparison function arguments (defaults
  765.                to identity)
  766.      returns   the sorted sequence
  767.  
  768. (search <seq1> <seq2> &key :test :test-not :key :start1 :end1 :start2 :end2)
  769.                                                         SEARCH FOR SEQUENCE
  770.      <seq1>    the sequence to search for
  771.      <seq2>    the sequence to search in
  772.      :test     the test function (defaults to eql)
  773.      :test-not the test function (sense inverted)
  774.      :key      function to  apply to  test function arguments  (defaults to
  775.                identity)
  776.      :start1   starting index in <seq1>
  777.      :end1     index of end+1 in <seq1> or NIL for end of sequence
  778.      :start2   starting index in <seq2>
  779.      :end2     index of end+1 in <seq2> or NIL for end of sequence
  780.      returns   position of first match
  781.  
  782. (remove <expr> <seq>  &key  :test :test-not :key :start :end :count :from-end)
  783. (remove-if <test> <seq> &key :key :start :end :count :from-end)
  784. (remove-if-not <test> <seq> &key :key :start :end :count :from-end)
  785.                                             REMOVE ELEMENTS FROM A SEQUENCE
  786.      <expr>    the element to remove
  787.      <test>    the test predicate, applied to each <seq> element in turn
  788.      <seq>     the sequence
  789.      :test     the test function (defaults to eql)
  790.      :test-not the test function (sense inverted)
  791.      :key      function  to  apply  to  each  <seq>  element  (defaults  to
  792.                identity)
  793.      :start    starting index
  794.      :end      index of end+1, or NIL for (length <seq>)
  795.      :count    maximum  number  of  elements  to  remove,  negative  values
  796.                treated as zero, NIL same as default -- unlimited.
  797.      :from-end if  non-nil, behaves  as  though elements  are removed  from
  798.                right end. This only has an affect when :count is used.
  799.      returns   copy  of  sequence  with  matching/non-matching  expressions
  800.                removed
  801.  
  802. (count <expr> <seq> &key :test :test-not :key :start :end :from-end)
  803. (count-if <test> <seq> &key :key :start :end :from-end)
  804. (count-if-not <test> <seq> &key :key :start :end :from-end)
  805.                                       COUNT MATCHING ELEMENTS IN A SEQUENCE
  806.      <expr>    element to count
  807.      <test>    the test predicate, applied to each <seq> element in turn
  808.      <seq>     the sequence
  809.      :test     the test function (defaults to eql)
  810.      :test-not the test function (sense inverted)
  811.      :key      function  to  apply  to  each  <seq>  element  (defaults  to
  812.                identity)
  813.      :start    starting index
  814.      :end      index of end+1, or NIL for (length <seq>)
  815.      :from-end this argument is ignored
  816.      returns   count of matching/non-matching elements
  817.  
  818. (find <expr> <seq> &key :test :test-not :key :start :end :from-end)
  819. (find-if <test> <seq> &key :key :start :end :from-end)
  820. (find-if-not <test> <seq> &key :key :start :end :from-end)
  821.                                                    FIND ELEMENT IN SEQUENCE
  822.      <expr>    element to search for
  823.      <test>    the test predicate, applied to each <seq> element in turn
  824.      <seq>     the sequence
  825.      :test     the test function (defaults to eql)
  826.      :test-not the test function (sense inverted)
  827.      :key      function  to  apply  to  each  <seq>  element  (defaults  to
  828.                identity)
  829.      :start    starting index
  830.      :end      index of end+1, or NIL for (length <seq>)
  831.      :from-end if non-nil search is done for last element
  832.      returns   first matching/non-matching element of sequence, or NIL
  833.  
  834. (position <expr> <seq> &key :test :test-not :key :start :end :from-end)
  835. (position-if <test> <seq> &key :key :start :end :from-end)
  836. (position-if-not <test> <seq> &key :key :start :end :from-end)
  837.                         FIND POSITION OF FIRST MATCHING ELEMENT IN SEQUENCE
  838.      <expr>    element to search for
  839.      <test>    the test predicate, applied to each <seq> element in turn
  840.      <seq>     the sequence
  841.      :test     the test function (defaults to eql)
  842.      :test-not the test function (sense inverted)
  843.      :key      function  to  apply  to  each  <seq>  element  (defaults  to
  844.                identity)
  845.      :start    starting index
  846.      :end      index of end+1, or NIL for (length <seq>)
  847.      :from-end if non-nil search is made for last element
  848.      returns   position of first matching/non-matching element of sequence,
  849.                or NIL
  850.  
  851. (delete <expr> <seq> &key :key :test :test-not :start :end :count :from-end)
  852. (delete-if <test> <seq> &key :key :start :end :count :from-end)
  853. (delete-if-not <test> <seq> &key :key :start :end :count :from-end)
  854.                                             DELETE ELEMENTS FROM A SEQUENCE
  855.      <expr>    the element to delete
  856.      <test>    the test predicate, applied to each <seq> element in turn
  857.      <seq>     the sequence
  858.      :test     the test function (defaults to eql)
  859.      :test-not the test function (sense inverted)
  860.      :key      function  to  apply  to  each  <seq>  element  (defaults  to
  861.                identity)
  862.      :start    starting index
  863.      :end      index of end+1, or NIL for (length <seq>)
  864.      :count    maximum  number  of  elements  to  remove,  negative  values
  865.                treated as zero, NIL same as default -- unlimited.
  866.      :from-end if  non-nil, behaves  as  though elements  are removed  from
  867.                right end. This only has an affect when :count is used.
  868.      returns   <seq> with the matching/non-matching expressions deleted
  869.  
  870. (substitute <r> <e> <s> &key :key :test :test-not :start :end :count :from-end)
  871. (substitute-if <r> <test> <s> &key :key :start :end :count :from-end)
  872. (substitute-if-not <r> <test> <s> &key :key :start :end :count :from-end)
  873.                                           SUBSTITUTE ELEMENTS IN A SEQUENCE
  874.      <r>       the replacement expression
  875.      <e>       the element to replace
  876.      <test>    the test predicate, applied to each <s> element in turn
  877.      <s>       the sequence
  878.      :test     the test function (defaults to eql)
  879.      :test-not the test function (sense inverted)
  880.      :key      function to apply to each <s> element (defaults to identity)
  881.      :start    starting index
  882.      :end      index of end+1, or NIL for (length <s>)
  883.      :count    maximum  number  of  elements  to  remove,  negative  values
  884.                treated as zero, NIL same as default -- unlimited.
  885.      :from-end if  non-nil, behaves  as  though elements  are removed  from
  886.                right end. This only has an affect when :count is used.
  887.      returns   copy  of  <s>  with  the  matching/non-matching  expressions
  888.                substituted
  889.  
  890. (nsubstitute <r><e><s> &key :key :test :test-not :start :end :count :from-end)
  891. (nsubstitute-if <r> <test> <s> &key :key :start :end :count :from-end)
  892. (nsubstitute-if-not <r> <test> <s> &key :key :start :end :count :from-end)
  893.                             DESTRUCTIVELY SUBSTITUTE ELEMENTS IN A SEQUENCE
  894.      <r>       the replacement expression
  895.      <e>       the element to replace
  896.      <test>    the test predicate, applied to each <s> element in turn
  897.      <s>       the sequence
  898.      :test     the test function (defaults to eql)
  899.      :test-not the test function (sense inverted)
  900.      :key      function to apply to each <s> element (defaults to identity)
  901.      :start    starting index
  902.      :end      index of end+1, or NIL for (length <s>)
  903.      :count    maximum  number  of  elements  to  remove,  negative  values
  904.                treated as zero, NIL same as default -- unlimited.
  905.      :from-end if  non-nil, behaves  as  though elements  are removed  from
  906.                right end. This only has an affect when :count is used.
  907.      returns   <s> with the matching/non-matching expressions substituted
  908.  
  909. (reduce <fcn> <seq> &key :initial-value :start :end)
  910.                                             REDUCE SEQUENCE TO SINGLE VALUE
  911.      <fcn>     function (of two arguments)  to apply to result of  previous
  912.                function application  (or first element) and  each member of
  913.                sequence.
  914.      <seq>     the sequence
  915.      :initial-value      value to  use as first argument  in first function
  916.                          application rather than using the first element of
  917.                          the sequence.
  918.      :start    starting index
  919.      :end      index of end+1, or NIL for (length <seq>)
  920.      returns   if  sequence is empty and there is no initial value, returns
  921.                result of applying function to  zero arguements. If there is
  922.                a single element, returns the element. Otherwise returns the
  923.                result of the last function application.
  924.  
  925. (remove-duplicates <seq> &key :test :test-not :key :start :end)
  926. (delete-duplicates <seq> &key :test :test-not :key :start :end)
  927.                                             DELETE DUPLICATES FROM SEQUENCE
  928.      Delete-duplicates defined in common2.lsp.
  929.      <seq>     the sequence
  930.      :test     comparison function (default eql)
  931.      :test-not comparison function (sense inverted)
  932.      :key      function to  apply to  test function arguments  (defaults to
  933.                identity)
  934.      :start    starting index
  935.      :end      index of end+1, or NIL for (length <seq>)
  936.      returns   copy  of sequence  with  duplicates removed,  or <seq>  with
  937.                duplicates deleted (destructive).
  938.  
  939. (fill <seq> <expr> &key :start :end)              REPLACE ITEMS IN SEQUENCE
  940.      Defined in common.lsp
  941.      <seq>     the sequence
  942.      <expr>    new value to place in sequence
  943.      :start    starting index
  944.      :end      index of end+1, or NIL for (length <seq>)
  945.      returns   sequence with items replaced with new item
  946.  
  947. (replace <seq1> <seq2> &key :start1 :end1 :start2 :end2)
  948.                                     REPLACE ITEMS IN SEQUENCE FROM SEQUENCE
  949.      Defined in common.lsp
  950.      <seq1>    the sequence to modify
  951.      <seq2>    sequence with new items
  952.      :start1   starting index in <seq1>
  953.      :end1     index of end+1 in <seq1> or NIL for end of sequence
  954.      :start2   starting index in <seq2>
  955.      :end2     index of end+1 in <seq2> or NIL for end of sequence
  956.      returns   first sequence with items replaced
  957.  
  958. (make-sequence <type> <size> &key :initial-element)         MAKE A SEQUENCE
  959.      Defined in common2.lsp.
  960.      <type>    type of sequence to create: CONS LIST ARRAY or STRING
  961.      <size>    size of sequence (non-negative integer)
  962.      :initial-element
  963.                initial value of all elements in sequence
  964.      returns   the new sequence
  965.  
  966. (copy-seq <seq>)                                            COPY A SEQUENCE
  967.      Defined in common2.lsp
  968.      <seq>     sequence to copy
  969.      returns   copy  of the sequence, sequence elements are eq those in the
  970.                original sequence.
  971.  
  972. (merge <type> <seq1> <seq2> <pred> &key :key)           MERGE TWO SEQUENCES
  973.      Defined in common2.lsp. Non-destructive,  although may be  destructive
  974.      in Common Lisp.
  975.      <type>    type of result sequence: CONS LIST ARRAY or STRING
  976.      <seq1>    first sequence to merge
  977.      <seq2>    second sequence to merge
  978.      <pred>    function of  two arguments which  returns true if  its first
  979.                argument should precede its second
  980.      :key      optional function  to apply to each  sequence element before
  981.                applying predicate function (defaults to identity)
  982.      returns   new sequence containing all the elements of  seq1 (in order)
  983.                merged  with  all the  elements  of seq2,  according  to the
  984.                predicate function
  985.  
  986. (mismatch <s1> <s2> &key :test :test-not :key :start1 :end1 :start2 :end2)
  987.                                       FIND DIFFERENCE BETWEEN TWO SEQUENCES
  988.      Defined in common2.lsp.
  989.      <s1>      first sequence
  990.      <s2>      second sequence
  991.      :test     the test function (defaults to eql)
  992.      :test-not the test function (sense inverted)
  993.      :key      function  to  apply  to  to  each  sequence  element  before
  994.                applying test function (defaults to identity)
  995.      :start1   starting index in <s1>
  996.      :end1     index of end+1 in <s1> or NIL for end of sequence
  997.      :start2   starting index in <s2>
  998.      :end2     index of end+1 in <s2> or NIL for end of sequence
  999.      returns   integer index of first mismatch in s1, or NIL if no mismatch
  1000.  
  1001. (car <expr>)                                  RETURN THE CAR OF A LIST NODE
  1002.      May be used as a place form.
  1003.      <expr>    the list node
  1004.      returns   the car of the list node
  1005.  
  1006. (cdr <expr>)                                  RETURN THE CDR OF A LIST NODE
  1007.      May be used as a place form.
  1008.      <expr>    the list node
  1009.      returns   the cdr of the list node
  1010.  
  1011. (caar <expr>)                      NESTED CAR/CDR EXPRESSIONS
  1012. (cadr <expr>)
  1013. (cdar <expr>)
  1014. (cddr <expr>)
  1015. (caaar <expr>)
  1016. (caadr <expr>)
  1017. (cadar <expr>)
  1018. (caddr <expr>)
  1019. (cdaar <expr>)
  1020. (cdadr <expr>)
  1021. (cddar <expr>)
  1022. (cdddr <expr>)
  1023. (caaaar <expr>)
  1024. (caaadr <expr>)
  1025. (caadar <expr>)
  1026. (caaddr <expr>)
  1027. (cadaar <expr>)
  1028. (cadadr <expr>)
  1029. (caddar <expr>)
  1030. (cadddr <expr>)
  1031. (cdaaar <expr>)
  1032. (cdaadr <expr>)
  1033. (cdadar <expr>)
  1034. (cdaddr <expr>)
  1035. (cddaar <expr>)
  1036. (cddadr <expr>)
  1037. (cdddar <expr>)
  1038. (cddddr <expr>)
  1039.     Applied from right to left: cadr means take the cdr then take the car.
  1040.  
  1041. (first <expr>)                                            A SYNONYM FOR CAR
  1042. (second <expr>)                                          A SYNONYM FOR CADR
  1043. (third <expr>)                                          A SYNONYM FOR CADDR
  1044. (fourth <expr>)                                        A SYNONYM FOR CADDDR
  1045. (fifth <expr>)                                           FIFTH LIST ELEMENT
  1046. (sixth <expr>)                                           SIXTH LIST ELEMENT
  1047. (seventh <expr>)                                       SEVENTH LIST ELEMENT
  1048. (eighth <expr>)                                         EIGHTH LIST ELEMENT
  1049. (ninth <expr>)                                           NINTH LIST ELEMENT
  1050. (tenth <expr>)                                           TENTH LIST ELEMENT
  1051. (rest <expr>)                                             A SYNONYM FOR CDR
  1052.      May  be used  as place  forms when  COMMON2.LSP loaded.  fifth through
  1053.      tenth defined in COMMON2.LSP.
  1054.  
  1055. (cons <expr1> <expr2>)                            CONSTRUCT A NEW LIST NODE
  1056.      <expr1>   the car of the new list node
  1057.      <expr2>   the cdr of the new list node
  1058.      returns   the new list node
  1059.  
  1060. (acons <expr1> <expr2> <alist>)                  ADD TO FRONT OF ASSOC LIST
  1061.      defined in common.lsp
  1062.      <expr1>   key of new association
  1063.      <expr2>   value of new association
  1064.      <alist>   association list
  1065.      returns   new association list, which  is (cons (cons <expr1> <expr2>)
  1066.                <expr3>))
  1067.  
  1068. (list <expr>...)                                    CREATE A LIST OF VALUES
  1069. (list* <expr> ... <list>)
  1070.      <expr>    expressions to be combined into a list
  1071.      returns   the new list
  1072.  
  1073. (append <expr>...)                                             APPEND LISTS
  1074.      <expr>    lists whose elements are to be appended
  1075.      returns   the new list
  1076.  
  1077. (revappend <expr1> <expr2>)                             APPEND REVERSE LIST
  1078.      Defined in common2.lsp
  1079.      <expr1>   first list
  1080.      <expr2>   second list
  1081.      returns   new list comprised of reversed first list appended to second
  1082.                list
  1083.  
  1084. (list-length <list>)                              FIND THE LENGTH OF A LIST
  1085.      <list>    the list
  1086.      returns   the length of the list or NIL if the list is circular
  1087.  
  1088. (last <list>)                           RETURN THE LAST LIST NODE OF A LIST
  1089.      <list>    the list
  1090.      returns   the last list node in the list
  1091.  
  1092. (tailp <sublist> <list>)                  IS ONE LIST A SUBLIST OF ANOTHER?
  1093.      Defined in common2.lsp
  1094.      <sublist> list to search for
  1095.      <list>    list to search in
  1096.      returns   T if sublist is EQ one of the top level conses of list
  1097.  
  1098. (butlast <list> [<n>])                  RETURN COPY OF ALL BUT LAST OF LIST
  1099. (nbutlast <list> [<n>])                        DELETE LAST ELEMENTS OF LIST
  1100.      nbutlast defined in common2.lsp
  1101.      <list>    the list
  1102.      <n>       count of elements to omit (default 1)
  1103.      returns   copy of list with last element(s) absent,  or, for nbutlast,
  1104.                the list with the last elements deleted (destructive).
  1105.  
  1106. (nth <n> <list>)                           RETURN THE NTH ELEMENT OF A LIST
  1107.      May be used as a place form
  1108.      <n>       the number of the element to return (zero origin)
  1109.      <list>    the list
  1110.      returns   the nth element or NIL if the list isn't that long
  1111.  
  1112. (nthcdr <n> <list>)                            RETURN THE NTH CDR OF A LIST
  1113.      <n>       the number of the element to return (zero origin)
  1114.      <list>    the list
  1115.      returns   the nth cdr or NIL if the list isn't that long
  1116.  
  1117. (member <expr> <list> &key :test :test-not :key)  FIND AN EXPRESSION IN A LIST
  1118. (member-if <test> <list> &key :key)               FIND ELEMENT PASSING TEST
  1119. (member-if-not <test> <list> &key :key)           FIND ELEMENT FAILING TEST
  1120.      Functions member-if and member-if-not defined in common2.lsp
  1121.      <expr>    the expression to find
  1122.      <test>    the test predicate
  1123.      <list>    the list to search
  1124.      :test     the test function (defaults to eql)
  1125.      :test-not the test function (sense inverted)
  1126.      :key      function to  apply to test function  list argument (defaults
  1127.                to identity)
  1128.      returns   the remainder  of the list  starting with the  expression or
  1129.                element passing/failing the test predicate
  1130.  
  1131. (assoc <expr> <alist> &key :test :test-not :key) FIND EXPRESSION IN AN A-LIST
  1132. (assoc-if <test> <alist> &key :key)     FIND ELEMENT IN A-LIST PASSING TEST
  1133. (assoc-if-not <test> <alist> &key :key) FIND ELEMENT IN A-LIST FAILING TEST
  1134. (rassoc <expr> <alist> &key :test :test-not :key) FIND EXPRESSION IN AN A-LIST
  1135. (rassoc-if <test> <alist> &key :key)    FIND ELEMENT IN A-LIST PASSING TEST
  1136. (rassoc-if-not <test> <alist> &key :key)FIND ELEMENT IN A-LIST FAILING TEST
  1137.      All functions but assoc defined  in common2.lsp. The rassoc  functions
  1138.      match the cdrs of the a-list elements  while the assoc functions match
  1139.      the cars.
  1140.      <expr>    the expression to find
  1141.      <test>    the test predicate
  1142.      <alist>   the association list
  1143.      :test     the test function (defaults to eql)
  1144.      :test-not the test function (sense inverted)
  1145.      :key      function to apply to a-list argument (defaults to identity)
  1146.      returns   the alist entry or NIL
  1147.  
  1148. (mapc <fcn> <list1> <list>...)            APPLY FUNCTION TO SUCCESSIVE CARS
  1149. (mapcar <fcn> <list1> <list>...)          APPLY FUNCTION TO SUCCESSIVE CARS
  1150. (mapcan <fcn> <list1> <list>...)          APPLY FUNCTION TO SUCCESSIVE CARS
  1151. (mapl <fcn> <list1> <list>...)            APPLY FUNCTION TO SUCCESSIVE CDRS
  1152. (maplist <fcn> <list1> <list>...)         APPLY FUNCTION TO SUCCESSIVE CDRS
  1153. (mapcon <fcn> <list1> <list>...)          APPLY FUNCTION TO SUCCESSIVE CDRS
  1154.      <fcn>     the function or function name
  1155.      <listn>   a list for each argument of the function
  1156.      returns   the first list  of arguments (mapc  or mapl), a list  of the
  1157.                values  returned (mapcar  or maplist),  or list  or returned
  1158.                values nconc'd together (mapcan or mapcon).
  1159.  
  1160. (subst <to> <from> <expr> &key :test :test-not :key)
  1161. (nsubst <to> <from> <expr> &key :test :test-not :key)
  1162. (nsubst-if <to> <test> <expr> &key :key)
  1163. (nsubst-if-not <to> <test> <expr> &key :key)
  1164.                                                      SUBSTITUTE EXPRESSIONS
  1165.      SUBST does minimum  copying as required by Common Lisp.  NSUBST is the
  1166.      destructive version.
  1167.      <to>      the new expression
  1168.      <from>    the  old  expression (match  to  part of  <expr>  using test
  1169.                function
  1170.      <test>    test predicate
  1171.      <expr>    the expression in which to do the substitutions
  1172.      :test     the test function (defaults to eql)
  1173.      :test-not the test function (sense inverted)
  1174.      :key      function  to  apply  to  subtree  test  function  expression
  1175.                argument (defaults to identity)
  1176.      returns   the expression with substitutions
  1177.  
  1178. (sublis <alist> <expr> &key :test :test-not :key)
  1179. (nsublis <alist> <expr> &key :test :test-not :key)
  1180.                                                   SUBSTITUTE WITH AN A-LIST
  1181.      SUBLIS does minimum copying as required by Common Lisp. NSUBLIS is the
  1182.      destructive version.
  1183.      <alist>   the association list
  1184.      <expr>    the expression in which to do the substitutions
  1185.      :test     the test function (defaults to eql)
  1186.      :test-not the test function (sense inverted)
  1187.      :key      function  to  apply  to  subtree  test  function  expression
  1188.                argument (defaults to identity)
  1189.      returns   the expression with substitutions
  1190.  
  1191. (pairlis <keys> <values> [<alist>])          BUILD AN A-LIST FROM TWO LISTS
  1192.      In file common.lsp
  1193.      <keys>    list of association keys
  1194.      <values>  list of association values, same length as keys
  1195.      <alist>   existing association list, default NIL
  1196.      returns   new association list
  1197.  
  1198. (make-list <size> &key :initial-element)                        MAKE A LIST
  1199.      In file common2.lsp
  1200.      <size>    size of list (non-negative integer)
  1201.      :initial-element
  1202.                initial value for each element, default NIL
  1203.      returns   the new list
  1204.  
  1205. (copy-list <list>)                             COPY THE TOP LEVEL OF A LIST
  1206.      In file common.lsp
  1207.      <list>    the list
  1208.      returns   a copy of the list (new cons cells in top level)
  1209.  
  1210. (copy-alist <alist>)                               COPY AN ASSOCIATION LIST
  1211.      In file common.lsp
  1212.      <alist>   the association list
  1213.      returns   a copy of the association list (keys and values not copies)
  1214.  
  1215. (copy-tree <tree>)                                              COPY A TREE
  1216.      In file common.lsp
  1217.      <tree>    a tree structure of cons cells
  1218.      returns   a copy of the tree structure
  1219.  
  1220. (intersection <list1> <list2> &key :test :test-not :key)      SET FUNCTIONS
  1221. (union <list1> <list2> &key :test :test-not :key)
  1222. (set-difference <list1> <list2> &key :test :test-not :key)
  1223. (set-exclusive-or <list1> <list2> &key :test :test-not :key)
  1224. (nintersection <list1> <list2> &key :test :test-not :key)
  1225. (nunion <list1> <list2> &key :test :test-not :key)
  1226. (nset-difference <list1> <list2> &key :test :test-not :key)
  1227. (nset-exclusive-or <list1> <list2> &key :test :test-not :key)
  1228.      set-exclusive-or and nset-exclusive-or defined in  common.lsp. nunion,
  1229.      nintersection,    and   nset-difference    are   aliased    to   their
  1230.      non-destructive counterparts in common.lsp.
  1231.      <list1>   first list
  1232.      <list2>   second list
  1233.      :test     the test function (defaults to eql)
  1234.      :test-not the test function (sense inverted)
  1235.      :key      function to  apply to  test function arguments  (defaults to
  1236.                identity)
  1237.      returns   intersection: list of all elements in both lists
  1238.                union: list of all elements in either list
  1239.                set-diference: list of all elements in first list but not in
  1240.                second list
  1241.                set-exclusive-or: list of all elements in only one list
  1242.                "n" versions are potentially destructive.
  1243.  
  1244. (adjoin <expr> <list> :test :test-not :key)              ADD UNIQUE TO LIST
  1245.      <expr>    new element to add
  1246.      <list>    the list
  1247.      :test     the test function (defaults to eql)
  1248.      :test-not the test function <sense inverted)
  1249.      :key      function to  apply to  test function arguments  (defaults to
  1250.                identity)
  1251.      returns   if  element not  in  list then  (cons  <expr> <list>),  else
  1252.                <list>.
  1253.  
  1254. (ldiff <list> <sublist>)                       GET INITIAL ELEMENTS OF LIST
  1255.      In file common2.lsp
  1256.      <list>    list to get elements of
  1257.      <sublist> list to search for in <list> (uses tailp)
  1258.      returns   copy of list up to match with sublist.
  1259.  
  1260. (rplaca <list> <expr>)                       REPLACE THE CAR OF A LIST NODE
  1261.      Modern practice is to use (setf (car <list>) <expr>)
  1262.      <list>    the list node
  1263.      <expr>    the new value for the car of the list node
  1264.      returns   the list node after updating the car
  1265.  
  1266. (rplacd <list> <expr>)                       REPLACE THE CDR OF A LIST NODE
  1267.      Modern practice is to use (setf (cdr <list>) <expr>)
  1268.      <list>    the list node
  1269.      <expr>    the new value for the cdr of the list node
  1270.      returns   the list node after updating the cdr
  1271.  
  1272. (nconc <list>...)                           DESTRUCTIVELY CONCATENATE LISTS
  1273.      <list>    lists to concatenate
  1274.      returns   the result of concatenating the lists
  1275.  
  1276. (nreconc <list1> <list2>)                   DESTRUCTIVELY CONCATENATE LISTS
  1277.      Defined in common2.lsp
  1278.      <list1>   first list
  1279.      <list2>   second list
  1280.      returns   second  list concantenated  to  the end  of the  first list,
  1281.                which has been destructively reversed.
  1282.  
  1283. (truncate <expr> <denom>)                             TRUNCATES TOWARD ZERO
  1284. (round <expr> <denom>)                   ROUNDS TOWARD NEAREST EVEN INTEGER
  1285. (floor <expr> <denom>)                   TRUNCATES TOWARD NEGATIVE INFINITY
  1286. (ceiling <expr> <denom>)                          TRUNCATES TOWARD INFINITY
  1287.      Round,  floor, and ceiling, and  the second argument  of truncate, are
  1288.      part of the math extension. Integers are returned as is.
  1289.      <expr>    the real number
  1290.      <denom>   real number to divide <expr> by before converting
  1291.      returns   the  integer result  of  converting the  number,  and, as  a
  1292.                second return value, the remainder of the operation, defined
  1293.                as  expr  -  result*denom.  The  type is  flonum  if  either
  1294.                argument is flonum, otherwise it is rational.
  1295.  
  1296. (float <expr>)               CONVERTS AN INTEGER TO A FLOATING POINT NUMBER
  1297.      <expr>    the real number
  1298.      returns   the number as a flonum
  1299.  
  1300. (rational <expr>)                      CONVERTS A REAL NUMBER TO A RATIONAL
  1301.      Rational numbers are returned as is. Part of the bignum extension.
  1302.      <expr>    the real number
  1303.      returns   the number as a ratio or integer. 
  1304.  
  1305. (+ [<expr>...])                                       ADD A LIST OF NUMBERS
  1306.      With no arguments returns addition identity, 0 (integer)
  1307.      <expr>    the numbers
  1308.      returns   the result of the addition
  1309.  
  1310. (- <expr>...)          SUBTRACT A LIST OF NUMBERS OR NEGATE A SINGLE NUMBER
  1311.      <expr>    the numbers
  1312.      returns   the result of the subtraction
  1313.  
  1314. (* [<expr>...])                                  MULTIPLY A LIST OF NUMBERS
  1315.      With no arguments returns multiplication identity, 1
  1316.      <expr>    the numbers
  1317.      returns   the result of the multiplication
  1318.  
  1319. (/ <expr>...)            DIVIDE A LIST OF NUMBERS OR INVERT A SINGLE NUMBER
  1320.      With  the bignum extension, division  of integer numbers  results in a
  1321.      rational quotient,  rather than integer. To  perform integer division,
  1322.      use TRUNCATE.
  1323.      <expr>    the numbers
  1324.      returns   the result of the division
  1325.  
  1326. (1+ <expr>)                                             ADD ONE TO A NUMBER
  1327.      <expr>    the number
  1328.      returns   the number plus one
  1329.  
  1330. (1- <expr>)                                      SUBTRACT ONE FROM A NUMBER
  1331.      <expr>    the number
  1332.      returns   the number minus one
  1333.  
  1334. (rem <expr>...)                              REMAINDER OF A LIST OF NUMBERS
  1335.      With the math extension, only two arguments allowed.
  1336.      <expr>    the real numbers (must be integers, without math extension)
  1337.      returns   the  result  of  the  remainder  operation  (remainder  with
  1338.                truncating division)
  1339.  
  1340. (mod <expr1> <expr2>)                          NUMBER MODULO ANOTHER NUMBER
  1341.      Part of math extension.
  1342.      <expr1>   real number
  1343.      <expr2>   real number divisor (may not be zero)
  1344.      returns   the  remainder  after  dividing  <expr1>  by  <expr2>  using
  1345.                flooring  division, thus  there is  no discontinuity  in the
  1346.                function around zero.
  1347.  
  1348. (min <expr>...)                           THE SMALLEST OF A LIST OF NUMBERS
  1349.      <expr>    the real numbers
  1350.      returns   the smallest number in the list
  1351.  
  1352. (max <expr>...)                            THE LARGEST OF A LIST OF NUMBERS
  1353.      <expr>    the real numbers
  1354.      returns   the largest number in the list
  1355.  
  1356. (abs <expr>)                                 THE ABSOLUTE VALUE OF A NUMBER
  1357.      <expr>    the number
  1358.      returns   the  absolute  value of  the number,  which is  the floating
  1359.                point magnitude for complex numbers.
  1360.  
  1361. (signum <expr>)                                    GET THE SIGN OF A NUMBER
  1362.      Defined in common.lsp
  1363.      <expr>    the number
  1364.      returns   zero if number is zero, one  if positive, or negative one if
  1365.                negative.  Numeric type  is  same as  number. For  a complex
  1366.                number, returns unit magnitude but same phase as number.
  1367.  
  1368. (float-sign <expr1> [<expr2>])                       APPLY SIGN TO A NUMBER
  1369.      Defined in common2.lsp
  1370.      <expr1>   the real number
  1371.      <expr2>   another real number, defaults to 1.0
  1372.      returns   the number <expr2> with the sign of <expr1>
  1373.  
  1374. (gcd [<n>...])                          COMPUTE THE GREATEST COMMON DIVISOR
  1375.      With no arguments returns 0, with one argument returns the argument.
  1376.      <n>       The number(s) (integer)
  1377.      returns   the greatest common divisor
  1378.  
  1379. (lcm <n>...)                              COMPUTE THE LEAST COMMON MULTIPLE
  1380.      Part  of math  extension.  A result  which would  be  larger than  the
  1381.      largest integer causes an error.
  1382.      <n>       The number(s) (integer)
  1383.      returns   the least common multiple
  1384.  
  1385. (random <n> [<state>])                       COMPUTE A PSEUDO-RANDOM NUMBER
  1386.      <n>       the real number upper bound
  1387.      <state>   a random-state (default is *random-state*)
  1388.      returns   a random number in range [0,n)
  1389.  
  1390. (make-random-state [<state>])                         CREATE A RANDOM-STATE
  1391.      <state>   a  random-state,   t,  or  NIL  (default   NIL).  NIL  means
  1392.                *random-state*
  1393.      returns   If  <state> is t, a random random-state, otherwise a copy of
  1394.                <state>
  1395.  
  1396. (sin <expr>)                                   COMPUTE THE SINE OF A NUMBER
  1397. (cos <expr>)                                 COMPUTE THE COSINE OF A NUMBER
  1398. (tan <expr>)                                COMPUTE THE TANGENT OF A NUMBER
  1399. (asin <expr>)                              COMPUTE THE ARC SINE OF A NUMBER
  1400. (acos <expr>)                            COMPUTE THE ARC COSINE OF A NUMBER
  1401.      <expr>    the floating point number
  1402.      returns   the  sine, cosine, tangent, arc  sine, or arc  cosine of the
  1403.                number
  1404.  
  1405. (atan <expr> [<expr2>])                 COMPUTE THE ARC TANGENT OF A NUMBER
  1406.      <expr>    the floating point number (numerator)
  1407.      <expr2>   the denominator,  default 1. May  only be specified  if math
  1408.                extension installed
  1409.      returns   the arc tangent of <expr>/<expr2>
  1410.  
  1411. (sinh <expr>)                       COMPUTE THE HYPERBOLIC SINE OF A NUMBER
  1412. (cosh <expr>)                     COMPUTE THE HYPERBOLIC COSINE OF A NUMBER
  1413. (tanh <expr>)                    COMPUTE THE HYPERBOLIC TANGENT OF A NUMBER
  1414. (asinh <expr>)                  COMPUTE THE HYPERBOLIC ARC SINE OF A NUMBER
  1415. (acosh <expr>)                COMPUTE THE HYPERBOLIC ARC COSINE OF A NUMBER
  1416. (atanh <expr>)               COMPUTE THE HYPERBOLIC ARC TANGENT OF A NUMBER
  1417.      Defined in common.lsp
  1418.      <expr>    the number
  1419.      returns   the hyperbolic sine, cosine,  tangent, arc sine, arc cosine,
  1420.                or arc tangent of the number.
  1421.  
  1422. (expt <x-expr> <y-expr>)                           COMPUTE X TO THE Y POWER
  1423.      <x-expr>  the number 
  1424.      <y-expr>  the exponent 
  1425.      returns   x to the y power. If  y is an integer, then the  result type
  1426.                is the same as the type of x.
  1427.  
  1428. (exp <x-expr>)                                     COMPUTE E TO THE X POWER
  1429.      <x-expr>  the floating point number 
  1430.      returns   e to the x power
  1431.  
  1432. (cis <x-expr>)                                      COMPUTE COSINE + I SINE
  1433.      Defined in common.lsp
  1434.      <x-expr>  the number
  1435.      returns   e to the ix power
  1436.  
  1437. (log <expr> [<base>])                                  COMPUTE THE LOGRITHM
  1438.      Part of the math extension
  1439.      <expr>    the number
  1440.      <base>    the base, default is e
  1441.      returns   log base <base> of <expr>
  1442.  
  1443. (sqrt <expr>)                           COMPUTE THE SQUARE ROOT OF A NUMBER
  1444.      <expr>    the number 
  1445.      returns   the square root of the number
  1446.  
  1447. (isqrt <expr>)                 COMPUTER THE INTEGER SQUARE ROOT OF A NUMBER
  1448.      Defined in common2.lsp
  1449.      <expr>    non-negative integer
  1450.      returns   the integer square root, either exact or the largest integer
  1451.                less than the exact value.
  1452.  
  1453. (numerator <expr>)                            GET THE NUMERATOR OF A NUMBER
  1454.      Part of bignum extension
  1455.      <expr>    rational number
  1456.      returns   numerator of number (number if integer)
  1457.  
  1458. (denominator <expr>)                        GET THE DENOMINATOR OF A NUMBER
  1459.      Part of bignum extension
  1460.      <expr>    rational number
  1461.      returns   denominator of number (1 if integer)
  1462.  
  1463. (complex <real> [<imag>])                         CONVERT TO COMPLEX NUMBER
  1464.      Part of math extension
  1465.      <real>    real number real part
  1466.      <imag>    real number imaginary part (default 0)
  1467.      returns   the complex number
  1468.  
  1469. (realpart <expr>)                             GET THE REAL PART OF A NUMBER
  1470.      Part of the math extension
  1471.      <expr>    the number
  1472.      returns   the real part of a complex number, or the number itself if a
  1473.      real number
  1474.  
  1475. (imagpart <expr>)                        GET THE IMAGINARY PART OF A NUMBER
  1476.      Part of the math extension
  1477.      <expr>    the number
  1478.      returns   the imaginary part of a complex number, or  zero of the type
  1479.                of the number if a real number.
  1480.  
  1481. (conjugate <expr>)                            GET THE CONJUGATE OF A NUMBER
  1482.      Part of the math extension
  1483.      <expr>    the number
  1484.      returns   the conjugate of a complex number, or the number itself if a
  1485.      real number.
  1486.  
  1487. (phase <expr>)                                    GET THE PHASE OF A NUMBER
  1488.      Part of the math extension
  1489.      <expr>    the number
  1490.      returns   the  phase  angle,  equivalent  to  (atan (imagpart  <expr>)
  1491.                (realpart <expr>))
  1492.  
  1493. (< <n1> <n2>...)                                         TEST FOR LESS THAN
  1494. (<= <n1> <n2>...)                            TEST FOR LESS THAN OR EQUAL TO
  1495. (= <n1> <n2>...)                                          TEST FOR EQUAL TO
  1496. (/= <n1> <n2>...)                                     TEST FOR NOT EQUAL TO
  1497. (>= <n1> <n2>...)                         TEST FOR GREATER THAN OR EQUAL TO
  1498. (> <n1> <n2>...)                                      TEST FOR GREATER THAN
  1499.      <n1>      the first real number to compare
  1500.      <n2>      the second real number to compare
  1501.      returns   the result of comparing <n1> with <n2>...
  1502.  
  1503. (logand [<expr>...])                  THE BITWISE AND OF A LIST OF INTEGERS
  1504.      With no arguments returns identity -1
  1505.      <expr>    the integers
  1506.      returns   the result of the and operation
  1507.  
  1508. (logior [<expr>...])         THE BITWISE INCLUSIVE OR OF A LIST OF INTEGERS
  1509.      With no arguments returns identity 0
  1510.      <expr>    the integers
  1511.      returns   the result of the inclusive or operation
  1512.  
  1513. (logxor [<expr>...])         THE BITWISE EXCLUSIVE OR OF A LIST OF INTEGERS
  1514.      With no arguments returns identity 0
  1515.      <expr>    the integers
  1516.      returns   the result of the exclusive or operation
  1517.  
  1518. (logeqv [<expr>...])          THE BITWISE EQUIVALENCE OF A LIST OF INTEGERS
  1519.      With no arguments returns identity -1
  1520.      <expr>    the integers
  1521.      returns   the result of the equivalence operation
  1522.  
  1523. (lognand <expr1> <expr2>)                         BITWISE LOGICAL FUNCTIONS
  1524. (logandc1 <expr1> <expr2>)
  1525. (logandc2 <expr1> <expr2>)
  1526. (lognor <expr1> <expr2>)
  1527. (logorc1 <expr1> <expr2>)
  1528. (logorc2 <expr1> <expr2>)
  1529.      Part  of the bignums extension, the remaining logical functions of two
  1530.      integers.
  1531.      <expr1>   the first integer
  1532.      <expr2>   the second integer
  1533.      returns   lognand: (lognot (logand <expr1> <expr2>))
  1534.                logandc1: (logand (lognot <expr1>) <expr2>)
  1535.                logandc2: (logand <expr1> (lognot <expr2>))
  1536.                lognor: (lognot (logor <expr1> <expr2>))
  1537.                logorc1: (logor (lognot <expr1>) <expr2>)
  1538.                logorc2: (logor <expr1> (lognot <expr2>))
  1539.  
  1540. (lognot <expr>)  THE BITWISE NOT OF A INTEGER
  1541.      <expr>    the integer
  1542.      returns   the bitwise inversion of integer
  1543.  
  1544. (logtest <expr1> <expr2>)                  TEST BITWISE AND OF TWO INTEGERS
  1545.      Defined in common.lsp when bignum extension not loaded
  1546.      <expr1>   the first integer
  1547.      <expr2>   the second integer
  1548.      returns   T if the result of the and operation is non-zero, else NIL
  1549.  
  1550. (logbitp <pos> <expr>)                                  TEST BIT OF INTEGER
  1551.      Part of bignums extension
  1552.      <pos>     non-negative fixnum bit position, as in (expt 2 <pos>)
  1553.      <expr>    integer to test
  1554.      returns   T if the bit is "1", else NIL.
  1555.  
  1556. (logcount <expr>)                                  COUNT BITS IN AN INTEGER
  1557.      Part of bignums extension
  1558.      <expr>    integer
  1559.      returns   if  <expr> is negative, returns  the number of  0 bits, else
  1560.                returns the number of 1 bits
  1561.  
  1562. (integer-length <expr>)                      CALCULATE LENGTH OF AN INTEGER
  1563.      Part of bignums extension
  1564.      <expr>    integer
  1565.      returns   the  minimum  number  of  bits necessary  to  represent  the
  1566.                integer, excluding any sign bit.
  1567.  
  1568. (ash <expr1> <expr2>)                                      ARITHMETIC SHIFT
  1569.      Part of math extension
  1570.      <expr1>   integer to shift
  1571.      <expr2>   number of bit positions to shift (positive is to left)
  1572.      returns   shifted integer
  1573.  
  1574. (byte <size> <pos>)                                 CREATE A BYTE SPECIFIER
  1575. (byte-size <spec>)                                 GET SPECIFIER SIZE FIELD
  1576. (byte-position <spec>)                         GET SPECIFIER POSITION FIELD
  1577.      Defined  in common2.lsp. A "byte  specifier" is implemented  as a CONS
  1578.      cell with the CAR being the size and the CDR being the position. These
  1579.      functions are aliases for CONS, CAR, and CDR, respectively.
  1580.      <size>    size of byte field (non-negative integer)
  1581.      <pos>     starting  position  of  byte field  (non-negative  integer),
  1582.                which is position with least bit weight
  1583.      <spec>    byte specifier (a CONS cell)
  1584.      returns   BYTE  returns  the  specifier,  BYTE-SIZE  returns the  size
  1585.                field, and BYTE-POSITION returns the starting position
  1586.  
  1587. (ldb <spec> <int>)                                                LOAD BYTE
  1588.      Defined in  common2.lsp. LDB can be  used with SETF, in  which case it
  1589.      performs a STB followed by a SETF into the field.
  1590.      <spec>    specifier of byte to extract
  1591.      <int>     integer to extract byte from
  1592.      returns   the extracted byte, a non-negative integer
  1593.  
  1594. (ldb-test <spec> <int>)                                         TEST A BYTE
  1595.      Defined in common2.lsp
  1596.      <spec>    specifier of byte to test
  1597.      <int>     integer containing byte to test
  1598.      returns   T if byte is zero, else NIL
  1599.  
  1600. (mask-field <spec> <int>)                                EXTRACT UNDER MASK
  1601.      Defined in common2.lsp.  MASK-FIELD can  be used with  SETF, in  which
  1602.      case it performs a DEPOSIT-FIELD followed by a SETF into the field.
  1603.      <spec>    specified byte to extract
  1604.      <int>     integer to extract byte from
  1605.      returns   the extracted byte  in the same  bit position as  it was  in
  1606.                <int>
  1607.  
  1608. (dpb <new> <spec> <int>)                                       DEPOSIT BYTE
  1609.      Defined in common2.lsp
  1610.      <new>     integer byte to insert
  1611.      <spec>    specifier of position and size of byte
  1612.      <int>     integer to insert byte into
  1613.      returns   <int> with <new> in the bit positions specified by <spec>
  1614.  
  1615. (deposit-field <new> <spec> <int>)                        INSERT UNDER MASK
  1616.      Defined in common2.lsp
  1617.      <new>     integer containing byte field to insert
  1618.      <spec>    specifier of position and size of byte
  1619.      <int>     integer to insert byte into
  1620.      returns   <new> at <spec> replacing bits at <spec> in <int>
  1621.  
  1622. (string <expr>)                   MAKE A STRING FROM AN INTEGER ASCII VALUE
  1623.      <expr>    an  integer  (which  is   first  converted  into  its  ASCII
  1624.                character value), string, character, or symbol
  1625.      returns   the string representation of the argument
  1626.  
  1627. (string-trim <bag> <str>)                        TRIM BOTH ENDS OF A STRING
  1628.      <bag>     a string containing characters to trim
  1629.      <str>     the string to trim
  1630.      returns   a trimed copy of the string
  1631.  
  1632. (string-left-trim <bag> <str>)                TRIM THE LEFT END OF A STRING
  1633.      <bag>     a string containing characters to trim
  1634.      <str>     the string to trim
  1635.      returns   a trimed copy of the string
  1636.  
  1637. (string-right-trim <bag> <str>)              TRIM THE RIGHT END OF A STRING
  1638.      <bag>     a string containing characters to trim
  1639.      <str>     the string to trim
  1640.      returns   a trimed copy of the string
  1641.  
  1642. (string-upcase <str> &key :start :end)                 CONVERT TO UPPERCASE
  1643.      <str>     the string
  1644.      :start    the starting offset
  1645.      :end      the ending offset + 1 or NIL for end of string
  1646.      returns   a converted copy of the string
  1647.  
  1648. (string-downcase <str> &key :start :end)               CONVERT TO LOWERCASE
  1649.      <str>     the string
  1650.      :start    the starting offset
  1651.      :end      the ending offset + 1 or NIL for end of string
  1652.      returns   a converted copy of the string
  1653.  
  1654. (string-capitalize <str> &key :start :end)                CAPITALIZE STRING
  1655.      <str>     the string
  1656.      :start    the starting offset
  1657.      :end      the ending offset + 1 or NIL for end of string
  1658.      returns   a  converted copy  of the  string with  each word  having an
  1659.                initial uppercase letter and following lowercase letters
  1660.  
  1661. (nstring-upcase <str> &key :start :end)                CONVERT TO UPPERCASE
  1662.      <str>     the string
  1663.      :start    the starting offset
  1664.      :end      the ending offset + 1 or NIL for end of string
  1665.      returns   the converted string (not a copy)
  1666.  
  1667. (nstring-downcase <str> &key :start :end)              CONVERT TO LOWERCASE
  1668.      <str>     the string
  1669.      :start    the starting offset
  1670.      :end      the ending offset + 1 or NIL for end of string
  1671.      returns   the converted string (not a copy)
  1672.  
  1673. (nstring-capitalize <str> &key :start :end)               CAPITALIZE STRING
  1674.      <str>     the string
  1675.      :start    the starting offset
  1676.      :end      the ending offset + 1 or NIL for end of string
  1677.      returns   the string with each word having an initial uppercase letter
  1678.                and following lowercase letters (not a copy)
  1679.  
  1680. (make-string  <size> &key :initial-element)                   MAKE A STRING
  1681.      Defined in common2.lsp.
  1682.      <size>    size of string (non-negative integer)
  1683.      :initial-element
  1684.                initial value of all characters in the string
  1685.      returns   the new string
  1686.  
  1687. (strcat <expr>...)                                      CONCATENATE STRINGS
  1688.      Macro in init.lsp, to maintain compatibility with XLISP.
  1689.      See CONCATENATE for preferred function.
  1690.      <expr>    the strings to concatenate
  1691.      returns   the result of concatenating the strings
  1692.  
  1693. (string< <str1> <str2> &key :start1 :end1 :start2 :end2)
  1694. (string<= <str1> <str2> &key :start1 :end1 :start2 :end2)
  1695. (string= <str1> <str2> &key :start1 :end1 :start2 :end2)
  1696. (string/= <str1> <str2> &key :start1 :end1 :start2 :end2)
  1697. (string>= <str1> <str2> &key :start1 :end1 :start2 :end2)
  1698. (string> <str1> <str2> &key :start1 :end1 :start2 :end2)
  1699.      <str1>    the first string to compare
  1700.      <str2>    the second string to compare
  1701.      :start1   first substring starting offset
  1702.      :end1     first substring ending offset + 1 or NIL for end of string
  1703.      :start2   second substring starting offset
  1704.      :end2     second substring ending offset + 1 or NIL for end of string
  1705.      returns   string=: t if predicate is true, NIL otherwise
  1706.                others: If predicate is true then number of initial matching
  1707.                characters, else NIL
  1708.      Note: case is significant with these comparison functions.
  1709.  
  1710. (string-lessp <str1> <str2> &key :start1 :end1 :start2 :end2)
  1711. (string-not-greaterp <str1> <str2> &key :start1 :end1 :start2 :end2)
  1712. (string-equal <str1> <str2> &key :start1 :end1 :start2 :end2)
  1713. (string-not-equal <str1> <str2> &key :start1 :end1 :start2 :end2)
  1714. (string-not-lessp <str1> <str2> &key :start1 :end1 :start2 :end2)
  1715. (string-greaterp <str1> <str2> &key :start1 :end1 :start2 :end2)
  1716.      <str1>    the first string to compare
  1717.      <str2>    the second string to compare
  1718.      :start1   first substring starting offset
  1719.      :end1     first substring ending offset + 1 or NIL for end of string
  1720.      :start2   second substring starting offset
  1721.      :end2     second substring ending offset + 1 or NIL for end of string
  1722.      returns   string-equal: t if predicate is true, NIL otherwise
  1723.                others: If predicate is true then number of initial matching
  1724.                characters, else NIL
  1725.      Note: case is not  significant with these comparison functions  -- all
  1726.      uppercase characters are converted to lowercase before being compared.
  1727.  
  1728. (char <string> <index>)                   EXTRACT A CHARACTER FROM A STRING
  1729.      <string>  the string
  1730.      <index>   the string index (zero relative)
  1731.      returns   the ascii code of the character
  1732.  
  1733. (alphanumericp <chr>)                       IS THIS CHARACTER ALPHANUMERIC?
  1734.      <chr>     the character
  1735.      returns   true  if  the  character   is  alphabetic  or  numeric,  NIL
  1736.                otherwise
  1737.  
  1738. (upper-case-p <chr>)                       IS THIS AN UPPER CASE CHARACTER?
  1739.      <chr>     the character
  1740.      returns   true if the character is upper case, NIL otherwise
  1741.  
  1742. (lower-case-p <chr>)                        IS THIS A LOWER CASE CHARACTER?
  1743.      <chr>     the character
  1744.      returns   true if the character is lower case, NIL otherwise
  1745.  
  1746. (alpha-char-p <chr>)                       IS THIS AN ALPHABETIC CHARACTER?
  1747.      <chr>     the character
  1748.      returns   true if the character is alphabetic, NIL otherwise
  1749.  
  1750. (both-case-p <chr>)          IS THIS AN ALPHABETIC (EITHER CASE) CHARACTER?
  1751.      <chr>     the character
  1752.      returns   true  if the  character  is  available  in both  cases,  NIL
  1753.                otherwise
  1754.  
  1755. (digit-char-p <chr>[<radix>])                    IS THIS A DIGIT CHARACTER?
  1756.      <chr>     the character
  1757.      <radix>   the radix (default 10)
  1758.      returns   the digit weight if character is a digit, NIL otherwise
  1759.  
  1760. (char-code <chr>)                         GET THE ASCII CODE OF A CHARACTER
  1761.      <chr>     the character
  1762.      returns   the ASCII character code (integer, parity bit stripped)
  1763.  
  1764. (code-char <code>)             GET THE CHARACTER WITH A SPECFIED ASCII CODE
  1765.      <code>    the ASCII code (integer, range 0-127)
  1766.      returns   the character with that code or NIL
  1767.  
  1768. (char-upcase <chr>)                       CONVERT A CHARACTER TO UPPER CASE
  1769.      <chr>     the character
  1770.      returns   the upper  case  version of  the character,  if one  exists,
  1771.                otherwise returns the character
  1772.  
  1773. (char-downcase <chr>)                     CONVERT A CHARACTER TO LOWER CASE
  1774.      <chr>     the character
  1775.      returns   the  lower case  version  of the  character, if  one exists,
  1776.                otherwise returns the character
  1777.  
  1778. (digit-char <n>[<radix>])                 CONVERT A DIGIT WEIGHT TO A DIGIT
  1779.      <n>       the digit weight (integer)
  1780.      <radix>   the radix (default 10)
  1781.      returns   the digit character or NIL
  1782.  
  1783. (char-int <chr>)                          CONVERT A CHARACTER TO AN INTEGER
  1784.      <chr>     the character
  1785.      returns   the ASCII character code (range 0-255)
  1786.  
  1787. (int-char <int>)                          CONVERT AN INTEGER TO A CHARACTER
  1788.      <int>     the ASCII character code (treated modulo 256)
  1789.      returns   the character with that code
  1790.  
  1791. (character <expr>)                                       CREATE A CHARACTER
  1792.      Defined in common2.lsp
  1793.      <expr>    single character symbol, string, or integer
  1794.      returns   <expr> converted into a character
  1795.  
  1796. (char-name <chr>)                                      CHARACTER PRINT NAME
  1797.      Defined in common2.lsp
  1798.      <chr>     the character
  1799.      returns   string which is the name of the character, or NIL if no name
  1800.  
  1801. (char< <chr1> <chr2>...)
  1802. (char<= <chr1> <chr2>...)
  1803. (char= <chr1> <chr2>...)
  1804. (char/= <chr1> <chr2>...)
  1805. (char>= <chr1> <chr2>...)
  1806. (char> <chr1> <chr2>...)
  1807.      <chr1>    the first character to compare
  1808.      <chr2>    the second character(s) to compare
  1809.      returns   t if predicate is true, NIL otherwise
  1810.      Note: case is significant with these comparison functions.
  1811.  
  1812. (char-lessp <chr1> <chr2>...)
  1813. (char-not-greaterp <chr1> <chr2>...)
  1814. (char-equal <chr1> <chr2>...)
  1815. (char-not-equal <chr1> <chr2>...)
  1816. (char-not-lessp <chr1> <chr2>...)
  1817. (char-greaterp <chr1> <chr2>...)
  1818.      <chr1>    the first string to compare
  1819.      <chr2>    the second string(s) to compare
  1820.      returns   t if predicate is true, NIL otherwise
  1821.      Note: case is not  significant with these comparison functions  -- all
  1822.      uppercase characters are converted to lowercase before the comparison.
  1823.  
  1824. (defstruct name [<comment>] <slot-desc>...)              DEFINE A STRUCTURE
  1825. (defstruct (name <option>...) [<comment>] <slot-desc>...)
  1826.      fsubr
  1827.      <name>              the structure name symbol (quoted)
  1828.      <option>            option description (quoted)
  1829.      <comment>           comment string (ignored)
  1830.      <slot-desc>         slot descriptions (quoted)
  1831.      returns             the structure name
  1832. The recognized options are:
  1833.      (:conc-name name)
  1834.      (:include name [<slot-desc>...])
  1835.      (:print-function <function>)
  1836. Note that if :CONC-NAME appears, it should be before :INCLUDE.
  1837. Each slot description takes the form:
  1838.      <name>
  1839. or
  1840.      (<name> <defexpr>)
  1841. If the default initialization expression is not specified, the slot will be
  1842. initialized  to NIL  if  no keyword  argument  is  passed to  the  creation
  1843. function.
  1844. The  optional  :PRINT-FUNCTION  overrides  the  default  #S  notation.  The
  1845. function must take three arguments, the structure instance, the stream, and
  1846. the current printing depth.
  1847. DEFSTRUCT  causes access functions to be created  for each of the slots and
  1848. also arranges that SETF will work  with those access functions. The  access
  1849. function  names are constructed by  taking the structure  name, appending a
  1850. '-' and then appending  the slot name. This can be  overridden by using the
  1851. :CONC-NAME option.
  1852. DEFSTRUCT also  makes a creation function called  MAKE-<structname>, a copy
  1853. function  called  COPY-<structname>   and  a   predicate  function   called
  1854. <structname>-P. The creation  function takes keyword arguments  for each of
  1855. the slots. Structures can be created using the #S( read macro, as well.
  1856. The  property  *struct-slots*  is  added  to  the  symbol  that  names  the
  1857. structure. This property  consists of an association list of slot names and
  1858. closures  that evaluate  to the  initial values  (NIL if  no initial  value
  1859. expression).
  1860.  
  1861. (send <object> <message> [<args>...])                        SEND A MESSAGE
  1862.      <object>  the object to receive the message
  1863.      <message> message sent to object
  1864.      <args>    arguments to method (if any)
  1865.      returns   the result of the method
  1866.  
  1867. (send-super <message> [<args>])                SEND A MESSAGE TO SUPERCLASS
  1868.      valid only in method context
  1869.      <message> message sent to method's superclass
  1870.      <args>    arguments to method (if any)
  1871.      returns   the result of the method
  1872.  
  1873. (defclass <sym> <ivars> [<cvars> [<super>]])             DEFINE A NEW CLASS
  1874.      defined in class.lsp as a macro
  1875.      <sym>     symbol  whose value  is  to be  bound  to the  class  object
  1876.                (quoted)
  1877.      <ivars>   list  of instance  variables  (quoted).  Instance  variables
  1878.                specified  either as  <ivar> or  (<ivar> <init>)  to specify
  1879.                non-NIL default initial value.
  1880.      <cvars>   list of class variables (quoted)
  1881.      <super>   superclass, or Object if absent.
  1882.      This function  sends :SET-PNAME  (defined in  classes.lsp) to  the new
  1883.      class to set the class' print name instance variable.
  1884.      Methods defined for classes defined with defclass:
  1885.      (send <object> :<ivar>)
  1886.                Returns the specified instance variable
  1887.      (send <object> :SET-IVAR <ivar> <value>)
  1888.                Used  to set an  instance variable, typically  with setf via
  1889.                (setf (send <object> :<ivar>) <value>).
  1890.      (send <sym> :NEW {:<ivar> <init>})
  1891.                Actually  definition   for   :ISNEW.  Creates   new   object
  1892.                initializing  instance variables  as  specified  in  keyword
  1893.                arguments,  or  to  their  default if  keyword  argument  is
  1894.                missing. Returns the object.
  1895.      returns   the new class object
  1896.  
  1897. (defmethod <class> <sym> <fargs> <expr> ...)            DEFINE A NEW METHOD
  1898.      defined in class.lsp as a macro
  1899.      <class>   Class which will respond to message
  1900.      <sym>     Message name (quoted)
  1901.      <fargs>   Formal argument list. Leading "self" is implied (quoted)
  1902.      <expr>    Expressions constituting body of method (quoted)
  1903.      returns   the class object.
  1904.  
  1905. (definst <class> <sym> [<args>...])            DEFINE A NEW GLOBAL INSTANCE
  1906.      defined in class.lsp as a macro
  1907.      <class>   Class of new object
  1908.      <sym>     Symbol whose value will be set to new object
  1909.      <args>    Arguments  passed  to  :NEW  (typically initial  values  for
  1910.                instance variables)
  1911.      returns   the new object
  1912.  
  1913. (atom <expr>)                                              IS THIS AN ATOM?
  1914.      <expr>    the expression to check
  1915.      returns   t if the value is an atom, NIL otherwise
  1916.  
  1917. (symbolp <expr>)                                          IS THIS A SYMBOL?
  1918.      <expr>    the expression to check
  1919.      returns   t if the expression is a symbol, NIL otherwise
  1920.  
  1921. (numberp <expr>)                                          IS THIS A NUMBER?
  1922.      <expr>    the expression to check
  1923.      returns   t if the expression is a number, NIL otherwise
  1924.  
  1925. (null <expr>)                                        IS THIS AN EMPTY LIST?
  1926.      <expr>    the list to check
  1927.      returns   t if the list is empty, NIL otherwise
  1928.  
  1929. (not <expr>)                                                 IS THIS FALSE?
  1930.      <expr>    the expression to check
  1931.      return    t if the value is NIL, NIL otherwise
  1932.  
  1933. (listp <expr>)                                              IS THIS A LIST?
  1934.      <expr>    the expression to check
  1935.      returns   t if the value is a cons or NIL, NIL otherwise
  1936.  
  1937. (endp <list>)                                    IS THIS THE END OF A LIST?
  1938.      <list>    the list
  1939.      returns   t if the value is NIL, NIL otherwise
  1940.  
  1941. (consp <expr>)                                    IS THIS A NON-EMPTY LIST?
  1942.      <expr>    the expression to check
  1943.      returns   t if the value is a cons, NIL otherwise
  1944.  
  1945. (constantp <expr>)                                      IS THIS A CONSTANT?
  1946.      <expr>    the expression to check
  1947.      returns   t if the value  is a constant (basically, would  EVAL <expr>
  1948.                repeatedly return the same thing?), NIL otherwise.
  1949.  
  1950. (specialp <expr>)                                 IS THIS A SPECIAL SYMBOL?
  1951.      <expr>    the expression to check
  1952.      returns   t if the value is a symbol which is SPECIAL, NIL otherwise.
  1953.  
  1954. (integerp <expr>)                                       IS THIS AN INTEGER?
  1955.      <expr>    the expression to check
  1956.      returns   t if the value is an integer, NIL otherwise
  1957.  
  1958. (floatp <expr>)                                            IS THIS A FLOAT?
  1959.      <expr>    the expression to check
  1960.      returns   t if the value is a float, NIL otherwise
  1961.  
  1962. (rationalp <expr>)                               IS THIS A RATIONAL NUMBER?
  1963.      Part of bignum extension.
  1964.      <expr>    the expression to check
  1965.      returns   t if the value is rational (integer or ratio), NIL otherwise
  1966.  
  1967. (realp <expr>)                                       IS THIS A REAL NUMBER?
  1968.      Defined in common2.lsp
  1969.      <expr>    the expression to check
  1970.      returns   t if the value is rational or float, NIL otherwise
  1971.  
  1972. (complexp <expr>)                                 IS THIS A COMPLEX NUMBER?
  1973.      Part of math extension.
  1974.      <expr>    the expression to check
  1975.      returns   t if the value is a complex number, NIL otherwise
  1976.  
  1977. (stringp <expr>)                                          IS THIS A STRING?
  1978.      <expr>    the expression to check
  1979.      returns   t if the value is a string, NIL otherwise
  1980.  
  1981. (characterp <expr>)                                    IS THIS A CHARACTER?
  1982.      <expr>    the expression to check
  1983.      returns   t if the value is a character, NIL otherwise
  1984.  
  1985. (arrayp <expr>)                                           IS THIS AN ARRAY?
  1986.      <expr>    the expression to check
  1987.      returns   t if the value is an array, NIL otherwise
  1988.  
  1989. (array-in-bounds-p <expr> <index>)                IS ARRAY INDEX IN BOUNDS?
  1990.      Defined in common2.lsp
  1991.      <expr>    the array
  1992.      <index>   index to check
  1993.      returns   t if index is in bounds for the array, NIL otherwise
  1994.  
  1995. (streamp <expr>)                                          IS THIS A STREAM?
  1996.      <expr>    the expression to check
  1997.      returns   t if the value is a stream, NIL otherwise
  1998.  
  1999. (open-stream-p <stream>)                                    IS STREAM OPEN?
  2000.      <stream>  the stream
  2001.      returns   t if the stream is open, NIL otherwise
  2002.  
  2003. (input-stream-p <stream>)                               IS STREAM READABLE?
  2004.      <stream>  the stream
  2005.      returns   t if stream is readable, NIL otherwise
  2006.  
  2007. (output-stream-p <stream>)                              IS STREAM WRITABLE?
  2008.      <stream>  the stream
  2009.      returns   t if stream is writable, NIL otherwise
  2010.  
  2011. (objectp <expr>)                                         IS THIS AN OBJECT?
  2012.      <expr>    the expression to check
  2013.      returns   t if the value is an object, NIL otherwise
  2014.  
  2015. (classp <expr>)                                     IS THIS A CLASS OBJECT?
  2016.      <expr>    the expression to check
  2017.      returns   t if the value is a class object, NIL otherwise
  2018.  
  2019. (hash-table-p <expr>)                                 IS THIS A HASH TABLE?
  2020.      Defined in common2.lsp
  2021.      <expr>    the expression to check
  2022.      returns   t if the value is a hash table, NIL otherwise
  2023.  
  2024. (keywordp <expr>)                                        IS THIS A KEYWORD?
  2025.      Defined in common2.lsp
  2026.      <expr>    the expression to check
  2027.      returns   t if the value is a keyword symbol, NIL otherwise
  2028.  
  2029. (packagep <expr>)                                        IS THIS A PACKAGE?
  2030.      Defined in common2.lsp
  2031.      <expr>    the expression to check
  2032.      returns   t if the value is a package, NIL otherwise
  2033.  
  2034. (boundp <sym>)                             IS A VALUE BOUND TO THIS SYMBOL?
  2035.      <sym>     the symbol
  2036.      returns   t if a value is bound to the symbol, NIL otherwise
  2037.  
  2038. (fboundp <sym>)                 IS A FUNCTIONAL VALUE BOUND TO THIS SYMBOL?
  2039.      <sym>     the symbol
  2040.      returns   t  if a  functional  value  is  bound  to  the  symbol,  NIL
  2041.                otherwise
  2042.  
  2043. (functionp <sym>)                                       IS THIS A FUNCTION?
  2044.      Defined in common.lsp
  2045.      <expr>    the expression to check
  2046.      returns   t if the value is a  function -- that is, can it be  applied
  2047.                to arguments. This is  true for any symbol (even  those with
  2048.                no function binding), list with car being lambda, a closure,
  2049.                or subr. Otherwise returns NIL.
  2050.  
  2051. (minusp <expr>)                                    IS THIS NUMBER NEGATIVE?
  2052.      <expr>    the number to test
  2053.      returns   t if the number is negative, NIL otherwise
  2054.  
  2055. (zerop <expr>)                                         IS THIS NUMBER ZERO?
  2056.      <expr>    the number to test
  2057.      returns   t if the number is zero, NIL otherwise
  2058.  
  2059. (plusp <expr>)                                     IS THIS NUMBER POSITIVE?
  2060.      <expr>    the number to test
  2061.      returns   t if the number is positive, NIL otherwise
  2062.  
  2063. (evenp <expr>)                                        IS THIS INTEGER EVEN?
  2064.      <expr>    the integer to test
  2065.      returns   t if the integer is even, NIL otherwise
  2066.  
  2067. (oddp <expr>)                                          IS THIS INTEGER ODD?
  2068.      <expr>    the integer to test
  2069.      returns   t if the integer is odd, NIL otherwise
  2070.  
  2071. (subsetp <list1> <list2> &key :test :test-not :key)        IS SET A SUBSET?
  2072.      <list1>   the first list
  2073.      <list2>   the second list
  2074.      :test     test function (defaults to eql)
  2075.      :test-not test function (sense inverted)
  2076.      :key      function to  apply to  test function arguments  (defaults to
  2077.                identity)
  2078.      returns   t if every element of the  first list is in the second list,
  2079.                NIL otherwise
  2080.  
  2081. (eq <expr1> <expr2>)                             ARE THE EXPRESSIONS EQUAL?
  2082. (eql <expr1> <expr2>)
  2083. (equal <expr1> <expr2>)
  2084. (equalp <expr1> <expr2>)
  2085.      equalp defined in common.lsp
  2086.      <expr1>   the first expression
  2087.      <expr2>   the second expression
  2088.      returns   t  if  equal,  NIL  otherwise. Each  is  progressively  more
  2089.                liberal in what is "equal":
  2090.                eq: identical  pointers --  works with characters,  symbols,
  2091.                          and arbitrarily small integers
  2092.                eql: works  with all numbers,  if same type
  2093.                equal: lists and strings
  2094.                equalp: case insensitive  characters (and strings),  numbers
  2095.                          of differing types, arrays (which can be equalp to
  2096.                          string containing same elements)
  2097.  
  2098. (typep <expr> <type>)                             IS THIS A SPECIFIED TYPE?
  2099.      <expr>    the expression to test
  2100.      <type>    the  type specifier.  Symbols  can either  be  one of  those
  2101.                listed under type-of or one of:
  2102.                ATOM      any atom
  2103.                NULL      NIL
  2104.                LIST      matches NIL or any cons cell
  2105.                STREAM    any stream
  2106.                NUMBER    any numeric type
  2107.                REAL      flonum or rational number
  2108.                INTEGER   fixnum or bignum
  2109.                RATIONAL  fixnum or ratio
  2110.                STRUCT    any structure (except hash-table)
  2111.                FUNCTION  any function, as defined by functionp
  2112.                The specifer can  also be a form (which can  be nested). All
  2113.                form elements are quoted. Valid form cars:
  2114.                or        any of the cdr type specifiers must be true
  2115.                and       all of the cdr type specifiers must be true
  2116.                not       the single cdr type specifier must be false
  2117.                satisfies the result  of applying the cdr predicate function
  2118.                          to <expr>
  2119.                member    <expr> must be eql to one of the cdr values
  2120.                object    <expr> must  be an  object, of class  specified by
  2121.                          the single  cdr  value. The  cdr  value can  be  a
  2122.                          symbol which must evaluate to a class.
  2123.                Note that  everything is of type  T, and nothing is  of type
  2124.                NIL.
  2125.      returns   t if <expr> is of type <type>, NIL otherwise.
  2126.  
  2127. (cond <pair>...)                                     EVALUATE CONDITIONALLY
  2128.      fsubr
  2129.      <pair>    pair consisting of:
  2130.                (<pred> <expr>...)
  2131.                where
  2132.                <pred>    is a predicate expression
  2133.                <expr>    evaluated if the predicate is not NIL
  2134.      returns   the value of the first expression whose predicate is not NIL
  2135.  
  2136. (and <expr>...)                    THE LOGICAL AND OF A LIST OF EXPRESSIONS
  2137.      fsubr
  2138.      <expr>    the expressions to be ANDed
  2139.      returns   NIL if any  expression evaluates to NIL, otherwise the value
  2140.                of  the last  expression  (evaluation  of expressions  stops
  2141.                after the first expression that evaluates to NIL)
  2142.  
  2143. (or <expr>...)                      THE LOGICAL OR OF A LIST OF EXPRESSIONS
  2144.      fsubr
  2145.      <expr>    the expressions to be ORed
  2146.      returns   NIL if all expressions evaluate to NIL, otherwise  the value
  2147.                of the  first non-NIL expression (evaluation  of expressions
  2148.                stops  after the first expression  that does not evaluate to
  2149.                NIL)
  2150.  
  2151. (if <texpr> <expr1> [<expr2>])           EVALUATE EXPRESSIONS CONDITIONALLY
  2152.      fsubr
  2153.      <texpr>   the test expression
  2154.      <expr1>   the expression to be evaluated if texpr is non-NIL
  2155.      <expr2>   the expression to be evaluated if texpr is NIL
  2156.      returns   the value of the selected expression
  2157.  
  2158. (when <texpr> <expr>...)             EVALUATE ONLY WHEN A CONDITION IS TRUE
  2159.      fsubr
  2160.      <texpr>   the test expression
  2161.      <expr>    the expression(s) to be evaluted if texpr is non-NIL
  2162.      returns   the value of the last expression or NIL
  2163.  
  2164. (unless <texpr> <expr>...)          EVALUATE ONLY WHEN A CONDITION IS FALSE
  2165.      fsubr
  2166.      <texpr>   the test expression
  2167.      <expr>    the expression(s) to be evaluated if texpr is NIL
  2168.      returns   the value of the last expression or NIL
  2169.  
  2170. (case <expr> <case>...[(t <expr>)])                          SELECT BY CASE
  2171.      fsubr
  2172.      <expr>    the selection expression
  2173.      <case>    pair consisting of:
  2174.                (<value> <expr>...)
  2175.                where:
  2176.                <value>   is a  single expression  or a list  of expressions
  2177.                          (unevaluated)
  2178.                <expr>    are expressions to execute if the case matches
  2179.      (t <expr>)          default case (no previous matching)
  2180.      returns   the value of the last expression of the matching case
  2181.  
  2182. (typecase <expr> <case>...[(t <expr>)])                      SELECT BY TYPE
  2183.      macro defined in common2.lsp
  2184.      <expr>    the selection expression
  2185.      <case>    pair consisting of:
  2186.                (<type> <expr>...)
  2187.                where:
  2188.                <type>    type specifier as in function TYPEP
  2189.                <expr>    are expressions to execute if the case matches
  2190.      (t <expr>)          default case (no previous matching)
  2191.      returns   the value of the last expression of the matching case
  2192.  
  2193. (let (<binding>...) <expr>...)                        CREATE LOCAL BINDINGS
  2194. (let* (<binding>...) <expr>...)                 LET WITH SEQUENTIAL BINDING
  2195.      fsubr
  2196.      <binding> the variable bindings each of which is either:
  2197.                1)        a symbol (which is initialized to NIL)
  2198.                2)        a  list whose car is a symbol and whose cadr is an
  2199.                          initialization expression
  2200.      <expr>    the expressions to be evaluated
  2201.      returns   the value of the last expression
  2202.  
  2203. (flet (<binding>...) <expr>...)                      CREATE LOCAL FUNCTIONS
  2204. (labels (<binding>...) <expr>...)             FLET WITH RECURSIVE FUNCTIONS
  2205. (macrolet (<binding>...) <expr>...)                     CREATE LOCAL MACROS
  2206.      fsubr
  2207.      <binding> the function bindings each of which is:
  2208.                (<sym> <fargs> <expr>...)
  2209.                where:
  2210.                <sym>     the function/macro name
  2211.                <fargs>   formal argument list (lambda list)
  2212.                <expr>    expressions   constituting   the   body   of   the
  2213.                          function/macro
  2214.      <expr>    the expressions to be evaluated
  2215.      returns   the value of the last expression
  2216.  
  2217. (catch <sym> <expr>...)               EVALUATE EXPRESSIONS AND CATCH THROWS
  2218.      fsubr
  2219.      <sym>     the catch tag
  2220.      <expr>    expressions to evaluate
  2221.      returns   the value of the last expression or the throw expression
  2222.  
  2223. (throw <sym> [<expr>])                                     THROW TO A CATCH
  2224.      fsubr
  2225.      <sym>     the catch tag
  2226.      <expr>    the value for the catch to return (defaults to NIL)
  2227.      returns   never returns
  2228.  
  2229. (unwind-protect <expr> <cexpr>...)      PROTECT EVALUATION OF AN EXPRESSION
  2230.      fsubr
  2231.      <expr>    the expression to protect
  2232.      <cexpr>   the cleanup expressions
  2233.      returns   the value of the expression
  2234.      Note:   unwind-protect guarantees  to execute the  cleanup expressions
  2235.      even  if a non-local exit  terminates the evaluation  of the protected
  2236.      expression
  2237.  
  2238. (loop <expr>...)                                         BASIC LOOPING FORM
  2239.      fsubr
  2240.      <expr>    the body of the loop
  2241.      returns   never returns (must use non-local exit, such as RETURN)
  2242.  
  2243. (do (<binding>...) (<texpr> <rexpr>...) <expr>...)     GENERAL LOOPING FORM
  2244. (do* (<binding>...) (<texpr> <rexpr>...) <expr>...)
  2245.      fsubr. do binds simultaneously, do* binds sequentially
  2246.      <binding> the variable bindings each of which is either:
  2247.                1)        a symbol (which is initialized to NIL)
  2248.                2)        a list of the form: (<sym> <init> [<step>])
  2249.                where:
  2250.                          <sym>     is the symbol to bind
  2251.                          <init>    the initial value of the symbol
  2252.                          <step>    a step expression
  2253.      <texpr>   the termination test expression
  2254.      <rexpr>   result expressions (the default is NIL)
  2255.      <expr>    the body of the loop (treated like an implicit prog)
  2256.      returns   the value of the last result expression
  2257.  
  2258. (dolist (<sym> <expr> [<rexpr>]) <expr>...)             LOOP THROUGH A LIST
  2259.      fsubr
  2260.      <sym>     the symbol to bind to each list element
  2261.      <expr>    the list expression
  2262.      <rexpr>   the result expression (the default is NIL)
  2263.      <expr>    the body of the loop (treated like an implicit prog)
  2264.      returns   the result expression
  2265.  
  2266. (dotimes (<sym> <expr> [<rexpr>]) <expr>...)          LOOP FROM ZERO TO N-1
  2267.      fsubr
  2268.      <sym>     the symbol to bind to each value from 0 to n-1
  2269.      <expr>    the number of times to loop (a fixnum)
  2270.      <rexpr>   the result expression (the default is NIL)
  2271.      <expr>    the body of the loop (treated like an implicit prog)
  2272.      returns   the result expression
  2273.  
  2274. (prog (<binding>...) <expr>...)                         THE PROGRAM FEATURE
  2275. (prog* (<binding>...) <expr>...)               PROG WITH SEQUENTIAL BINDING
  2276.      fsubr -- equivalent to (let () (block NIL (tagbody ...)))
  2277.      <binding> the variable bindings each of which is either:
  2278.                1)        a symbol (which is initialized to NIL)
  2279.                2)        a list whose car is a  symbol and whose cadr is an
  2280.                          initialization expression
  2281.      <expr>    expressions to evaluate or tags (symbols)
  2282.      returns   NIL or the argument passed to the return function
  2283.  
  2284. (block <name> <expr>...)                                        NAMED BLOCK
  2285.      fsubr
  2286.      <name>    the block name (quoted symbol)
  2287.      <expr>    the block body
  2288.      returns   the value of the last expression
  2289.  
  2290. (return [<expr>])                  CAUSE A PROG CONSTRUCT TO RETURN A VALUE
  2291.      fsubr
  2292.      <expr>    the value (defaults to NIL)
  2293.      returns   never returns
  2294.  
  2295. (return-from <name> [<value>])        RETURN FROM A NAMED BLOCK OR FUNCTION
  2296.      fsubr.  In traditional  Xlisp,  the names  are  dynamically scoped.  A
  2297.      compilation option (default) uses lexical scoping like Common Lisp.
  2298.      <name>    the  block or function name (quoted symbol). If name is NIL,
  2299.                use function RETURN.
  2300.      <value>   the value to return (defaults to NIL)
  2301.      returns   never returns
  2302.  
  2303. (tagbody <expr>...)                                       BLOCK WITH LABELS
  2304.      fsubr
  2305.      <expr>    expression(s) to evaluate or tags (symbols)
  2306.      returns   NIL
  2307.  
  2308. (go <sym>)                                     GO TO A TAG WITHIN A TAGBODY
  2309.      fsubr.  In   traditional  Xlisp,   tags  are  dynamically   scoped.  A
  2310.      compilation option (default) uses lexical scoping like Common Lisp.
  2311.      <sym>     the tag (quoted)
  2312.      returns   never returns
  2313.  
  2314. (progv <slist> <vlist> <expr>...)                  DYNAMICALLY BIND SYMBOLS
  2315.      fsubr
  2316.      <slist>   list of symbols (evaluated)
  2317.      <vlist>   list of values to bind to the symbols (evaluated)
  2318.      <expr>    expression(s) to evaluate
  2319.      returns   the value of the last expression
  2320.  
  2321. (prog1 <expr1> <expr>...)                  EXECUTE EXPRESSIONS SEQUENTIALLY
  2322.      fsubr
  2323.      <expr1>   the first expression to evaluate
  2324.      <expr>    the remaining expressions to evaluate
  2325.      returns   the value of the first expression
  2326.  
  2327. (prog2 <expr1> <expr2> <expr>...)          EXECUTE EXPRESSIONS SEQUENTIALLY
  2328.      fsubr
  2329.      <expr1>   the first expression to evaluate
  2330.      <expr2>   the second expression to evaluate
  2331.      <expr>    the remaining expressions to evaluate
  2332.      returns   the value of the second expression
  2333.  
  2334. (progn <expr>...)                          EXECUTE EXPRESSIONS SEQUENTIALLY
  2335.      fsubr
  2336.      <expr>    the expressions to evaluate
  2337.      returns   the value of the last expression (or NIL)
  2338.  
  2339. (read [<stream> [<eofp> [<eof> [<rflag>]]]])             READ AN EXPRESSION
  2340.      NOTE:  there has been an  incompatible change in  arguments from prior
  2341.      versions.
  2342.      <stream>  the input stream (default, or NIL, is *standard-input*, T is
  2343.                *terminal-io*)
  2344.      <eofp>    When T,  signal an  error on end  of file,  when NIL  return
  2345.                <eof> (default is T)
  2346.      <eof>     the value to return on end of file (default is NIL)
  2347.      <rflag>   recursive read flag. The value is ignored
  2348.      returns   the expression read
  2349.  
  2350. (set-macro-character <ch> <fcn> [ T ])                    MODIFY READ TABLE
  2351.      defined in init.lsp
  2352.      <ch>      character to define
  2353.      <fcn>     function to bind to character
  2354.      T         if TMACRO rather than NMACRO
  2355.  
  2356. (get-macro-character <ch>)                               EXAMINE READ TABLE
  2357.      defined in init.lsp
  2358.      <ch>      character
  2359.      returns   function bound to character
  2360.  
  2361. (print <expr> [<stream>])                 PRINT AN EXPRESSION ON A NEW LINE
  2362.      The expression is printed using prin1, then current line is terminated
  2363.      (Note: this is backwards from Common Lisp).
  2364.      <expr>    the expression to be printed
  2365.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2366.                is *terminal-io*)
  2367.      returns   the expression
  2368.  
  2369. (prin1 <expr> [<stream>])                               PRINT AN EXPRESSION
  2370.      symbols, cons cells (without circularities), arrays, strings, numbers,
  2371.      and characters are  printed in  a format generally  acceptable to  the
  2372.      read  function.  Printing  format  can  be   affected  by  the  global
  2373.      formatting variables: *print-level* and  *print-length* for lists  and
  2374.      arrays,  *print-base*  for  rationals,  *integer-format*  for fixnums,
  2375.      *float-format*   for   flonums,   *ratio-format*   for   ratios,   and
  2376.      *print-case* and *readtable-case* for symbols.
  2377.      <expr>    the expression to be printed
  2378.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2379.                is *terminal-io*)
  2380.      returns   the expression
  2381.  
  2382. (princ <expr> [<stream>])               PRINT AN EXPRESSION WITHOUT QUOTING
  2383.      Like  PRIN1  except  symbols  (including  uninterned),  strings,   and
  2384.      characters are printed without using any quoting mechanisms.
  2385.      <expr>    the expressions to be printed
  2386.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2387.                is *terminal-io*)
  2388.      returns   the expression
  2389.  
  2390. (pprint <expr> [<stream>])                       PRETTY PRINT AN EXPRESSION
  2391.      Uses prin1 for printing.
  2392.      <expr>    the expressions to be printed
  2393.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2394.                is *terminal-io*)
  2395.      returns   the expression
  2396.  
  2397. (terpri [<stream>])                        TERMINATE THE CURRENT PRINT LINE
  2398.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2399.                is *terminal-io*)
  2400.      returns   NIL
  2401.  
  2402. (fresh-line [<stream>])                                    START A NEW LINE
  2403.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2404.                is *terminal-io*)
  2405.      returns   t if  a new list was started, NIL if already at the start of
  2406.                a line.
  2407.  
  2408. (flatsize <expr>)              LENGTH OF PRINTED REPRESENTATION USING PRIN1
  2409.      <expr>    the expression
  2410.      returns   the length
  2411.  
  2412. (flatc <expr>)                 LENGTH OF PRINTED REPRESENTATION USING PRINC
  2413.      <expr>    the expression
  2414.      returns   the length
  2415.  
  2416. (y-or-n-p [<fmt> [<arg>...]])                      ASK A YES OR NO QUESTION
  2417. (yes-or-no-p [<fmt> [<arg>...]])
  2418.      defined  in common.lsp.  Uses  *terminal-io* stream  for  interaction.
  2419.      y-or-n-p  strives for  a  single character  answer,  using get-key  if
  2420.      defined.
  2421.      <fmt>     optional format string for question
  2422.      <arg>     arguments, if any, for format string
  2423.      returns   T for yes, NIL for no.
  2424.  
  2425. (prin1-to-string <expr>)                                  PRINT TO A STRING
  2426. (princ-to-string <expr>)
  2427.      defined in common2.lsp. Uses prin1 or princ conventions, respectively.
  2428.      <expr>    the expression to print
  2429.      returns   the string containing the "printed" expression
  2430.  
  2431. (read-from-string <str> [<eofp> [<eof>]] &key :start :end)
  2432.                                                          READ AN EXPRESSION
  2433.      defined in common2.lsp.
  2434.      <str>     the input string
  2435.      <eofp>    When  T, signal an  error on end of  string, when NIL return
  2436.                <eof> (default is T)
  2437.      <eof>     the value to return on end of string (default is NIL)
  2438.      :start    starting index of <str>, default 0
  2439.      :end      ending index of <str>, default NIL (end of string)
  2440.      returns   two values: the expression read and index of character after
  2441.                last one used
  2442.  
  2443. (format <stream> <fmt> [<arg>...])                      DO FORMATTED OUTPUT
  2444.      <stream>  the output stream (T is *standard-output*)
  2445.      <fmt>     the format string
  2446.      <arg>     the format arguments
  2447.      returns   output string if <stream> is NIL, NIL otherwise
  2448. The format string can contain characters that  should be copied directly to
  2449. the output and formatting directives. The formatting directives are:
  2450.      ~?        use next argument as recursive format string
  2451.      ~( ~)     process format string with case conversion
  2452.      ~{ ~}     process format string repetitively
  2453.      ~*        skip arguments
  2454.      ~%        start a new line
  2455.      ~&        start a new line if not on a new line
  2456.      ~\n       ignore return and following whitespace
  2457.      ~|        start a new page
  2458.      ~~        print a tilde character
  2459.      ~A or ~a  print next argument using princ
  2460.      ~B or ~b  print next argument as binary integer (bignum extension)
  2461.      ~D or ~d  print next argument as decimal integer
  2462.      ~E or ~e  print next argument in exponential form
  2463.      ~F or ~f  print next argument in fixed point form
  2464.      ~G or ~g  print next  argument  using either  ~E  or ~F  depending  on
  2465.                magnitude
  2466.      ~O or ~o  print next argument as octal integer
  2467.      ~R or ~r  print next number in any radix (bignum extension)
  2468.      ~S or ~s  print next argument using prin1
  2469.      ~T or ~t  go to a specified column
  2470.      ~X or ~x  print next argument as hexidecimal integer
  2471.      ~[ ~; ~]  process format string conditionally
  2472.  
  2473. (read-char [<stream>[<eofp>[<eof>]]])        READ A CHARACTER FROM A STREAM
  2474.      NOTE: New eof arguments are incompatible with older XLISP versions.
  2475.      <stream>  the input stream (default, or NIL, is *standard-input*, T is
  2476.                *terminal-io*)
  2477.      <eofp>    When  T, signal  an error  on end  of file, when  NIL return
  2478.                <eof> (default is T)
  2479.      <eof>     the value to return on end of file (default is NIL)
  2480.      returns   the character or <eof> at end of file
  2481.  
  2482. (peek-char [<flag> [<stream> [<eofp> [<eof>]]]])  
  2483.                                                  PEEK AT THE NEXT CHARACTER
  2484.      <flag>    flag for skipping white space (default is NIL)
  2485.      <stream>  the input stream (default, or NIL, is *standard-input*, T is
  2486.                *terminal-io*)
  2487.      <eofp>    When  T, signal  an error  on end of  file, when  NIL return
  2488.                <eof> (default is T)
  2489.      <eof>     the value to return on end of file (default is NIL)
  2490.      returns   the character or <eof> at end of file
  2491.  
  2492. (write-char <ch> [<stream>])                  WRITE A CHARACTER TO A STREAM
  2493.      <ch>      the character to write
  2494.      <stream>  the output stream (default,  or NIL, is *standard-output*, T
  2495.                is *terminal-io*)
  2496.      returns   the character
  2497.  
  2498. (read-line [<stream>[<eofp>[<eof>]]])             READ A LINE FROM A STREAM
  2499.      NOTE: New eof arguments are incompatible with older XLISP versions.
  2500.      <stream>  the input stream (default, or NIL, is *standard-input*, T is
  2501.                *terminal-io*)
  2502.      <eofp>    When  T, signal an  error on  end of  file, when  NIL return
  2503.                <eof> (default is T)
  2504.      <eof>     the value to return on end of file (default is NIL)
  2505.      returns   the string excluding the #\newline, or <eof> at end of file
  2506.  
  2507. (open <fname> &key :direction :element-type :if-exists :if-does-not-exist)
  2508.                                                          OPEN A FILE STREAM
  2509.      The function OPEN has been significantly enhanced over original XLISP.
  2510.      The original function only had the  :direction keyword argument, which
  2511.      could only  have  the values  :input or  :output. When  used with  the
  2512.      :output keyword, it was equivalent to (open <fname> :direction :output
  2513.      :if-exists :supersede). A maximum of ten files can be open  at any one
  2514.      time, including any files open via the LOAD, DRIBBLE, SAVE and RESTORE
  2515.      commands. The open command  may force a garbage collection  to reclaim
  2516.      file slots used by unbound file streams. 
  2517.  
  2518.      <fname>        the file  name string,  symbol, or file  stream created
  2519.                     via OPEN. In the last case, the name is used  to open a
  2520.                     second stream  on  the  same  file --  this  can  cause
  2521.                     problems if one or more streams is used for writing.
  2522.      :direction     Read  and  write  permission  for  stream  (default  is
  2523.                     :input).
  2524.        :input       Open file for read operations only.
  2525.        :probe       Open file for reading,  then close it (use to  test for
  2526.                     file existance)
  2527.        :output      Open file for write operations only.
  2528.        :io          Like :output, but reading also allowed.
  2529.      :element-type  FIXNUM or CHARACTER (default is CHARACTER), as returned
  2530.                     by  type-of function, or  UNSIGNED-BYTE,
  2531.                     SIGNED-BYTE,  (UNSIGNED-BYTE  <size>), or  (SIGNED-BYTE
  2532.                     <size>)  with  the  bignum  extension.  CHARACTER  (the
  2533.                     default)  is for text  files, the  other types  are for
  2534.                     binary files and  can only be  used with READ-BYTE  and
  2535.                     WRITE-BYTE.  FIXNUM is  a vestige  of older  XLISP-PLUS
  2536.                     releases and  is identical to (UNSIGNED-BYTE  8). If no
  2537.                     size is given, then size defaults  to 8. Size must be a
  2538.                     multiple of 8.
  2539.      :if-exists     action  to take  if file  exists. Argument  ignored for
  2540.                     :input (file is positioned at start) or :probe (file is
  2541.                     closed)
  2542.        :error       give error message
  2543.        :rename      rename file  to generated backup name, then  open a new
  2544.                     file of the original name. This is the default action
  2545.        :new-version same as :rename
  2546.        :overwrite   file is positioned to start, original data intact
  2547.        :append      file is positioned to end
  2548.        :supersede   delete original file and open new file of the same name
  2549.        :rename-and-delete  same as :supersede
  2550.        NIL          close file and return NIL
  2551.      :if-does-not-exist    action to take if file does not exist.
  2552.        :error       give error message  (default for :input,  or :overwrite
  2553.                     or :append)
  2554.        :create      create  a new file (default for :output or :io when not
  2555.                     :overwrite or :append)
  2556.        NIL          return NIL (default for :probe)
  2557.      returns        a file stream, or sometimes NIL
  2558.  
  2559. (close <stream>)                                        CLOSE A FILE STREAM
  2560.      The stream becomes a  "closed stream." Note that unbound  file streams
  2561.      are closed automatically during a garbage collection.
  2562.      <stream>  the stream, which may be a string stream
  2563.      returns   t  if stream closed, NIL  if terminal (cannot  be closed) or
  2564.                already closed.
  2565.  
  2566. (probe-file <fname>)                          CHECK FOR EXISTANCE OF A FILE
  2567.      Defined in common2.lsp
  2568.      <fname>   file name string or symbol
  2569.      returns   t if file exists, else NIL
  2570.  
  2571. (delete-file <fname>)                                         DELETE A FILE
  2572.      <fname>   file name string, symbol or a stream opened with OPEN
  2573.      returns   t if  file does not  exist or  is deleted. If  <fname> is  a
  2574.                stream,  the stream is closed before the file is deleted. An
  2575.                error occurs if the file cannot be deleted.
  2576.  
  2577. (truename <fname>)                                OBTAIN THE FILE PATH NAME
  2578.      <fname>   file name string, symbol, or a stream opened with OPEN
  2579.      returns   string  representing the  true file  name (absolute  path to
  2580.      file).
  2581.  
  2582. (with-open-file (<var> <fname> [<karg>...]) [<expr>...])
  2583. (with-open-stream (<var> <stream>) [<expr>...])
  2584.                                             EVALUATE USING AN OPENED STREAM
  2585.      Defined in common.lsp and common2.lsp, respectively, as macros. Stream
  2586.      will always be closed upon completion
  2587.      <var>     symbol name to bind  stream to while evaluating expresssions
  2588.                (quoted)
  2589.      <fname>   file name string or symbol
  2590.      <stream>  a file or string stream
  2591.      <karg>    keyword arguments for the implicit open command
  2592.      <expr>    expressions to evaluate while file is open (implicit progn)
  2593.      returns   value of last <expr>.
  2594.  
  2595. (read-byte <stream>[<eofp>[<eof>]])               READ A BYTE FROM A STREAM
  2596.      NOTE: New  eof arguments are  incompatible with older  XLISP versions.
  2597.      Stream  argument  used to  be optional.  Number  of system  bytes read
  2598.      depend on :element-type specified in the open command.
  2599.      <stream>  the input stream
  2600.      <eofp>    When T, signal  an error  on end  of file,  when NIL  return
  2601.                <eof> (default is T)
  2602.      <eof>     the value to return on end of file (default is NIL)
  2603.      returns   the byte (integer) or <eof> at end of file
  2604.  
  2605. (write-byte <byte> <stream>)                       WRITE A BYTE TO A STREAM
  2606.      NOTE:  Stream argument  used to  be optional.  Number of  system bytes
  2607.      writen depend  on :element-type specified  in open command.  No checks
  2608.      are  made for overflow, however  negative values cannot  be written to
  2609.      unsigned-byte streams.
  2610.      <byte>    the byte to write (integer)
  2611.      <stream>  the output stream
  2612.      returns   the byte (integer)
  2613.  
  2614. (file-length <stream>)                                   GET LENGTH OF FILE
  2615.      For a  CHARACTER file,  the length  reported  may  be larger  than the 
  2616.      number of characters read or written because of CR conversion.
  2617.      <stream>  the file stream (should be disk file)
  2618.      returns   length of file, or NIL if cannot be determined.
  2619.  
  2620. (file-position <stream> [<expr>])                  GET OR SET FILE POSITION
  2621.      For  a CHARACTER file,  the file position  may not be the same  as the 
  2622.      number of characters read or written because of CR conversion. It will
  2623.      be correct when using  file-position to  position a file at a location
  2624.      earlier reported by file-position.
  2625.      <stream>  the file stream (should be a disk file)
  2626.      <expr>    desired  file position,  if  setting position.  Can also  be
  2627.                :start for start of file or :end for end of file.
  2628.      returns   if  setting position,  and  successful, then  T; if  getting
  2629.                position and successful then the position; otherwise NIL
  2630.  
  2631. (make-string-input-stream <str> [<start> [<end>]])
  2632.      <str>     the string
  2633.      <start>   the starting offset
  2634.      <end>     the ending offset + 1 or NIL for end of string
  2635.      returns   an unnamed stream that reads from the string
  2636.  
  2637. (make-string-output-stream)
  2638.      returns   an unnamed output stream
  2639.  
  2640. (get-output-stream-string <stream>)
  2641.      The output stream is emptied by this function
  2642.      <stream>  the output stream
  2643.      returns   the output so far as a string
  2644.  
  2645. (get-output-stream-list <stream>)
  2646.      The output stream is emptied by this function
  2647.      <stream>  the output stream
  2648.      returns   the output so far as a list
  2649.  
  2650. (with-input-from-string (<var> <str> &key :start :end :index) [<expr>...])
  2651.      Defined in common.lsp as a macro
  2652.      <var>     symbol  that   stream  is  bound  to   during  execution  of
  2653.                expressions (quoted)
  2654.      <str>     the string
  2655.      :start    starting offset into string (default 0)
  2656.      :end      ending offset + 1  (default, or NIL, is end of string)
  2657.      :index    setf  place form which  gets final  index into  string after
  2658.                last expression is executed (quoted)
  2659.      <expr>    expressions to evaluate (implicit progn)
  2660.      returns   the value of the last <expr>
  2661.  
  2662. (with-output-to-string (<var>) [<expr>...])
  2663.      Defined in common.lsp as a macro
  2664.      <var>     symbol  that   stream  is  bound  to   during  execution  of
  2665.                expressions (quoted)
  2666.      <expr>    expressions to evaluate (implicit progn)
  2667.      returns   contents of stream, as a string
  2668.  
  2669. (trace [<sym>...])                         ADD A FUNCTION TO THE TRACE LIST
  2670.      fsubr
  2671.      <sym>     the function(s) to add (quoted)
  2672.      returns   the trace list
  2673.  
  2674. (untrace [<sym>...])                  REMOVE A FUNCTION FROM THE TRACE LIST
  2675.      fsubr. If no functions given, all functions are removed from the trace
  2676.      list.
  2677.      <sym>     the function(s) to remove (quoted)
  2678.      returns   the trace list
  2679.  
  2680. (error <emsg> {<arg>})                       SIGNAL A NON-CORRECTABLE ERROR
  2681.      Note  that the definition  of this function has  changed from 2.1e and
  2682.      earlier so to match Common Lisp.
  2683.      <emsg>    the error message string, which is processed by FORMAT
  2684.      <arg>     optional argument{s} for FORMAT 
  2685.      returns   never returns
  2686.  
  2687. (cerror <cmsg> <emsg> {<arg>})                   SIGNAL A CORRECTABLE ERROR
  2688.      Note that the definition  of this function  has changed from 2.1e  and
  2689.      earlier so to match Common Lisp.
  2690.      <cmsg>    the continue message string, which is processed by FORMAT
  2691.      <emsg>    the error message string, which is processed by FORMAT
  2692.      <arg>     optional argument(s) for both FORMATs (arguments are useable
  2693.                twice)
  2694.      returns   NIL when continued from the break loop
  2695.  
  2696. (break <bmsg> {<arg>})                                   ENTER A BREAK LOOP
  2697.      Note that the  definition of this function  has changed from 2.1e  and
  2698.      earlier so to match Common Lisp.
  2699.      <bmsg>    the break message string, which is processed by FORMAT
  2700.      <arg>     optional argument(s) for FORMAT
  2701.      returns   NIL when continued from the break loop
  2702.  
  2703. (clean-up)                                          CLEAN-UP AFTER AN ERROR
  2704.      returns   never returns
  2705.  
  2706. (top-level)             CLEAN-UP AFTER AN ERROR AND RETURN TO THE TOP LEVEL
  2707.      Runs  the function in  variable *top-level-loop*  (ususally TOP-LEVEL-
  2708.      LOOP)
  2709.      returns   never returns
  2710.  
  2711. (continue)                                CONTINUE FROM A CORRECTABLE ERROR
  2712.      returns   never returns
  2713.  
  2714. (errset <expr> [<pflag>])                                       TRAP ERRORS
  2715.      fsubr
  2716.      <expr>    the expression to execute
  2717.      <pflag>   flag to control printing of the error message (default t)
  2718.      returns   the value of  the last expression consed with NIL  or NIL on
  2719.                error
  2720.  
  2721. (baktrace [<n>])                   PRINT N LEVELS OF TRACE BACK INFORMATION
  2722.      <n>       the number of levels (defaults to all levels)
  2723.      returns   NIL
  2724.  
  2725. (evalhook <expr> <ehook> <ahook> [<env>])               EVALUATE WITH HOOKS
  2726.      <expr>    the expression to evaluate.  <ehook> is not used at  the top
  2727.                level.
  2728.      <ehook>   the value for *evalhook*
  2729.      <ahook>   the value for *applyhook*
  2730.      <env>     the  environment (default  is NIL). The  format is  a dotted
  2731.                pair of value (car)  and function (cdr) binding lists.  Each
  2732.                binding  list is a list  of level binding  a-lists, with the
  2733.                innermost a-list  first. The level binding a-list associates
  2734.                the bound symbol with its value.
  2735.      returns   the result of evaluating the expression
  2736.  
  2737. (applyhook <fun> <arglist> <ehook> <ahook>)                APPLY WITH HOOKS
  2738.      <fun>     The function closure. <ahook> is not used  for this function
  2739.                application.
  2740.      <arglist> The list of arguments.
  2741.      <ehook>   the value for *evalhook*
  2742.      <ahook>   the value for *applyhook*
  2743.      returns   the result of applying <fun> to <arglist>
  2744.  
  2745. (debug)                                                 ENABLE DEBUG BREAKS
  2746. (nodebug)                                              DISABLE DEBUG BREAKS
  2747.      Defined in init.lsp
  2748.  
  2749. (ecase <expr> <case>...)                                     SELECT BY CASE
  2750. (ccase <expr> <case>...)
  2751.      Defined  in common2.lsp  as  macros. ECASE  signals a  non-continuable
  2752.      error if there are no case matches,  while CCASE signals a continuable
  2753.      error and allows changing the value of <expr>.
  2754.      <expr>    the selection expression
  2755.      <case>    pair consisting of:
  2756.                (<value> <expr>...)
  2757.                where:
  2758.                <value>   is a  single expression  or a list  of expressions
  2759.                          (unevaluated)
  2760.                <expr>    are expressions to execute if the case matches
  2761.      returns   the value of the last expression of the matching case
  2762.  
  2763. (etypecase <expr> <case>...)                                 SELECT BY TYPE
  2764. (ctypecase <expr> <case>...)
  2765.      Defined in common2.lsp as  macros. ETYPECASE signals a non-continuable
  2766.      error  if there  are  no  case  matches,  while  CTYPECASE  signals  a
  2767.      continuable error and allows changing the value of <expr>.
  2768.      <expr>    the selection expression
  2769.      <case>    pair consisting of:
  2770.                (<type> <expr>...)
  2771.                where:
  2772.                <type>    type specifier as in function TYPEP
  2773.                <expr>    are expressions to execute if the case matches
  2774.      returns   the value of the last expression of the matching case
  2775.  
  2776. (check-type <place> <type> [<string>])                     VERIFY DATA TYPE
  2777.      Defined in common2.lsp  as a macro. If value stored  at <place> is not
  2778.      of  type  <type> then  a continuable  error  is signaled  which allows
  2779.      changing the value at <place>.
  2780.      <place>   a valid field specifier (generalized variable)
  2781.      <type>    a valid type specifier as in function TYPEP
  2782.      <string>  string to print as the error message
  2783.      returns   NIL
  2784.  
  2785. (assert <test> [([<place>...]) [<string> [<args>...]]])   MAKE AN ASSERTION
  2786.      Defined  in common2.lsp. If value of  <test> is NIL then a continuable
  2787.      error is signaled which allows changing the place values.
  2788.      <test>    assertion test
  2789.      <place>   zero or more valid field specifiers
  2790.      <string>  error  message  printed  using  FORMAT  (evaluated  only  if
  2791.                assertion fails)
  2792.      <args>    arguments for FORMAT (evaluated only if assertion fails)
  2793.      returns   NIL
  2794.  
  2795. (load <fname> &key :verbose :print)                      LOAD A SOURCE FILE
  2796.      An  implicit ERRSET exists  in this function  so that  if error occurs
  2797.      during  loading, and *breakenable* is NIL, then the error message will
  2798.      be printed and  NIL will  be returned. The  OS environmental  variable
  2799.      XLPATH is  used as a  search path for  files in this  function. If the
  2800.      filename  does not contain path  separators ('/' for  UNIX, and either
  2801.      '/' or  '\' for MS-DOS) and  XLPATH is defined, then  each pathname in
  2802.      XLPATH is tried in turn until a matching file is found.  If no file is
  2803.      found,  then one last  attempt is made  in the current  directory. The
  2804.      pathnames are separated by either a space or semicolon, and a trailing
  2805.      path separator character is optional.
  2806.      <fname>   the filename string,  symbol, or a file stream  created with
  2807.                OPEN. The extension "lsp" is assumed.
  2808.      :verbose  the verbose flag (default is t)
  2809.      :print    the print flag (default is NIL)
  2810.      returns   t if successful, else NIL
  2811.  
  2812. (restore <fname>)                             RESTORE WORKSPACE FROM A FILE
  2813.      The OS  environmental variable XLPATH  is used  as a  search path  for
  2814.      files in this function. See the note under function "load", above. The
  2815.      standard  system streams  are  restored to  the  defaults as  of  when
  2816.      XLISP-PLUS  was started. Files streams  are restored in  the same mode
  2817.      they were created, if possible, and  are positioned where they were at
  2818.      the time of the  save. If the files  have been altered or moved  since
  2819.      the time  of the save, the restore  will not be completely successful.
  2820.      Memory  allocation will  not be  the same as  the current  settings of
  2821.      ALLOC are  used. Execution  proceeds at the  top-level read-eval-print
  2822.      loop. The  state of  the transcript  logging is  not affected  by this
  2823.      function.
  2824.      <fname>   the filename string,  symbol, or a file stream  created with
  2825.                OPEN. The extension "wks" is assumed.
  2826.      returns   NIL on failure, otherwise never returns
  2827.  
  2828. (save <fname>)                                     SAVE WORKSPACE TO A FILE
  2829.      You cannot save from within a load.  Not all of the state may be saved
  2830.      -- see "restore", above. By saving a workspace with the  name "xlisp",
  2831.      that  workspace   will  be   loaded  automatically  when   you  invoke
  2832.      XLISP-PLUS.
  2833.      <fname>   the filename string,  symbol, or a file stream  created with
  2834.                OPEN. The extension "wks" is assumed.
  2835.      returns   t if workspace was written, NIL otherwise
  2836.  
  2837. (savefun <fcn>)                                     SAVE FUNCTION TO A FILE
  2838.      defined in init.lsp
  2839.      <fcn>     function name (saves it to file of same name, with extension
  2840.                ".lsp")
  2841.      returns   t if successful
  2842.  
  2843. (dribble [<fname>])            CREATE A FILE WITH A TRANSCRIPT OF A SESSION
  2844.      <fname>   file name string, symbol, or file stream created with OPEN
  2845.                (if missing, close current transcript)
  2846.      returns   t if the transcript is opened, NIL if it is closed
  2847.  
  2848. (gc)                                               FORCE GARBAGE COLLECTION
  2849.      returns   NIL
  2850.  
  2851. (expand [<num>])                           EXPAND MEMORY BY ADDING SEGMENTS
  2852.      <num>     the (fixnum) number of segments to add, default 1
  2853.      returns   the (fixnum) number of segments added
  2854.  
  2855. (alloc <num> [<num2> [<num3]])                          CHANGE SEGMENT SIZE
  2856.      <num>     the (fixnum) number of nodes to allocate
  2857.      <num2>    the (fixnum) number  of pointer elements  to allocate in  an
  2858.                array  segment  (when  dynamic array  allocation  compiled).
  2859.                Default is no change.
  2860.      <num3>    the <fixnum>  ideal ratio  of free  to unused  vector  space
  2861.                (versions of XLISP using dldmem.c).  Default is 1.  Increase
  2862.                if  extensive time is spent in garbage collection  in bignum
  2863.                math intensive programs.
  2864.      returns   the old number of nodes to allocate
  2865.  
  2866. (room)                                    SHOW MEMORY ALLOCATION STATISTICS
  2867.      Statistics (which are sent to *STANDARD-OUTPUT*) include:
  2868.                Nodes - number of nodes, free and used
  2869.                Free nodes - number of free nodes
  2870.                Segments - number of node segments, including those reserved
  2871.                          for characters and small integers.
  2872.                Allocate  -  number of  nodes to  allocate  in any  new node
  2873.                          segments
  2874.                Total  - total  memory  bytes allocated  for node  segments,
  2875.                          arrays, and strings
  2876.                Collections - number of garbage collections
  2877.                Time  -  time  spent  performing   garbage  collections  (in
  2878.                seconds)
  2879.      When dynamic  array allocation  is compiled, the  following additional
  2880.      statistics are printed:
  2881.                Vector  nodes  - total vector space (pointers and strings in
  2882.                          pointer sized units)
  2883.                Vector free - free  space in vector area (may  be fragmented
  2884.                          across segments)
  2885.                Vector  segs  - number  of  vector  segments. Increases  and
  2886.                          decreases as needed.
  2887.                Vec allocate - number of pointer elements to allocate in any
  2888.                          new vector segment
  2889.                Vec collect -  number of garbage  collections instigated  by 
  2890.                          vector space exhaustion
  2891.      returns   NIL
  2892.  
  2893. (time <expr>)                                        MEASURE EXECUTION TIME
  2894.      fsubr.
  2895.      <expr>    the expression to evaluate
  2896.      returns   the result of  the expression. The execution time is printed
  2897.                to *TRACE-OUTPUT*
  2898.  
  2899. (sleep <expr>)                                                   TIME DELAY
  2900.      defined in common2.lsp
  2901.      <expr>    time in seconds
  2902.      returns   NIL, after <expr> seconds delay
  2903.  
  2904. (get-internal-real-time)                             GET ELAPSED CLOCK TIME
  2905. (get-internal-run-time)                          GET ELAPSED EXECUTION TIME
  2906.      returns   integer time in system units.  Meaning of absolute values is 
  2907.                system dependent.
  2908.  
  2909. (coerce <expr> <type>)                  FORCE EXPRESSION TO DESIGNATED TYPE
  2910.      Sequences  can  be  coerced  into other  sequences,  single  character
  2911.      strings or  symbols with  single character  printnames can  be coerced
  2912.      into characters, integers can  be coerced into characters  or flonums.
  2913.      Ratios  can be  coerced  into flonums.  Flonums  can be  coerced  into
  2914.      complex.
  2915.      <expr>    the expression to coerce
  2916.      <type>    desired type, as returned by type-of
  2917.      returns   <expr> if type is correct, or converted object.
  2918.  
  2919. (type-of <expr>)                         RETURNS THE TYPE OF THE EXPRESSION
  2920.      It is recommended that typep  be used instead, as it is  more general.
  2921.      In the original XLISP, the value NIL was returned for NIL.
  2922.      <expr>    the expression to return the type of
  2923.      returns   One of the symbols:
  2924.                LIST                for NIL (lists, conses return CONS)
  2925.                SYMBOL              for symbols
  2926.                OBJECT              for objects
  2927.                CONS                for conses
  2928.                SUBR                for built-in functions
  2929.                FSUBR               for special forms
  2930.                CLOSURE             for defined functions
  2931.                STRING              for strings
  2932.                FIXNUM              for integers
  2933.                BIGNUM              for large integers
  2934.                RATIO               for ratios
  2935.                FLONUM              for floating point numbers
  2936.                COMPLEX             for complex numbers
  2937.                CHARACTER           for characters
  2938.                FILE-STREAM         for file pointers
  2939.                UNNAMED-STREAM      for unnamed streams
  2940.                ARRAY               for arrays
  2941.                HASH-TABLE          for hash tables
  2942.                sym                 for structures of type "sym"
  2943.  
  2944. (peek <addrs>)                                 PEEK AT A LOCATION IN MEMORY
  2945.      <addrs>   the address to peek at (fixnum)
  2946.      returns   the value at the specified address (integer)
  2947.  
  2948. (poke <addrs> <value>)                             POKE A VALUE INTO MEMORY
  2949.      <addrs>   the address to poke (fixnum)
  2950.      <value>   the value to poke into the address (fixnum)
  2951.      returns   the value
  2952.  
  2953. (address-of <expr>)                        GET THE ADDRESS OF AN XLISP NODE
  2954.      <expr>    the node
  2955.      returns   the address of the node (fixnum)
  2956.  
  2957. (get-key)                                     READ A KEYSTROKE FROM CONSOLE
  2958.      OS dependent.
  2959.      returns   integer value of key (no echo)
  2960.  
  2961. (system <command>)                                 EXECUTE A SYSTEM COMMAND
  2962.      OS dependent -- not always available.
  2963.      <command> Command string, if 0 length then spawn OS shell
  2964.      returns   T if successful (note that MS/DOS command.com always returns
  2965.                success)
  2966.  
  2967. (set-stack-mark <size>)                      SET SYSTEM STACK WARNING POINT
  2968.      OS  dependent --  not  always available.  The  system will  perform  a
  2969.      continuable  error when the  amount of  remaining system  stack passes
  2970.      below this setting. The trap is reset  at the top-level. This function
  2971.      is useful for debugging runaway recursive functions.
  2972.      <size>    Remaining stack,  in bytes.  Minimum value  is fixed  at the
  2973.                value that causes the system stack overflow error, while the
  2974.                maximum value is limitied to somewhat less than  the current
  2975.                remaining stack space. Use "0" to turn the warnings off.
  2976.      returns   the previous value.
  2977.  
  2978. (top-level-loop)                                     DEFAULT TOP LEVEL LOOP
  2979.      Runs  the XLISP  top  level read-eval-print  loop, described  earlier.
  2980.      Never returns.
  2981.  
  2982. (reset-system)                                          FLUSH INPUT BUFFERS
  2983.      Used by user-implemented top level loops to flush the input buffer
  2984.      returns   NIL
  2985.  
  2986. (exit)                                                           EXIT XLISP
  2987.      returns   never returns
  2988.  
  2989. (generic <expr>)              CREATE A GENERIC TYPED COPY OF THE EXPRESSION
  2990.      Note: added function, Tom Almy's creation for debugging xlisp.
  2991.      <expr>    the expression to copy
  2992.      returns   NIL if  value is NIL  and NILSYMBOL  compilation option  not
  2993.                declared, otherwise if type is:
  2994.                SYMBOL              copy as an ARRAY
  2995.                OBJECT              copy as an ARRAY
  2996.                CONS                (CONS (CAR <expr>)(CDR <expr>))
  2997.                CLOSURE             copy as an ARRAY
  2998.                STRING              copy of the string
  2999.                FIXNUM              value
  3000.                FLONUM              value
  3001.                RATIO               value
  3002.                CHARACTER           value
  3003.                UNNAMED-STREAM      copy as a CONS
  3004.                ARRAY               copy of the array
  3005.                COMPLEX             copy as an ARRAY
  3006.                HASH-TABLE          copy as an ARRAY
  3007.                BIGNUM              copy as a string
  3008.                structure           copy as an ARRAY
  3009.  
  3010. (eval-when <condition> <body> ...)
  3011.      Macro  defined in common.lsp, and provided to assist in porting Common
  3012.      Lisp applications to XLISP-PLUS.
  3013.      <condition>         List of conditions
  3014.      <body>    expressions which are evaluated if one of the  conditions is
  3015.                EXECUTE or LOAD.
  3016.      returns   result of last body expression
  3017.  
  3018. (cls)                                                         CLEAR DISPLAY
  3019.      Clear the display and position cursor at upper left corner.
  3020.      returns   nil
  3021.  
  3022. (cleol)                                                CLEAR TO END OF LINE
  3023.      Clears current line to end.
  3024.      returns   nil
  3025.  
  3026. (goto-xy [<column> <row>])                       GET OR SET CURSOR POSITION
  3027.      Cursor  is   repositioned   if  optional   arguments  are   specified.
  3028.      Coordinates are clipped to actual size of display.
  3029.      <column>  0-based column (x coordinate)
  3030.      <row>     0-based row (y coordinate)
  3031.      returns   list of original column and row positions
  3032.  
  3033. (mode <ax> [<bx> <width> <height>)                         SET DISPLAY MODE
  3034.      Standard modes require only <ax> argument. Extended modes are  "Super-
  3035.      VGA"  or  "Super-EGA" and  are display  card  specific. Not  all XLISP
  3036.      versions support all modes.
  3037.      <ax>      Graphic mode (value passed in register AX)
  3038.                Common standard Modes:
  3039.                0,1 - 40x25 text
  3040.                2,3 - 80x25 text
  3041.                4,5 - 320x200 4 color graphics (CGA)
  3042.                6 - 640x200 monchrome graphics (CGA)
  3043.                13 - 320x200 16 color graphics (EGA)
  3044.                14 - 640x200 16 color graphics (EGA)
  3045.                16 - 640x350 16 color graphics (EGA)
  3046.                18 - 640x480 16 color graphics (VGA)
  3047.                19 - 320x200 256 color graphics (VGA)
  3048.      <bx>      BX value for some extended graphic modes
  3049.      <width>   width for extended graphic modes
  3050.      <height>  height for extended graphic modes
  3051.      returns   a list  of the  number of columns,  number of  lines (1  for
  3052.                CGA), maximum X graphic coordinate (-1 for text modes),  and
  3053.                the maximum Y graphic coordinate (-1 for text modes), or NIL
  3054.                if fails
  3055.  
  3056. (color <value>)                                           SET DRAWING COLOR
  3057.      <value>   Drawing color (not checked for validity)
  3058.      returns   <value>
  3059.  
  3060. (move <x1> <y1> [<x2> <y2> ...])                              ABSOLUTE MOVE
  3061. (moverel <x1> <y2> [<x2> <y2> ...])                           RELATIVE MOVE
  3062.      For moverel, all coordinates are relative to the preceeding point.
  3063.      <x1> <y1> Moves to point x1,y1 in anticipation of draw.
  3064.      <x2> <y2> Draws to points specified in additional arguments.
  3065.      returns   T if succeeds, else NIL
  3066.  
  3067. (draw [<x1> <y1> ...])                                        ABSOLUTE DRAW
  3068. (drawrel [<x1> <y1> ...])                                     RELATIVE DRAW
  3069.      For drawrel, all coordinates are relative to the preceeding point.
  3070.      <x1> <y1> Point(s) drawn to, in order.
  3071.      returns   T if succeeds, else NIL
  3072.