Complete Linux

home *** CD-ROM | disk | FTP | other *** search

/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / doc / prindoc.out < prev next >

Wrap

Text File | 1986-07-17 | 339.6 KB | 6,595 lines

Kyoto Common Lisp Dictionary Version 01.25 17 JUL 86 by Taiichi Yuasa Masami Hagiya Research Institute for Mathematical Sciences Kyoto University Kyoto 606, Japan (C) Copyright Taiichi Yuasa and Masami Hagiya, 1986 Preface This Dictionary was produced from the on-line documentation of Kyoto Common Lisp (KCL for short). Its primary purpose is to maintain the KCL on-line documentation, but it is available to the public as a reference material. The contents of this Dictionary are updated periodically as the on-line documentation is revised. This Dictionary lists all special form names, all built-in macro names, all built-in function names, all built-in variable names, all built-in constant names, and some type names, in alphabetic order, along with the documentation strings associated with these symbols. Some useful system internals are also listed in alphabetic order, after the description of ZEROP. A key index to the built-in symbols are provided at the end. There, keys are listed in alphabetic order, and for each key, the symbols indexed with that key are listed in alphabetic order. The number after each symbol is the page of this Dictionary where the documentation of the symbol is found. A 'key' of a symbol SYMBOL is a substring of the print name of SYMBOL consisting of two or more alphanumeric characters. For example, the symbol WITH-INPUT-FROM-STRING has four keys WITH, INPUT, FORM, and STRING Some phrases in the documentation strings came from Steele's manual and some from Spice code. But almost all sentences are tuned for KCL. If you find any error in the documentation strings, please report to us at the following network addresses. Thank you for your cooperation. 11 MAR 86 Taiichi Yuasa "kddlab!kurims!yuasa"@Shasta.arpa yuasa@kurims.junet Masami Hagiya "kddlab!kurims!hagiya"@Shasta.arpa hagiya@kurims.junetKCL Dictionary Page 1 ------------------------------------------------------------------------------ * [Function] Args: (&rest numbers) Returns the product of its arguments. With no args, returns 1. ------------------------------------------------------------------------------ * [Variable] Holds the value of the most recent top-level form. ------------------------------------------------------------------------------ ** [Variable] Gets the previous value of * when KCL evaluates a top-level form. ------------------------------------------------------------------------------ *** [Variable] Gets the previous value of ** when KCL evaluates a top-level form. ------------------------------------------------------------------------------ + [Function] Args: (&rest numbers) Returns the sum of its arguments. With no args, returns 0. ------------------------------------------------------------------------------ + [Variable] Holds the most recent top-level form. ------------------------------------------------------------------------------ ++ [Variable] Gets the previous value of + when KCL evaluates a top-level form. ------------------------------------------------------------------------------ +++ [Variable] Gets the previous value of ++ when KCL evaluates a top-level form. ------------------------------------------------------------------------------ - [Function] Args: (number &rest more-numbers) Subtracts the second NUMBER and all subsequent NUMBERs from the first NUMBER. With one arg, negates it. ------------------------------------------------------------------------------ - [Variable] Holds the top-level form that KCL is currently evaluating. ------------------------------------------------------------------------------ / [Function] Args: (number &rest more-numbers) Divides the first NUMBER by each of the subsequent NUMBERS, in turn. With one arg, returns reciprocal. ------------------------------------------------------------------------------ / [Variable] Holds a list of all the values of the most recent top-level form. ------------------------------------------------------------------------------ // [Variable] Gets the previous value of / when KCL evaluates a top-level form. ------------------------------------------------------------------------------ KCL Dictionary Page 2 ------------------------------------------------------------------------------ /// [Variable] Gets the previous value of // when KCL evaluates a top-level form. ------------------------------------------------------------------------------ /= [Function] Args: (number &rest more-numbers) Returns T if no two of its arguments are numerically equal; NIL otherwise. ------------------------------------------------------------------------------ 1+ [Function] Args: (number) Returns NUMBER + 1. ------------------------------------------------------------------------------ 1- [Function] Args: (number) Returns NUMBER - 1. ------------------------------------------------------------------------------ < [Function] Args: (number &rest more-numbers) Returns T if its arguments are in strictly increasing order; NIL otherwise. ------------------------------------------------------------------------------ <= [Function] Args: (number &rest more-numbers) Returns T if arguments are in strictly non-decreasing order; NIL otherwise. ------------------------------------------------------------------------------ = [Function] Args: (number &rest more-numbers) Returns T if all of its arguments are numerically equal; NIL otherwise. ------------------------------------------------------------------------------ > [Function] Args: (number &rest more-numbers) Returns T if its arguments are in strictly decreasing order; NIL otherwise. ------------------------------------------------------------------------------ >= [Function] Args: (number &rest more-numbers) Returns T if arguments are in strictly non-increasing order; NIL otherwise. ------------------------------------------------------------------------------ ABS [Function] Args: (number) Returns the absolute value of the number. ------------------------------------------------------------------------------ ACONS [Function] Args: (key datum alist) Constructs a new alist by adding the pair (KEY . DATUM) to ALIST. ------------------------------------------------------------------------------ ACOS [Function] Args: (number) Returns the arc cosine of NUMBER. ------------------------------------------------------------------------------ KCL Dictionary Page 3 ------------------------------------------------------------------------------ ACOSH [Function] Args: (number) Returns the hyperbolic arc cosine of NUMBER. ------------------------------------------------------------------------------ ADJOIN [Function] Args: (item list &key (test #'eql) test-not (key #'identity)) Adds ITEM to LIST unless it is already a member. ------------------------------------------------------------------------------ ADJUST-ARRAY [Function] Args: (array dimensions &key (element-type (array-element-type array)) initial-element (initial-contents nil) (fill-pointer nil) (displaced-to nil) (displaced-index-offset 0)) Adjusts the dimensions of ARRAY to the given DIMENSIONS. The default for INITIAL-ELEMENT depends on ELEMENT-TYPE. ------------------------------------------------------------------------------ ADJUSTABLE-ARRAY-P [Function] Args: (array) Returns T if ARRAY is adjustable; NIL otherwise. ------------------------------------------------------------------------------ ALLOCATE [Function] Args: (type number &optional (really-allocate nil)) KCL specific: Sets the maximum number of pages for the type class of the KCL implementation type TYPE to NUMBER. If REALLY-ALLOCATE is given a non-NIL value, then the specified number of pages will be allocated immediately. ------------------------------------------------------------------------------ ALLOCATE-CONTIGUOUS-PAGES [Function] Args: (number &optional (really-allocate nil)) KCL specific: Sets the maximum number of pages for contiguous blocks to NUMBER. If REALLY-ALLOCATE is given a non-NIL value, then the specified number of pages will be allocated immediately. ------------------------------------------------------------------------------ ALLOCATE-RELOCATABLE-PAGES [Function] Args: (number) KCL specific: Sets the maximum number of pages for relocatable blocks to NUMBER. ------------------------------------------------------------------------------ ALLOCATED-CONTIGUOUS-PAGES [Function] Args: () KCL specific: Returns the number of pages currently allocated for contiguous blocks. ------------------------------------------------------------------------------ ALLOCATED-PAGES [Function] Args: (type) KCL specific: Returns the number of pages currently allocated for the type class of the KCL implementation type TYPE. ------------------------------------------------------------------------------ KCL Dictionary Page 4 ------------------------------------------------------------------------------ ALLOCATED-RELOCATABLE-PAGES [Function] Args: () KCL specific: Returns the number of pages currently allocated for relocatable blocks. ------------------------------------------------------------------------------ ALPHA-CHAR-P [Function] Args: (char) Returns T if CHAR is an alphabetic character, A-Z or a-z; NIL otherwise. ------------------------------------------------------------------------------ ALPHANUMERICP [Function] Args: (char) Returns T if CHAR is either numeric or alphabetic; NIL otherwise. ------------------------------------------------------------------------------ AND [Macro] Syntax: (and {form}*) Evaluates FORMs in order from left to right. If any FORM evaluates to NIL, quits and returns NIL. Else, returns the value(s) of the last FORM. ------------------------------------------------------------------------------ APPEND [Function] Args: (&rest lists) Constructs a new list by concatenating its arguments. ------------------------------------------------------------------------------ APPLY [Function] Args: (function arg &rest more-args) Applies FUNCTION to a list of arguments produced by evaluating ARGs. The arguments consist of the last ARG appended to the end of a list of all the other ARGs. ------------------------------------------------------------------------------ APPLYHOOK [Function] Args: (function args evalhookfn applyhookfn &optional (env nil)) Applies FUNCTION to ARGS, with *EVALHOOK* bound to EVALHOOKFN and with *APPLYHOOK* bound to APPLYHOOKFN. Ignores the hook function once, for the top-level application of FUNCTION to ARGS. ------------------------------------------------------------------------------ *APPLYHOOK* [Variable] Used to substitute another function for the implicit APPLY normally done within EVAL. If *APPLYHOOK* is not NIL, its value must be a function which takes three arguments: a function to be applied, a list of arguments, and an environment. This function does the application instead of APPLY. ------------------------------------------------------------------------------ APROPOS [Function] Args: (string &optional (package nil)) Prints out all symbols (in the specified package, if PACKAGE is non-NIL) whose print-names contain STRING as substring. ------------------------------------------------------------------------------ APROPOS-LIST [Function] Args: (string &optional (package nil)) Returns, as a list, all symbols (in the specified package, if PACKAGE is non-NIL) whose print-names contain STRING as substring. ------------------------------------------------------------------------------ KCL Dictionary Page 5 ------------------------------------------------------------------------------ AREF [Function] Args: (array &rest subscripts) Returns the element of ARRAY specified by SUBSCRIPTS. ------------------------------------------------------------------------------ ARRAY [Type] An array is an object with components arranged according to Cartesian coordinate system. Vectors are kinds of arrays. Other arrays are called general arrays and are denoted as #?a( ... ) or #?A( ... ) where '?' is actually the rank of the array. Some arrays may be displaced to another array, may have a fill pointer, or may be adjusted its size. Other arrays are called simple arrays. ------------------------------------------------------------------------------ ARRAY-DIMENSION [Function] Args: (array axis-number) Returns the length of AXIS-NUMBER of ARRAY. ------------------------------------------------------------------------------ ARRAY-DIMENSION-LIMIT [Constant] The exclusive upper bound any given dimension of an array. ------------------------------------------------------------------------------ ARRAY-DIMENSIONS [Function] Args: (array) Returns a list whose elements are the dimensions of ARRAY ------------------------------------------------------------------------------ ARRAY-ELEMENT-TYPE [Function] Args: (array) Returns the type of the elements of ARRAY ------------------------------------------------------------------------------ ARRAY-HAS-FILL-POINTER-P [Function] Args: (array) Returns T if ARRAY has a fill pointer; NIL otherwise. ------------------------------------------------------------------------------ ARRAY-IN-BOUNDS-P [Function] Args: (array &rest subscripts) Returns T if SUBSCRIPTS are in bounds for the array ARRAY; NIL otherwise. ------------------------------------------------------------------------------ ARRAY-RANK [Function] Args: (array) Returns the number of dimensions of ARRAY. ------------------------------------------------------------------------------ ARRAY-RANK-LIMIT [Constant] The exclusive upper bound on the rank of an array. ------------------------------------------------------------------------------ ARRAY-ROW-MAJOR-INDEX [Function] Args: (array &rest subscripts) Returns the index into ARRAY's data vector for SUBSCRIPTS. ------------------------------------------------------------------------------ KCL Dictionary Page 6 ------------------------------------------------------------------------------ ARRAY-TOTAL-SIZE [Function] Args: (array) Returns the total number of elements in ARRAY. ------------------------------------------------------------------------------ ARRAY-TOTAL-SIZE-LIMIT [Constant] The exclusive upper bound on the total number of elements in an array. ------------------------------------------------------------------------------ ARRAYP [Function] Args: (x) Returns T if X is an array; NIL otherwise. ------------------------------------------------------------------------------ ASH [Function] Args: (integer count) Shifts INTEGER left by COUNT places preserving sign. Minus COUNT shifts right. ------------------------------------------------------------------------------ ASIN [Function] Args: (number) Returns the arc sine of NUMBER. ------------------------------------------------------------------------------ ASINH [Function] Args: (number) Returns the hyperbolic arc sine of NUMBER. ------------------------------------------------------------------------------ ASSERT [Macro] Syntax: (assert test-form [({place}*) [string {arg}*]]) Signals an error if the value of TEST-FORM is NIL. STRING is an error message string and ARGs are additional arguments. ------------------------------------------------------------------------------ ASSOC [Function] Args: (item alist &key (test #'eql) test-not) Returns the cons in ALIST whose car is equal to ITEM. ------------------------------------------------------------------------------ ASSOC-IF [Function] Args: (test alist) Returns the first cons in ALIST whose car satisfies TEST. ------------------------------------------------------------------------------ ASSOC-IF-NOT [Function] Args: (test alist) Returns the first cons in ALIST whose car does not satisfy TEST. ------------------------------------------------------------------------------ ATAN [Function] Args: (x &optional y) Returns the arc tangent of X (if Y is not supplied) or X/Y. ------------------------------------------------------------------------------ KCL Dictionary Page 7 ------------------------------------------------------------------------------ ATANH [Function] Args: (number) Returns the hyperbolic arc tangent of NUMBER. ------------------------------------------------------------------------------ ATOM [Function] Args: (x) Returns T if X is not a cons; NIL otherwise. ------------------------------------------------------------------------------ BIGNUM [Type] A bignum is an integer that is not a fixnum. ------------------------------------------------------------------------------ BIT [Function] Args: (bit-array &rest subscripts) Returns the bit from BIT-ARRAY at SUBSCRIPTS. ------------------------------------------------------------------------------ BIT-AND [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical AND on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-ANDC1 [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical ANDC1 on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-ANDC2 [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical ANDC2 on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-EQV [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical EQV on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-IOR [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical IOR on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 8 ------------------------------------------------------------------------------ BIT-NAND [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical NAND on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-NOR [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical NOR on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-NOT [Function] Args: (bit-array &optional (result-bit-array nil)) Performs a bit-wise logical NOT in the elements of BIT-ARRAY. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-ORC1 [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical ORC1 on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-ORC2 [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical ORC2 on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ BIT-VECTOR [Type] A bit-vector is a vector of bits. A bit-vector is denoted by '#*' followed by the constituent bits (0 or 1). Some bit-vectors may be displaced to another bit-vectors, may have a fill pointer, or may be adjusted its size. Other bit-vectors are called simple bit-vectors. ------------------------------------------------------------------------------ BIT-VECTOR-P [Function] Args: (x) Returns T if X is a bit vector; NIL otherwise. ------------------------------------------------------------------------------ BIT-XOR [Function] Args: (bit-array1 bit-array2 &optional (result-bit-array nil)) Performs a bit-wise logical XOR on the elements of BIT-ARRAY1 and BIT-ARRAY2. Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 9 ------------------------------------------------------------------------------ BLOCK [Special form] Syntax: (block name {form}*) The FORMs are evaluated in order, but it is possible to exit the block using (RETURN-FROM name value). The RETURN-FROM must be lexically contained within the block. ------------------------------------------------------------------------------ BOOLE [Function] Args: (op integer1 integer2) Returns an integer produced by performing the logical operation specified by OP on the two integers. OP must be the value of one of the following constants: BOOLE-CLR BOOLE-C1 BOOLE-XOR BOOLE-ANDC1 BOOLE-SET BOOLE-C2 BOOLE-EQV BOOLE-ANDC2 BOOLE-1 BOOLE-AND BOOLE-NAND BOOLE-ORC1 BOOLE-2 BOOLE-IOR BOOLE-NOR BOOLE-ORC2 See the variable docs of these constants for their operations. ------------------------------------------------------------------------------ BOOLE-1 [Constant] Makes BOOLE return INTEGER1. ------------------------------------------------------------------------------ BOOLE-2 [Constant] Makes BOOLE return INTEGER2. ------------------------------------------------------------------------------ BOOLE-AND [Constant] Makes BOOLE return LOGAND of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-ANDC1 [Constant] Makes BOOLE return LOGANDC1 of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-ANDC2 [Constant] Makes BOOLE return LOGANDC2 of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-C1 [Constant] Makes BOOLE return the complement of INTEGER1. ------------------------------------------------------------------------------ BOOLE-C2 [Constant] Makes BOOLE return the complement of INTEGER2. ------------------------------------------------------------------------------ BOOLE-CLR [Constant] Makes BOOLE return 0. ------------------------------------------------------------------------------ BOOLE-EQV [Constant] Makes BOOLE return LOGEQV of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-IOR [Constant] Makes BOOLE return LOGIOR of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ KCL Dictionary Page 10 ------------------------------------------------------------------------------ BOOLE-NAND [Constant] Makes BOOLE return LOGNAND of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-NOR [Constant] Makes BOOLE return LOGNOR of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-ORC1 [Constant] Makes BOOLE return LOGORC1 of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-ORC2 [Constant] Makes BOOLE return LOGORC2 of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOOLE-SET [Constant] Makes BOOLE return -1. ------------------------------------------------------------------------------ BOOLE-XOR [Constant] Makes BOOLE return LOGXOR of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ BOTH-CASE-P [Function] Args: (char) Returns T if CHAR is an alphabetic character and if CHAR exists in both upper and lower case; NIL otherwise. Equivalent to ALPHA-CHAR-P. ------------------------------------------------------------------------------ BOUNDP [Function] Args: (symbol) Returns T if the dynamic (special) variable named by SYMBOL has a value; NIL otherwise. ------------------------------------------------------------------------------ BREAK [Function] Args: (&optional (format-string nil) &rest args) Enters a break loop. If FORMAT-STRING is non-NIL, formats FORMAT-STRING and ARGS to *ERROR-OUTPUT* before entering a break loop. Typing :HELP at the break loop will list the break-loop commands. ------------------------------------------------------------------------------ *BREAK-ENABLE* [Variable] KCL specific: Specifies whether (non-NIL) or not (NIL) the break loop is entered when an error occurred. ------------------------------------------------------------------------------ *BREAK-ON-WARNINGS* [Variable] If non-NIL, then WARN will enter a break loop before returning. ------------------------------------------------------------------------------ BUTLAST [Function] Args: (list &optional (n 1)) Creates and returns a list with the same elements as LIST, excepting the last N elements. ------------------------------------------------------------------------------ KCL Dictionary Page 11 ------------------------------------------------------------------------------ BY [Function] Args: () KCL specific: Exits from KCL. ------------------------------------------------------------------------------ BYE [Function] Args: () KCL specific: Exits from KCL. ------------------------------------------------------------------------------ BYTE [Function] Args: (size position) Returns a byte specifier which may be used by other byte functions. ------------------------------------------------------------------------------ BYTE-POSITION [Function] Args: (bytespec) Returns the position part of the byte specifier. ------------------------------------------------------------------------------ BYTE-SIZE [Function] Args: (bytespec) Returns the size part of the byte specifier. ------------------------------------------------------------------------------ CAAAAR [Function] Args: (x) Equivalent to (CAR (CAR (CAR (CAR X)))). ------------------------------------------------------------------------------ CAAADR [Function] Args: (x) Equivalent to (CAR (CAR (CAR (CDR X)))). ------------------------------------------------------------------------------ CAAAR [Function] Args: (x) Equivalent to (CAR (CAR (CAR X))). ------------------------------------------------------------------------------ CAADAR [Function] Args: (x) Equivalent to (CAR (CAR (CDR (CAR X)))). ------------------------------------------------------------------------------ CAADDR [Function] Args: (x) Equivalent to (CAR (CAR (CDR (CDR X)))). ------------------------------------------------------------------------------ CAADR [Function] Args: (x) Equivalent to (CAR (CAR (CDR X))). ------------------------------------------------------------------------------ CAAR [Function] Args: (x) Equivalent to (CAR (CAR X)). ------------------------------------------------------------------------------ KCL Dictionary Page 12 ------------------------------------------------------------------------------ CADAAR [Function] Args: (x) Equivalent to (CAR (CDR (CAR (CAR X)))). ------------------------------------------------------------------------------ CADADR [Function] Args: (x) Equivalent to (CAR (CDR (CAR (CDR X)))). ------------------------------------------------------------------------------ CADAR [Function] Args: (x) Equivalent to (CAR (CDR (CAR X))). ------------------------------------------------------------------------------ CADDAR [Function] Args: (x) Equivalent to (CAR (CDR (CDR (CAR X)))). ------------------------------------------------------------------------------ CADDDR [Function] Args: (x) Equivalent to (CAR (CDR (CDR (CDR X)))). ------------------------------------------------------------------------------ CADDR [Function] Args: (x) Equivalent to (CAR (CDR (CDR X))). ------------------------------------------------------------------------------ CADR [Function] Args: (x) Equivalent to (CAR (CDR X)). ------------------------------------------------------------------------------ CALL-ARGUMENTS-LIMIT [Constant] The upper exclusive bound on the number of arguments that may be passed to a function. Actually, however, there is no such upper bound in KCL. ------------------------------------------------------------------------------ CAR [Function] Args: (list) Returns the car of LIST. Returns NIL if LIST is NIL. ------------------------------------------------------------------------------ CASE [Macro] Syntax: (case keyform {({key | ({key}*)} {form}*)}*) Evaluates KEYFORM and tries to find the KEY that is EQL to the value of KEYFORM. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, simply returns NIL. ------------------------------------------------------------------------------ CATCH [Special form] Syntax: (catch tag {form}*) Evaluates TAG and sets up a catcher with that value. Then evaluates FORMs as a PROGN, but may possibly abort the evaluation by executing THROW with the same tag value. ------------------------------------------------------------------------------ KCL Dictionary Page 13 ------------------------------------------------------------------------------ CCASE [Macro] Syntax: (ccase keyplace {({key | ({key}*)} {form}*)}*) Evaluates KEYPLACE and tries to find the KEY that is EQL to the value of KEYPLACE. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, signals an correctable error. ------------------------------------------------------------------------------ CDAAAR [Function] Args: (x) Equivalent to (CDR (CAR (CAR (CAR X)))). ------------------------------------------------------------------------------ CDAADR [Function] Args: (x) Equivalent to (CDR (CAR (CAR (CDR X)))). ------------------------------------------------------------------------------ CDAAR [Function] Args: (x) Equivalent to (CDR (CAR (CAR X))). ------------------------------------------------------------------------------ CDADAR [Function] Args: (x) Equivalent to (CDR (CAR (CDR (CAR X)))). ------------------------------------------------------------------------------ CDADDR [Function] Args: (x) Equivalent to (CDR (CAR (CDR (CDR X)))). ------------------------------------------------------------------------------ CDADR [Function] Args: (x) Equivalent to (CDR (CAR (CDR X))). ------------------------------------------------------------------------------ CDAR [Function] Args: (x) Equivalent to (CDR (CAR X)). ------------------------------------------------------------------------------ CDDAAR [Function] Args: (x) Equivalent to (CDR (CDR (CAR (CAR X)))). ------------------------------------------------------------------------------ CDDADR [Function] Args: (x) Equivalent to (CDR (CDR (CAR (CDR X)))). ------------------------------------------------------------------------------ CDDAR [Function] Args: (x) Equivalent to (CDR (CDR (CAR X))). ------------------------------------------------------------------------------ KCL Dictionary Page 14 ------------------------------------------------------------------------------ CDDDAR [Function] Args: (x) Equivalent to (CDR (CDR (CDR (CAR X)))). ------------------------------------------------------------------------------ CDDDDR [Function] Args: (x) Equivalent to (CDR (CDR (CDR (CDR X)))). ------------------------------------------------------------------------------ CDDDR [Function] Args: (x) Equivalent to (CDR (CDR (CDR X))). ------------------------------------------------------------------------------ CDDR [Function] Args: (x) Equivalent to (CDR (CDR X)). ------------------------------------------------------------------------------ CDR [Function] Args: (list) Returns the cdr of LIST. Returns NIL if LIST is NIL. ------------------------------------------------------------------------------ CEILING [Function] Args: (number &optional (divisor 1)) Returns the smallest integer not less than or NUMBER/DIVISOR. The second returned value is the remainder. ------------------------------------------------------------------------------ CERROR [Function] Args: (continue-format-string error-format-string &rest args) Signals a correctable error. ------------------------------------------------------------------------------ CHAR [Function] Args: (string index) Returns the character object representing the INDEX-th character in STRING. ------------------------------------------------------------------------------ CHAR-BIT [Function] Args: (char name) Returns T if the named bit is set in the character CHAR; NIL otherwise. This function is useless in KCL. ------------------------------------------------------------------------------ CHAR-BITS [Function] Args: (char) Returns the bits attribute (which is always 0) of CHAR. ------------------------------------------------------------------------------ CHAR-BITS-LIMIT [Constant] The upper exclusive bound on values produced by CHAR-BITS. ------------------------------------------------------------------------------ KCL Dictionary Page 15 ------------------------------------------------------------------------------ CHAR-CODE [Function] Args: (char) Returns the code attribute of CHAR. ------------------------------------------------------------------------------ CHAR-CODE-LIMIT [Constant] The upper exclusive bound on values produced by CHAR-CODE. ------------------------------------------------------------------------------ CHAR-CONTROL-BIT [Constant] The bit that indicates a control character. ------------------------------------------------------------------------------ CHAR-DOWNCASE [Function] Args: (char) Returns a character with the same bits and font as CHAR, converted to lower-case if possible. ------------------------------------------------------------------------------ CHAR-EQUAL [Function] Args: (char &rest more-chars) Returns T if all of its arguments are the same character; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-FONT [Function] Args: (char) Returns the font attribute of CHAR. ------------------------------------------------------------------------------ CHAR-FONT-LIMIT [Constant] The upper exclusive bound on values produced by CHAR-FONT. ------------------------------------------------------------------------------ CHAR-GREATERP [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly decreasing alphabetic order; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-HYPER-BIT [Constant] The bit that indicates a hyper character. ------------------------------------------------------------------------------ CHAR-INT [Function] Args: (char) Returns the font, bits, and code attributes as a single non-negative integer. Equivalent to CHAR-CODE in KCL. ------------------------------------------------------------------------------ CHAR-LESSP [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly increasing alphabetic order; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-META-BIT [Constant] The bit that indicates a meta character. ------------------------------------------------------------------------------ KCL Dictionary Page 16 ------------------------------------------------------------------------------ CHAR-NAME [Function] Args: (char) Returns the name for CHAR as a string; NIL if CHAR has no name. Only #\Backspace, #\Tab, #\Newline (or #\Linefeed), #\Page, #\Return, and #\Rubout have names. ------------------------------------------------------------------------------ CHAR-NOT-EQUAL [Function] Args: (char &rest more-chars) Returns T if no two of CHARs are the same character; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-NOT-GREATERP [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly non-decreasing alphabetic order; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-NOT-LESSP [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly non-increasing alphabetic order; NIL otherwise. Font, bits, and case are ignored. ------------------------------------------------------------------------------ CHAR-SUPER-BIT [Constant] The bit that indicates a super character. ------------------------------------------------------------------------------ CHAR-UPCASE [Function] Args: (char) Returns a character with the same bits and font as CHAR, converted to upper-case if possible. ------------------------------------------------------------------------------ CHAR/= [Function] Args: (char &rest more-chars) Returns T if no two of CHARs are the same character; NIL otherwise. ------------------------------------------------------------------------------ CHAR< [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly increasing alphabetic order; NIL otherwise. ------------------------------------------------------------------------------ CHAR<= [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly non-decreasing alphabetic order; NIL otherwise. ------------------------------------------------------------------------------ CHAR= [Function] Args: (char &rest more-chars) Returns T if all CHARs are the same character; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 17 ------------------------------------------------------------------------------ CHAR> [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly decreasing alphabetic order; NIL otherwise. ------------------------------------------------------------------------------ CHAR>= [Function] Args: (char &rest more-chars) Returns T if CHARs are in strictly non-increasing alphabetic order; NIL otherwise. ------------------------------------------------------------------------------ CHARACTER [Type] A character object represents a character. Characters have font, bits, and code attributes. Font and bits attributes are always 0 in KCL. Most versions of KCL uses ASCII code: 000 - 037 #\^@ #\^A #^B ... #\Z #\^[ #\^\ #\^] #\^^ #\^_ except #\Tab(011) #\Newline(012) #\Page(014) #\Return(015) #\Backspace(031) 040 - 057 #\Space #\! #\" #\# #\$ #\% #\& #\' #$ #$ #\* #\+ #\, #\- #\. #\/ 060 - 071 #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 072 - 100 #\: #\; #\< #\= #\> #\? #\@ 101 - 132 #\A ... #\Z 133 - 140 #\[ #\\ #\] #\^ #\_ #\` 141 - 172 #\a ... #\z 173 - 177 #\{ #\| #\} #\~ #\Rubout Some versions of KCL support additional characters to represent Japanese KANJI characters with. ------------------------------------------------------------------------------ CHARACTER [Function] Args: (x) Coerces X into a character object if possible. ------------------------------------------------------------------------------ CHARACTERP [Function] Args: (x) Returns T if X is a character; NIL otherwise. ------------------------------------------------------------------------------ CHECK-TYPE [Macro] Syntax: (check-type place typespec [string]) Signals an error, if the contents of PLACE are not of the specified type. ------------------------------------------------------------------------------ CIS [Function] Args: (radians) Returns e raised to i*RADIANS. ------------------------------------------------------------------------------ CLEAR-INPUT [Function] Args: (&optional (stream *standard-input*)) Clears any buffered input associated with STREAM. ------------------------------------------------------------------------------ KCL Dictionary Page 18 ------------------------------------------------------------------------------ CLEAR-OUTPUT [Function] Args: (&optional (stream *standard-output*)) Clears the output stream STREAM. ------------------------------------------------------------------------------ CLINES [Macro] Syntax: (clines {string}*) KCL specific: The KCL compiler embeds STRINGs into the intermediate C language code. The interpreter ignores this form. ------------------------------------------------------------------------------ CLOSE [Function] Args: (stream &key (abort nil)) Closes STREAM. A non-NIL value of :ABORT indicates an abnormal termination of the use of the stream. ------------------------------------------------------------------------------ CLRHASH [Function] Args: (hash-table) Removes all entries of HASH-TABLE and returns the hash table itself. ------------------------------------------------------------------------------ CODE-CHAR [Function] Args: (code &optional (bits 0) (font 0)) Returns a character object with the specified code, bits, and font, or returns NIL if this is not possible. ------------------------------------------------------------------------------ COERCE [Function] Args: (x type) Coerces X to an object of the type TYPE. ------------------------------------------------------------------------------ COMMON [Type] COMMON is the type of all legal Common Lisp data types. ------------------------------------------------------------------------------ COMMONP [Function] Args: (x) Returns T if X is a legal Common Lisp object; NIL otherwise. ------------------------------------------------------------------------------ COMPILE [Function] Args: (name &optional (definition nil) &key (leave-gazonk nil)) If DEFINITION is NIL, NAME must be the name of a not-yet-compiled function. In this case, COMPILE compiles the function, installs the compiled function as the global function definition of NAME, and returns NAME. If DEFINITION is non-NIL, it must be a lambda expression and NAME must be a symbol. COMPILE compiles the lambda expression, installs the compiled function as the function definition of NAME, and returns NAME. There is only one exception for this: If NAME is NIL, then the compiled function is not installed but is simply returned as the value of COMPILE. In any case, COMPILE creates temporary files whose filenames are "gazonk***". By default, i.e. if :LEAVE-GAZONK is not supplied or is NIL, these files are automatically deleted after compilation. ------------------------------------------------------------------------------ KCL Dictionary Page 19 ------------------------------------------------------------------------------ COMPILE-FILE [Function] Args: (input-pathname &key output-file (load nil) (message-file nil) (verbose nil)) Compiles the file specified by INPUT-PATHNAME and generates a fasl file specified by OUTPUT-FILE. If the filetype is not specified in INPUT-PATHNAME, then ".lsp" is used as the default file type for the source file. :LOAD specifies whether to load the generated fasl file after compilation. :MESSAGE-FILE specifies the log file for the compiler messages. It defaults to the value of the variable COMPILER:*DEFAULT- MESSAGE-FILE*. A non-NIL value of :VERBOSE forces the compiler to indicate the form currently being compiled. More keyword parameters are accepted, depending on the version. Most versions of KCL can receive :O-FILE, :C-FILE, :H-FILE, and :DATA-FILE keyword parameters, with which you can control the intermediate files generated by the KCL compiler. See the KCL Report at your hand for the details. ------------------------------------------------------------------------------ COMPILED-FUNCTION [Type] A compiled function is a compiled code object. A compiled function is denoted in either of the form: #<compiled-function ?> #<compiled-closure nil> where '?' is actually the name of the compiled-function. ------------------------------------------------------------------------------ COMPILED-FUNCTION-P [Function] Args: (x) Returns T if X is a compiled function object; NIL otherwise. ------------------------------------------------------------------------------ COMPILER-LET [Special form] Syntax: (compiler-let ({var | (var [value])}*) {form}*) In the interpreter, works just like LET with all VARs declared special. On the other hand, the compiler processes FORMs with the VARs bound in the compiler's environment, and the compiled code causes no bindings. ------------------------------------------------------------------------------ COMPLEX [Type] A complex number consists of a real part and an imaginary part. A complex number is denoted as #c( realpart imagpart ) or #C( realpart imagpart ) where realpart and imagpart are non-complex numbers. ------------------------------------------------------------------------------ COMPLEX [Function] Args: (realpart &optional (imagpart 0)) Returns a complex number with the given real part and imaginary part. ------------------------------------------------------------------------------ COMPLEXP [Function] Args: (x) Returns T if X is a complex number; NIL otherwise. ------------------------------------------------------------------------------ CONCATENATE [Function] Args: (result-type &rest sequences) Returns a new sequence of all SEQUENCEs concatenated together of the specified RESULT-TYPE. ------------------------------------------------------------------------------ KCL Dictionary Page 20 ------------------------------------------------------------------------------ COND [Macro] Syntax: (cond {(test {form}*)}*) Evaluates each TEST in order until one evaluates to non-NIL. Then evaluates the associated FORMs in order and returns whatever the last FORM returns. If all TESTs evaluate to NIL, simply returns NIL. ------------------------------------------------------------------------------ CONJUGATE [Function] Args: (number) Returns the complex conjugate of NUMBER. For non-complex numbers, this is an identity. ------------------------------------------------------------------------------ CONS [Type] A cons is a record structure containing two components called the car and the cdr. ------------------------------------------------------------------------------ CONS [Function] Args: (x y) Returns a new cons whose car and cdr are X and Y, respectively. ------------------------------------------------------------------------------ CONSP [Function] Args: (x) Returns T if X is a cons; NIL otherwise. ------------------------------------------------------------------------------ CONSTANTP [Function] Args: (symbol) Returns T if the variable named by SYMBOL is a constant; NIL otherwise. ------------------------------------------------------------------------------ COPY-ALIST [Function] Args: (alist) Returns a new association list EQUAL but not EQ to ALIST. ------------------------------------------------------------------------------ COPY-LIST [Function] Args: (list) Returns a new list EQUAL but not EQ to LIST. ------------------------------------------------------------------------------ COPY-READTABLE [Function] Args: (&optional (from-readtable *readtable*) (to-readtable nil)) Returns a copy of the readtable FROM-READTABLE. If TO-READTABLE is non-NIL, then copies into TO-READTABLE. Otherwise, creates a fresh readtable. ------------------------------------------------------------------------------ COPY-SEQ [Function] Args: (sequence) Returns a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ. ------------------------------------------------------------------------------ KCL Dictionary Page 21 ------------------------------------------------------------------------------ COPY-SYMBOL [Function] Args: (symbol &optional (copy-props nil)) Creates and returns a new uninterned symbol with the same print name as SYMBOL. If COPY-PROPS is NIL, the new symbol has no properties. Else, it is given a copy of SYMBOL's property list. ------------------------------------------------------------------------------ COPY-TREE [Function] Args: (object) Recursively copies trees of conses in OBJECT and returns the result. ------------------------------------------------------------------------------ COS [Function] Args: (radians) Returns the cosine of RADIANS. ------------------------------------------------------------------------------ COSH [Function] Args: (number) Returns the hyperbolic cosine of NUMBER. ------------------------------------------------------------------------------ COUNT [Function] Args: (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) Returns the number of elements in SEQUENCE satisfying TEST with ITEM. ------------------------------------------------------------------------------ COUNT-IF [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the number of elements in SEQUENCE satisfying TEST. ------------------------------------------------------------------------------ COUNT-IF-NOT [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the number of elements in SEQUENCE not satisfying TEST. ------------------------------------------------------------------------------ CTYPECASE [Macro] Syntax: (ctypecase keyplace {(type {form}*)}*) Evaluates KEYPLACE and tries to find the TYPE in which the value of KEYPLACE belongs. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, signals a correctable error. ------------------------------------------------------------------------------ *DEBUG-IO* [Variable] The interactive debugging stream. ------------------------------------------------------------------------------ DECF [Macro] Syntax: (decf place [delta]) Subtracts the number produced by DELTA (which defaults to 1) from the number in PLACE. ------------------------------------------------------------------------------ KCL Dictionary Page 22 ------------------------------------------------------------------------------ DECLARE [Special form] Syntax: (declare {decl-spec}*) Gives a declaration. Possible DECL-SPECs are: (SPECIAL {var}*) (TYPE type {var}*) (type {var}*) : where 'type' is one of the following symbols array fixnum package simple-bit-vector atom float pathname simple-string bignum function random-state simple-vector bit hash-table ratio single-float bit-vector integer rational standard-char character keyword readtable stream common list sequence string compiled-function long-float short-float string-char complex nil signed-byte symbol cons null unsigned-byte t double-float number simple-array vector (OBJECT {var}*) (FTYPE type {function-name}*) (FUNCTION ({arg-type}*) {return-type}*) (INLINE {function-name}*) (NOTINLINE {function-name}*) (IGNORE {var}*) (OPTIMIZE {({SPEED | SPACE | SAFETY | COMPILATION-SPEED} {0 | 1 | 2 | 3})}*) (DECLARATION {non-standard-decl-name}*). ------------------------------------------------------------------------------ DECODE-FLOAT [Function] Args: (float) Returns three values. The first value is a floating-point number that represents the significand of FLOAT. The second value is an integer that represents the exponent of FLOAT. The third value is a floating-point number that indicates the sign of FLOAT. ------------------------------------------------------------------------------ DECODE-UNIVERSAL-TIME [Function] Args: (universal-time &optional (timezone -9)) Converts UNIVERSAL-TIME into the decoded time format at the TIMEZONE. Returns nine values: second, minute, hour, date, month, year, day-of-week, daylight-saving-time-p, and time-zone. TIMEZONE in KCL defaults to -9, which is the time zone in Japan. ------------------------------------------------------------------------------ *DEFAULT-PATHNAME-DEFAULTS* [Variable] The default pathname-defaults pathname. ------------------------------------------------------------------------------ KCL Dictionary Page 23 ------------------------------------------------------------------------------ DEFCFUN [Macro] Syntax: (defcfun header n {element}*) KCL specific: Defines a C-language function which calls Lisp functions and/or handles Lisp objects. HEADER gives the header of the C function as a string. N is the number of the main stack entries used by the C function, primarily for protecting Lisp objects from being garbage-collected. Each ELEMENT may give a C code fragment as a string, or it may be a list ((symbol {arg}*) {place}*) which, when executed, calls the Lisp function named by SYMBOL with the specified arguments and saves the value(s) to the specified places. The DEFCFUN form has the above meanings only after compiled; The KCL interpreter simply ignores this form. ------------------------------------------------------------------------------ DEFCONSTANT [Macro] Syntax: (defconstant name initial-value [doc]) Declares that the variable NAME is constant. If the variable already has a value, and this is not equal to the value of INITIAL-VALUE, an error is signalled. The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be retrieved by (documentation 'NAME 'variable). ------------------------------------------------------------------------------ DEFENTRY [Macro] Syntax: (defentry name lambda-list C-function) KCL specific: The compiler defines a Lisp function whose body consists of a calling sequence to the C language function specified by C-FUNCTION. The interpreter ignores this form. See the doc of DEFUN for the complete syntax of a lambda-list. ------------------------------------------------------------------------------ DEFINE-MODIFY-MACRO [Macro] Syntax: (define-modify-macro name lambda-list fun [doc]) Defines a read-modify-write macro, like PUSH or INCF. The defined macro will expand a form (NAME place val1 ... valn) into a form that in effect SETFs the value of the call (FUN PLACE arg1 ... argm) into PLACE, where arg1 ... argm are parameters in LAMBDA-LIST which are bound to the forms VAL1 ... VALn. The doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved by (documentation 'NAME 'setf). ------------------------------------------------------------------------------ KCL Dictionary Page 24 ------------------------------------------------------------------------------ DEFINE-SETF-METHOD [Macro] Syntax: (define-setf-method access-fun defmacro-lambda-list {decl | doc}* {form}*) Defines how to SETF a generalized-variable reference of the form (ACCESS-FUN ...). When a form (setf (ACCESS-FUN arg1 ... argn) value) is being evaluated, the FORMs are first evaluated as a PROGN with the parameters in DEFMACRO-LAMBDA-LIST bound to ARG1 ... ARGn. Assuming that the last FORM returns five values (temp-var-1 ... temp-var-k) (value-from-1 ... value-form-k) (store-var) storing-form access-form in order, the whole SETF is then expanded into (let* ((temp-var-1 value-from-1) ... (temp-k value-form-k) (store-var VALUE)) storing-from) Incidentally, the five values are called the five gangs of a SETF method. The doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved by (documentation 'NAME 'setf). ------------------------------------------------------------------------------ DEFLA [Macro] Syntax: (defla name lambda-list {decl | doc}* {form}*) KCL specific: Used to DEFine Lisp Alternative. For the interpreter, DEFLA is equivalent to DEFUN, but the compiler ignores this form. ------------------------------------------------------------------------------ KCL Dictionary Page 25 ------------------------------------------------------------------------------ DEFMACRO [Macro] Syntax: (defmacro name defmacro-lambda-list {decl | doc}* {form}*) Defines a macro as the global macro definition of the symbol NAME. The complete syntax of a defmacro-lambda-list is: ( [&whole var] [&environment var] {pseudo-var}* [&optional {var | (pseudo-var [initform [pseudo-var]])}*] {[{&rest | &body} pseudo-var] [&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}* [&allow-other-keys]] [&aux {var | (pseudo-var [initform])}*] | . var}) where pseudo-var is either a symbol or a list of the following form: ( {pseudo-var}* [&optional {var | (pseudo-var [initform [pseudo-var]])}*] {[{&rest | &body} pseudo-var] [&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}* [ &allow-other-keys ] ] [&aux {var | (pseudo-var [initform])}*] | . var}) As a special case, a non-NIL symbol is accepcted as a defmacro-lambda-list: (DEFMACRO <name> <symbol> ...) is equivalent to (DEFMACRO <name> (&REST <symbol>) ...). The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be retrieved by (documentation 'NAME 'function). See the type doc of LIST for the backquote macro useful for defining macros. Also, see the function doc of PPRINT for the output-formatting. ------------------------------------------------------------------------------ DEFPARAMETER [Macro] Syntax: (defparameter name initial-value [doc]) Defines a parameter which is not normally changed by the program, but which may be changed without causing an error. Declares the variable as special and initializes the value. The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be retrieved by (documentation 'NAME 'variable). ------------------------------------------------------------------------------ DEFSETF [Macro] Syntax: (defsetf access-fun {update-fun [doc] | lambda-list (store-var) {decl | doc}* {form}*) Defines how to SETF a generalized-variable reference of the form (ACCESS-FUN ...). The doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved by (documentation 'NAME 'setf). (defsetf access-fun update-fun) defines an expansion from (setf (ACCESS-FUN arg1 ... argn) value) to (UPDATE-FUN arg1 ... argn value). (defsetf access-fun lambda-list (store-var) . body) defines a macro which expands (setf (ACCESS-FUN arg1 ... argn) value) into the form (let* ((temp1 ARG1) ... (tempn ARGn) (temp0 value)) rest) where REST is the value of BODY with parameters in LAMBDA-LIST bound to the symbols TEMP1 ... TEMPn and with STORE-VAR bound to the symbol TEMP0. ------------------------------------------------------------------------------ KCL Dictionary Page 26 ------------------------------------------------------------------------------ DEFSTRUCT [Macro] Syntax: (defstruct {name | (name {:conc-name | (:conc-name prefix-string) | :constructor | (:constructor symbol [lambda-list]) | :copier | (:copier symbol) | :predicate | (:predicate symbol) | (:include symbol) | (:print-function function) | (:type {vector | (vector type) | list}) | :named | (:initial-offset number)}*)} [doc] {slot-name | (slot-name [default-value-form] {:type type | :read-only flag}*) }* ) Defines a structure. The doc-string DOC, if supplied, is saved as a STRUCTURE doc and can be retrieved by (documentation 'NAME 'structure). ------------------------------------------------------------------------------ DEFTYPE [Macro] Syntax: (deftype name lambda-list {decl | doc}* {form}*) Defines a new type-specifier abbreviation in terms of an 'expansion' function (lambda lambda-list1 {decl}* {form}*) where lambda-list1 is identical to LAMBDA-LIST except that all optional parameters with no default value specified in LAMBDA-LIST defaults to the symbol '*', but not to NIL. When the type system of KCL encounters a type specifier (NAME arg1 ... argn), it calls the expansion function with the arguments arg1 ... argn, and uses the returned value instead of the original type specifier. When the symbol NAME is used as a type specifier, the expansion function is called with no argument. The doc-string DOC, if supplied, is saved as the TYPE doc of NAME, and is retrieved by (documentation 'NAME 'type). ------------------------------------------------------------------------------ DEFUN [Macro] Syntax: (defun name lambda-list {decl | doc}* {form}*) Defines a function as the global function definition of the symbol NAME. The complete syntax of a lambda-list is: ({var}* [&optional {var | (var [initform [svar]])}*] [&rest var] [&key {var | ({var | (keyword var)} [initform [svar]])}* [&allow-other-keys]] [&aux {var | (var [initform])}*]) The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be retrieved by (documentation 'NAME 'function). ------------------------------------------------------------------------------ DEFVAR [Macro] Syntax: (defvar name [initial-value [doc]]) Declares the variable NAME as special and, optionally, initializes it. The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be retrieved by (documentation 'NAME 'variable). ------------------------------------------------------------------------------ KCL Dictionary Page 27 ------------------------------------------------------------------------------ DELETE [Function] Args: (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence formed by destructively removing the specified ITEM from the SEQUENCE. ------------------------------------------------------------------------------ DELETE-DUPLICATES [Function] Args: (sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) The elements of SEQUENCE are examined, and if any two match, one is discarded. Returns the resulting sequence, which may be formed by destroying SEQUENCE. ------------------------------------------------------------------------------ DELETE-FILE [Function] Args: (file) Deletes the file specified by FILE. ------------------------------------------------------------------------------ DELETE-IF [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence formed by destructively removing the elements satisfying TEST from SEQUENCE. ------------------------------------------------------------------------------ DELETE-IF-NOT [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence formed by destructively removing the elements not satisfying TEST from SEQUENCE. ------------------------------------------------------------------------------ DENOMINATOR [Function] Args: (rational) Returns as an integer the denominator of the given rational number. ------------------------------------------------------------------------------ DEPOSIT-FIELD [Function] Args: (newbyte bytespec integer) Returns an integer that contains the bits of NEWBYTE within the byte specified by BYTESPEC, and elsewhere contains the bits of INTEGER. ------------------------------------------------------------------------------ DESCRIBE [Function] Args: (x) Prints a description of the object X on the standard output. ------------------------------------------------------------------------------ DIGIT-CHAR [Function] Args: (weight &optional (radix 10) (font 0)) Returns a character object that represents a digit of the given WEIGHT in the specified RADIX. Returns NIL if no such character exists. The character will have the specified FONT attribute. ------------------------------------------------------------------------------ KCL Dictionary Page 28 ------------------------------------------------------------------------------ DIGIT-CHAR-P [Function] Args: (char &optional (radix 10)) Returns T if CHAR represents a digit in RADIX; NIL otherwise. ------------------------------------------------------------------------------ DIRECTORY [Function] Args: (name) Returns a list of files that match NAME. NAME may be a string, a pathname, or a file stream. ------------------------------------------------------------------------------ DIRECTORY-NAMESTRING [Function] Args: (pathname) Returns the device and directory parts of PATHNAME as a string. ------------------------------------------------------------------------------ DISASSEMBLE [Function] Args: (&optional (thing nil) &key (h-file nil) (data-file nil)) Compiles the form specified by THING and prints the intermediate C language code for that form. But does NOT install the result of compilation. If THING is NIL, then the previously disassembled form is re-disassembled. If THING is a symbol that names a not-yet-compiled function, the function definition is disassembled. If THING is a lambda expression, it is disassembled as a function definition. Otherwise, THING itself is disassembled as a top-level form. ------------------------------------------------------------------------------ DO [Macro] Syntax: (do ({(var [init [step]])}*) (endtest {result}*) {decl}* {tag | statement}*) Creates a NIL block, binds each VAR to the value of the corresponding INIT, then executes STATEMENTs repeatedly until ENDTEST is satisfied. After each iteration, assigns to each VAR the value of the corresponding STEP. When ENDTEST is satisfied, evaluates RESULTs as a PROGN and returns. Performs variable bindings and assignments all at once, just like LET and PSETQ do. ------------------------------------------------------------------------------ DO* [Macro] Syntax: (do* ({(var [init [step]])}*) (endtest {result}*) {decl}* {tag | statement}*) Just like DO, but performs variable bindings and assignments in serial, just like LET* and SETQ do. ------------------------------------------------------------------------------ DO-ALL-SYMBOLS [Macro] Syntax: (do-all-symbols (var [result-form]) {decl}* {tag | statement}*) Executes STATEMENTs once for each symbol in each package with VAR bound to the current symbol. Then evaluates RESULT-FORM (which defaults to NIL) and returns the value. ------------------------------------------------------------------------------ DO-EXTERNAL-SYMBOLS [Macro] Syntax: (do-external-symbols (var [package [result-form]]) {decl}* {tag | statement}*) Executes STATEMENTs once for each external symbol in the PACKAGE (which defaults to the current package) with VAR bound to the current symbol. Then evaluates RESULT-FORM (which defaults to NIL) and returns the value. ------------------------------------------------------------------------------ KCL Dictionary Page 29 ------------------------------------------------------------------------------ DO-SYMBOLS [Macro] Syntax: (do-symbols (var [package [result-form]]) {decl}* {tag | statement}*) Executes STATEMENTs once for each symbol in the PACKAGE (which defaults to the current package) with VAR bound to the current symbol. Then evaluates RESULT-FORM (which defaults to NIL) and returns the value. ------------------------------------------------------------------------------ DOCUMENTATION [Function] Args: (symbol doc-type) Returns the doc-string of DOC-TYPE for SYMBOL; NIL if none exists. Possible doc-types are: FUNCTION (special forms, macros, and functions) VARIABLE (dynamic variables, including constants) TYPE (types defined by DEFTYPE) STRUCTURE (structures defined by DEFSTRUCT) SETF (SETF methods defined by DEFSETF, DEFINE-SETF-METHOD, and DEFINE-MODIFY-MACRO) All built-in special forms, macros, functions, and variables have their doc-strings. ------------------------------------------------------------------------------ DOLIST [Macro] Syntax: (dolist (var listform [result]) {decl}* {tag | statement}*) Executes STATEMENTs with VAR bound to each member of the list value of LISTFORM, then returns the value of RESULT which defaults to NIL. ------------------------------------------------------------------------------ DOTIMES [Macro] Syntax: (dotimes (var countform [result]) {decl}* {tag | statement}*) Executes STATEMENTs with VAR increasing from 0 (inclusive) to the value of COUNTFORM (exclusive). Returns the value of RESULT which defaults to NIL. ------------------------------------------------------------------------------ DOUBLE-FLOAT-EPSILON [Constant] Same as LONG-FLOAT-EPSILON. ------------------------------------------------------------------------------ DOUBLE-FLOAT-NEGATIVE-EPSILON [Constant] Same as LONG-FLOAT-NEGATIVE-EPSILON. ------------------------------------------------------------------------------ DPB [Function] Args: (newbyte bytespec integer) Returns the same number as INTEGER except in the specified bits which are occupied by the bits from NEWBYTE. ------------------------------------------------------------------------------ DRIBBLE [Function] Args: (&optional pathname) If PATHNAME is given, begins to send a record of the interaction to the specified file. If not, terminates the recording. ------------------------------------------------------------------------------ ECASE [Macro] Syntax: (ecase keyform {({key | ({key}*)} {form}*)}*) Evaluates KEYFORM and tries to find the KEY that is EQL to the value of KEYFORM. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, signals an error. ------------------------------------------------------------------------------ KCL Dictionary Page 30 ------------------------------------------------------------------------------ ED [Function] Args: (&optional x) Invokes the editor. The action depends on the version of KCL. See the KCL Report for details. ------------------------------------------------------------------------------ EIGHTH [Function] Args: (x) Equivalent to (CADDDR (CDDDDR X)). ------------------------------------------------------------------------------ ELT [Function] Args: (sequence index) Returns the element of SEQUENCE specified by INDEX. The first element of a sequence has index 0. ------------------------------------------------------------------------------ ENCODE-UNIVERSAL-TIME [Function] Args: (second minute hour date month year &optional (timezone -9)) Encodes the time specified by the arguments into universal time format, and returns it. TIMEZONE in KCL defaults to -9, the time zone in Japan. ------------------------------------------------------------------------------ ENDP [Function] Args: (x) Returns T if X is NIL. Returns NIL if X is a cons. Otherwise, signals an error. ------------------------------------------------------------------------------ ENOUGH-NAMESTRING [Function] Args: (pathname &optional (defaults *default-pathname-defaults*)) Returns a string which uniquely identifies PATHNAME with respect to DEFAULTS. ------------------------------------------------------------------------------ EQ [Function] Args: (x y) Returns T if X and Y are the same identical object; NIL otherwise. ------------------------------------------------------------------------------ EQL [Function] Args: (x y) Returns T if X and Y are EQ, or if they are numbers of the same type with the same value, or if they are character objects that represent the same character. Returns NIL otherwise. ------------------------------------------------------------------------------ EQUAL [Function] Args: (x y) Returns T if X and Y are EQL or if they are of the same type and corresponding components are EQUAL. Returns NIL otherwise. Strings and bit-vectors are EQUAL if they are the same length and have identical components. Other arrays must be EQ to be EQUAL. ------------------------------------------------------------------------------ KCL Dictionary Page 31 ------------------------------------------------------------------------------ EQUALP [Function] Args: (x y) Returns T if X and Y are EQUAL; if they are characters and satisfy CHAR-EQUAL; if they are numbers and have the same numerical value; or if they have components that are all EQUALP. Returns NIL otherwise. ------------------------------------------------------------------------------ ERROR [Function] Args: (control-string &rest args) Signals a fatal error. CONTROL-STRING and ARGS are formatted to *ERROR-OUTPUT*. ------------------------------------------------------------------------------ *ERROR-OUTPUT* [Variable] The error output stream. ------------------------------------------------------------------------------ ETYPECASE [Macro] Syntax: (etypecase keyform {(type {form}*)}*) Evaluates KEYFORM and tries to find the TYPE in which the value of KEYFORM belongs. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, signals an error. ------------------------------------------------------------------------------ EVAL [Function] Args: (exp) Evaluates its single arg in a null lexical environment, returns the result or results. ------------------------------------------------------------------------------ EVAL-WHEN [Special form] Syntax: (eval-when ({situation}*) {form}*) Each situation must be a symbol, either COMPILE, LOAD, or EVAL. If the symbol EVAL is specified as a SITUATION, FORMs are evaluated by the interpreter. If COMPILE is specified, FORMs are evaluated within the compiler environment. If LOAD is specified, the compiler arranges for FORMs to be evaluated when the compiled file is loaded. ------------------------------------------------------------------------------ *EVAL-WHEN-COMPILE* [Variable] KCL specific: Tells the KCL compiler whether (non-NIL) or not (NIL) the compiler should process top-level forms in compile-time-too mode. ------------------------------------------------------------------------------ EVALHOOK [Function] Args: (form evalhookfn applyhookfn &optional (env nil)) Evaluates FORM with *EVALHOOK* bound to EVALHOOKFN and *APPLYHOOK* bound to APPLYHOOKFN. Ignores these hooks once, for the top-level evaluation of FORM. ------------------------------------------------------------------------------ *EVALHOOK* [Variable] Used to substitute another function for EVAL, for use by STEP, etc. If *EVALHOOK* is not NIL, its value must be a function that can receive two arguments: a form to evaluate and an environment. This function does the evaluation instead of EVAL. ------------------------------------------------------------------------------ KCL Dictionary Page 32 ------------------------------------------------------------------------------ EVENP [Function] Args: (integer) Returns T if INTEGER is even; NIL otherwise. ------------------------------------------------------------------------------ EVERY [Function] Args: (predicate sequence &rest more-sequences) PREDICATE is applied to the 0-th elements of SEQUENCEs, then possibly 1-st elments, and so on. Returns NIL as soon as any invocation of PREDICATE returns NIL, or T if every invocation is non-NIL. ------------------------------------------------------------------------------ EXP [Function] Args: (number) Calculates e raised to the power NUMBER, where e is the base of natural logarithms. ------------------------------------------------------------------------------ EXPORT [Function] Args: (symbols &optional (package *package*)) Makes SYMBOLS accessible as external symbols in PACKAGE. SYMBOLS must be a list of symbols or a symbol. ------------------------------------------------------------------------------ EXPT [Function] Args: (base-number power-number) Returns BASE-NUMBER raised to the power POWER-NUMBER. ------------------------------------------------------------------------------ FBOUNDP [Function] Args: (symbol) Returns T if SYMBOL has a global function definition or if SYMBOL names a special form or a macro; NIL otherwise. ------------------------------------------------------------------------------ FCEILING [Function] Args: (number &optional (divisor 1)) Same as CEILING, but returns first value as a float. ------------------------------------------------------------------------------ *FEATURES* [Variable] List of symbols that name features of the current version of KCL. These features are used to decide the read-time conditionalization facility provided by '#+' and '#-' read macros. When the KCL reader encounters #+ feature-description form it reads FORM in the usual manner if FEATURE-DESCRIPTION is true. Otherwise, the reader just skips FORM. #- feature-description form is equivalent to #- (not feature-description) form A feature-description may be a symbol, which is true only when it is an element of *FEATURES*. Or else, it must be one of the following: (and feature-desciption-1 ... feature-desciption-n) (or feature-desciption-1 ... feature-desciption-n) (not feature-desciption) The AND description is true only when all of its sub-descriptions are true. The OR description is true only when at least one of its sub-descriptions is true. The NOT description is true only when its sub-description is false. ------------------------------------------------------------------------------ KCL Dictionary Page 33 ------------------------------------------------------------------------------ FFLOOR [Function] Args: (number &optional (divisor 1)) Same as FLOOR, but returns first value as a float. ------------------------------------------------------------------------------ FIFTH [Function] Args: (x) Equivalent to (CAR (CDDDDR X)). ------------------------------------------------------------------------------ FILE-AUTHOR [Function] Args: (file) Returns the name of the author of the specified file, as a string. FILE may be a string or a stream ------------------------------------------------------------------------------ FILE-LENGTH [Function] Args: (file-stream) Returns the length of the specified stream. ------------------------------------------------------------------------------ FILE-NAMESTRING [Function] Args: (pathname) Returns the name, type, and version of PATHNAME as a string. ------------------------------------------------------------------------------ FILE-POSITION [Function] Args: (file-stream &optional position) With one argument, this function returns the current file position of the specified file, as an integer. If POSITION is given, this function sets the file position of the specified file to POSITION. ------------------------------------------------------------------------------ FILE-WRITE-DATE [Function] Args: (file) Returns the time at which the specified file is written, as an integer in universal time format. FILE may be a string or a stream ------------------------------------------------------------------------------ FILL [Function] Args: (sequence item &key (start 0) (end (length sequence))) Replaces the specified elements of SEQUENCE with ITEM. ------------------------------------------------------------------------------ FILL-POINTER [Function] Args: (vector) Returns the fill pointer of VECTOR. Signals an error if VECTOR does not have a fill pointer. ------------------------------------------------------------------------------ FIND [Function] Args: (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) Returns the first element in SEQUENCE satisfying TEST with ITEM. ------------------------------------------------------------------------------ KCL Dictionary Page 34 ------------------------------------------------------------------------------ FIND-ALL-SYMBOLS [Function] Args: (string-or-symbol) Returns a list of all symbols in the system having the specified name. ------------------------------------------------------------------------------ FIND-IF [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the index of the first element in SEQUENCE that satisfies TEST; NIL if no such element exists. ------------------------------------------------------------------------------ FIND-IF-NOT [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the index of the first element in SEQUENCE that does not satisfy TEST; NIL if no such element exists. ------------------------------------------------------------------------------ FIND-PACKAGE [Function] Args: (name) Returns the specified package if it already exists; NIL otherwise. NAME may be a string that is the name or nickname of the package. NAME may also be a symbol, in which case the symbol's print name is used. ------------------------------------------------------------------------------ FIND-SYMBOL [Function] Args: (name &optional (package *package*)) Returns the symbol named NAME in PACKAGE. If such a symbol is found, then the second value is :INTERN, :EXTERNAL, or :INHERITED to indicate how the symbol is accessible. If no symbol is found then both values are NIL. ------------------------------------------------------------------------------ FINISH-OUTPUT [Function] Args: (&optional (stream *standard-output*)) Attempts to ensure that all output sent to STREAM has reached its destination, and only then returns. ------------------------------------------------------------------------------ FIRST [Function] Args: (x) Equivalent to (CAR X). ------------------------------------------------------------------------------ FIXNUM [Type] A fixnum is an integer between MOST-NEGATIVE-FIXNUM (= -2147483648) and MOST-POSITIVE-FIXNUM (= 2147483647), inclusive. Other integers are bignums. ------------------------------------------------------------------------------ FLET [Special form] Syntax: (flet ({(name lambda-list {decl | doc}* {form}*)}*) . body) Evaluates BODY as a PROGN, with the local function definitions in effect. The scope of the locally defined functions does not include the function definitions themselves, so they can reference externally defined functions of the same name. See the doc of DEFUN for the complete syntax of a lambda- list. Doc-strings for local functions are simply ignored. ------------------------------------------------------------------------------ KCL Dictionary Page 35 ------------------------------------------------------------------------------ FLOAT [Type] KCL supports two kinds of floating-point numbers. One kind is called short-float and the other kind is called single-float, double-float, or long-float. Precisions and exponent sizes of floating-point numbers depends on the version of KCL. See the KCL Report at your hand for details. The following syntax is used to denote a floating-point number. { [sign] {radix-10-digit}* decimal-point {radix-10-digit}+ [exponent] | [sign] {radix-10-digit}+ [decimal-point {radix-10-digit}*}] exponent } where EXPONENT is { e | s | f | d | l | E | S | F | D | L } [sign] {radix-10-digit}+ See the type doc of INTEGER for the syntactic variables used here. The exponent markers in EXPONENT have the following interpretations. e or E floating-point number in the default float format s or S short-float f or F single-float d or D double-float l or L long-float The default float format is single-float normally, but may be any other float format. See the variable doc of *READ-DEFAULT-FLOAT-FORMAT*. ------------------------------------------------------------------------------ FLOAT [Function] Args: (number &optional (other nil)) Converts a number of any type to floating point. If OTHER is not provided, it returns a SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the result is the same float format as OTHER. ------------------------------------------------------------------------------ FLOAT-DIGITS [Function] Args: (float) Returns the number of the radix digits used to represent the floating-point number FLOAT. ------------------------------------------------------------------------------ FLOAT-PRECISION [Function] Args: (float) Returns the number of the significant radix digits used to represent the floating-point number FLOAT. ------------------------------------------------------------------------------ FLOAT-RADIX [Function] Args: (float) Returns the radix of the floating-point number FLOAT. ------------------------------------------------------------------------------ FLOAT-SIGN [Function] Args: (float1 &optional (float2 (float 1 float1))) Returns a floating-point number with the same sign as FLOAT1 and with the same absolute value as FLOAT2. ------------------------------------------------------------------------------ FLOATP [Function] Args: (x) Returns T if X is a floating-point number; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 36 ------------------------------------------------------------------------------ FLOOR [Function] Args: (number &optional (divisor 1)) Returns the greatest integer not greater than NUMBER/DIVISOR. The second returned value is (MOD NUMBER DIVISOR). ------------------------------------------------------------------------------ FMAKUNBOUND [Function] Args: (symbol) Causes the global function definition named by SYMBOL to become unbound. Returns SYMBOL. ------------------------------------------------------------------------------ FORCE-OUTPUT [Function] Args: (&optional (stream *standard-output*)) Attempts to force any buffered output to be sent. ------------------------------------------------------------------------------ FORMAT [Function] Args: (destination control-string &rest arguments) Provides various facilities for formatting output. CONTROL-STRING is a string to be output, possibly with embedded formatting directives, which are flagged with the escape character "~". Directives generally expand into additional text to be output, usually consuming one or more of ARGUMENTs in the process. A few useful directives are: ~A, ~nA, ~n@A Prints one argument as if by PRINC ~S, ~nS, ~n@S Prints one argument as if by PRIN1 ~D, ~B, ~O, ~X Prints one integer in decimal, binary, octal, and hexa ~% Does TERPRI ~& Does FRESH-LINE where n is the minimal width of the field in which the object is printed. ~nA and ~nS put padding spaces on the right; ~n@A and ~n@S put on the left. DESTINATION controls where the result will go. If DESTINATION is T, then the output is sent to the standard output stream. If it is NIL, then the output is returned in a string as the value of the call. Otherwise, DESTINATION must be a stream to which the output will be sent. ------------------------------------------------------------------------------ FOURTH [Function] Args: (x) Equivalent to (CADDDR X). ------------------------------------------------------------------------------ FRESH-LINE [Function] Args: (&optional (stream *standard-output*)) Outputs a newline if it is not positioned at the beginning of a line. Returns T if it output a newline; NIL otherwise. ------------------------------------------------------------------------------ FROUND [Function] Args: (number &optional (divisor 1)) Same as ROUND, but returns first value as a float. ------------------------------------------------------------------------------ KCL Dictionary Page 37 ------------------------------------------------------------------------------ FTRUNCATE [Function] Args: (number &optional (divisor 1)) Same as TRUNCATE, but returns first value as a float. ------------------------------------------------------------------------------ FUNCALL [Function] Args: (function &rest arguments) Applies FUNCTION to the ARGUMENTs ------------------------------------------------------------------------------ FUNCTION [Type] A function is anything that may be correctly given to the FUNCALL or APPLY function, and is to be executed as code when arguments are supplied. A function is either: * a compiled function (compiled-function or compiled-closure) * a list in one of the following format. (lambda lambda-list . body) (lambda-block block-name lambda-list . body) (lambda-closure env1 env2 env3 lambda-list . body) (lambda-block-closure env1 env2 env3 block-name lambda-list . body) where env1, env2, and env3 respectively represent the variable environment, the function/macro environment, and the block/tagbody environment at the time of the function creation. * a symbol that names a function. See the doc of DEFUN for the complete syntax of a lambda-list. ------------------------------------------------------------------------------ FUNCTION [Special form] Syntax: (function x) or #'x If X is a lambda expression, creates and returns a lexical closure of X in the current lexical environment. If X is a symbol that names a function, returns that function. ------------------------------------------------------------------------------ FUNCTIONP [Function] Args: (x) Returns T if X is a function, suitable for use by FUNCALL or APPLY. Returns NIL otherwise. ------------------------------------------------------------------------------ GBC [Function] Args: (x) KCL specific: Invokes the garbage collector (GC) with the collection level specified by X. NIL as the argument causes GC to collect cells only. T as the argument causes GC to collect everything. ------------------------------------------------------------------------------ GCD [Function] Args: (&rest integers) Returns the greatest common divisor of INTEGERs. ------------------------------------------------------------------------------ GENSYM [Function] Args: (&optional (x nil)) Creates and returns a new uninterned symbol whose name is a prefix string (defaults to "G"), followed by a decimal number. The number is incremented by each call to GENSYM. X, if an integer, resets the counter. If X is a string, it becomes the new prefix. ------------------------------------------------------------------------------ KCL Dictionary Page 38 ------------------------------------------------------------------------------ GENTEMP [Function] Args: (&optional (prefix "t") (package *package*)) Creates a new symbol interned in the package PACKAGE with the given PREFIX. ------------------------------------------------------------------------------ GET [Function] Args: (symbol indicator &optional (default nil)) Looks on the property list of SYMBOL for the specified INDICATOR. If this is found, returns the associated value. Otherwise, returns DEFAULT. ------------------------------------------------------------------------------ GET-DECODED-TIME [Function] Args: () Returns the current time in decoded time format. Returns nine values: second, minute, hour, date, month, year, day-of-week, daylight-saving-time-p, and time-zone. ------------------------------------------------------------------------------ GET-DISPATCH-MACRO-CHARACTER [Function] Args: (disp-char sub-char &optional (readtable *readtable*)) Returns the macro-character function for SUB-CHAR under DISP-CHAR. ------------------------------------------------------------------------------ GET-INTERNAL-REAL-TIME [Function] Args: () Returns the real time in the internal time format. This is useful for finding elapsed time. ------------------------------------------------------------------------------ GET-INTERNAL-RUN-TIME [Function] Args: () Returns the run time in the internal time format. This is useful for finding CPU usage. ------------------------------------------------------------------------------ GET-MACRO-CHARACTER [Function] Args: (char &optional (readtable *readtable*)) Returns the function associated with CHAR and, as a second value, returns the non-terminating-p flag. ------------------------------------------------------------------------------ GET-OUTPUT-STREAM-STRING [Function] Args: (stream) Returns a string of all the characters sent to STREAM made by MAKE-STRING-OUTPUT-STREAM since the last call to this function. ------------------------------------------------------------------------------ GET-PROPERTIES [Function] Args: (place indicator-list) Looks for the elements of INDICATOR-LIST in the property list stored in PLACE. If found, returns the indicator, the value, and T as multiple-values. If not, returns NILs as its three values. ------------------------------------------------------------------------------ KCL Dictionary Page 39 ------------------------------------------------------------------------------ GET-SETF-METHOD [Function] Args: (form) Returns the five values (or five 'gangs') constituting the SETF method for FORM. See the doc of DEFINE-SETF-METHOD for the meanings of the gangs. It is an error if the third value (i.e., the list of store variables) is not a one-element list. See the doc of GET-SETF-METHOD-MULTIPLE-VALUE for comparison. ------------------------------------------------------------------------------ GET-SETF-METHOD-MULTIPLE-VALUE [Function] Args: (form) Returns the five values (or five 'gangs') constituting the SETF method for FORM. See the doc of DEFINE-SETF-METHOD for the meanings of the gangs. The third value (i.e., the list of store variables) may consist of any number of elements. See the doc of GET-SETF-METHOD for comparison. ------------------------------------------------------------------------------ GET-UNIVERSAL-TIME [Function] Args: () Returns the current time as a single integer in universal time format. ------------------------------------------------------------------------------ GETF [Function] Args: (place indicator &optional (default nil)) Searches the property list stored in Place for an indicator EQ to Indicator. If one is found, the corresponding value is returned, else the Default is returned. ------------------------------------------------------------------------------ GETHASH [Function] Args: (key hash-table &optional (default nil)) Finds the entry in HASH-TABLE whose key is KEY and returns the associated value and T, as multiple values. Returns DEFAULT and NIL if there is no such entry. ------------------------------------------------------------------------------ GO [Special form] Syntax: (go tag) Jumps to the specified TAG established by a lexically surrounding TAGBODY. ------------------------------------------------------------------------------ GRAPHIC-CHAR-P [Function] Args: (char) Returns T if CHAR is a printing character, i.e., #\Space through #\~; NIL otherwise. ------------------------------------------------------------------------------ HASH-TABLE [Type] Hash tables provide an efficient way of mapping any Lisp object to an associated object. A hash table is denoted as #<a hash-table>. ------------------------------------------------------------------------------ HASH-TABLE-COUNT [Function] Args: (hash-table) Returns the number of entries in the given Hash-Table. ------------------------------------------------------------------------------ KCL Dictionary Page 40 ------------------------------------------------------------------------------ HASH-TABLE-P [Function] Args: (x) Returns T if X is a hash table object; NIL otherwise. ------------------------------------------------------------------------------ HELP [Function] Args: (&optional symbol) KCL specific: Prints the documentation associated with SYMBOL. With no argument, this function prints the greeting message to KCL beginners. ------------------------------------------------------------------------------ HELP* [Function] Args: (string &optional (package 'lisp)) KCL specific: Prints the documentation associated with those symbols in the specified package whose print names contain STRING as substring. STRING may be a symbol, in which case the print-name of that symbol is used. If PACKAGE is NIL, then all packages are searched. ------------------------------------------------------------------------------ HOST-NAMESTRING [Function] Args: (pathname) Returns the host part of PATHNAME as a string. ------------------------------------------------------------------------------ IDENTITY [Function] Args: (x) Simply returns X. ------------------------------------------------------------------------------ IF [Special form] Syntax: (if test then [else]) If TEST evaluates to non-NIL, then evaluates THEN and returns the result. If not, evaluates ELSE (which defaults to NIL) and returns the result. ------------------------------------------------------------------------------ *IGNORE-MAXIMUM-PAGES* [Variable] KCL specific: Tells the KCL memory manager whether (non-NIL) or not (NIL) it should expand memory whenever the maximum allocatable pages have been used up. ------------------------------------------------------------------------------ IMAGPART [Function] Args: (number) Extracts the imaginary part of NUMBER. ------------------------------------------------------------------------------ IMPORT [Function] Args: (symbols &optional (package *package*)) Makes SYMBOLS available as internal symbols in PACKAGE. If a symbol is already available then it has no effect. If a name conflict would result from the importation, then a correctable error is signalled. SYMBOLS must be a list of symbols or a symbol. ------------------------------------------------------------------------------ KCL Dictionary Page 41 ------------------------------------------------------------------------------ IN-PACKAGE [Function] Args: (package-name &key (nicknames nil) (use '(lisp))) Sets *PACKAGE* to the package with PACKAGE-NAME, creating the package if it does not exist. If the package already exists then it is modified to agree with USE and NICKNAMES arguments. Any new nicknames are added without removing any old ones not specified. If any package in the USE list is not currently used, then it is added to the use list. ------------------------------------------------------------------------------ INCF [Macro] Syntax: (incf place [delta]) Adds the number produced by DELTA (which defaults to 1) to the number in PLACE. ------------------------------------------------------------------------------ INPUT-STREAM-P [Function] Args: (stream) Returns non-NIL if STREAM can handle input operations; NIL otherwise. ------------------------------------------------------------------------------ INSPECT [Function] Args: (x) Shows the information about the object X in an interactive manner ------------------------------------------------------------------------------ INT-CHAR [Function] Args: (integer) Performs the inverse of CHAR-INT. Equivalent to CODE-CHAR in KCL. ------------------------------------------------------------------------------ INTEGER [Type] An integer represents a mathematical integer. An integer may be a fixnum, or else it is a bignum. Normally, the following syntax is used to denote an integer: { [sign]{digit-in-default-radix}+ | {#b | #B} [sign] {radix-2-digit}+ | {#o | #O} [sign] {radix-8-digit}+ | [sign] {radix-10-digit}+ decimal-point | {#x | #X} [sign] {radix-16-digit}+ | {#2r | #2R} [sign] {radix-2-digit}+ .... | {#36r | #36R} [sign] {radix-36-digit}+ } where SIGN is either '+' or '-', DECIMAL-POINT is '.', and digit-in-radix-2 ::= { 0 | 1 } ... digit-in-radix-10 ::= { 0 | 1 | ... | 9 } digit-in-radix-11 ::= { 0 | 1 | ... | 9 | a | A } ... digit-in-radix-36 ::= { 0 | 1 | ... | 9 | a | ... | z | A | ... | Z } The default radix is 10 normally, but may be any integer between 2 and 36 inclusive. See the variable docs of *PRINT-RADIX* and *READ-BASE*. ------------------------------------------------------------------------------ INTEGER-DECODE-FLOAT [Function] Args: (float) Returns as an integer the significand of the floating-point number. ------------------------------------------------------------------------------ KCL Dictionary Page 42 ------------------------------------------------------------------------------ INTEGER-LENGTH [Function] Args: (integer) Returns the number of significant bits in the absolute value of INTEGER. ------------------------------------------------------------------------------ INTEGERP [Function] Args: (x) Returns T if X is an integer (fixnum or bignum); NIL otherwise. ------------------------------------------------------------------------------ INTERN [Function] Args: (name &optional (package *package*)) Returns a symbol having the specified name, creating it if necessary. Returns as the second value one of the symbols :INTERNAL, :EXTERNAL, :INHERITED, and NIL. ------------------------------------------------------------------------------ INTERNAL-TIME-UNITS-PER-SECOND [Constant] The number of internal time units that fit into a second. ------------------------------------------------------------------------------ INTERSECTION [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns the intersection of List1 and List2. ------------------------------------------------------------------------------ ISQRT [Function] Args: (integer) Returns the greatest integer less than or equal to the square root of the given non-negative integer. ------------------------------------------------------------------------------ KEYWORDP [Function] Args: (x) Returns T if X is a symbol and it belongs to the KEYWORD package; NIL otherwise. ------------------------------------------------------------------------------ LABELS [Special form] Syntax: (labels ({(name lambda-list {decl | doc}* {form}*)}*) . body) Evaluates BODY as a PROGN, with the local function definitions in effect. The scope of the locally defined functions include the function definitions themselves, so they can reference externally defined functions of the same name. See the doc of DEFUN for the complete syntax of a lambda-list. Doc-strings for local functions are simply ignored. ------------------------------------------------------------------------------ LAMBDA-LIST-KEYWORDS [Constant] List of all the lambda-list keywords used in KCL. ------------------------------------------------------------------------------ LAMBDA-PARAMETERS-LIMIT [Constant] The exclusive upper bound on the number of distinct parameter names that may appear in a single lambda-list. Actually, however, there is no such upper bound in KCL. ------------------------------------------------------------------------------ KCL Dictionary Page 43 ------------------------------------------------------------------------------ LAST [Function] Args: (list) Returns the last cons in LIST ------------------------------------------------------------------------------ LAST-TERMINATION-MESSAGE [Function] Args: () KCL specific: Flushes all the message currently spooled and returns the last termination message as a string. Only KCL/AOS supports this function. ------------------------------------------------------------------------------ LCM [Function] Args: (integer &rest more-integers) Returns the least common multiple of the arguments. ------------------------------------------------------------------------------ LDB [Function] Args: (bytespec integer) Extracts the specified byte from INTEGER, and right justifies the result. ------------------------------------------------------------------------------ LDB-TEST [Function] Args: (bytespec integer) Returns T if any of the specified bits in INTEGER are 1. ------------------------------------------------------------------------------ LDIFF [Function] Args: (list sublist) Returns a new list, whose elements are those of LIST that appear before SUBLIST. If SUBLIST is not a tail of LIST, a copy of LIST is returned. ------------------------------------------------------------------------------ LEAST-NEGATIVE-DOUBLE-FLOAT [Constant] Same as LEAST-NEGATIVE-LONG-FLOAT. ------------------------------------------------------------------------------ LEAST-NEGATIVE-LONG-FLOAT [Constant] The negative long-float closest in value to zero. ------------------------------------------------------------------------------ LEAST-NEGATIVE-SHORT-FLOAT [Constant] The negative short-float closest in value to zero. ------------------------------------------------------------------------------ LEAST-NEGATIVE-SINGLE-FLOAT [Constant] Same as LEAST-NEGATIVE-LONG-FLOAT. ------------------------------------------------------------------------------ LEAST-POSITIVE-DOUBLE-FLOAT [Constant] Same as LEAST-POSITIVE-LONG-FLOAT. ------------------------------------------------------------------------------ LEAST-POSITIVE-LONG-FLOAT [Constant] The positive long-float closest in value to zero. ------------------------------------------------------------------------------ LEAST-POSITIVE-SHORT-FLOAT [Constant] The positive short-float closest in value to zero. ------------------------------------------------------------------------------ KCL Dictionary Page 44 ------------------------------------------------------------------------------ LEAST-POSITIVE-SINGLE-FLOAT [Constant] Same as LEAST-POSITIVE-LONG-FLOAT. ------------------------------------------------------------------------------ LENGTH [Function] Args: (sequence) Returns the length of SEQUENCE. ------------------------------------------------------------------------------ LET [Special form] Syntax: (let ({var | (var [value])}*) {decl}* {form}*) Initializes VARs, binding them to the values of VALUEs (which defaults to NIL) all at once, then evaluates FORMs as a PROGN. ------------------------------------------------------------------------------ LET* [Special form] Syntax: (let* ({var | (var [value])}*) {decl}* {form}*) Initializes VARs, binding them to the values of VALUEs (which defaults to NIL) from left to right, then evaluates FORMs as a PROGN. ------------------------------------------------------------------------------ LISP-IMPLEMENTATION-TYPE [Function] Args: () Returns a string that tells you that you are using a version of KCL. ------------------------------------------------------------------------------ LISP-IMPLEMENTATION-VERSION [Function] Args: () Returns a string that tells you when the current KCL implementation is brought up. ------------------------------------------------------------------------------ LIST [Type] A list is either NIL (the empty list) or a cons whose cdr is a list. A list is denoted by writing its element in order, separated by blank space, and surrounded by parentheses. A dotted list is a cons whose cdr is either a non-cons object or a dotted list. A dotted list is denoted in the same way as a list is, but the last cdr in the cdr chain is preceded by a dot '.' and blank space. The backquote macro is sometimes useful to construct a compilcated list structure. When evaluating `(...) ,form embeds the value of FORM, ,@form and ,.form embed all elements of the list value of FORM, and other things embed itself into the structure at their position. For example, `(a b ,c d e) expands to (list* 'a 'b c '(d e)) `(a b ,@c d e) expands to (list* 'a 'b (append c '(d e))) `(a b ,.c d e) expands to (list* 'a 'b (nconc c '(d e))) ------------------------------------------------------------------------------ LIST [Function] Args: (&rest args) Returns a list of its arguments ------------------------------------------------------------------------------ KCL Dictionary Page 45 ------------------------------------------------------------------------------ LIST* [Function] Args: (arg &rest others) Returns a list of its arguments with the last cons being a dotted pair of the next to the last argument and the last argument. ------------------------------------------------------------------------------ LIST-ALL-PACKAGES [Function] Args: () Returns a list of all existing packages. ------------------------------------------------------------------------------ LIST-LENGTH [Function] Args: (list) Returns the length of LIST, or NIL if LIST is circular. ------------------------------------------------------------------------------ LISTEN [Function] Args: (&optional (stream *standard-input*)) Returns T if a character is available on STREAM; NIL otherwise. This function does not correctly work in some versions of KCL because of the lack of such mechanism in the underlying operating system. ------------------------------------------------------------------------------ LISTP [Function] Args: (x) Returns T if X is either a cons or NIL; NIL otherwise. ------------------------------------------------------------------------------ LOAD [Function] Args: (filename &key (verbose *load-verbose*) (print nil) (if-does-not-exist :error)) Loads the file named by FILENAME into KCL. ------------------------------------------------------------------------------ *LOAD-VERBOSE* [Variable] The default for the VERBOSE argument to LOAD. ------------------------------------------------------------------------------ LOCALLY [Macro] Syntax: (locally {decl}* {form}*) Gives local pervasive declarations. ------------------------------------------------------------------------------ LOG [Function] Args: (number &optional base) Returns the logarithm of NUMBER in the base BASE. BASE defaults to the base of natural logarithms. ------------------------------------------------------------------------------ LOGAND [Function] Args: (&rest integers) Returns the bit-wise AND of its arguments. ------------------------------------------------------------------------------ LOGANDC1 [Function] Args: (integer1 integer2) Returns the logical AND of (LOGNOT INTEGER1) and INTEGER2. ------------------------------------------------------------------------------ KCL Dictionary Page 46 ------------------------------------------------------------------------------ LOGANDC2 [Function] Args: (integer1 integer2) Returns the logical AND of INTEGER1 and (LOGNOT INTEGER2). ------------------------------------------------------------------------------ LOGBITP [Function] Args: (index integer) Returns T if the INDEX-th bit of INTEGER is 1. ------------------------------------------------------------------------------ LOGCOUNT [Function] Args: (integer) If INTEGER is negative, returns the number of 0 bits. Otherwise, returns the number of 1 bits. ------------------------------------------------------------------------------ LOGEQV [Function] Args: (&rest integers) Returns the bit-wise EQUIVALENCE of its arguments. ------------------------------------------------------------------------------ LOGIOR [Function] Args: (&rest integers) Returns the bit-wise INCLUSIVE OR of its arguments. ------------------------------------------------------------------------------ LOGNAND [Function] Args: (integer1 integer2) Returns the complement of the logical AND of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ LOGNOR [Function] Args: (integer1 integer2) Returns the complement of the logical OR of INTEGER1 and INTEGER2. ------------------------------------------------------------------------------ LOGNOT [Function] Args: (integer) Returns the bit-wise logical NOT of INTEGER. ------------------------------------------------------------------------------ LOGORC1 [Function] Args: (integer1 integer2) Returns the logical OR of (LOGNOT INTEGER1) and INTEGER2. ------------------------------------------------------------------------------ LOGORC2 [Function] Args: (integer1 integer2) Returns the logical OR of INTEGER1 and (LOGNOT INTEGER2). ------------------------------------------------------------------------------ LOGTEST [Function] Args: (integer1 integer2) Returns T if LOGAND of INTEGER1 and INTEGER2 is not zero; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 47 ------------------------------------------------------------------------------ LOGXOR [Function] Args: (&rest integers) Returns the bit-wise EXCLUSIVE OR of its arguments. ------------------------------------------------------------------------------ LONG-FLOAT-EPSILON [Constant] The smallest positive long-float that satisfies (not (= (float 1 e) (+ (float 1 e) e))). ------------------------------------------------------------------------------ LONG-FLOAT-NEGATIVE-EPSILON [Constant] The smallest positive long-float that satisfies (not (= (float 1 e) (- (float 1 e) e))). ------------------------------------------------------------------------------ LONG-SITE-NAME [Function] Args: () Returns a string that identifies the physical location of the current KCL. ------------------------------------------------------------------------------ LOOP [Macro] Syntax: (loop {form}*) Executes FORMs repeatedly until exited by a THROW or RETURN. The FORMs are surrounded by an implicit NIL block. ------------------------------------------------------------------------------ LOWER-CASE-P [Function] Args: (char) Returns T if CHAR is a lower-case character; NIL otherwise. ------------------------------------------------------------------------------ MACHINE-INSTANCE [Function] Args: () Returns a string that identifies the machine instance of the machine on which KCL is currently running. ------------------------------------------------------------------------------ MACHINE-TYPE [Function] Args: () Returns a string that identifies the machine type of the machine on which KCL is currently running. ------------------------------------------------------------------------------ MACHINE-VERSION [Function] Args: () Returns a string that identifies the machine version of the machine on which KCL is currently running. ------------------------------------------------------------------------------ MACRO-FUNCTION [Function] Args: (symbol) If SYMBOL globally names a macro, then returns the expansion function. Returns NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 48 ------------------------------------------------------------------------------ MACROEXPAND [Function] Args: (form &optional (env nil)) If FORM is a macro form, then expands it repeatedly until it is not a macro any more. Returns two values: the expanded form and a T-or-NIL flag indicating whether the original form was a macro. ------------------------------------------------------------------------------ MACROEXPAND-1 [Function] Args: (form &optional (env nil)) If FORM is a macro form, then expands it once. Returns two values: the expanded form and a T-or-NIL flag indicating whether the original form was a macro. ------------------------------------------------------------------------------ *MACROEXPAND-HOOK* [Variable] Holds a function that can take two arguments (a macro expansion function and the macro form to be expanded) and returns the expanded form. This function is whenever a macro-expansion takes place. Initially this is set to #'FUNCALL. ------------------------------------------------------------------------------ MACROLET [Special form] Syntax: (macrolet ({(name defmacro-lambda-list {decl | doc}* . body)}*) {form}*) Evaluates FORMs as a PROGN, with the local macro definitions in effect. See the doc of DEFMACRO for the complete syntax of a defmacro-lambda-list. Doc-strings for local macros are simply ignored. ------------------------------------------------------------------------------ MAKE-ARRAY [Function] Args: (dimensions &key (element-type t) initial-element (initial-contents nil) (adjustable nil) (fill-pointer nil) (displaced-to nil) (displaced-index-offset 0)) Creates an array of the specified DIMENSIONS. The default for INITIAL- ELEMENT depends on ELEMENT-TYPE. ------------------------------------------------------------------------------ MAKE-BROADCAST-STREAM [Function] Args: (&rest streams) Returns an output stream which sends its output to all of the given streams. ------------------------------------------------------------------------------ MAKE-CHAR [Function] Args: (char &optional (bits 0) (font 0)) Returns a character object with the same code attribute as CHAR and with the specified BITS and FONT attributes. ------------------------------------------------------------------------------ MAKE-CONCATENATED-STREAM [Function] Args: (&rest streams) Returns a stream which takes its input from each of the STREAMs in turn, going on to the next at end of stream. ------------------------------------------------------------------------------ MAKE-DISPATCH-MACRO-CHARACTER [Function] Args: (char &optional (non-terminating-p nil) (readtable *readtable*)) Causes the character CHAR to be a dispatching macro character in READTABLE. ------------------------------------------------------------------------------ KCL Dictionary Page 49 ------------------------------------------------------------------------------ MAKE-ECHO-STREAM [Function] Args: (input-stream output-stream) Returns a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM. In addition, all input is echoed to OUTPUT-STREAM. ------------------------------------------------------------------------------ MAKE-HASH-TABLE [Function] Args: (&key (test 'eql) (size 1024) (rehash-size 1.5) (rehash-threshold 0.7)) Creates and returns a hash table. ------------------------------------------------------------------------------ MAKE-LIST [Function] Args: (size &key (initial-element nil)) Creates and returns a list containing SIZE elements, each of which is initialized to INITIAL-ELEMENT. ------------------------------------------------------------------------------ MAKE-PACKAGE [Function] Args: (package-name &key (nicknames nil) (use '(lisp))) Makes a new package having the specified PACKAGE-NAME and NICKNAMES. The package will inherit all external symbols from each package in the USE list. ------------------------------------------------------------------------------ MAKE-PATHNAME [Function] Args: (&key (defaults *make-pathname-default-pathname*) (host (pathname-host defaults)) (device (pathname-device defaults)) (directory (pathname-directory defaults)) (name (pathname-name defaults)) (type (pathname-type defaults)) (version (pathname-version defaults))) Create a pathname from HOST, DEVICE, DIRECTORY, NAME, TYPE and VERSION. ------------------------------------------------------------------------------ MAKE-RANDOM-STATE [Function] Args: (&optional (state *random-state*)) Creates and returns a copy of the specified random state. If STATE is NIL, then the value of *RANDOM-STATE* is used. If STATE is T, then returns a random state object generated from the universal time. ------------------------------------------------------------------------------ MAKE-SEQUENCE [Function] Args: (type length &key initial-element) Returns a sequence of the given TYPE and LENGTH, with elements initialized to INITIAL-ELEMENT. The default value of INITIAL-ELEMENT depends on TYPE. ------------------------------------------------------------------------------ MAKE-STRING [Function] Args: (size &key (initial-element #\Space)) Creates and returns a new string of SIZE length whose elements are all INITIAL-ELEMENT. ------------------------------------------------------------------------------ MAKE-STRING-INPUT-STREAM [Function] Args: (string &optional (start 0) (end (length string))) Returns an input stream which will supply the characters of String between Start and End in order. ------------------------------------------------------------------------------ KCL Dictionary Page 50 ------------------------------------------------------------------------------ MAKE-STRING-OUTPUT-STREAM [Function] Args: () Returns an output stream which will accumulate all output given it for the benefit of the function GET-OUTPUT-STREAM-STRING. ------------------------------------------------------------------------------ MAKE-SYMBOL [Function] Args: (string) Creates and returns a new uninterned symbol whose print name is STRING. ------------------------------------------------------------------------------ MAKE-SYNONYM-STREAM [Function] Args: (symbol) Returns a stream which performs its operations on the stream which is the value of the dynamic variable named by SYMBOL. ------------------------------------------------------------------------------ MAKE-TWO-WAY-STREAM [Function] Args: (input-stream output-stream) Returns a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM. ------------------------------------------------------------------------------ MAKUNBOUND [Function] Args: (symbol) Causes the dynamic variable named by SYMBOL to have not value. Returns SYMBOL. ------------------------------------------------------------------------------ MAP [Function] Args: (result-type function sequence &rest more-sequences) FUNCTION must take as many arguments as there are sequences provided. The result is a sequence such that the i-th element is the result of applying FUNCTION to the i-th elements of the SEQUENCEs. ------------------------------------------------------------------------------ MAPC [Function] Args: (fun list &rest more-lists) Applies FUN to successive cars of LISTs. Returns the first LIST. ------------------------------------------------------------------------------ MAPCAN [Function] Args: (fun list &rest more-lists) Applies FUN to successive cars of LISTs, NCONCs the results, and returns it. ------------------------------------------------------------------------------ MAPCAR [Function] Args: (fun list &rest more-lists) Applies FUN to successive cars of LISTs and returns the results as a list. ------------------------------------------------------------------------------ MAPCON [Function] Args: (fun list &rest more-lists) Applies FUN to successive cdrs of LISTs, NCONCs the results, and returns it. ------------------------------------------------------------------------------ KCL Dictionary Page 51 ------------------------------------------------------------------------------ MAPHASH [Function] Args: #'hash-table For each entry in HASH-TABLE, calls FUNCTION on the key and value of the entry; returns NIL. ------------------------------------------------------------------------------ MAPL [Function] Args: (fun list &rest more-lists) Applies FUN to successive cdrs of LISTs. Returns the first LIST. ------------------------------------------------------------------------------ MAPLIST [Function] Args: (fun list &rest more-lists) Applies FUN to successive cdrs of LISTs and returns the results as a list. ------------------------------------------------------------------------------ MASK-FIELD [Function] Args: (bytespec integer) Extracts the specified byte from INTEGER, without right justification. ------------------------------------------------------------------------------ MAX [Function] Args: (number &rest more-numbers) Returns the greatest of its arguments. ------------------------------------------------------------------------------ MAXIMUM-ALLOCATABLE-PAGES [Function] Args: (type) KCL specific: Returns the current maximum number of pages for the type class of the KCL implementation type TYPE. ------------------------------------------------------------------------------ MAXIMUM-CONTIGUOUS-PAGES [Function] Args: () KCL specific: Returns the current maximum number of pages for contiguous blocks. ------------------------------------------------------------------------------ MEMBER [Function] Args: (item list &key (test #'eql) test-not (key #'identity)) Returns the tail of LIST beginning with the first ITEM. ------------------------------------------------------------------------------ MEMBER-IF [Function] Args: (test list &key (key #'identity)) Returns the tail of LIST beginning with the first element satisfying TEST. ------------------------------------------------------------------------------ MEMBER-IF-NOT [Function] Args: (test list &key (key #'identity)) Returns the tail of LIST beginning with the first element not satisfying TEST. ------------------------------------------------------------------------------ MERGE [Function] Args: (result-type sequence1 sequence2 predicate &key (key #'identity)) SEQUENCE1 and SEQUENCE2 are destructively merged into a sequence of type RESULT-TYPE using PREDICATE to order the elements. ------------------------------------------------------------------------------ KCL Dictionary Page 52 ------------------------------------------------------------------------------ MERGE-PATHNAMES [Function] Args: (pathname &optional (defaults *default-pathname-defaults*) default-version) Fills in unspecified slots of PATHNAME from DEFAULTS. DEFAULT-VERSION is ignored in KCL. ------------------------------------------------------------------------------ MIN [Function] Args: (number &rest more-numbers) Returns the least of its arguments. ------------------------------------------------------------------------------ MINUSP [Function] Args: (number) Returns T if NUMBER < 0; NIL otherwise. ------------------------------------------------------------------------------ MISMATCH [Function] Args: (sequence1 sequence2 &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) (end1 (length sequence1)) (end2 (length sequence2)) (key #'identity)) The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared element-wise. If they are of equal length and match in every element, the result is NIL. Otherwise, the result is a non-negative integer, the index within SEQUENCE1 of the leftmost position at which they fail to match; or, if one is shorter than and a matching prefix of the other, the index within SEQUENCE1 beyond the last position tested is returned. ------------------------------------------------------------------------------ MOD [Function] Args: (number divisor) Returns the second result of (FLOOR NUMBER DIVISOR). ------------------------------------------------------------------------------ *MODULES* [Variable] A list of names of the modules that have been loaded into KCL. ------------------------------------------------------------------------------ MOST-NEGATIVE-DOUBLE-FLOAT [Constant] Same as MOST-NEGATIVE-LONG-FLOAT. ------------------------------------------------------------------------------ MOST-NEGATIVE-FIXNUM [Constant] The fixnum closest in value to negative infinity. ------------------------------------------------------------------------------ MOST-NEGATIVE-LONG-FLOAT [Constant] The long-float closest in value to negative infinity. ------------------------------------------------------------------------------ MOST-NEGATIVE-SHORT-FLOAT [Constant] The short-float closest in value to negative infinity. ------------------------------------------------------------------------------ MOST-NEGATIVE-SINGLE-FLOAT [Constant] Same as MOST-NEGATIVE-LONG-FLOAT. ------------------------------------------------------------------------------ KCL Dictionary Page 53 ------------------------------------------------------------------------------ MOST-POSITIVE-DOUBLE-FLOAT [Constant] Same as MOST-POSITIVE-LONG-FLOAT. ------------------------------------------------------------------------------ MOST-POSITIVE-FIXNUM [Constant] The fixnum closest in value to positive infinity. ------------------------------------------------------------------------------ MOST-POSITIVE-LONG-FLOAT [Constant] The long-float closest in value to positive infinity. ------------------------------------------------------------------------------ MOST-POSITIVE-SHORT-FLOAT [Constant] The short-float closest in value to positive infinity. ------------------------------------------------------------------------------ MOST-POSITIVE-SINGLE-FLOAT [Constant] Same as MOST-POSITIVE-LONG-FLOAT. ------------------------------------------------------------------------------ MULTIPLE-VALUE-BIND [Macro] Syntax: (multiple-value-bind ({var}*) values-form {decl}* {form}*) Binds the VARiables to the results of VALUES-FORM, in order (defaulting to NIL) and evaluates FORMs in order. ------------------------------------------------------------------------------ MULTIPLE-VALUE-CALL [Special form] Syntax: (multiple-value-call function {form}*) Calls FUNCTION with all the values of FORMs as arguments. ------------------------------------------------------------------------------ MULTIPLE-VALUE-LIST [Macro] Syntax: (multiple-value-list form) Evaluates FORM, and returns a list of multiple values it returned. ------------------------------------------------------------------------------ MULTIPLE-VALUE-PROG1 [Special form] Syntax: (multiple-value-prog1 form {form}*) Evaluates the first FORM, saves all the values produced, then evaluates the other FORMs. Returns the saved values. ------------------------------------------------------------------------------ MULTIPLE-VALUE-SETQ [Macro] Syntax: (multiple-value-setq variables form) Sets each variable in the list VARIABLES to the corresponding value of FORM. Returns the value assigned to the first variable. ------------------------------------------------------------------------------ MULTIPLE-VALUES-LIMIT [Constant] The exclusive upper bound on the number of values that may be returned from a function. Actually, however, there is no such upper bound in KCL. ------------------------------------------------------------------------------ NAME-CHAR [Function] Args: (name) Given an argument acceptable to string, Returns a character object whose name is NAME if one exists. Returns NIL otherwise. NAME must be an object that can be coerced to a string. ------------------------------------------------------------------------------ KCL Dictionary Page 54 ------------------------------------------------------------------------------ NAMESTRING [Function] Args: (pathname) Returns the full form of PATHNAME as a string. ------------------------------------------------------------------------------ NBUTLAST [Function] Args: (list &optional (n 1)) Changes the cdr of the N+1 th cons from the end of the list LIST to NIL. Returns the whole list. ------------------------------------------------------------------------------ NCONC [Function] Args: (&rest lists) Concatenates LISTs by destructively modifying them. ------------------------------------------------------------------------------ NIL [Type] The type NIL is a subtype of every type. No object belongs to this type. ------------------------------------------------------------------------------ NIL [Constant] Holds NIL. ------------------------------------------------------------------------------ NINTERSECTION [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns the intersection of LIST1 and LIST2. LIST1 may be destroyed. ------------------------------------------------------------------------------ NINTH [Function] Args: (x) Equivalent to (CAR (CDDDDR (CDDDDR X))). ------------------------------------------------------------------------------ NOT [Function] Args: (x) Returns T if X is NIL; NIL otherwise. ------------------------------------------------------------------------------ NOTANY [Function] Args: (predicate sequence &rest more-sequences) PREDICATE is applied to 0-th elements of SEQUENCEs, then possibly to 1-st elements, and so on. Returns NIL as soon as any invocation of PREDICATE returns a non-NIL value, or T if the end of a sequence is reached. ------------------------------------------------------------------------------ NOTEVERY [Function] Args: (predicate sequence &rest more-sequences) PREDICATE is applied to 0-th elements of SEQUENCEs, then possibly to 1-st elements, and so on. Returns T as soon as any invocation of PREDICATE returns NIL, or NIL if every invocation returns non-NIL. ------------------------------------------------------------------------------ NRECONC [Function] Args: (x y) Equivalent to (NCONC (NREVERSE X) Y). ------------------------------------------------------------------------------ KCL Dictionary Page 55 ------------------------------------------------------------------------------ NREVERSE [Function] Args: (sequence) Returns a sequence of the same elements as SEQUENCE but in reverse order. SEQUENCE may be destroyed. ------------------------------------------------------------------------------ NSET-DIFFERENCE [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns a list of elements of LIST1 that do not appear in LIST2. LIST1 may be destroyed. ------------------------------------------------------------------------------ NSET-EXCLUSIVE-OR [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns a list with elements which appear but once in LIST1 and LIST2. ------------------------------------------------------------------------------ NSTRING-CAPITALIZE [Function] Args: (string &key (start 0) (end (length string))) Returns STRING with the first character of each word converted to upper-case, and remaining characters in the word converted to lower case. ------------------------------------------------------------------------------ NSTRING-DOWNCASE [Function] Args: (string &key (start 0) (end (length string))) Returns STRING with all upper case characters converted to lowercase. ------------------------------------------------------------------------------ NSTRING-UPCASE [Function] Args: (string &key (start 0) (end (length string))) Returns STRING with all lower case characters converted to uppercase. ------------------------------------------------------------------------------ NSUBLIS [Function] Args: (alist tree &key (test #'eql) test-not (key #'identity)) Substitutes from ALIST for subtrees of TREE. ------------------------------------------------------------------------------ NSUBST [Function] Args: (new old tree &key (test #'eql) test-not (key #'identity)) Substitutes NEW for subtrees in TREE that match OLD. ------------------------------------------------------------------------------ NSUBST-IF [Function] Args: (new test tree &key (key #'identity)) Substitutes NEW for subtrees of TREE that satisfy TEST. ------------------------------------------------------------------------------ NSUBST-IF-NOT [Function] Args: (new test tree &key (key #'identity)) Substitutes NEW for subtrees of TREE that do not satisfy TEST. ------------------------------------------------------------------------------ KCL Dictionary Page 56 ------------------------------------------------------------------------------ NSUBSTITUTE [Function] Args: (newitem olditem sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that OLDITEMs are replaced with NEWITEM. SEQUENCE may be destroyed. ------------------------------------------------------------------------------ NSUBSTITUTE-IF [Function] Args: (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that all elements satisfying TEST are replaced with NEWITEM. SEQUENCE may be destroyed. ------------------------------------------------------------------------------ NSUBSTITUTE-IF-NOT [Function] Args: (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that all elements not satisfying TEST are replaced with NEWITEM. SEQUENCE may be destroyed. ------------------------------------------------------------------------------ NTH [Function] Args: (n list) Returns the N-th element of LIST, where the car of LIST is the zeroth element. ------------------------------------------------------------------------------ NTHCDR [Function] Args: (n list) Returns the result of performing the CDR operation N times on LIST. ------------------------------------------------------------------------------ NULL [Function] Args: (x) Returns T if X is NIL; NIL otherwise. ------------------------------------------------------------------------------ NUMBER [Type] A number is either an integer, a ratio, a floating-point number, or a complex number. Integers and ratios are collectively called rationals. ------------------------------------------------------------------------------ NUMBERP [Function] Args: (x) Returns T if X is any kind of number; NIL otherwise. ------------------------------------------------------------------------------ NUMERATOR [Function] Args: (rational) Returns as an integer the numerator of the given rational number. ------------------------------------------------------------------------------ KCL Dictionary Page 57 ------------------------------------------------------------------------------ NUNION [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns the union of LIST1 and LIST2. LIST1 and/or LIST2 may be destroyed. ------------------------------------------------------------------------------ ODDP [Function] Args: (integer) Returns T if INTEGER is odd; NIL otherwise. ------------------------------------------------------------------------------ OPEN [Function] Args: (filename &key (direction :input) (element-type 'string-char) (if-exists :error) (if-does-not-exist :error)) Opens the file specified by FILENAME, which may be a string, a pathname, or a stream. Returns a stream for the open file. Possible DIRECTION values are :INPUT, :OUTPUT, :IO and :PROBE. Possible ELEMENT-TYPE values are STRING-CHAR, (UNSIGNED-BYTE n), UNSIGNED-BYTE, (SIGNED-BYTE n), SIGNED-BYTE, CHARACTER, BIT, (MOD n), and :DEFAULT. Possible IF-EXISTS values are :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE, and NIL. Possible IF-DOES-NOT-EXIST values are :ERROR, :CREATE, and NIL. ------------------------------------------------------------------------------ OR [Macro] Syntax: (or {form}*) Evaluates FORMs in order from left to right. If any FORM evaluates to non-NIL, quits and returns that (single) value. If the last FORM is reached, returns whatever values it returns. ------------------------------------------------------------------------------ OUTPUT-STREAM-P [Function] Args: (stream) Returns non-nil if STREAM can handle output operations; NIL otherwise. ------------------------------------------------------------------------------ PACKAGE [Type] Packages are collections of symbols that serve as name spaces. A package is denoted as #<? package> where '?' is actually the name of the package. KCL provides five built-in packages: lisp symbols that names Common Lisp functions and variables. user the standard package used by the user. keyword the keyword package. system symbols that names internal functions and variables. Has nicknames SYS and SI. compiler symbols that names functions and variables internally used by the KCL compiler. ------------------------------------------------------------------------------ *PACKAGE* [Variable] The current package. ------------------------------------------------------------------------------ PACKAGE-NAME [Function] Args: (package) Returns the string that names the specified PACKAGE. ------------------------------------------------------------------------------ KCL Dictionary Page 58 ------------------------------------------------------------------------------ PACKAGE-NICKNAMES [Function] Args: (package) Returns as a list the nickname strings for the specified PACKAGE. ------------------------------------------------------------------------------ PACKAGE-SHADOWING-SYMBOLS [Function] Args: (package) Returns the list of symbols that have been declared as shadowing symbols in PACKAGE. ------------------------------------------------------------------------------ PACKAGE-USE-LIST [Function] Args: (package) Returns the list of packages used by PACKAGE. ------------------------------------------------------------------------------ PACKAGE-USED-BY-LIST [Function] Args: (package) Returns the list of packages that use PACKAGE. ------------------------------------------------------------------------------ PACKAGEP [Function] Args: (x) Returns T if X is a package; NIL otherwise. ------------------------------------------------------------------------------ PAIRLIS [Function] Args: (keys data &optional (alist nil)) Constructs an association list from KEYS and DATA adding to ALIST. ------------------------------------------------------------------------------ PARSE-INTEGER [Function] Args: (string &key (start 0) (end (length string)) (radix 10) (junk-allowed nil)) Parses STRING for an integer and returns it. ------------------------------------------------------------------------------ PARSE-NAMESTRING [Function] Args: (thing &optional host (defaults *default-pathname-defaults*) &key (start 0) (end (length thing)) (junk-allowed nil)) Parses a string representation of a pathname into a pathname. HOST is ignored. ------------------------------------------------------------------------------ PATHNAME [Type] Pathnames are the means by which a Lisp program can interface to an external file system in a reasonably implementation-independent manner. Among the six elements in a pathname described in Steele's manual, HOST, DEVICE, and VERSION are meaningless in KCL, though they are harmless at all. A pathname is denoted as #"???" where '???' is actually some pathname information. This depends on the version of KCL. Refer to the KCL report at your hand for details. ------------------------------------------------------------------------------ PATHNAME [Function] Args: (x) Turns X into a pathname. X may be a string, symbol, stream, or pathname. ------------------------------------------------------------------------------ KCL Dictionary Page 59 ------------------------------------------------------------------------------ PATHNAME-DEVICE [Function] Args: (pathname) Returns the device slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAME-DIRECTORY [Function] Args: (pathname) Returns the directory slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAME-HOST [Function] Args: (pathname) Returns the host slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAME-NAME [Function] Args: (pathname) Returns the name slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAME-TYPE [Function] Args: (pathname) Returns the type slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAME-VERSION [Function] Args: (pathname) Returns the version slot of PATHNAME. ------------------------------------------------------------------------------ PATHNAMEP [Function] Args: (x) Returns T if X is a pathname object; NIL otherwise. ------------------------------------------------------------------------------ PEEK-CHAR [Function] Args: (&optional (peek-type nil) (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) Peeks at the next character in the input stream STREAM. ------------------------------------------------------------------------------ PHASE [Function] Args: (number) Returns the angle part of the polar representation of a complex number. For non-complex numbers, this is 0. ------------------------------------------------------------------------------ PI [Constant] The floating-point number that is appropriately equal to the ratio of the circumference of the circle to the diameter. ------------------------------------------------------------------------------ PLUSP [Function] Args: (number) Returns T if NUMBER > 0; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 60 ------------------------------------------------------------------------------ POP [Macro] Syntax: (pop place) Pops one item off the front of the list in PLACE and returns it. ------------------------------------------------------------------------------ POSITION [Function] Args: (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) Returns the index of the first element in SEQUENCE that satisfies TEST with ITEM; NIL if no such element exists. ------------------------------------------------------------------------------ POSITION-IF [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the index of the first element in SEQUENCE that satisfies TEST; NIL if no such element exists. ------------------------------------------------------------------------------ POSITION-IF-NOT [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) Returns the index of the first element in SEQUENCE that does not satisfy TEST; NIL if no such element exists. ------------------------------------------------------------------------------ PPRINT [Function] Args: (object &optional (stream *standard-output*)) Pretty-prints OBJECT. Returns OBJECT. Equivalent to (WRITE :STREAM STREAM :PRETTY T) The SI:PRETTY-PRINT-FORMAT property N (which must be a non-negative integer) of a symbol SYMBOL controls the pretty-printing of form (SYMBOL f1 ... fN fN+1 ... fM) in such a way that the subforms fN+1, ..., fM are regarded as the 'body' of the entire form. For instance, the property value of 2 is initially given to the symbol DO. ------------------------------------------------------------------------------ PRIN1 [Function] Args: (object &optional (stream *standard-output*)) Prints OBJECT in the mostly readable representation. Returns OBJECT. Equivalent to (WRITE :STREAM STREAM :ESCAPE T). ------------------------------------------------------------------------------ PRIN1-TO-STRING [Function] Args: (object) Returns as a string the printed representation of OBJECT in the mostly readable representation. Equivalent to (WRITE-TO-STRING :STREAM STREAM :ESCAPE T). ------------------------------------------------------------------------------ PRINC [Function] Args: (object &optional (stream *standard-output*)) Prints OBJECT without escape characters. Returns OBJECT. Equivalent to (WRITE :STREAM STREAM :ESCAPE NIL). ------------------------------------------------------------------------------ KCL Dictionary Page 61 ------------------------------------------------------------------------------ PRINC-TO-STRING [Function] Args: (object) Returns as a string the printed representation of OBJECT without escape characters. Equivalent to (WRITE-TO-STRING :STREAM STREAM :ESCAPE NIL). ------------------------------------------------------------------------------ PRINT [Function] Args: (object &optional (stream *standard-output*)) Outputs a newline character, and then prints OBJECT in the mostly readable representation. Returns OBJECT. Equivalent to (PROGN (TERPRI STREAM) (WRITE :STREAM STREAM :ESCAPE T)). ------------------------------------------------------------------------------ *PRINT-ARRAY* [Variable] Whether the KCL printer should print array elements. ------------------------------------------------------------------------------ *PRINT-BASE* [Variable] The radix in which the KCL printer prints integers and rationals. The value must be an integer from 2 to 36, inclusive. ------------------------------------------------------------------------------ *PRINT-CASE* [Variable] The case in which the KCL printer should print ordinary symbols. The value must be one of the keywords :UPCASE, :DOWNCASE, and :CAPITALIZE. ------------------------------------------------------------------------------ *PRINT-CIRCLE* [Variable] Whether the KCL printer should take care of circular lists. ------------------------------------------------------------------------------ *PRINT-ESCAPE* [Variable] Whether the KCL printer should put escape characters whenever appropriate. ------------------------------------------------------------------------------ *PRINT-GENSYM* [Variable] Whether the KCL printer should prefix symbols with no home package with "#:". ------------------------------------------------------------------------------ *PRINT-LENGTH* [Variable] How many elements the KCL printer should print at each level of nested data object. Unlimited if NIL. ------------------------------------------------------------------------------ *PRINT-LEVEL* [Variable] How many levels deep the KCL printer should print. Unlimited if NIL. ------------------------------------------------------------------------------ *PRINT-PRETTY* [Variable] Whether the KCL printer should pretty-print. See the function doc of PPRINT for more information about pretty-printing. ------------------------------------------------------------------------------ *PRINT-RADIX* [Variable] Whether the KCL printer should print the radix indicator when printing integers and rationals. ------------------------------------------------------------------------------ KCL Dictionary Page 62 ------------------------------------------------------------------------------ PROBE-FILE [Function] Args: (file) Returns T if the file exists; NIL otherwise. ------------------------------------------------------------------------------ PROCESS [Function] Args: (progname &optional (ipc-message "") &key block console debug dir input output username list data ioc) KCL specific: Creates a process. Only KCL/AOS supports this function. ------------------------------------------------------------------------------ PROCLAIM [Function] Args: (decl-spec) Puts the declaration given by DECL-SPEC into effect globally. See the doc of DECLARE for possible DECL-SPECs. ------------------------------------------------------------------------------ PROCLAMATION [Function] Args: (decl-spec) KCL specific: Returns T if the specified declaration is globally in effect; NIL otherwise. See the doc of DECLARE for possible DECL-SPECs. ------------------------------------------------------------------------------ PROG [Macro] Syntax: (prog ({var | (var [init])}*) {decl}* {tag | statement}*) Creates a NIL block, binds VARs in parallel, and then executes STATEMENTs. ------------------------------------------------------------------------------ PROG* [Macro] Syntax: (prog* ({var | (var [init])}*) {decl}* {tag | statement}*) Creates a NIL block, binds VARs sequentially, and then executes STATEMENTs. ------------------------------------------------------------------------------ PROG1 [Macro] Syntax: (prog1 first {form}*) Evaluates FIRST and FORMs in order, and returns the (single) value of FIRST. ------------------------------------------------------------------------------ PROG2 [Macro] Syntax: (prog2 first second {forms}*) Evaluates FIRST, SECOND, and FORMs in order, and returns the (single) value of SECOND. ------------------------------------------------------------------------------ PROGN [Special form] Syntax: (progn {form}*) Evaluates FORMs in order, and returns whatever the last FORM returns. ------------------------------------------------------------------------------ PROGV [Special form] Syntax: (progv symbols values {form}*) SYMBOLS must evaluate to a list of variables. VALUES must evaluate to a list of initial values. Evaluates FORMs as a PROGN, with each variable bound (as special) to the corresponding value. ------------------------------------------------------------------------------ KCL Dictionary Page 63 ------------------------------------------------------------------------------ PROVIDE [Function] Args: (module-name) Adds the specified module to the list of modules maintained in *MODULES*. ------------------------------------------------------------------------------ PSETF [Macro] Syntax: (psetf {place newvalue}*) Similar to SETF, but evaluates all NEWVALUEs first, and then replaces the value in each PLACE with the value of the corresponding NEWVALUE. Returns NIL always. ------------------------------------------------------------------------------ PSETQ [Macro] Syntax: (psetq {var form}*) Similar to SETQ, but evaluates all FORMs first, and then assigns each value to the corresponding VAR. Returns NIL always. ------------------------------------------------------------------------------ PUSH [Macro] Syntax: (push item place) Conses ITEM onto the list in PLACE, and returns the new list. ------------------------------------------------------------------------------ PUSHNEW [Macro] Syntax: (pushnew item place {keyword value}*) If ITEM is already in the list stored in PLACE, does nothing. Else, conses ITEM onto the list. Returns NIL. If no KEYWORDs are supplied, each element in the list is compared with ITEM by EQL, but the comparison can be controlled by supplying keywords :TEST, :TEST-NOT, and/or :KEY. ------------------------------------------------------------------------------ *QUERY-IO* [Variable] The query I/O stream. ------------------------------------------------------------------------------ QUOTE [Special form] Syntax: (quote x) or 'x Simply returns X without evaluating it. ------------------------------------------------------------------------------ RANDOM [Function] Args: (number &optional (state *random-state*)) Generates a uniformly distributed pseudo-random number between zero (inclusive) and NUMBER (exclusive), by using the random state object STATE. ------------------------------------------------------------------------------ RANDOM-STATE [Type] A random state is used to encapsulate state information used by the pseudo-random number generator. A random state is denoted by prefixing a number with '#$'. ------------------------------------------------------------------------------ *RANDOM-STATE* [Variable] The default random-state object used by RAMDOM. ------------------------------------------------------------------------------ KCL Dictionary Page 64 ------------------------------------------------------------------------------ RANDOM-STATE-P [Function] Args: (x) Returns T if X is a random-state object; NIL otherwise. ------------------------------------------------------------------------------ RASSOC [Function] Args: (item alist &key (test #'eql) test-not (key #'identity)) Returns the first cons in ALIST whose cdr is equal to ITEM. ------------------------------------------------------------------------------ RASSOC-IF [Function] Args: (predicate alist) Returns the first cons in ALIST whose cdr satisfies PREDICATE. ------------------------------------------------------------------------------ RASSOC-IF-NOT [Function] Args: (predicate alist) Returns the first cons in ALIST whose cdr does not satisfy PREDICATE. ------------------------------------------------------------------------------ RATIO [Type] A ratio represents a mathematical ratio of two integers. A ratio is denoted by its numerator and denominator, separated by a slash '/'. More precisely, the following syntax is normally used. { [sign]{digit-in-default-radix}+ / {digit-in-default-radix}+ | {#b | #B} [sign] {radix-2-digit}+ / {radix-2-digit}+ | {#o | #O} [sign] {radix-8-digit}+ / {radix-8-digit}+ | {#x | #X} [sign] {radix-16-digit}+ / {radix-16-digit}+ | {#2r | #2R} [sign] {radix-2-digit}+ / {radix-2-digit}+ .... | {#36r | #36R} [sign] {radix-36-digit}+ / {radix-36-digit}+ } See the type doc of INTEGER for the syntactic variables used here. ------------------------------------------------------------------------------ RATIONAL [Function] Args: (number) Converts NUMBER into rational accurately and returns it. ------------------------------------------------------------------------------ RATIONALIZE [Function] Args: (number) Converts NUMBER into rational approximately and returns it. ------------------------------------------------------------------------------ RATIONALP [Function] Args: (x) Returns T if X is an integer or a ratio; NIL otherwise. ------------------------------------------------------------------------------ READ [Function] Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursivep nil)) Reads in the next object from STREAM. ------------------------------------------------------------------------------ *READ-BASE* [Variable] The radix that the KCL reader reads numbers in. ------------------------------------------------------------------------------ KCL Dictionary Page 65 ------------------------------------------------------------------------------ READ-BYTE [Function] Args: (stream &optional (eof-error-p t) (eof-value nil)) Reads the next byte from STREAM. ------------------------------------------------------------------------------ READ-CHAR [Function] Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) Reads a character from STREAM. ------------------------------------------------------------------------------ READ-CHAR-NO-HANG [Function] Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) Returns the next character from STREAM if one is available; NIL otherwise. ------------------------------------------------------------------------------ *READ-DEFAULT-FLOAT-FORMAT* [Variable] The floating-point format the KCL reader uses when reading floating-point numbers that have no exponent marker or have e or E for an exponent marker. Must be one of SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, and LONG-FLOAT. ------------------------------------------------------------------------------ READ-DELIMITED-LIST [Function] Args: (char &optional (stream *standard-input*) (recursive-p nil)) Reads objects from STREAM until the next character after an object's representation is CHAR. Returns a list of the objects read. ------------------------------------------------------------------------------ READ-FROM-STRING [Function] Args: (string &optional (eof-error-p t) (eof-value nil) &key (start 0) (end (length string)) (preserve-whitespace nil)) Reads an object from STRING. ------------------------------------------------------------------------------ READ-LINE [Function] Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) Returns a line of text read from STREAM as a string, discarding the newline character. ------------------------------------------------------------------------------ READ-PRESERVING-WHITESPACE [Function] Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) Reads an object from STREAM, preserving the whitespace that followed the object. ------------------------------------------------------------------------------ *READ-SUPPRESS* [Variable] When the value of this variable is NIL, the KCL reader operates normally. When it is non-NIL, then the reader parses input characters but much of what is read is not interpreted. ------------------------------------------------------------------------------ KCL Dictionary Page 66 ------------------------------------------------------------------------------ READTABLE [Type] A readtable is a data structure that maps characters into syntax types for the KCL parser. A readtable is denoted as #<a readtable>. ------------------------------------------------------------------------------ *READTABLE* [Variable] The current readtable. ------------------------------------------------------------------------------ READTABLEP [Function] Args: (x) Returns T if X is a readtable object; NIL otherwise. ------------------------------------------------------------------------------ REALPART [Function] Args: (number) Extracts the real part of NUMBER. ------------------------------------------------------------------------------ REDUCE [Function] Args: (function sequence &key (from-end nil) (start 0) (end (length sequence)) initial-value) Combines all the elements of SEQUENCE using a binary operation FUNCTION. If INITIAL-VALUE is supplied, it is logically placed before the SEQUENCE. ------------------------------------------------------------------------------ REM [Function] Args: (number divisor) Returns the second value of (TRUNCATE NUMBER DIVISOR). ------------------------------------------------------------------------------ REMF [Macro] Syntax: (remf place indicator) PLACE may be any place expression acceptable to SETF, and is expected to hold a property list or NIL. This list is destructively altered to remove the property specified by INDICATOR. Returns T if such a property was present; NIL otherwise. ------------------------------------------------------------------------------ REMHASH [Function] Args: (key hash-table) Removes any entry for KEY in HASH-TABLE. Returns T if such an entry existed; NIL otherwise. ------------------------------------------------------------------------------ REMOVE [Function] Args: (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a copy of SEQUENCE with ITEM removed. ------------------------------------------------------------------------------ KCL Dictionary Page 67 ------------------------------------------------------------------------------ REMOVE-DUPLICATES [Function] Args: (sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) The elements of SEQUENCE are examined, and if any two match, one is discarded. Returns the resulting sequence. ------------------------------------------------------------------------------ REMOVE-IF [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a copy of SEQUENCE with elements satisfying TEST removed. ------------------------------------------------------------------------------ REMOVE-IF-NOT [Function] Args: (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a copy of SEQUENCE with elements not satisfying TEST removed. ------------------------------------------------------------------------------ REMPROP [Function] Args: (symbol indicator) Look on property list of SYMBOL for property with specified INDICATOR. If found, splice this indicator and its value out of the plist, and return the tail of the original list starting with INDICATOR. If not found, returns NIL with no side effects. ------------------------------------------------------------------------------ RENAME-FILE [Function] Args: (file new-name) Renames the file FILE to NEW-NAME. FILE may be a string, a pathname, or a stream. ------------------------------------------------------------------------------ RENAME-PACKAGE [Function] Args: (package new-name &optional (new-nicknames nil)) Replaces the old name and nicknames of PACKAGE with NEW-NAME and NEW-NICKNAMES. ------------------------------------------------------------------------------ REPLACE [Function] Args: (sequence1 sequence2 &key (start1 0) (end1 (length sequence1)) (start2 0) (end2 (length sequence2))) Destructively modifies SEQUENCE1 by copying successive elements into it from SEQUENCE2. ------------------------------------------------------------------------------ REQUIRE [Function] Args: (module-name &optional (pathname)) If the specified module is not present, then loads the appropriate file(s). PATHNAME may be a single pathname or it may be a list of pathnames. ------------------------------------------------------------------------------ KCL Dictionary Page 68 ------------------------------------------------------------------------------ REST [Function] Args: (x) Equivalent to (CDR X). ------------------------------------------------------------------------------ RETURN [Macro] Syntax: (return [result]) Returns from the lexically surrounding NIL block. The value of RESULT, which defaults to NIL, is returned as the value of the block. ------------------------------------------------------------------------------ RETURN-FROM [Special form] Syntax: (return-from name [result]) Returns from the lexically surrounding block whose name is NAME. The value of RESULT, which defaults to NIL, is returned as the value of the block. ------------------------------------------------------------------------------ REVAPPEND [Function] Args: (x y) Equivalent to (APPEND (REVERSE X) Y) ------------------------------------------------------------------------------ REVERSE [Function] Args: (sequence) Returns a new sequence containing the same elements as SEQUENCE but in reverse order. ------------------------------------------------------------------------------ ROOM [Function] Args: (&optional (x t)) Displays information about storage allocation in the following format. * for each type class * the number of pages so-far allocated for the type class * the maximum number of pages for the type class * the percentage of used cells to cells so-far allocated * the number of times the garbage collector has been called to collect cells of the type class * the implementation types that belongs to the type class * the number of pages actually allocated for contiguous blocks * the maximum number of pages for contiguous blocks * the number of times the garbage collector has been called to collect contiguous blocks * the number of pages in the hole * the maximum number of pages for relocatable blocks * the number of times the garbage collector has been called to collect relocatable blocks * the total number of pages allocated for cells * the total number of pages allocated * the number of available pages * the number of pages KCL can use. The number of times the garbage collector has been called is not shown, if the number is zero. The optional X is ignored. ------------------------------------------------------------------------------ KCL Dictionary Page 69 ------------------------------------------------------------------------------ ROTATEF [Macro] Syntax: (rotatef {place}*) Evaluates PLACEs in turn, then assigns to each PLACE the value of the form to its right. The rightmost PLACE gets the value of the leftmost PLACE. Returns NIL always. ------------------------------------------------------------------------------ ROUND [Function] Args: (number &optional (divisor 1)) Rounds NUMBER/DIVISOR to nearest integer. The second returned value is the remainder. ------------------------------------------------------------------------------ RPLACA [Function] Args: (x y) Replaces the car of X with Y, and returns the modified X. ------------------------------------------------------------------------------ RPLACD [Function] Args: (x y) Replaces the cdr of X with Y, and returns the modified X. ------------------------------------------------------------------------------ SAVE [Function] Args: (pathname) KCL specific: Saves the current KCL core image into a program file specified by PATHNAME. This function depends on the version of KCL. See KCL Report for the details. ------------------------------------------------------------------------------ SBIT [Function] Args: (simple-bit-array &rest subscripts) Returns the bit from SIMPLE-BIT-ARRAY at SUBSCRIPTS. ------------------------------------------------------------------------------ SCALE-FLOAT [Function] Args: (float integer) Returns (* FLOAT (expt (float-radix FLOAT) INTEGER)). ------------------------------------------------------------------------------ SCHAR [Function] Args: (simple-string index) Returns the character object representing the INDEX-th character in STRING. This is faster than CHAR. ------------------------------------------------------------------------------ SEARCH [Function] Args: (sequence1 sequence2 &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) (end1 (length sequence1)) (end2 (length sequence2)) (key #'identity)) A search is conducted for the first subsequence of SEQUENCE2 which element-wise matches SEQUENCE1. If there is such a subsequence in SEQUENCE2, the index of the its leftmost element is returned; otherwise, NIL is returned. ------------------------------------------------------------------------------ KCL Dictionary Page 70 ------------------------------------------------------------------------------ SECOND [Function] Args: (x) Equivalent to (CADR X). ------------------------------------------------------------------------------ SEQUENCE [Type] A sequence is either a list or a vector. ------------------------------------------------------------------------------ SET [Function] Args: (symbol value) Assigns the value of VALUE to the dynamic variable named by SYMBOL, and returns the value assigned. ------------------------------------------------------------------------------ SET-CHAR-BIT [Function] Args: (char name newvalue) Returns a character just like CHAR except that the named bit is set or cleared, according to whether NEWVALUE is non-NIL or NIL. This function is useless in KCL. ------------------------------------------------------------------------------ SET-DIFFERENCE [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns a list of elements of LIST1 that do not appear in LIST2. ------------------------------------------------------------------------------ SET-DISPATCH-MACRO-CHARACTER [Function] Args: (disp-char sub-char function &optional (readtable *readtable*)) Causes FUNCTION to be called when the DISP-CHAR followed by SUB-CHAR is read. ------------------------------------------------------------------------------ SET-EXCLUSIVE-OR [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns a list of elements appearing exactly once in LIST1 and LIST2. ------------------------------------------------------------------------------ SET-MACRO-CHARACTER [Function] Args: (char function &optional (non-terminating-p nil) (readtable *readtable*)) Causes CHAR to be a macro character that, when seen by READ, causes FUNCTION to be called. ------------------------------------------------------------------------------ SET-SYNTAX-FROM-CHAR [Function] Args: (to-char from-char &optional (to-readtable *readtable*) (from-readtable nil)) Makes the syntax of TO-CHAR in TO-READTABLE be the same as the syntax of FROM-CHAR in FROM-READTABLE. ------------------------------------------------------------------------------ KCL Dictionary Page 71 ------------------------------------------------------------------------------ SETF [Macro] Syntax: (setf {place newvalue}*) Replaces the value in PLACE with the value of NEWVALUE, from left to right. Returns the value of the last NEWVALUE. Each PLACE may be any one of the following: * A symbol that names a variable. * A function call form whose first element is the name of the following functions: nth elt subseq rest first ... tenth c?r c??r c???r c????r aref svref char schar bit sbit fill-poiter get getf documentation symbol-value symbol-function symbol-plist macro-function gethash char-bit ldb mask-field apply where '?' stands for either 'a' or 'd'. * the form (THE type place) with PLACE being a place recognized by SETF. * a macro call which expands to a place recognized by SETF. * any form for which a DEFSETF or DEFINE-SETF-METHOD declaration has been made. ------------------------------------------------------------------------------ SETQ [Special form] Syntax: (setq {var form}*) VARs are not evaluated and must be symbols. Assigns the value of the first FORM to the first VAR, then assigns the value of the second FORM to the second VAR, and so on. Returns the last value assigned. ------------------------------------------------------------------------------ SEVENTH [Function] Args: (x) Equivalent to (CADDR (CDDDDR X)). ------------------------------------------------------------------------------ SHADOW [Function] Args: (symbols &optional (package *package*)) Creates an internal symbol in PACKAGE with the same name as each of the specified SYMBOLS. SYMBOLS must be a list of symbols or a symbol. ------------------------------------------------------------------------------ SHADOWING-IMPORT [Function] Args: (symbols &optional (package *package*)) Imports SYMBOLS into PACKAGE, disregarding any name conflict. If a symbol of the same name is already present, then it is uninterned. SYMBOLS must be a list of symbols or a symbol. ------------------------------------------------------------------------------ SHIFTF [Macro] Syntax: (shiftf {place}+ newvalue) Evaluates all PLACEs and NEWVALUE in turn, then assigns the value of each form to the PLACE on its left. Returns the original value of the leftmost form. ------------------------------------------------------------------------------ SHORT-FLOAT-EPSILON [Constant] The smallest positive short-float that satisfies (not (= (float 1 e) (+ (float 1 e) e))). ------------------------------------------------------------------------------ KCL Dictionary Page 72 ------------------------------------------------------------------------------ SHORT-FLOAT-NEGATIVE-EPSILON [Constant] The smallest positive short-float that satisfies (not (= (float 1 e) (- (float 1 e) e))). ------------------------------------------------------------------------------ SHORT-SITE-NAME [Function] Args: () Returns a string that identifies the physical location of the current KCL. ------------------------------------------------------------------------------ SIGNUM [Function] Args: (number) If NUMBER is zero, returns NUMBER; else returns (/ NUMBER (ABS NUMBER)). ------------------------------------------------------------------------------ SIMPLE-ARRAY [Type] A simple-array is an array that is not displaced to another array, has no fill pointer, and is not to have its size adjusted. ------------------------------------------------------------------------------ SIMPLE-BIT-VECTOR [Type] A simple-bit-vector is a bit-vector that is not displaced to another bit-vector, has no fill pointer, and is not to have its size adjusted. ------------------------------------------------------------------------------ SIMPLE-BIT-VECTOR-P [Function] Args: (x) Returns T if X is a simple bit-vector; NIL otherwise. ------------------------------------------------------------------------------ SIMPLE-STRING [Type] A simple-string is a string that is not displaced to another string, has no fill pointer, and is not to have its size adjusted. ------------------------------------------------------------------------------ SIMPLE-STRING-P [Function] Args: (x) Returns T if X is a simple string; NIL otherwise. ------------------------------------------------------------------------------ SIMPLE-VECTOR [Type] A simple-vector is a vector that is not displaced to another vector, has no fill pointer, and is not to have its size adjusted. ------------------------------------------------------------------------------ SIMPLE-VECTOR-P [Function] Args: (x) Returns T if X is a simple vector; NIL otherwise. ------------------------------------------------------------------------------ SIN [Function] Args: (radians) Returns the sine of RADIANS. ------------------------------------------------------------------------------ SINGLE-FLOAT-EPSILON [Constant] Same as LONG-FLOAT-EPSILON. ------------------------------------------------------------------------------ KCL Dictionary Page 73 ------------------------------------------------------------------------------ SINGLE-FLOAT-NEGATIVE-EPSILON [Constant] Same as LONG-FLOAT-NEGATIVE-EPSILON. ------------------------------------------------------------------------------ SINH [Function] Args: (number) Returns the hyperbolic sine of NUMBER. ------------------------------------------------------------------------------ SIXTH [Function] Args: (x) Equivalent to (CADR (CDDDDR X)). ------------------------------------------------------------------------------ SLEEP [Function] Args: (n) This function causes execution to be suspended for N seconds. N may be any non-negative, non-complex number. ------------------------------------------------------------------------------ SOFTWARE-TYPE [Function] Args: () Returns a string that identifies the software type of the software under which KCL is currently running. ------------------------------------------------------------------------------ SOFTWARE-VERSION [Function] Args: () Returns a string that identifies the software version of the software under which KCL is currently running. ------------------------------------------------------------------------------ SOME [Function] Args: (predicate sequence &rest more-sequences) PREDICATE is applied to the 0-th elements of SEQUENCEs, then possibly to 1-st elements, and so on. Returns the first non-NIL value encountered, or NIL if the end of a sequence is reached. ------------------------------------------------------------------------------ SORT [Function] Args: (sequence predicate &key (key #'identity)) Destructively sorts SEQUENCE. PREDICATE should return non-NIL if its first argument is to precede its second argument. ------------------------------------------------------------------------------ KCL Dictionary Page 74 ------------------------------------------------------------------------------ SPECIAL-FORM-P [Function] Args: (symbol) Returns T if SYMBOL globally names a special form; NIL otherwise. The special forms defined in Steele's manual are: block if progv catch labels quote compiler-let let return-from declare let* setq eval-when macrolet tagbody flet multiple-value-call the function multiple-value-prog1 throw go progn unwind-protect In addition, KCL implements the following macros as special forms, though of course macro-expanding functions such as MACROEXPAND work correctly for these macros. and incf prog1 case locally prog2 cond loop psetq decf multiple-value-bind push defmacro multiple-value-list return defun multiple-value-set setf do or unless do* pop when dolist prog dotimes prog* ------------------------------------------------------------------------------ SQRT [Function] Args: (number) Returns the principal square root of NUMBER. ------------------------------------------------------------------------------ STABLE-SORT [Function] Args: (sequence predicate &key (key #'identity)) Destructively sorts SEQUENCE. PREDICATE should return non-NIL if its first argument is to precede its second argument. ------------------------------------------------------------------------------ STANDARD-CHAR [Type] A standard-char is a space character (#\Space), a newline character (#\Newline,) or a character that represents one of the following letters. ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~ ------------------------------------------------------------------------------ STANDARD-CHAR-P [Function] Args: (char) Returns T if CHAR is a standard character, i.e., one of the 95 ASCII printing characters #\Space to #\~ and #Newline; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 75 ------------------------------------------------------------------------------ *STANDARD-INPUT* [Variable] The default input stream used by the KCL reader. ------------------------------------------------------------------------------ *STANDARD-OUTPUT* [Variable] The default output stream used by the KCL printer. ------------------------------------------------------------------------------ STEP [Macro] Syntax: (step form) Evaluates FORM in the single-step mode and returns the value. ------------------------------------------------------------------------------ STREAM [Type] A stream is a source or sink of data, typically characters or bytes. A stream is denoted in one of the following ways: #<input stream ??> ?? being a file name #<output stream ??> ?? being a file name #<string-input stream from ??> ?? being a string #<a string-output stream> #<a two-way stream> #<an echo stream> #<synonym stream to ??> ?? being a symbol #<a concatenated stream> #<a broadcast stream> ------------------------------------------------------------------------------ STREAM-ELEMENT-TYPE [Function] Args: (stream) Returns a type specifier for the kind of object returned by STREAM. ------------------------------------------------------------------------------ STREAMP [Function] Args: (x) Returns T if X is a stream object; NIL otherwise. ------------------------------------------------------------------------------ STRING [Type] A string is a vector of characters. A string is denoted by surrounding the characters with double quotes '"'. Some strings may be displaced to another string, may have a fill pointer, or may be adjusted its size. Other strings are called simple strings. ------------------------------------------------------------------------------ STRING [Function] Args: (x) Coerces X into a string. If X is a string, then returns X itself. If X is a symbol, then returns X's print name. If X is a character, then returns a one element string containing that character. Signals an error if X cannot be coerced into a string. ------------------------------------------------------------------------------ STRING-CAPITALIZE [Function] Args: (string &key (start 0) (end (length string))) Returns a copy of STRING with the first character of each word converted to upper-case, and remaining characters in the word converted to lower case. ------------------------------------------------------------------------------ KCL Dictionary Page 76 ------------------------------------------------------------------------------ STRING-CHAR [Type] A string-char is a character whose bits and font attributes are zero. Any KCL character is a string-character. ------------------------------------------------------------------------------ STRING-CHAR-P [Function] Args: (char) Returns T if CHAR can be stored in a string. In KCL, this function always returns T since any character in KCL can be stored in a string. ------------------------------------------------------------------------------ STRING-DOWNCASE [Function] Args: (string &key (start 0) (end (length string))) Returns a copy of STRING with all upper case characters converted to lowercase. ------------------------------------------------------------------------------ STRING-EQUAL [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Given two strings (string1 and string2), and optional integers start1, start2, end1 and end2, compares characters in string1 to characters in string2 (using char-equal). ------------------------------------------------------------------------------ STRING-GREATERP [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Similar to STRING>, but ignores cases. ------------------------------------------------------------------------------ STRING-LEFT-TRIM [Function] Args: (char-bag string) Returns a copy of STRING with the characters in CHAR-BAG removed from the left end. ------------------------------------------------------------------------------ STRING-LESSP [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Similar to STRING<, but ignores cases. ------------------------------------------------------------------------------ STRING-NOT-EQUAL [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Similar to STRING=, but ignores cases. ------------------------------------------------------------------------------ STRING-NOT-GREATERP [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Similar to STRING<=, but ignores cases. ------------------------------------------------------------------------------ KCL Dictionary Page 77 ------------------------------------------------------------------------------ STRING-NOT-LESSP [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Similar to STRING>=, but ignores cases. ------------------------------------------------------------------------------ STRING-RIGHT-TRIM [Function] Args: (char-bag string) Returns a copy of STRING with the characters in CHAR-BAG removed from the right end. ------------------------------------------------------------------------------ STRING-TRIM [Function] Args: (char-bag string) Returns a copy of STRING with the characters in CHAR-BAG removed from both ends. ------------------------------------------------------------------------------ STRING-UPCASE [Function] Args: (string &key (start 0) (end (length string))) Returns a copy of STRING with all lower case characters converted to uppercase. ------------------------------------------------------------------------------ STRING/= [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Returns NIL if STRING1 and STRING2 are character-wise CHAR=. Otherwise, returns the index to the longest common prefix of the strings. ------------------------------------------------------------------------------ STRING< [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) If STRING1 is lexicographically less than STRING2, then returns the longest common prefix of the strings. Otherwise, returns NIL. ------------------------------------------------------------------------------ STRING<= [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) If STRING1 is lexicographically less than or equal to STRING2, then returns the longest common prefix of the two strings. Otherwise, returns NIL. ------------------------------------------------------------------------------ STRING= [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) Returns T if the two strings are character-wise CHAR=; NIL otherwise. ------------------------------------------------------------------------------ KCL Dictionary Page 78 ------------------------------------------------------------------------------ STRING> [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) If STRING1 is lexicographically greater than STRING2, then returns the longest common prefix of the strings. Otherwise, returns NIL. ------------------------------------------------------------------------------ STRING>= [Function] Args: (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) If STRING1 is lexicographically greater than or equal to STRING2, then returns the longest common prefix of the strings. Otherwise, returns NIL. ------------------------------------------------------------------------------ STRINGP [Function] Args: (x) Returns T if X is a string; NIL otherwise. ------------------------------------------------------------------------------ STRUCTURE [Type] Structures are instances of user-defined data types that have a fixed number of named components. In the simplest case, a structure is denoted as #s(structure-name slot-value1 ... slot-valuen) ------------------------------------------------------------------------------ SUBLIS [Function] Args: (alist tree &key (test #'eql) test-not (key #'identity)) Substitutes from ALIST for subtrees of TREE nondestructively. ------------------------------------------------------------------------------ SUBSEQ [Function] Args: (sequence start &optional (end (length sequence))) Returns a copy of a subsequence of SEQUENCE between START (inclusive) and END (exclusive). ------------------------------------------------------------------------------ SUBSETP [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns T if every element of LIST1 appears in LIST2; NIL otherwise. ------------------------------------------------------------------------------ SUBST [Function] Args: (new old tree &key (test #'eql) test-not (key #'identity)) Substitutes NEW for subtrees of TREE that match OLD. ------------------------------------------------------------------------------ SUBST-IF [Function] Args: (new test tree &key (key #'identity)) Substitutes NEW for subtrees of TREE that satisfy TEST. ------------------------------------------------------------------------------ SUBST-IF-NOT [Function] Args: (new test tree &key (key #'identity)) Substitutes NEW for subtrees of TREE that do not satisfy TEST. ------------------------------------------------------------------------------ KCL Dictionary Page 79 ------------------------------------------------------------------------------ SUBSTITUTE [Function] Args: (newitem olditem sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that OLDITEMs are replaced with NEWITEM. ------------------------------------------------------------------------------ SUBSTITUTE-IF [Function] Args: (newitem test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that all elements satisfying TEST are replaced with NEWITEM. ------------------------------------------------------------------------------ SUBSTITUTE-IF-NOT [Function] Args: (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) Returns a sequence of the same kind as SEQUENCE with the same elements except that all elements not satisfying TEST are replaced with NEWITEM. ------------------------------------------------------------------------------ SUBTYPEP [Function] Args: (type1 type2) Returns T if TYPE1 is a subtype of TYPE2; NIL otherwise. If it could not determine, then returns NIL as the second value. Otherwise, the second value is T. ------------------------------------------------------------------------------ SVREF [Function] Args: (simple-vector index) Returns the INDEX-th element of SIMPLE-VECTOR. ------------------------------------------------------------------------------ SXHASH [Function] Args: (object) Computes a hash code for OBJECT and returns it as an integer. ------------------------------------------------------------------------------ SYMBOL-FUNCTION [Function] Args: (symbol) Returns the current global function definition named by SYMBOL. ------------------------------------------------------------------------------ SYMBOL-NAME [Function] Args: (symbol) Returns the print name of the symbol SYMBOL. ------------------------------------------------------------------------------ SYMBOL-PACKAGE [Function] Args: (symbol) Returns the contents of the package cell of the symbol SYMBOL. ------------------------------------------------------------------------------ KCL Dictionary Page 80 ------------------------------------------------------------------------------ SYMBOL-PLIST [Function] Args: (symbol) Returns the property list of SYMBOL. ------------------------------------------------------------------------------ SYMBOL-VALUE [Function] Args: (symbol) Returns the current value of the dynamic (special) variable named by SYMBOL. ------------------------------------------------------------------------------ SYMBOLP [Function] Args: (x) Returns T if X is a symbol; NIL otherwise. ------------------------------------------------------------------------------ SYSTEM [Function] Args: (string) KCL specific: Executes a Shell command as if STRING is an input to the Shell. Not all versions of KCL support this function. ------------------------------------------------------------------------------ T [Type] The type T is a supertype of every type. ------------------------------------------------------------------------------ T [Constant] Holds T. ------------------------------------------------------------------------------ TAGBODY [Special form] Syntax: (tagbody {tag | statement}*) Executes STATEMENTs and returns NIL if it falls off the end. ------------------------------------------------------------------------------ TAILP [Function] Args: (sublist list) Returns T if SUBLIST is one of the conses in LIST; NIL otherwise. ------------------------------------------------------------------------------ TAN [Function] Args: (radians) Returns the tangent of RADIANS. ------------------------------------------------------------------------------ TANH [Function] Args: (number) Returns the hyperbolic tangent of NUMBER. ------------------------------------------------------------------------------ TENTH [Function] Args: (x) Equivalent to (CADR (CDDDDR (CDDDDR X))). ------------------------------------------------------------------------------ *TERMINAL-IO* [Variable] The terminal I/O stream. ------------------------------------------------------------------------------ KCL Dictionary Page 81 ------------------------------------------------------------------------------ TERMINATION-MESSAGE [Function] Args: () KCL specific: Returns the termination message of the son as a string. Only KCL/AOS supports this function. ------------------------------------------------------------------------------ TERPRI [Function] Args: (&optional (stream *standard-output*)) Outputs a newline character. ------------------------------------------------------------------------------ THE [Special form] Syntax: (the value-type form) Declares that the value of FORM must be of VALUE-TYPE. Signals an error if this is not the case. ------------------------------------------------------------------------------ THIRD [Function] Args: (x) Equivalent to (CADDR X). ------------------------------------------------------------------------------ THROW [Special form] Syntax: (throw tag result) Evaluates TAG and aborts the execution of the most recent CATCH form that sets up a catcher with the same tag value. The CATCH form returns whatever RESULT returned. ------------------------------------------------------------------------------ TIME [Macro] Syntax: (time form) Evaluates FORM and outputs timing statistics on *TRACE-OUTPUT*. ------------------------------------------------------------------------------ TRACE [Macro] Syntax: (trace {function-name}*) Traces the specified functions. With no FUNCTION-NAMEs, returns a list of functions currently being traced. ------------------------------------------------------------------------------ *TRACE-OUTPUT* [Variable] The trace output stream. ------------------------------------------------------------------------------ TREE-EQUAL [Function] Args: (x y &key (test #'eql) test-not) Returns T if X and Y are isomorphic trees with identical leaves. ------------------------------------------------------------------------------ TRUENAME [Function] Args: (pathname) Returns the pathname for the actual file described by PATHNAME. ------------------------------------------------------------------------------ TRUNCATE [Function] Args: (number &optional (divisor 1)) Returns NUMBER/DIVISOR as an integer, rounded toward 0. The second returned value is the remainder. ------------------------------------------------------------------------------ KCL Dictionary Page 82 ------------------------------------------------------------------------------ TYPE-OF [Function] Args: (x) Returns the type of X. ------------------------------------------------------------------------------ TYPECASE [Macro] Syntax: (typecase keyform {(type {form}*)}*) Evaluates KEYFORM and tries to find the TYPE in which the value of KEYFORM belongs. If one is found, then evaluates FORMs that follow the KEY and returns the value of the last FORM. If not, simply returns NIL. ------------------------------------------------------------------------------ TYPEP [Function] Args: (x type) Returns T if X is of the type TYPE; NIL otherwise. ------------------------------------------------------------------------------ UNEXPORT [Function] Args: (symbols &optional (package *package*)) Makes SYMBOLS no longer accessible as external symbols in PACKAGE. SYMBOLS must be a list of symbols or a symbol. ------------------------------------------------------------------------------ UNINTERN [Function] Args: (symbol &optional (package *package*)) Makes SYMBOL no longer present in PACKAGE. Returns T if SYMBOL was present; NIL otherwise. If PACKAGE is the home package of SYMBOL, then makes SYMBOL uninterned. ------------------------------------------------------------------------------ UNION [Function] Args: (list1 list2 &key (test #'eql) test-not (key #'identity)) Returns the union of LIST1 and LIST2. ------------------------------------------------------------------------------ UNLESS [Macro] Syntax: (unless test {form}*) If TEST evaluates to NIL, then evaluates FORMs as a PROGN. If not, simply returns NIL. ------------------------------------------------------------------------------ UNREAD-CHAR [Function] Args: (character &optional (stream *standard-input*)) Puts CHARACTER back on the front of the input stream STREAM. ------------------------------------------------------------------------------ UNTRACE [Macro] Syntax: (untrace {function-name}*) Removes tracing from the specified functions. With no FUNCTION-NAMEs, untraces all functions. ------------------------------------------------------------------------------ UNUSE-PACKAGE [Function] Args: (packages-to-unuse &optional (package *package*)) Removes PACKAGES-TO-UNUSE from the use list for PACKAGE. ------------------------------------------------------------------------------ KCL Dictionary Page 83 ------------------------------------------------------------------------------ UNWIND-PROTECT [Special form] Syntax: (unwind-protect protected-form {cleanup-form}*) Evaluates PROTECTED-FORM and returns whatever it returned. Guarantees that CLEANUP-FORMs be always evaluated before exiting from the UNWIND-PROTECT form. ------------------------------------------------------------------------------ UPPER-CASE-P [Function] Args: (char) Returns T if CHAR is an upper-case character; NIL otherwise. ------------------------------------------------------------------------------ USE-PACKAGE [Function] Args: (packages-to-use &optional (package *package*)) Adds all packages in PACKAGE-TO-USE list to the use list for PACKAGE so that the external symbols of the used packages are available as internal symbols in PACKAGE. ------------------------------------------------------------------------------ USER-HOMEDIR-PATHNAME [Function] Args: (&optional host) Returns the home directory of the logged in user as a pathname. HOST is ignored. ------------------------------------------------------------------------------ VALUES [Function] Args: (&rest args) Returns ARGs in order, as values. ------------------------------------------------------------------------------ VALUES-LIST [Function] Args: (list) Returns all of the elements of LIST in order, as values. ------------------------------------------------------------------------------ VECTOR [Type] A vector is a one-dimensional array. Strings and bit-vectors are kinds of vectors. Other vectors are called general vectors and are denoted as #(elem0 ... elemn) where n is the length of the vector minus one. Some vectors may be displaced to another vector, may have a fill pointer, or may be adjusted its size. Other vectors are called simple vectors. ------------------------------------------------------------------------------ VECTOR [Function] Args: (&rest objects) Constructs a Simple-Vector from the given objects. ------------------------------------------------------------------------------ VECTOR-POP [Function] Args: (vector) Attempts to decrease the fill-pointer of VECTOR by 1 and returns the element pointed to by the new fill pointer. Signals an error if the old value of the fill pointer is 0. ------------------------------------------------------------------------------ KCL Dictionary Page 84 ------------------------------------------------------------------------------ VECTOR-PUSH [Function] Args: (new-element vector) Attempts to set the element of ARRAY designated by its fill pointer to NEW-ELEMENT and increments the fill pointer by one. Returns NIL if the fill pointer is too large. Otherwise, returns the new fill pointer value. ------------------------------------------------------------------------------ VECTOR-PUSH-EXTEND [Function] Args: (new-element vector &optional (extension (length vector))) Similar to VECTOR-PUSH except that, if the fill pointer gets too large, extends VECTOR rather then simply returns NIL. ------------------------------------------------------------------------------ VECTORP [Function] Args: (x) Returns T if X is a vector; NIL otherwise. ------------------------------------------------------------------------------ WARN [Function] Args: (format-string &rest args) Formats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message. ------------------------------------------------------------------------------ WHEN [Macro] Syntax: (when test {form}*) If TEST evaluates to non-NIL, then evaluates FORMs as a PROGN. If not, simply returns NIL. ------------------------------------------------------------------------------ WITH-INPUT-FROM-STRING [Macro] Syntax: (with-input-from-string (var string {keyword value}*) {decl}* {form}*) Binds VAR to an input stream that returns characters from STRING and evaluates the FORMs. The stream is automatically closed on exit. Allowed keywords are :INDEX, :START, and :END. ------------------------------------------------------------------------------ WITH-OPEN-FILE [Macro] Syntax: (with-open-file (stream filename {options}*) {decl}* {form}*) Opens the file whose name is FILENAME, using OPTIONs, and binds the variable STREAM to a stream to/from the file. Then evaluates FORMs as a PROGN. The file is automatically closed on exit. ------------------------------------------------------------------------------ WITH-OPEN-STREAM [Macro] Syntax: (with-open-stream (var stream) {decl}* {form}*) Evaluates FORMs as a PROGN with VAR bound to the value of STREAM. The stream is automatically closed on exit. ------------------------------------------------------------------------------ WITH-OUTPUT-TO-STRING [Macro] Syntax: (with-output-to-string (var [string]) {decl}* {form}*) Binds VAR to a string output stream that puts characters into STRING, which defaults to a new string. The stream is automatically closed on exit and the string is returned. ------------------------------------------------------------------------------ KCL Dictionary Page 85 ------------------------------------------------------------------------------ WRITE [Function] Args: (object &key (stream *standard-output*) (escape *print-escape*) (radix *print-radix*) (base *print-base*) (circle *print-circle*) (pretty *print-pretty*) (level *print-level*) (length *print-length*) (case *print-case*) (array *print-array*) (gensym *print-gensym*)) Prints OBJECT in the specified mode. See the variable docs of *PRINT-...* for the mode. ------------------------------------------------------------------------------ WRITE-BYTE [Function] Args: (integer stream) Outputs INTEGER to the binary stream STREAM. Returns INTEGER. ------------------------------------------------------------------------------ WRITE-CHAR [Function] Args: (char &optional (stream *standard-output*)) Outputs CHAR and returns it. ------------------------------------------------------------------------------ WRITE-LINE [Function] Args: (string &optional (stream *standard-output*) &key (start 0) (end (length string))) Outputs STRING and then outputs a newline character. Returns STRING. ------------------------------------------------------------------------------ WRITE-STRING [Function] Args: (string &optional (stream *standard-output*) &key (start 0) (end (length string))) Outputs STRING and returns it. ------------------------------------------------------------------------------ WRITE-TO-STRING [Function] Args: (object &key (escape *print-escape*) (radix *print-radix*) (base *print-base*) (circle *print-circle*) (pretty *print-pretty*) (level *print-level*) (length *print-length*) (case *print-case*) (array *print-array*) (gensym *print-gensym*)) Returns as a string the printed representation of OBJECT in the specified mode. See the variable docs of *PRINT-...* for the mode. ------------------------------------------------------------------------------ Y-OR-N-P [Function] Args: (&optional (format-string nil) &rest args) Asks the user a question whose answer is either 'Y' or 'N'. If FORMAT-STRING is non-NIL, then FRESH-LINE operation is performed, a message is printed as if FORMAT-STRING and ARGs were given to FORMAT, and then a prompt "(Y or N)" is printed. Otherwise, no prompt will appear. ------------------------------------------------------------------------------ YES-OR-NO-P [Function] Args: (&optional (format-string nil) &rest args) Asks the user a question whose answer is either 'YES' or 'NO'. If FORMAT- STRING is non-NIL, then FRESH-LINE operation is performed, a message is printed as if FORMAT-STRING and ARGs were given to FORMAT, and then a prompt "(Yes or No)" is printed. Otherwise, no prompt will appear. ------------------------------------------------------------------------------ KCL Dictionary Page 86 ------------------------------------------------------------------------------ ZEROP [Function] Args: (number) Returns T if NUMBER = 0; NIL otherwise. ------------------------------------------------------------------------------ si:ADDRESS [Function] Args: (object) KCL specific: Returns the address of the OBJECT as a fixnum. The address of an object depends on the version of KCL. E.g. (SI:ADDRESS NIL) returns 1879062044 on KCL/AOSVS dated March 14, 1986. ------------------------------------------------------------------------------ si:ARGC [Function] Args: () KCL specific: Returns the number of arguments on the command line that invoked the KCL process. ------------------------------------------------------------------------------ si:ARGV [Function] Args: (fixnum) KCL specific: Returns the FIXNUM-th argument on the command line that invoked the KCL process. ------------------------------------------------------------------------------ si:BDS-VAL [Function] Args: (i) KCL specific: Returns the value of the i-th entity in the bind stack. ------------------------------------------------------------------------------ si:BDS-VAR [Function] Args: (i) KCL specific: Returns the symbol of the i-th entity in the bind stack. ------------------------------------------------------------------------------ si:CATCH-BAD-SIGNALS [Function] Args: () KCL/BSD specific: Installs a signal catcher for bad signals: SIGILL, SIGIOT, SIGEMT, SIGBUS, SIGSEGV, SIGSYS. The signal catcher, upon catching the signal, signals an error (and enter the break-level). Since the internal memory of KCL may be broken, the user should check the signal and exit from KCL if necessary. When the signal is caught during garbage collection, KCL terminates immediately. ------------------------------------------------------------------------------ si:CHDIR [Function] Args: (pathname) KCL/UNIX specific: Changes the current working directory to the specified pathname. ------------------------------------------------------------------------------ si:COMPILED-FUNCTION-NAME [Function] Args: (compiled-function-object) KCL specific: Returns the name of the COMPILED-FUNCTION-OBJECT. ------------------------------------------------------------------------------ KCL Dictionary Page 87 ------------------------------------------------------------------------------ si:COPY-STREAM [Function] Args: (in-stream out-stream) KCL specific: Copies IN-STREAM to OUT-STREAM until the end-of-file on IN- STREAM. ------------------------------------------------------------------------------ si:CREATE-IPC-FILE [Function] Args: (pathname local-port-number) KCL/AOSVS specific: Creates an IPC file with the name PATHNAME and with the specified LOCAL-PORT-NUMBER. LOCAL-PORT-NUMBER should be a fixxnum. ------------------------------------------------------------------------------ si:*DEFAULT-TIME-ZONE* [Variable] KCL specific: Holds the default time zone. The initial value of SI:*DEFAULT- TIME-ZONE* is -9 (the time zone of Japan). ------------------------------------------------------------------------------ si:DISPLACED-ARRAY-P [Function] Args (array) KCL specific: Returns T if the ARRAY is a displaced array; NIL otherwise. ------------------------------------------------------------------------------ si:FRS-BDS [Function] Args: (i) KCL specific: Returns the bind stack index of the i-th entity in the frame stack. ------------------------------------------------------------------------------ si:FRS-IHS [Function] Args: (i) KCL specific: Returns the invocation history stack index of the i-th entity in the frame stack. ------------------------------------------------------------------------------ si:FRS-VS [Function] Args: (i) KCL specific: Returns the value stack index of the i-th entity in the frame stack. ------------------------------------------------------------------------------ si:ERROR-SET [Function] Args: (form) KCL specific: Evaluates the FORM in the null environment. If the evaluation of the FORM has successfully completed, SI:ERROR-SET returns NIL as the first value and the result of the evaluation as the rest of the values. If, in the course of the evaluation, a non-local jump from the FORM is atempted, SI:ERROR-SET traps the jump and returns the corresponding jump tag as its value. ------------------------------------------------------------------------------ si:FASLINK [Function] Args: (file string) KCL/BSD specific: Loads the FASL file FILE while linking the object files and libraries specified by STRING. For example, (faslink "foo.o" "bar.o boo.o -lpixrect") loads foo.o while linking two object files (bar.o and boo.o) and the library pixrect. Usually, foo.o consists of the C language interface for the functions defined in the object files or the libraries. ------------------------------------------------------------------------------ KCL Dictionary Page 88 ------------------------------------------------------------------------------ si:FIXNUMP [Function] Args: (object) KCL specific: Returns T if the OBJECT is a fixnum; NIL otherwise. ------------------------------------------------------------------------------ si:*GBC-MESSAGE* [Variable] KCL specific: If the value of SI:*GBC-MESSAGE* is non-NIL, the garbage collector prints some information on the terminal. Usually SI:*GBC-MESSAGE* should be set NIL. ------------------------------------------------------------------------------ si:GET-STRING-INPUT-STREAM-INDEX [Function] Args: (string-input-stream) KCL specific: Returns the current index of the STRING-INPUT-STREAM. ------------------------------------------------------------------------------ si:GETENV [Function] Args: (string) KCL/UNIX specific: Returns the environment with the name STRING as a string; if the environment specified by STRING is not found, returns NIL. ------------------------------------------------------------------------------ si:GET-HOLE-SIZE [Function] Args: () KCL specific: Returns as a fixnum the size of the memory hole (in pages). ------------------------------------------------------------------------------ si:*IGNORE-EOF-ON-TERMINAL-IO* [Variable] KCL specific: If the value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is non-NIL, KCL ignores the eof-character (usually ^D) on the terminal and the terminal never becomes end-of-file. The default value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is NIL. ------------------------------------------------------------------------------ si:IHS-FUN [Function] Args: (i) KCL specific: Returns the function value of the i-th entity in the invocation history stack. ------------------------------------------------------------------------------ si:IHS-VS [Function] Args: (i) KCL specific: Returns the value stack index of the i-th entity in the invocation history stack. ------------------------------------------------------------------------------ si:ILKUP [Function] Args: (pathname) KCL/AOSVS specific: Returns the global port number of the IPC file specified by the PATHNAME. ------------------------------------------------------------------------------ si:*INDENT-FORMATTED-OUTPUT* [Variable] KCL specific: The FORMAT directive ~% indents the next line if the value of this variable is non-NIL. If NIL, ~% simply does Newline. ------------------------------------------------------------------------------ KCL Dictionary Page 89 ------------------------------------------------------------------------------ si:INIT-SYSTEM [Function] Args: () KCL specific: Initializes the library and the compiler of KCL. Since they have already been initialized in the standard image of KCL, calling SI:INIT- SYSTEM will cause an error. ------------------------------------------------------------------------------ si:*INTERRUPT-ENABLE* [Variable] KCL specific: If the value of SI:*INTERRUPT-ENABLE* is non-NIL, KCL signals an error on the terminal interrupt (this is the default case). If it is NIL, KCL ignores the interrupt and assigns T to SI:*INTERRUPT-ENABLE*. ------------------------------------------------------------------------------ si:IREC [Function] Args: (global-port-number local-port-number string) KCL/AOSVS specific: Receives a message from the specified port into the STRING. GLOBAL-PORT-NUMBER and LOCAL-PORT-NUMBER should be fixnums. The STRING should have a fill-pointer. ------------------------------------------------------------------------------ si:ISEND [Function] Args: (global-port-number local-port-number string) KCL/AOSVS specific: Sends a message in the STRING to the specified port. GLOBAL-PORT-NUMBER and LOCAL-PORT-NUMBER should be fixnums. ------------------------------------------------------------------------------ si:*LISP-MAXPAGES* [Variable] KCL specific: Holds the maximum number of pages (1 page = 2048 bytes) for the KCL process. The result of changing the value of SI:*LISP-MAXPAGES* is unpredictable. ------------------------------------------------------------------------------ si:*MAKE-CONSTANT [Function] Args: (symbol value) KCL specific: Makes the SYMBOL a constant with the specified VALUE. ------------------------------------------------------------------------------ si:*MAKE-SPECIAL [Function] Args (symbol) KCL specific: Makes the SYMBOL globally special. ------------------------------------------------------------------------------ si:MAKE-STRING-OUTPUT-STREAM-FROM-STRING [Function] Args (string) KCL specific: Creates a string-output-stream corresponding to the STRING and returns it. The STRING should have a fill-pointer. ------------------------------------------------------------------------------ si:NANI [Function] Args: (fixnum) KCL specific: Returns the object in the address FIXNUM. This function is the inverse of SI:ADDRESS. Although SI:ADDRESS is a harmless operation, SI:NANI is quite dangerous and should be used with care. ------------------------------------------------------------------------------ KCL Dictionary Page 90 ------------------------------------------------------------------------------ si:*NOTIFY-GBC* [Variable] KCL specific: If the value of this variable is non-NIL, then the garbage collector notifies that it begins to run whenever it is invoked. Otherwise, garbage collection begins silently. ------------------------------------------------------------------------------ si:OUTPUT-STREAM-STRING [Function] Args: (string-output-stream) KCL specific: Returns the string corresponding to the STRING-OUTPUT-STREAM. ------------------------------------------------------------------------------ si:RESET-GBC-COUNT [Function] Args: () KCL specific: Resets the counter of the garbage collector that records how many times the garbage collector has been called for each implementation type. ------------------------------------------------------------------------------ si:RESET-STACK-LIMITS [Function] Args: () KCL specific: Resets the stack limits to the normal state. When a stack has overflowed, KCL extends the limit for the stack in order to execute the error handler. After processing the error, KCL resets the stack limit by calling SI:RESET-STACK-LIMITS. ------------------------------------------------------------------------------ si:SAVE-SYSTEM [Function] Args: (pathname) KCL specific: Saves the current KCL core imange into a program file specified by PATHNAME. This function differs from SAVE in that the contiguous and relocatable areas are made permanent in the saved image. Usually the standard image of KCL interpreter/compiler is saved by SI:SAVE-SYSTEM. ------------------------------------------------------------------------------ si:SET-HOLE-SIZE [Function] Args: (fixnum) KCL specific: Sets the size of the memory hole (in pages). ------------------------------------------------------------------------------ si:SPECIALP [Function] Args: (symbol) KCL specific: Returns T if the SYMBOL is a globally special variable; NIL otherwise. ------------------------------------------------------------------------------ si:STRING-CONCATENATE [Function] Args: (&rest strings) KCL specific: Returns the result of concatenating the given STRINGS. ------------------------------------------------------------------------------ si:STRING-TO-OBJECT [Function] Args: (string) KCL specific: (SI:STRING-TO-OBJECT STRING) is equivalent to (READ-FROM-STRING STRING), but much faster. ------------------------------------------------------------------------------ KCL Dictionary Page 91 ------------------------------------------------------------------------------ si:STRUCTUREP [Function] Args: (object) KCL specific: Returns T if the OBJECT is a structure; NIL otherwise. ------------------------------------------------------------------------------ si:*SYSTEM-DIRECTORY* [Variable] KCL specific: Holds the name of the system directory of KCL. ------------------------------------------------------------------------------ si:TOP-LEVEL [Function] Args: () KCL specific: Starts the standard top-level listner of KCL. When the KCL process is invoked, it calls SI:TOP-LEVEL by (FUNCALL 'SI:TOP-LEVEL). To change the top-level of KCL, redefine SI:TOP-LEVEL and save the core imange in a file. When the saved imange is invoked, it will start the redefined top-level. ------------------------------------------------------------------------------ si:UNIVERSAL-ERROR-HANDLER [Function] Args: (error-name correctable function-name continue-format-string error-format-string &rest args) KCL specific: Starts the error handler of KCL. When an error is detected, KCL calls SI:UNIVERSAL-ERROR-HANDLER with the specified arguments. ERROR-NAME is the name of the error. CORRECTABLE is T for a correctable error and NIL for a fatal error. FUNCTION-NAME is the name of the function that caused the error. CONTINUE-FORMAT-STRING and ERROR-FORMAT-STRING are the format strings of the error message. ARGS are the arguments to the format strings. To change the error handler of KCL, redefine SI:UNIVERSAL-ERROR- HANDLER. ------------------------------------------------------------------------------ si:UNCATCH-BAD-SIGNALS [Function] Args: () KCL/BSD specific: Undoes the effect of SI:CATCH-BAD-SIGNALS. ------------------------------------------------------------------------------ si:VS [Function] Args: (i) KCL specific: Returns the i-th entity in the value stack. ------------------------------------------------------------------------------ *DEFAULT-MESSAGE-FILE* [Variable] KCL specific: Gives the default value of the :MESSAGE-FILE parameter to COMPILE-FILE. The initial value is NIL, meaning that no log file is prepared. ------------------------------------------------------------------------------ KCL Dictionary Page 92 ABS ARGUMENTS ABS 2 CALL-ARGUMENTS-LIMIT 12 ACONS ARGV ACONS 2 ARGV 86 ACOS ARRAY ACOS 2 ADJUST-ARRAY 3 ACOSH ADJUSTABLE-ARRAY-P 3 ACOSH 3 ARRAY 5 ADDRESS ARRAY-DIMENSION 5 ADDRESS 86 ARRAY-DIMENSION-LIMIT 5 ADJOIN ARRAY-DIMENSIONS 5 ADJOIN 3 ARRAY-ELEMENT-TYPE 5 ADJUST ARRAY-HAS-FILL-POINTER-P 5 ADJUST-ARRAY 3 ARRAY-IN-BOUNDS-P 5 ADJUSTABLE ARRAY-RANK 5 ADJUSTABLE-ARRAY-P 3 ARRAY-RANK-LIMIT 5 ALIST ARRAY-ROW-MAJOR-INDEX 5 COPY-ALIST 20 ARRAY-TOTAL-SIZE 6 ALL ARRAY-TOTAL-SIZE-LIMIT 6 DO-ALL-SYMBOLS 28 MAKE-ARRAY 48 FIND-ALL-SYMBOLS 34 *PRINT-ARRAY* 61 LIST-ALL-PACKAGES 45 SIMPLE-ARRAY 72 ALLOCATABLE DISPLACED-ARRAY-P 87 MAXIMUM-ALLOCATABLE-PAGES 51 ARRAYP ALLOCATE ARRAYP 6 ALLOCATE 3 ASH ALLOCATE-CONTIGUOUS-PAGES 3 ASH 6 ALLOCATE-RELOCATABLE-PAGES 3 ASIN ALLOCATED ASIN 6 ALLOCATED-CONTIGUOUS-PAGES 3 ASINH ALLOCATED-PAGES 3 ASINH 6 ALLOCATED-RELOCATABLE-PAGES 4 ASSERT ALPHA ASSERT 6 ALPHA-CHAR-P 4 ASSOC ALPHANUMERICP ASSOC 6 ALPHANUMERICP 4 ASSOC-IF 6 AND ASSOC-IF-NOT 6 AND 4 ATAN BIT-AND 7 ATAN 6 BOOLE-AND 9 ATANH ANDC1 ATANH 7 BIT-ANDC1 7 ATOM BOOLE-ANDC1 9 ATOM 7 ANDC2 AUTHOR BIT-ANDC2 7 FILE-AUTHOR 33 BOOLE-ANDC2 9 BAD APPEND CATCH-BAD-SIGNALS 86 APPEND 4 UNCATCH-BAD-SIGNALS 91 APPLY BASE APPLY 4 *PRINT-BASE* 61 APPLYHOOK *READ-BASE* 64 APPLYHOOK 4 BDS *APPLYHOOK* 4 BDS-VAL 86 APROPOS BDS-VAR 86 APROPOS 4 FRS-BDS 87 APROPOS-LIST 4 BIGNUM AREF BIGNUM 7 AREF 5 BIND ARGC MULTIPLE-VALUE-BIND 53 ARGC 86 BIT KCL Dictionary Page 93 BIT 7 BY 11 BIT-AND 7 PACKAGE-USED-BY-LIST 58 BIT-ANDC1 7 BYE BIT-ANDC2 7 BYE 11 BIT-EQV 7 BYTE BIT-IOR 7 BYTE 11 BIT-NAND 8 BYTE-POSITION 11 BIT-NOR 8 BYTE-SIZE 11 BIT-NOT 8 READ-BYTE 65 BIT-ORC1 8 WRITE-BYTE 85 BIT-ORC2 8 C1 BIT-VECTOR 8 BOOLE-C1 9 BIT-VECTOR-P 8 C2 BIT-XOR 8 BOOLE-C2 9 CHAR-BIT 14 CAAAAR CHAR-CONTROL-BIT 15 CAAAAR 11 CHAR-HYPER-BIT 15 CAAADR CHAR-META-BIT 15 CAAADR 11 CHAR-SUPER-BIT 16 CAAAR SET-CHAR-BIT 70 CAAAR 11 SIMPLE-BIT-VECTOR 72 CAADAR SIMPLE-BIT-VECTOR-P 72 CAADAR 11 BITS CAADDR CHAR-BITS 14 CAADDR 11 CHAR-BITS-LIMIT 14 CAADR BLOCK CAADR 11 BLOCK 9 CAAR BOOLE CAAR 11 BOOLE 9 CADAAR BOOLE-1 9 CADAAR 12 BOOLE-2 9 CADADR BOOLE-AND 9 CADADR 12 BOOLE-ANDC1 9 CADAR BOOLE-ANDC2 9 CADAR 12 BOOLE-C1 9 CADDAR BOOLE-C2 9 CADDAR 12 BOOLE-CLR 9 CADDDR BOOLE-EQV 9 CADDDR 12 BOOLE-IOR 9 CADDR BOOLE-NAND 10 CADDR 12 BOOLE-NOR 10 CADR BOOLE-ORC1 10 CADR 12 BOOLE-ORC2 10 CALL BOOLE-SET 10 CALL-ARGUMENTS-LIMIT 12 BOOLE-XOR 10 MULTIPLE-VALUE-CALL 53 BOTH CAPITALIZE BOTH-CASE-P 10 NSTRING-CAPITALIZE 55 BOUNDP STRING-CAPITALIZE 75 BOUNDP 10 CAR BOUNDS CAR 12 ARRAY-IN-BOUNDS-P 5 CASE BREAK BOTH-CASE-P 10 BREAK 10 CASE 12 *BREAK-ENABLE* 10 LOWER-CASE-P 47 *BREAK-ON-WARNINGS* 10 *PRINT-CASE* 61 BROADCAST UPPER-CASE-P 83 MAKE-BROADCAST-STREAM 48 CATCH BUTLAST CATCH 12 BUTLAST 10 CATCH-BAD-SIGNALS 86 BY CCASE KCL Dictionary Page 94 CCASE 13 CHAR< 16 CDAAAR CHAR<= 16 CDAAAR 13 CHAR= 16 CDAADR CHAR> 17 CDAADR 13 CHAR>= 17 CDAAR CODE-CHAR 18 CDAAR 13 DIGIT-CHAR 27 CDADAR DIGIT-CHAR-P 28 CDADAR 13 GRAPHIC-CHAR-P 39 CDADDR INT-CHAR 41 CDADDR 13 MAKE-CHAR 48 CDADR NAME-CHAR 53 CDADR 13 PEEK-CHAR 59 CDAR READ-CHAR 65 CDAR 13 READ-CHAR-NO-HANG 65 CDDAAR SET-CHAR-BIT 70 CDDAAR 13 SET-SYNTAX-FROM-CHAR 70 CDDADR STANDARD-CHAR 74 CDDADR 13 STANDARD-CHAR-P 74 CDDAR STRING-CHAR 76 CDDAR 13 STRING-CHAR-P 76 CDDDAR UNREAD-CHAR 82 CDDDAR 14 WRITE-CHAR 85 CDDDDR CHARACTER CDDDDR 14 CHARACTER 17 CDDDR GET-DISPATCH-MACRO-CHARACTER 38 CDDDR 14 GET-MACRO-CHARACTER 38 CDDR MAKE-DISPATCH-MACRO-CHARACTER 48 CDDR 14 SET-DISPATCH-MACRO-CHARACTER 70 CDR SET-MACRO-CHARACTER 70 CDR 14 CHARACTERP CEILING CHARACTERP 17 CEILING 14 CHDIR CERROR CHDIR 86 CERROR 14 CHECK CHAR CHECK-TYPE 17 ALPHA-CHAR-P 4 CIRCLE CHAR 14 *PRINT-CIRCLE* 61 CHAR-BIT 14 CIS CHAR-BITS 14 CIS 17 CHAR-BITS-LIMIT 14 CLEAR CHAR-CODE 15 CLEAR-INPUT 17 CHAR-CODE-LIMIT 15 CLEAR-OUTPUT 18 CHAR-CONTROL-BIT 15 CLINES CHAR-DOWNCASE 15 CLINES 18 CHAR-EQUAL 15 CLOSE CHAR-FONT 15 CLOSE 18 CHAR-FONT-LIMIT 15 CLR CHAR-GREATERP 15 BOOLE-CLR 9 CHAR-HYPER-BIT 15 CLRHASH CHAR-INT 15 CLRHASH 18 CHAR-LESSP 15 CODE CHAR-META-BIT 15 CHAR-CODE 15 CHAR-NAME 16 CHAR-CODE-LIMIT 15 CHAR-NOT-EQUAL 16 CODE-CHAR 18 CHAR-NOT-GREATERP 16 COERCE CHAR-NOT-LESSP 16 COERCE 18 CHAR-SUPER-BIT 16 COMMON CHAR-UPCASE 16 COMMON 18 CHAR/= 16 COMMONP KCL Dictionary Page 95 COMMONP 18 DATE COMPILE FILE-WRITE-DATE 33 COMPILE 18 DEBUG COMPILE-FILE 19 *DEBUG-IO* 21 *EVAL-WHEN-COMPILE* 31 DECF COMPILED DECF 21 COMPILED-FUNCTION 19 DECLARE COMPILED-FUNCTION-P 19 DECLARE 22 COMPILED-FUNCTION-NAME 86 DECODE COMPILER DECODE-FLOAT 22 COMPILER-LET 19 DECODE-UNIVERSAL-TIME 22 COMPLEX INTEGER-DECODE-FLOAT 41 COMPLEX 19 DECODED COMPLEXP GET-DECODED-TIME 38 COMPLEXP 19 DEFAULT CONCATENATE *DEFAULT-PATHNAME-DEFAULTS* 22 CONCATENATE 19 *READ-DEFAULT-FLOAT-FORMAT* 65 STRING-CONCATENATE 90 *DEFAULT-TIME-ZONE* 87 CONCATENATED *DEFAULT-MESSAGE-FILE* 91 MAKE-CONCATENATED-STREAM 48 DEFAULTS COND *DEFAULT-PATHNAME-DEFAULTS* 22 COND 20 DEFCFUN CONJUGATE DEFCFUN 23 CONJUGATE 20 DEFCONSTANT CONS DEFCONSTANT 23 CONS 20 DEFENTRY CONSP DEFENTRY 23 CONSP 20 DEFINE CONSTANT DEFINE-MODIFY-MACRO 23 *MAKE-CONSTANT 89 DEFINE-SETF-METHOD 24 CONSTANTP DEFLA CONSTANTP 20 DEFLA 24 CONTIGUOUS DEFMACRO ALLOCATE-CONTIGUOUS-PAGES 3 DEFMACRO 25 ALLOCATED-CONTIGUOUS-PAGES 3 DEFPARAMETER MAXIMUM-CONTIGUOUS-PAGES 51 DEFPARAMETER 25 CONTROL DEFSETF CHAR-CONTROL-BIT 15 DEFSETF 25 COPY DEFSTRUCT COPY-ALIST 20 DEFSTRUCT 26 COPY-LIST 20 DEFTYPE COPY-READTABLE 20 DEFTYPE 26 COPY-SEQ 20 DEFUN COPY-SYMBOL 21 DEFUN 26 COPY-TREE 21 DEFVAR COPY-STREAM 87 DEFVAR 26 COS DELETE COS 21 DELETE 27 COSH DELETE-DUPLICATES 27 COSH 21 DELETE-FILE 27 COUNT DELETE-IF 27 COUNT 21 DELETE-IF-NOT 27 COUNT-IF 21 DELIMITED COUNT-IF-NOT 21 READ-DELIMITED-LIST 65 HASH-TABLE-COUNT 39 DENOMINATOR RESET-GBC-COUNT 90 DENOMINATOR 27 CREATE DEPOSIT CREATE-IPC-FILE 87 DEPOSIT-FIELD 27 CTYPECASE DESCRIBE CTYPECASE 21 DESCRIBE 27 KCL Dictionary Page 96 DEVICE ECHO PATHNAME-DEVICE 59 MAKE-ECHO-STREAM 49 DIFFERENCE ED NSET-DIFFERENCE 55 ED 30 SET-DIFFERENCE 70 EIGHTH DIGIT EIGHTH 30 DIGIT-CHAR 27 ELEMENT DIGIT-CHAR-P 28 ARRAY-ELEMENT-TYPE 5 DIGITS STREAM-ELEMENT-TYPE 75 FLOAT-DIGITS 35 ELT DIMENSION ELT 30 ARRAY-DIMENSION 5 ENABLE ARRAY-DIMENSION-LIMIT 5 *BREAK-ENABLE* 10 DIMENSIONS *INTERRUPT-ENABLE* 89 ARRAY-DIMENSIONS 5 ENCODE DIRECTORY ENCODE-UNIVERSAL-TIME 30 DIRECTORY 28 ENDP DIRECTORY-NAMESTRING 28 ENDP 30 PATHNAME-DIRECTORY 59 ENOUGH *SYSTEM-DIRECTORY* 91 ENOUGH-NAMESTRING 30 DISASSEMBLE EOF DISASSEMBLE 28 *IGNORE-EOF-ON-TERMINAL-IO* 88 DISPATCH EPSILON GET-DISPATCH-MACRO-CHARACTER 38 DOUBLE-FLOAT-EPSILON 29 MAKE-DISPATCH-MACRO-CHARACTER 48 DOUBLE-FLOAT-NEGATIVE-EPSILON 29 SET-DISPATCH-MACRO-CHARACTER 70 LONG-FLOAT-EPSILON 47 DISPLACED LONG-FLOAT-NEGATIVE-EPSILON 47 DISPLACED-ARRAY-P 87 SHORT-FLOAT-EPSILON 71 DO SHORT-FLOAT-NEGATIVE-EPSILON 72 DO 28 SINGLE-FLOAT-EPSILON 72 DO* 28 SINGLE-FLOAT-NEGATIVE-EPSILON 73 DO-ALL-SYMBOLS 28 EQ DO-EXTERNAL-SYMBOLS 28 EQ 30 DO-SYMBOLS 29 EQL DOCUMENTATION EQL 30 DOCUMENTATION 29 EQUAL DOLIST CHAR-EQUAL 15 DOLIST 29 CHAR-NOT-EQUAL 16 DOTIMES EQUAL 30 DOTIMES 29 STRING-EQUAL 76 DOUBLE STRING-NOT-EQUAL 76 DOUBLE-FLOAT-EPSILON 29 TREE-EQUAL 81 DOUBLE-FLOAT-NEGATIVE-EPSILON 29 EQUALP LEAST-NEGATIVE-DOUBLE-FLOAT 43 EQUALP 31 LEAST-POSITIVE-DOUBLE-FLOAT 43 EQV MOST-NEGATIVE-DOUBLE-FLOAT 52 BIT-EQV 7 MOST-POSITIVE-DOUBLE-FLOAT 53 BOOLE-EQV 9 DOWNCASE ERROR CHAR-DOWNCASE 15 ERROR 31 NSTRING-DOWNCASE 55 *ERROR-OUTPUT* 31 STRING-DOWNCASE 76 ERROR-SET 87 DPB UNIVERSAL-ERROR-HANDLER 91 DPB 29 ESCAPE DRIBBLE *PRINT-ESCAPE* 61 DRIBBLE 29 ETYPECASE DUPLICATES ETYPECASE 31 DELETE-DUPLICATES 27 EVAL REMOVE-DUPLICATES 67 EVAL 31 ECASE EVAL-WHEN 31 ECASE 29 *EVAL-WHEN-COMPILE* 31 KCL Dictionary Page 97 EVALHOOK FINISH-OUTPUT 34 EVALHOOK 31 FIRST *EVALHOOK* 31 FIRST 34 EVENP FIXNUM EVENP 32 FIXNUM 34 EVERY MOST-NEGATIVE-FIXNUM 52 EVERY 32 MOST-POSITIVE-FIXNUM 53 EXCLUSIVE FIXNUMP NSET-EXCLUSIVE-OR 55 FIXNUMP 88 SET-EXCLUSIVE-OR 70 FLET EXP FLET 34 EXP 32 FLOAT EXPORT DECODE-FLOAT 22 EXPORT 32 DOUBLE-FLOAT-EPSILON 29 EXPT DOUBLE-FLOAT-NEGATIVE-EPSILON 29 EXPT 32 FLOAT 35 EXTEND FLOAT-DIGITS 35 VECTOR-PUSH-EXTEND 84 FLOAT-PRECISION 35 EXTERNAL FLOAT-RADIX 35 DO-EXTERNAL-SYMBOLS 28 FLOAT-SIGN 35 FASLINK INTEGER-DECODE-FLOAT 41 FASLINK 87 LEAST-NEGATIVE-DOUBLE-FLOAT 43 FBOUNDP LEAST-NEGATIVE-LONG-FLOAT 43 FBOUNDP 32 LEAST-NEGATIVE-SHORT-FLOAT 43 FCEILING LEAST-NEGATIVE-SINGLE-FLOAT 43 FCEILING 32 LEAST-POSITIVE-DOUBLE-FLOAT 43 FEATURES LEAST-POSITIVE-LONG-FLOAT 43 *FEATURES* 32 LEAST-POSITIVE-SHORT-FLOAT 43 FFLOOR LEAST-POSITIVE-SINGLE-FLOAT 44 FFLOOR 33 LONG-FLOAT-EPSILON 47 FIELD LONG-FLOAT-NEGATIVE-EPSILON 47 DEPOSIT-FIELD 27 MOST-NEGATIVE-DOUBLE-FLOAT 52 MASK-FIELD 51 MOST-NEGATIVE-LONG-FLOAT 52 FIFTH MOST-NEGATIVE-SHORT-FLOAT 52 FIFTH 33 MOST-NEGATIVE-SINGLE-FLOAT 52 FILE MOST-POSITIVE-DOUBLE-FLOAT 53 COMPILE-FILE 19 MOST-POSITIVE-LONG-FLOAT 53 DELETE-FILE 27 MOST-POSITIVE-SHORT-FLOAT 53 FILE-AUTHOR 33 MOST-POSITIVE-SINGLE-FLOAT 53 FILE-LENGTH 33 *READ-DEFAULT-FLOAT-FORMAT* 65 FILE-NAMESTRING 33 SCALE-FLOAT 69 FILE-POSITION 33 SHORT-FLOAT-EPSILON 71 FILE-WRITE-DATE 33 SHORT-FLOAT-NEGATIVE-EPSILON 72 PROBE-FILE 62 SINGLE-FLOAT-EPSILON 72 RENAME-FILE 67 SINGLE-FLOAT-NEGATIVE-EPSILON 73 WITH-OPEN-FILE 84 FLOATP CREATE-IPC-FILE 87 FLOATP 35 *DEFAULT-MESSAGE-FILE* 91 FLOOR FILL FLOOR 36 ARRAY-HAS-FILL-POINTER-P 5 FMAKUNBOUND FILL 33 FMAKUNBOUND 36 FILL-POINTER 33 FONT FIND CHAR-FONT 15 FIND 33 CHAR-FONT-LIMIT 15 FIND-ALL-SYMBOLS 34 FORCE FIND-IF 34 FORCE-OUTPUT 36 FIND-IF-NOT 34 FORM FIND-PACKAGE 34 SPECIAL-FORM-P 74 FIND-SYMBOL 34 FORMAT FINISH FORMAT 36 KCL Dictionary Page 98 *READ-DEFAULT-FLOAT-FORMAT* 65 GETENV FORMATTED GETENV 88 *INDENT-FORMATTED-OUTPUT* 88 GETF FOURTH GETF 39 FOURTH 36 GETHASH FRESH GETHASH 39 FRESH-LINE 36 GO FROM GO 39 READ-FROM-STRING 65 GRAPHIC RETURN-FROM 68 GRAPHIC-CHAR-P 39 SET-SYNTAX-FROM-CHAR 70 GREATERP WITH-INPUT-FROM-STRING 84 CHAR-GREATERP 15 make-string-output-stream-from.. 89 CHAR-NOT-GREATERP 16 FROUND STRING-GREATERP 76 FROUND 36 STRING-NOT-GREATERP 76 FRS HANDLER FRS-BDS 87 UNIVERSAL-ERROR-HANDLER 91 FRS-IHS 87 HANG FRS-VS 87 READ-CHAR-NO-HANG 65 FTRUNCATE HAS FTRUNCATE 37 ARRAY-HAS-FILL-POINTER-P 5 FUN HASH IHS-FUN 88 HASH-TABLE 39 FUNCALL HASH-TABLE-COUNT 39 FUNCALL 37 HASH-TABLE-P 40 FUNCTION MAKE-HASH-TABLE 49 COMPILED-FUNCTION 19 HELP COMPILED-FUNCTION-P 19 HELP 40 FUNCTION 37 HELP* 40 MACRO-FUNCTION 47 HOLE SYMBOL-FUNCTION 79 GET-HOLE-SIZE 88 COMPILED-FUNCTION-NAME 86 SET-HOLE-SIZE 90 FUNCTIONP HOMEDIR FUNCTIONP 37 USER-HOMEDIR-PATHNAME 83 GBC HOOK GBC 37 *MACROEXPAND-HOOK* 48 *GBC-MESSAGE* 88 HOST *NOTIFY-GBC* 90 HOST-NAMESTRING 40 RESET-GBC-COUNT 90 PATHNAME-HOST 59 GCD HYPER GCD 37 CHAR-HYPER-BIT 15 GENSYM IDENTITY GENSYM 37 IDENTITY 40 *PRINT-GENSYM* 61 IF GENTEMP ASSOC-IF 6 GENTEMP 38 ASSOC-IF-NOT 6 GET COUNT-IF 21 GET 38 COUNT-IF-NOT 21 GET-DECODED-TIME 38 DELETE-IF 27 GET-DISPATCH-MACRO-CHARACTER 38 DELETE-IF-NOT 27 GET-INTERNAL-REAL-TIME 38 FIND-IF 34 GET-INTERNAL-RUN-TIME 38 FIND-IF-NOT 34 GET-MACRO-CHARACTER 38 IF 40 GET-OUTPUT-STREAM-STRING 38 MEMBER-IF 51 GET-PROPERTIES 38 MEMBER-IF-NOT 51 GET-SETF-METHOD 39 NSUBST-IF 55 GET-SETF-METHOD-MULTIPLE-VALUE 39 NSUBST-IF-NOT 55 GET-UNIVERSAL-TIME 39 NSUBSTITUTE-IF 56 GET-STRING-INPUT-STREAM-INDEX 88 NSUBSTITUTE-IF-NOT 56 GET-HOLE-SIZE 88 POSITION-IF 60 KCL Dictionary Page 99 POSITION-IF-NOT 60 INTERN 42 RASSOC-IF 64 INTERNAL RASSOC-IF-NOT 64 GET-INTERNAL-REAL-TIME 38 REMOVE-IF 67 GET-INTERNAL-RUN-TIME 38 REMOVE-IF-NOT 67 INTERNAL-TIME-UNITS-PER-SECOND 42 SUBST-IF 78 INTERRUPT SUBST-IF-NOT 78 *INTERRUPT-ENABLE* 89 SUBSTITUTE-IF 79 INTERSECTION SUBSTITUTE-IF-NOT 79 INTERSECTION 42 IGNORE IO *IGNORE-MAXIMUM-PAGES* 40 *DEBUG-IO* 21 *IGNORE-EOF-ON-TERMINAL-IO* 88 *QUERY-IO* 63 IHS *TERMINAL-IO* 80 FRS-IHS 87 *IGNORE-EOF-ON-TERMINAL-IO* 88 IHS-FUN 88 IOR IHS-VS 88 BIT-IOR 7 ILKUP BOOLE-IOR 9 ILKUP 88 IPC IMAGPART CREATE-IPC-FILE 87 IMAGPART 40 IREC IMPLEMENTATION IREC 89 LISP-IMPLEMENTATION-TYPE 44 ISEND LISP-IMPLEMENTATION-VERSION 44 ISEND 89 IMPORT ISQRT IMPORT 40 ISQRT 42 SHADOWING-IMPORT 71 KEYWORDP IN KEYWORDP 42 ARRAY-IN-BOUNDS-P 5 KEYWORDS IN-PACKAGE 41 LAMBDA-LIST-KEYWORDS 42 INCF LABELS INCF 41 LABELS 42 INDENT LAMBDA *INDENT-FORMATTED-OUTPUT* 88 LAMBDA-LIST-KEYWORDS 42 INDEX LAMBDA-PARAMETERS-LIMIT 42 ARRAY-ROW-MAJOR-INDEX 5 LAST GET-STRING-INPUT-STREAM-INDEX 88 LAST 43 INIT LAST-TERMINATION-MESSAGE 43 INIT-SYSTEM 89 LCM INPUT LCM 43 CLEAR-INPUT 17 LDB INPUT-STREAM-P 41 LDB 43 MAKE-STRING-INPUT-STREAM 49 LDB-TEST 43 *STANDARD-INPUT* 75 LDIFF WITH-INPUT-FROM-STRING 84 LDIFF 43 GET-STRING-INPUT-STREAM-INDEX 88 LEAST INSPECT LEAST-NEGATIVE-DOUBLE-FLOAT 43 INSPECT 41 LEAST-NEGATIVE-LONG-FLOAT 43 INSTANCE LEAST-NEGATIVE-SHORT-FLOAT 43 MACHINE-INSTANCE 47 LEAST-NEGATIVE-SINGLE-FLOAT 43 INT LEAST-POSITIVE-DOUBLE-FLOAT 43 CHAR-INT 15 LEAST-POSITIVE-LONG-FLOAT 43 INT-CHAR 41 LEAST-POSITIVE-SHORT-FLOAT 43 INTEGER LEAST-POSITIVE-SINGLE-FLOAT 44 INTEGER 41 LEFT INTEGER-DECODE-FLOAT 41 STRING-LEFT-TRIM 76 INTEGER-LENGTH 42 LENGTH PARSE-INTEGER 58 FILE-LENGTH 33 INTEGERP INTEGER-LENGTH 42 INTEGERP 42 LENGTH 44 INTERN LIST-LENGTH 45 KCL Dictionary Page 100 *PRINT-LENGTH* 61 LOGANDC1 LESSP LOGANDC1 45 CHAR-LESSP 15 LOGANDC2 CHAR-NOT-LESSP 16 LOGANDC2 46 STRING-LESSP 76 LOGBITP STRING-NOT-LESSP 77 LOGBITP 46 LET LOGCOUNT COMPILER-LET 19 LOGCOUNT 46 LET 44 LOGEQV LET* 44 LOGEQV 46 LEVEL LOGIOR *PRINT-LEVEL* 61 LOGIOR 46 TOP-LEVEL 91 LOGNAND LIMIT LOGNAND 46 ARRAY-DIMENSION-LIMIT 5 LOGNOR ARRAY-RANK-LIMIT 5 LOGNOR 46 ARRAY-TOTAL-SIZE-LIMIT 6 LOGNOT CALL-ARGUMENTS-LIMIT 12 LOGNOT 46 CHAR-BITS-LIMIT 14 LOGORC1 CHAR-CODE-LIMIT 15 LOGORC1 46 CHAR-FONT-LIMIT 15 LOGORC2 LAMBDA-PARAMETERS-LIMIT 42 LOGORC2 46 MULTIPLE-VALUES-LIMIT 53 LOGTEST LIMITS LOGTEST 46 RESET-STACK-LIMITS 90 LOGXOR LINE LOGXOR 47 FRESH-LINE 36 LONG READ-LINE 65 LEAST-NEGATIVE-LONG-FLOAT 43 WRITE-LINE 85 LEAST-POSITIVE-LONG-FLOAT 43 LISP LONG-FLOAT-EPSILON 47 LISP-IMPLEMENTATION-TYPE 44 LONG-FLOAT-NEGATIVE-EPSILON 47 LISP-IMPLEMENTATION-VERSION 44 LONG-SITE-NAME 47 *LISP-MAXPAGES* 89 MOST-NEGATIVE-LONG-FLOAT 52 LIST MOST-POSITIVE-LONG-FLOAT 53 APROPOS-LIST 4 LOOP COPY-LIST 20 LOOP 47 LAMBDA-LIST-KEYWORDS 42 LOWER LIST 44 LOWER-CASE-P 47 LIST* 45 MACHINE LIST-ALL-PACKAGES 45 MACHINE-INSTANCE 47 LIST-LENGTH 45 MACHINE-TYPE 47 MAKE-LIST 49 MACHINE-VERSION 47 MULTIPLE-VALUE-LIST 53 MACRO PACKAGE-USE-LIST 58 DEFINE-MODIFY-MACRO 23 PACKAGE-USED-BY-LIST 58 GET-DISPATCH-MACRO-CHARACTER 38 READ-DELIMITED-LIST 65 GET-MACRO-CHARACTER 38 VALUES-LIST 83 MACRO-FUNCTION 47 LISTEN MAKE-DISPATCH-MACRO-CHARACTER 48 LISTEN 45 SET-DISPATCH-MACRO-CHARACTER 70 LISTP SET-MACRO-CHARACTER 70 LISTP 45 MACROEXPAND LOAD MACROEXPAND 48 LOAD 45 MACROEXPAND-1 48 *LOAD-VERBOSE* 45 *MACROEXPAND-HOOK* 48 LOCALLY MACROLET LOCALLY 45 MACROLET 48 LOG MAJOR LOG 45 ARRAY-ROW-MAJOR-INDEX 5 LOGAND MAKE LOGAND 45 MAKE-ARRAY 48 KCL Dictionary Page 101 MAKE-BROADCAST-STREAM 48 META MAKE-CHAR 48 CHAR-META-BIT 15 MAKE-CONCATENATED-STREAM 48 METHOD MAKE-DISPATCH-MACRO-CHARACTER 48 DEFINE-SETF-METHOD 24 MAKE-ECHO-STREAM 49 GET-SETF-METHOD 39 MAKE-HASH-TABLE 49 GET-SETF-METHOD-MULTIPLE-VALUE 39 MAKE-LIST 49 MIN MAKE-PACKAGE 49 MIN 52 MAKE-PATHNAME 49 MINUSP MAKE-RANDOM-STATE 49 MINUSP 52 MAKE-SEQUENCE 49 MISMATCH MAKE-STRING 49 MISMATCH 52 MAKE-STRING-INPUT-STREAM 49 MOD MAKE-STRING-OUTPUT-STREAM 50 MOD 52 MAKE-SYMBOL 50 MODIFY MAKE-SYNONYM-STREAM 50 DEFINE-MODIFY-MACRO 23 MAKE-TWO-WAY-STREAM 50 MODULES *MAKE-CONSTANT 89 *MODULES* 52 *MAKE-SPECIAL 89 MOST make-string-output-stream-from.. 89 MOST-NEGATIVE-DOUBLE-FLOAT 52 MAKUNBOUND MOST-NEGATIVE-FIXNUM 52 MAKUNBOUND 50 MOST-NEGATIVE-LONG-FLOAT 52 MAP MOST-NEGATIVE-SHORT-FLOAT 52 MAP 50 MOST-NEGATIVE-SINGLE-FLOAT 52 MAPC MOST-POSITIVE-DOUBLE-FLOAT 53 MAPC 50 MOST-POSITIVE-FIXNUM 53 MAPCAN MOST-POSITIVE-LONG-FLOAT 53 MAPCAN 50 MOST-POSITIVE-SHORT-FLOAT 53 MAPCAR MOST-POSITIVE-SINGLE-FLOAT 53 MAPCAR 50 MULTIPLE MAPCON GET-SETF-METHOD-MULTIPLE-VALUE 39 MAPCON 50 MULTIPLE-VALUE-BIND 53 MAPHASH MULTIPLE-VALUE-CALL 53 MAPHASH 51 MULTIPLE-VALUE-LIST 53 MAPL MULTIPLE-VALUE-PROG1 53 MAPL 51 MULTIPLE-VALUE-SETQ 53 MAPLIST MULTIPLE-VALUES-LIMIT 53 MAPLIST 51 NAME MASK CHAR-NAME 16 MASK-FIELD 51 LONG-SITE-NAME 47 MAX NAME-CHAR 53 MAX 51 PACKAGE-NAME 57 MAXIMUM PATHNAME-NAME 59 *IGNORE-MAXIMUM-PAGES* 40 SHORT-SITE-NAME 72 MAXIMUM-ALLOCATABLE-PAGES 51 SYMBOL-NAME 79 MAXIMUM-CONTIGUOUS-PAGES 51 COMPILED-FUNCTION-NAME 86 MAXPAGES NAMESTRING *LISP-MAXPAGES* 89 DIRECTORY-NAMESTRING 28 MEMBER ENOUGH-NAMESTRING 30 MEMBER 51 FILE-NAMESTRING 33 MEMBER-IF 51 HOST-NAMESTRING 40 MEMBER-IF-NOT 51 NAMESTRING 54 MERGE PARSE-NAMESTRING 58 MERGE 51 NAND MERGE-PATHNAMES 52 BIT-NAND 8 MESSAGE BOOLE-NAND 10 LAST-TERMINATION-MESSAGE 43 NANI TERMINATION-MESSAGE 81 NANI 89 *GBC-MESSAGE* 88 NBUTLAST *DEFAULT-MESSAGE-FILE* 91 NBUTLAST 54 KCL Dictionary Page 102 NCONC NREVERSE 55 NCONC 54 NSET NEGATIVE NSET-DIFFERENCE 55 DOUBLE-FLOAT-NEGATIVE-EPSILON 29 NSET-EXCLUSIVE-OR 55 LEAST-NEGATIVE-DOUBLE-FLOAT 43 NSTRING LEAST-NEGATIVE-LONG-FLOAT 43 NSTRING-CAPITALIZE 55 LEAST-NEGATIVE-SHORT-FLOAT 43 NSTRING-DOWNCASE 55 LEAST-NEGATIVE-SINGLE-FLOAT 43 NSTRING-UPCASE 55 LONG-FLOAT-NEGATIVE-EPSILON 47 NSUBLIS MOST-NEGATIVE-DOUBLE-FLOAT 52 NSUBLIS 55 MOST-NEGATIVE-FIXNUM 52 NSUBST MOST-NEGATIVE-LONG-FLOAT 52 NSUBST 55 MOST-NEGATIVE-SHORT-FLOAT 52 NSUBST-IF 55 MOST-NEGATIVE-SINGLE-FLOAT 52 NSUBST-IF-NOT 55 SHORT-FLOAT-NEGATIVE-EPSILON 72 NSUBSTITUTE SINGLE-FLOAT-NEGATIVE-EPSILON 73 NSUBSTITUTE 56 NICKNAMES NSUBSTITUTE-IF 56 PACKAGE-NICKNAMES 58 NSUBSTITUTE-IF-NOT 56 NIL NTH NIL 54 NTH 56 NINTERSECTION NTHCDR NINTERSECTION 54 NTHCDR 56 NINTH NULL NINTH 54 NULL 56 NO NUMBER READ-CHAR-NO-HANG 65 NUMBER 56 YES-OR-NO-P 85 NUMBERP NOR NUMBERP 56 BIT-NOR 8 NUMERATOR BOOLE-NOR 10 NUMERATOR 56 NOT NUNION ASSOC-IF-NOT 6 NUNION 57 BIT-NOT 8 OBJECT CHAR-NOT-EQUAL 16 STRING-TO-OBJECT 90 CHAR-NOT-GREATERP 16 ODDP CHAR-NOT-LESSP 16 ODDP 57 COUNT-IF-NOT 21 OF DELETE-IF-NOT 27 TYPE-OF 82 FIND-IF-NOT 34 ON MEMBER-IF-NOT 51 *BREAK-ON-WARNINGS* 10 NOT 54 *IGNORE-EOF-ON-TERMINAL-IO* 88 NSUBST-IF-NOT 55 OPEN NSUBSTITUTE-IF-NOT 56 OPEN 57 POSITION-IF-NOT 60 WITH-OPEN-FILE 84 RASSOC-IF-NOT 64 WITH-OPEN-STREAM 84 REMOVE-IF-NOT 67 OR STRING-NOT-EQUAL 76 NSET-EXCLUSIVE-OR 55 STRING-NOT-GREATERP 76 OR 57 STRING-NOT-LESSP 77 SET-EXCLUSIVE-OR 70 SUBST-IF-NOT 78 Y-OR-N-P 85 SUBSTITUTE-IF-NOT 79 YES-OR-NO-P 85 NOTANY ORC1 NOTANY 54 BIT-ORC1 8 NOTEVERY BOOLE-ORC1 10 NOTEVERY 54 ORC2 NOTIFY BIT-ORC2 8 *NOTIFY-GBC* 90 BOOLE-ORC2 10 NRECONC OUTPUT NRECONC 54 CLEAR-OUTPUT 18 NREVERSE *ERROR-OUTPUT* 31 KCL Dictionary Page 103 FINISH-OUTPUT 34 MERGE-PATHNAMES 52 FORCE-OUTPUT 36 PEEK GET-OUTPUT-STREAM-STRING 38 PEEK-CHAR 59 MAKE-STRING-OUTPUT-STREAM 50 PER OUTPUT-STREAM-P 57 INTERNAL-TIME-UNITS-PER-SECOND 42 *STANDARD-OUTPUT* 75 PHASE *TRACE-OUTPUT* 81 PHASE 59 WITH-OUTPUT-TO-STRING 84 PI *INDENT-FORMATTED-OUTPUT* 88 PI 59 make-string-output-stream-from.. 89 PLIST OUTPUT-STREAM-STRING 90 SYMBOL-PLIST 80 PACKAGE PLUSP FIND-PACKAGE 34 PLUSP 59 IN-PACKAGE 41 POINTER MAKE-PACKAGE 49 ARRAY-HAS-FILL-POINTER-P 5 PACKAGE 57 FILL-POINTER 33 *PACKAGE* 57 POP PACKAGE-NAME 57 POP 60 PACKAGE-NICKNAMES 58 VECTOR-POP 83 PACKAGE-SHADOWING-SYMBOLS 58 POSITION PACKAGE-USE-LIST 58 BYTE-POSITION 11 PACKAGE-USED-BY-LIST 58 FILE-POSITION 33 RENAME-PACKAGE 67 POSITION 60 SYMBOL-PACKAGE 79 POSITION-IF 60 UNUSE-PACKAGE 82 POSITION-IF-NOT 60 USE-PACKAGE 83 POSITIVE PACKAGEP LEAST-POSITIVE-DOUBLE-FLOAT 43 PACKAGEP 58 LEAST-POSITIVE-LONG-FLOAT 43 PACKAGES LEAST-POSITIVE-SHORT-FLOAT 43 LIST-ALL-PACKAGES 45 LEAST-POSITIVE-SINGLE-FLOAT 44 PAGES MOST-POSITIVE-DOUBLE-FLOAT 53 ALLOCATE-CONTIGUOUS-PAGES 3 MOST-POSITIVE-FIXNUM 53 ALLOCATE-RELOCATABLE-PAGES 3 MOST-POSITIVE-LONG-FLOAT 53 ALLOCATED-CONTIGUOUS-PAGES 3 MOST-POSITIVE-SHORT-FLOAT 53 ALLOCATED-PAGES 3 MOST-POSITIVE-SINGLE-FLOAT 53 ALLOCATED-RELOCATABLE-PAGES 4 PPRINT *IGNORE-MAXIMUM-PAGES* 40 PPRINT 60 MAXIMUM-ALLOCATABLE-PAGES 51 PRECISION MAXIMUM-CONTIGUOUS-PAGES 51 FLOAT-PRECISION 35 PAIRLIS PRESERVING PAIRLIS 58 READ-PRESERVING-WHITESPACE 65 PARAMETERS PRETTY LAMBDA-PARAMETERS-LIMIT 42 *PRINT-PRETTY* 61 PARSE PRIN1 PARSE-INTEGER 58 PRIN1 60 PARSE-NAMESTRING 58 PRIN1-TO-STRING 60 PATHNAME PRINC *DEFAULT-PATHNAME-DEFAULTS* 22 PRINC 60 MAKE-PATHNAME 49 PRINC-TO-STRING 61 PATHNAME 58 PRINT PATHNAME-DEVICE 59 PRINT 61 PATHNAME-DIRECTORY 59 *PRINT-ARRAY* 61 PATHNAME-HOST 59 *PRINT-BASE* 61 PATHNAME-NAME 59 *PRINT-CASE* 61 PATHNAME-TYPE 59 *PRINT-CIRCLE* 61 PATHNAME-VERSION 59 *PRINT-ESCAPE* 61 USER-HOMEDIR-PATHNAME 83 *PRINT-GENSYM* 61 PATHNAMEP *PRINT-LENGTH* 61 PATHNAMEP 59 *PRINT-LEVEL* 61 PATHNAMES *PRINT-PRETTY* 61 KCL Dictionary Page 104 *PRINT-RADIX* 61 RATIONAL 64 PROBE RATIONALIZE PROBE-FILE 62 RATIONALIZE 64 PROCESS RATIONALP PROCESS 62 RATIONALP 64 PROCLAIM READ PROCLAIM 62 READ 64 PROCLAMATION *READ-BASE* 64 PROCLAMATION 62 READ-BYTE 65 PROG READ-CHAR 65 PROG 62 READ-CHAR-NO-HANG 65 PROG* 62 *READ-DEFAULT-FLOAT-FORMAT* 65 PROG1 READ-DELIMITED-LIST 65 MULTIPLE-VALUE-PROG1 53 READ-FROM-STRING 65 PROG1 62 READ-LINE 65 PROG2 READ-PRESERVING-WHITESPACE 65 PROG2 62 *READ-SUPPRESS* 65 PROGN READTABLE PROGN 62 COPY-READTABLE 20 PROGV READTABLE 66 PROGV 62 *READTABLE* 66 PROPERTIES READTABLEP GET-PROPERTIES 38 READTABLEP 66 PROTECT REAL UNWIND-PROTECT 83 GET-INTERNAL-REAL-TIME 38 PROVIDE REALPART PROVIDE 63 REALPART 66 PSETF REDUCE PSETF 63 REDUCE 66 PSETQ RELOCATABLE PSETQ 63 ALLOCATE-RELOCATABLE-PAGES 3 PUSH ALLOCATED-RELOCATABLE-PAGES 4 PUSH 63 REM VECTOR-PUSH 84 REM 66 VECTOR-PUSH-EXTEND 84 REMF PUSHNEW REMF 66 PUSHNEW 63 REMHASH QUERY REMHASH 66 *QUERY-IO* 63 REMOVE QUOTE REMOVE 66 QUOTE 63 REMOVE-DUPLICATES 67 RADIX REMOVE-IF 67 FLOAT-RADIX 35 REMOVE-IF-NOT 67 *PRINT-RADIX* 61 REMPROP RANDOM REMPROP 67 MAKE-RANDOM-STATE 49 RENAME RANDOM 63 RENAME-FILE 67 RANDOM-STATE 63 RENAME-PACKAGE 67 *RANDOM-STATE* 63 REPLACE RANDOM-STATE-P 64 REPLACE 67 RANK REQUIRE ARRAY-RANK 5 REQUIRE 67 ARRAY-RANK-LIMIT 5 RESET RASSOC RESET-GBC-COUNT 90 RASSOC 64 RESET-STACK-LIMITS 90 RASSOC-IF 64 REST RASSOC-IF-NOT 64 REST 68 RATIO RETURN RATIO 64 RETURN 68 RATIONAL RETURN-FROM 68 KCL Dictionary Page 105 REVAPPEND SHADOW REVAPPEND 68 SHADOW 71 REVERSE SHADOWING REVERSE 68 PACKAGE-SHADOWING-SYMBOLS 58 RIGHT SHADOWING-IMPORT 71 STRING-RIGHT-TRIM 77 SHIFTF ROOM SHIFTF 71 ROOM 68 SHORT ROTATEF LEAST-NEGATIVE-SHORT-FLOAT 43 ROTATEF 69 LEAST-POSITIVE-SHORT-FLOAT 43 ROUND MOST-NEGATIVE-SHORT-FLOAT 52 ROUND 69 MOST-POSITIVE-SHORT-FLOAT 53 ROW SHORT-FLOAT-EPSILON 71 ARRAY-ROW-MAJOR-INDEX 5 SHORT-FLOAT-NEGATIVE-EPSILON 72 RPLACA SHORT-SITE-NAME 72 RPLACA 69 SIGN RPLACD FLOAT-SIGN 35 RPLACD 69 SIGNALS RUN CATCH-BAD-SIGNALS 86 GET-INTERNAL-RUN-TIME 38 UNCATCH-BAD-SIGNALS 91 SAVE SIGNUM SAVE 69 SIGNUM 72 SAVE-SYSTEM 90 SIMPLE SBIT SIMPLE-ARRAY 72 SBIT 69 SIMPLE-BIT-VECTOR 72 SCALE SIMPLE-BIT-VECTOR-P 72 SCALE-FLOAT 69 SIMPLE-STRING 72 SCHAR SIMPLE-STRING-P 72 SCHAR 69 SIMPLE-VECTOR 72 SEARCH SIMPLE-VECTOR-P 72 SEARCH 69 SIN SECOND SIN 72 INTERNAL-TIME-UNITS-PER-SECOND 42 SINGLE SECOND 70 LEAST-NEGATIVE-SINGLE-FLOAT 43 SEQ LEAST-POSITIVE-SINGLE-FLOAT 44 COPY-SEQ 20 MOST-NEGATIVE-SINGLE-FLOAT 52 SEQUENCE MOST-POSITIVE-SINGLE-FLOAT 53 MAKE-SEQUENCE 49 SINGLE-FLOAT-EPSILON 72 SEQUENCE 70 SINGLE-FLOAT-NEGATIVE-EPSILON 73 SET SINH BOOLE-SET 10 SINH 73 SET 70 SITE SET-CHAR-BIT 70 LONG-SITE-NAME 47 SET-DIFFERENCE 70 SHORT-SITE-NAME 72 SET-DISPATCH-MACRO-CHARACTER 70 SIXTH SET-EXCLUSIVE-OR 70 SIXTH 73 SET-MACRO-CHARACTER 70 SIZE SET-SYNTAX-FROM-CHAR 70 ARRAY-TOTAL-SIZE 6 ERROR-SET 87 ARRAY-TOTAL-SIZE-LIMIT 6 SET-HOLE-SIZE 90 BYTE-SIZE 11 SETF GET-HOLE-SIZE 88 DEFINE-SETF-METHOD 24 SET-HOLE-SIZE 90 GET-SETF-METHOD 39 SLEEP GET-SETF-METHOD-MULTIPLE-VALUE 39 SLEEP 73 SETF 71 SOFTWARE SETQ SOFTWARE-TYPE 73 MULTIPLE-VALUE-SETQ 53 SOFTWARE-VERSION 73 SETQ 71 SOME SEVENTH SOME 73 SEVENTH 71 SORT KCL Dictionary Page 106 SORT 73 STRING-EQUAL 76 STABLE-SORT 74 STRING-GREATERP 76 SPECIAL STRING-LEFT-TRIM 76 SPECIAL-FORM-P 74 STRING-LESSP 76 *MAKE-SPECIAL 89 STRING-NOT-EQUAL 76 SPECIALP STRING-NOT-GREATERP 76 SPECIALP 90 STRING-NOT-LESSP 77 SQRT STRING-RIGHT-TRIM 77 SQRT 74 STRING-TRIM 77 STABLE STRING-UPCASE 77 STABLE-SORT 74 STRING/= 77 STACK STRING< 77 RESET-STACK-LIMITS 90 STRING<= 77 STANDARD STRING= 77 STANDARD-CHAR 74 STRING> 78 STANDARD-CHAR-P 74 STRING>= 78 *STANDARD-INPUT* 75 WITH-INPUT-FROM-STRING 84 *STANDARD-OUTPUT* 75 WITH-OUTPUT-TO-STRING 84 STATE WRITE-STRING 85 MAKE-RANDOM-STATE 49 WRITE-TO-STRING 85 RANDOM-STATE 63 GET-STRING-INPUT-STREAM-INDEX 88 *RANDOM-STATE* 63 make-string-output-stream-from.. 89 RANDOM-STATE-P 64 OUTPUT-STREAM-STRING 90 STEP STRING-CONCATENATE 90 STEP 75 STRING-TO-OBJECT 90 STREAM STRINGP GET-OUTPUT-STREAM-STRING 38 STRINGP 78 INPUT-STREAM-P 41 STRUCTURE MAKE-BROADCAST-STREAM 48 STRUCTURE 78 MAKE-CONCATENATED-STREAM 48 STRUCTUREP MAKE-ECHO-STREAM 49 STRUCTUREP 91 MAKE-STRING-INPUT-STREAM 49 SUBLIS MAKE-STRING-OUTPUT-STREAM 50 SUBLIS 78 MAKE-SYNONYM-STREAM 50 SUBSEQ MAKE-TWO-WAY-STREAM 50 SUBSEQ 78 OUTPUT-STREAM-P 57 SUBSETP STREAM 75 SUBSETP 78 STREAM-ELEMENT-TYPE 75 SUBST WITH-OPEN-STREAM 84 SUBST 78 COPY-STREAM 87 SUBST-IF 78 GET-STRING-INPUT-STREAM-INDEX 88 SUBST-IF-NOT 78 make-string-output-stream-from.. 89 SUBSTITUTE OUTPUT-STREAM-STRING 90 SUBSTITUTE 79 STREAMP SUBSTITUTE-IF 79 STREAMP 75 SUBSTITUTE-IF-NOT 79 STRING SUBTYPEP GET-OUTPUT-STREAM-STRING 38 SUBTYPEP 79 MAKE-STRING 49 SUPER MAKE-STRING-INPUT-STREAM 49 CHAR-SUPER-BIT 16 MAKE-STRING-OUTPUT-STREAM 50 SUPPRESS PRIN1-TO-STRING 60 *READ-SUPPRESS* 65 PRINC-TO-STRING 61 SVREF READ-FROM-STRING 65 SVREF 79 SIMPLE-STRING 72 SXHASH SIMPLE-STRING-P 72 SXHASH 79 STRING 75 SYMBOL STRING-CAPITALIZE 75 COPY-SYMBOL 21 STRING-CHAR 76 FIND-SYMBOL 34 STRING-CHAR-P 76 MAKE-SYMBOL 50 STRING-DOWNCASE 76 SYMBOL-FUNCTION 79 KCL Dictionary Page 107 SYMBOL-NAME 79 TIME 81 SYMBOL-PACKAGE 79 *DEFAULT-TIME-ZONE* 87 SYMBOL-PLIST 80 TO SYMBOL-VALUE 80 PRIN1-TO-STRING 60 SYMBOLP PRINC-TO-STRING 61 SYMBOLP 80 WITH-OUTPUT-TO-STRING 84 SYMBOLS WRITE-TO-STRING 85 DO-ALL-SYMBOLS 28 STRING-TO-OBJECT 90 DO-EXTERNAL-SYMBOLS 28 TOP DO-SYMBOLS 29 TOP-LEVEL 91 FIND-ALL-SYMBOLS 34 TOTAL PACKAGE-SHADOWING-SYMBOLS 58 ARRAY-TOTAL-SIZE 6 SYNONYM ARRAY-TOTAL-SIZE-LIMIT 6 MAKE-SYNONYM-STREAM 50 TRACE SYNTAX TRACE 81 SET-SYNTAX-FROM-CHAR 70 *TRACE-OUTPUT* 81 SYSTEM TREE SYSTEM 80 COPY-TREE 21 INIT-SYSTEM 89 TREE-EQUAL 81 SAVE-SYSTEM 90 TRIM *SYSTEM-DIRECTORY* 91 STRING-LEFT-TRIM 76 TABLE STRING-RIGHT-TRIM 77 HASH-TABLE 39 STRING-TRIM 77 HASH-TABLE-COUNT 39 TRUENAME HASH-TABLE-P 40 TRUENAME 81 MAKE-HASH-TABLE 49 TRUNCATE TAGBODY TRUNCATE 81 TAGBODY 80 TWO TAILP MAKE-TWO-WAY-STREAM 50 TAILP 80 TYPE TAN ARRAY-ELEMENT-TYPE 5 TAN 80 CHECK-TYPE 17 TANH LISP-IMPLEMENTATION-TYPE 44 TANH 80 MACHINE-TYPE 47 TENTH PATHNAME-TYPE 59 TENTH 80 SOFTWARE-TYPE 73 TERMINAL STREAM-ELEMENT-TYPE 75 *TERMINAL-IO* 80 TYPE-OF 82 *IGNORE-EOF-ON-TERMINAL-IO* 88 TYPECASE TERMINATION TYPECASE 82 LAST-TERMINATION-MESSAGE 43 TYPEP TERMINATION-MESSAGE 81 TYPEP 82 TERPRI UNCATCH TERPRI 81 UNCATCH-BAD-SIGNALS 91 TEST UNEXPORT LDB-TEST 43 UNEXPORT 82 THE UNINTERN THE 81 UNINTERN 82 THIRD UNION THIRD 81 UNION 82 THROW UNITS THROW 81 INTERNAL-TIME-UNITS-PER-SECOND 42 TIME UNIVERSAL DECODE-UNIVERSAL-TIME 22 DECODE-UNIVERSAL-TIME 22 ENCODE-UNIVERSAL-TIME 30 ENCODE-UNIVERSAL-TIME 30 GET-DECODED-TIME 38 GET-UNIVERSAL-TIME 39 GET-INTERNAL-REAL-TIME 38 UNIVERSAL-ERROR-HANDLER 91 GET-INTERNAL-RUN-TIME 38 UNLESS GET-UNIVERSAL-TIME 39 UNLESS 82 INTERNAL-TIME-UNITS-PER-SECOND 42 UNREAD KCL Dictionary Page 108 UNREAD-CHAR 82 WARN UNTRACE WARN 84 UNTRACE 82 WARNINGS UNUSE *BREAK-ON-WARNINGS* 10 UNUSE-PACKAGE 82 WAY UNWIND MAKE-TWO-WAY-STREAM 50 UNWIND-PROTECT 83 WHEN UPCASE EVAL-WHEN 31 CHAR-UPCASE 16 *EVAL-WHEN-COMPILE* 31 NSTRING-UPCASE 55 WHEN 84 STRING-UPCASE 77 WHITESPACE UPPER READ-PRESERVING-WHITESPACE 65 UPPER-CASE-P 83 WITH USE WITH-INPUT-FROM-STRING 84 PACKAGE-USE-LIST 58 WITH-OPEN-FILE 84 USE-PACKAGE 83 WITH-OPEN-STREAM 84 USED WITH-OUTPUT-TO-STRING 84 PACKAGE-USED-BY-LIST 58 WRITE USER FILE-WRITE-DATE 33 USER-HOMEDIR-PATHNAME 83 WRITE 85 VAL WRITE-BYTE 85 BDS-VAL 86 WRITE-CHAR 85 VALUE WRITE-LINE 85 GET-SETF-METHOD-MULTIPLE-VALUE 39 WRITE-STRING 85 MULTIPLE-VALUE-BIND 53 WRITE-TO-STRING 85 MULTIPLE-VALUE-CALL 53 XOR MULTIPLE-VALUE-LIST 53 BIT-XOR 8 MULTIPLE-VALUE-PROG1 53 BOOLE-XOR 10 MULTIPLE-VALUE-SETQ 53 YES SYMBOL-VALUE 80 YES-OR-NO-P 85 VALUES ZEROP MULTIPLE-VALUES-LIMIT 53 ZEROP 86 VALUES 83 ZONE VALUES-LIST 83 *DEFAULT-TIME-ZONE* 87 VAR BDS-VAR 86 VECTOR BIT-VECTOR 8 BIT-VECTOR-P 8 SIMPLE-BIT-VECTOR 72 SIMPLE-BIT-VECTOR-P 72 SIMPLE-VECTOR 72 SIMPLE-VECTOR-P 72 VECTOR 83 VECTOR-POP 83 VECTOR-PUSH 84 VECTOR-PUSH-EXTEND 84 VECTORP VECTORP 84 VERBOSE *LOAD-VERBOSE* 45 VERSION LISP-IMPLEMENTATION-VERSION 44 MACHINE-VERSION 47 PATHNAME-VERSION 59 SOFTWARE-VERSION 73 VS FRS-VS 87 IHS-VS 88 VS 91