CS 51: Introduction to Computer Science II
Online LISP manual
The following is the gnu commonlisp help file that documents, somewhat,
most of the COMMONLISP FUNCTIONS.
======================================
GCL (GNU Common Lisp) Version(1.1) Tue Jan 10 15:56:33 EST 1995
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
>Loading /tmp_mnt/home/usr12/cheatham/walton/gcl/gcl-1.1/doc/DOC-keys.el
Finished loading /tmp_mnt/home/usr12/cheatham/walton/gcl/gcl-1.1/doc/DOC-keys.el
-----------------------------------------------------------------------------
LISP::SHARP-+-READER [Function]
Args: (STREAM LISP::SUBCHAR LISP::ARG)
-----------------------------------------------------------------------------
LISP::SHARP---READER [Function]
Args: (STREAM LISP::SUBCHAR LISP::ARG)
-----------------------------------------------------------------------------
LISP::EVAL-FEATURE [Function]
Args: (LISP::X)
-----------------------------------------------------------------------------
LISP::*TYPE-LIST* [Special variable]
-----------------------------------------------------------------------------
BIT-AND [Function]
BIT-AND
Function in LISP package:
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.
-----------------------------------------------------------------------------
CADDDR [Function]
-----------------------------------------------------------------------------
CADDDR [Setf]
Defined as: (DEFSETF CADDDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDDR X) Y) Y))
See the doc of DEFSETF. CADDDR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CDR (CDR X)))).
-----------------------------------------------------------------------------
ASINH [Function]
ASINH
Function in LISP package:
Args: (number)
Returns the hyperbolic arc sine of NUMBER.
-----------------------------------------------------------------------------
PUSH [Special form and Macro]
PUSH
Special Form in LISP package:
Syntax: (push item place)
Conses ITEM onto the list in PLACE, and returns the new list.
-----------------------------------------------------------------------------
MAKE-STRING [Function]
MAKE-STRING
Function in LISP package:
Args: (size &key (initial-element #\Space))
Creates and returns a new string of SIZE length whose elements are all
INITIAL-ELEMENT.
-----------------------------------------------------------------------------
READ-DELIMITED-LIST [Function]
READ-DELIMITED-LIST
Function in LISP package:
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.
-----------------------------------------------------------------------------
FLOAT-RADIX [Function]
FLOAT-RADIX
Function in LISP package: Args: (float)
Returns the representation radix (or base) of the floating-point
number.
-----------------------------------------------------------------------------
CDDDDR [Function]
-----------------------------------------------------------------------------
CDDDDR [Setf]
Defined as: (DEFSETF CDDDDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDDDR X) Y) Y))
See the doc of DEFSETF. CDDDDR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CDR (CDR X)))).
-----------------------------------------------------------------------------
LOOP [Special form and Macro]
LOOP
Special Form in LISP package:
Syntax: (loop {form}*)
Executes FORMs repeatedly until exited by a THROW or RETURN. The FORMs are
surrounded by an implicit NIL block.
-----------------------------------------------------------------------------
REMHASH [Function]
REMHASH
Function in LISP package:
Args: (key hash-table)
Removes any entry for KEY in HASH-TABLE. Returns T if such an entry
existed; NIL otherwise.
-----------------------------------------------------------------------------
INPUT-STREAM-P [Function]
INPUT-STREAM-P
Function in LISP package:
Args: (stream)
Returns non-NIL if STREAM can handle input operations; NIL otherwise.
-----------------------------------------------------------------------------
MAPC [Function]
MAPC
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs. Returns the first LIST.
-----------------------------------------------------------------------------
WRITE-BYTE [Function]
WRITE-BYTE
Function in LISP package:
Args: (integer stream)
Outputs INTEGER to the binary stream STREAM. Returns INTEGER.
-----------------------------------------------------------------------------
SET-DIFFERENCE [Function]
SET-DIFFERENCE
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list of elements of LIST1 that do not appear in LIST2.
-----------------------------------------------------------------------------
CHAR> [Function]
CHAR>
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly decreasing order; NIL
otherwise.
-----------------------------------------------------------------------------
*STANDARD-OUTPUT* [Special variable]
*STANDARD-OUTPUT*
Variable in LISP package:
The default output stream used by the KCL printer.
-----------------------------------------------------------------------------
SYSTEM [Function]
SYSTEM
Function in LISP package:
Args: (string)
GCL specific: Executes a Shell command as if STRING is an input to the Shell.
Not all versions of GCL support this function.
-----------------------------------------------------------------------------
MULTIPLE-VALUE-SETQ [Special form and Macro]
MULTIPLE-VALUE-SETQ
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
MACHINE-TYPE [Function]
Args: NIL MACHINE-TYPE
Function in LISP package:
Args: ()
Returns a string that identifies the machine type of the machine
on which KCL is currently running.
-----------------------------------------------------------------------------
MAKE-SYNONYM-STREAM [Function]
MAKE-SYNONYM-STREAM
Function in LISP package:
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]
MAKE-TWO-WAY-STREAM
Function in LISP package:
Args: (input-stream output-stream)
Returns a bidirectional stream which gets its input from INPUT-STREAM and
sends its output to OUTPUT-STREAM.
-----------------------------------------------------------------------------
NCONC [Function]
NCONC
Function in LISP package:
Args: (&rest lists)
Concatenates LISTs by destructively modifying them.
-----------------------------------------------------------------------------
READ-BYTE [Function]
READ-BYTE
Function in LISP package:
Args: (stream &optional (eof-error-p t) (eof-value nil))
Reads the next byte from STREAM.
-----------------------------------------------------------------------------
FRESH-LINE [Function]
FRESH-LINE
Function in LISP package:
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.
-----------------------------------------------------------------------------
ARRAY-TOTAL-SIZE-LIMIT [Constant]
ARRAY-TOTAL-SIZE-LIMIT
Variable in LISP package:
The exclusive upper bound on the total number of elements of an array.
-----------------------------------------------------------------------------
FILL-POINTER [Function]
-----------------------------------------------------------------------------
FILL-POINTER [Setf]
Defined as: (DEFSETF FILL-POINTER FILL-POINTER-SET)
See the doc of DEFSETF. FILL-POINTER
Function in LISP package:
Args: (vector)
Returns the fill pointer of VECTOR.
-----------------------------------------------------------------------------
UNSIGNED-BYTE [Type]
Defined as: (DEFTYPE UNSIGNED-BYTE (&OPTIONAL (S '*))
(IF (EQ S '*) '(INTEGER 0 *)
(LIST 'INTEGER 0 (1- (EXPT 2 S)))))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
NBUTLAST [Function]
NBUTLAST
Function in LISP package:
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.
-----------------------------------------------------------------------------
WRITE [Function]
WRITE
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHAR-NOT-EQUAL [Function]
CHAR-NOT-EQUAL
Function in LISP package:
Args: (char &rest more-chars)
Returns T if no two of CHARs are the same character; NIL otherwise.
Upper case character and its lower case equivalent are regarded the same.
-----------------------------------------------------------------------------
REDUCE [Function]
REDUCE
Function in LISP package:
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.
-----------------------------------------------------------------------------
TIME [Macro]
TIME
Macro in LISP package:
Syntax: (time form)
Evaluates FORM and outputs timing statistics on *TRACE-OUTPUT*.
-----------------------------------------------------------------------------
CDADR [Function]
-----------------------------------------------------------------------------
CDADR [Setf]
Defined as: (DEFSETF CDADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CADR X) Y) Y))
See the doc of DEFSETF. CDADR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CDR X))).
-----------------------------------------------------------------------------
BREAK [Function]
BREAK
Function in LISP package:
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.
-----------------------------------------------------------------------------
PATHNAME-TYPE [Function]
PATHNAME-TYPE
Function in LISP package:
Args: (pathname)
Returns the type slot of PATHNAME.
-----------------------------------------------------------------------------
PRINC [Function]
PRINC
Function in LISP package:
Args: (object &optional (stream *standard-output*))
Prints OBJECT without escape characters. Returns OBJECT. Equivalent to
(WRITE OBJECT :STREAM STREAM :ESCAPE NIL).
-----------------------------------------------------------------------------
REQUIRE [Function]
REQUIRE
Function in LISP package:
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.
-----------------------------------------------------------------------------
PROG2 [Special form and Macro]
PROG2
Special Form in LISP package:
Syntax: (prog2 first second {forms}*)
Evaluates FIRST, SECOND, and FORMs in order, and returns the (single) value
of SECOND.
-----------------------------------------------------------------------------
FORCE-OUTPUT [Function]
FORCE-OUTPUT
Function in LISP package:
Args: (&optional (stream *standard-output*))
Attempts to force any buffered output to be sent.
-----------------------------------------------------------------------------
CHAR/= [Function]
CHAR/=
Function in LISP package:
Args: (char &rest more-chars)
Returns T if no two of CHARs are the same character; NIL otherwise.
-----------------------------------------------------------------------------
*PRINT-CIRCLE* [Special variable]
*PRINT-CIRCLE*
Variable in LISP package:
Whether the KCL printer should take care of circular lists.
-----------------------------------------------------------------------------
SOME [Function]
SOME
Function in LISP package:
Args: (predicate sequence &rest more-sequences)
Returns T if at least one of the elements in SEQUENCEs satisfies PREDICATE;
NIL otherwise.
-----------------------------------------------------------------------------
SLEEP [Function]
SLEEP
Function in LISP package:
Args: (n)
This function causes execution to be suspended for N seconds. N may
be any non-negative, non-complex number.
-----------------------------------------------------------------------------
READ-CHAR-NO-HANG [Function]
READ-CHAR-NO-HANG
Function in LISP package:
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.
-----------------------------------------------------------------------------
*APPLYHOOK* [Special variable]
*APPLYHOOK*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
CHAR-NOT-GREATERP [Function]
CHAR-NOT-GREATERP
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-decreasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
-----------------------------------------------------------------------------
*TRACE-OUTPUT* [Special variable]
*TRACE-OUTPUT*
Variable in LISP package:
The trace output stream.
-----------------------------------------------------------------------------
BOOLE-SET [Constant]
BOOLE-SET
Variable in LISP package:
Makes BOOLE return -1.
-----------------------------------------------------------------------------
BOOLE-CLR [Constant]
BOOLE-CLR
Variable in LISP package:
Makes BOOLE return 0.
-----------------------------------------------------------------------------
MAKE-PACKAGE [Function]
MAKE-PACKAGE
Function in LISP package:
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.
-----------------------------------------------------------------------------
QUOTE [Special form]
QUOTE
Special Form in LISP package:
Syntax: (quote x) or 'x
Simply returns X without evaluating it.
-----------------------------------------------------------------------------
MASK-FIELD [Function]
-----------------------------------------------------------------------------
MASK-FIELD [Setf]
MASK-FIELD
Function in LISP package:
Args: (bytespec integer)
Extracts the specified byte from INTEGER.
-----------------------------------------------------------------------------
DOTIMES [Special form and Macro]
DOTIMES
Special Form in LISP package:
Syntax: (dotimes (var countform [result]) {decl}* {tag | statement}*)
Executes STATEMENTs, with VAR bound to each number between 0 (inclusive) and
the value of COUNTFORM (exclusive). Then returns the value(s) of RESULT
(which defaults to NIL).
-----------------------------------------------------------------------------
MACROLET [Special form]
MACROLET
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
CAAAAR [Function]
-----------------------------------------------------------------------------
CAAAAR [Setf]
Defined as: (DEFSETF CAAAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CAAAR X) Y) Y))
See the doc of DEFSETF. CAAAAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CAR (CAR X)))).
-----------------------------------------------------------------------------
LISTP [Function]
LISTP
Function in LISP package:
Args: (x)
Returns T if X is either a cons or NIL; NIL otherwise.
-----------------------------------------------------------------------------
CDAAAR [Function]
-----------------------------------------------------------------------------
CDAAAR [Setf]
Defined as: (DEFSETF CDAAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CAAAR X) Y) Y))
See the doc of DEFSETF. CDAAAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CAR (CAR X)))).
-----------------------------------------------------------------------------
* [Function]
-----------------------------------------------------------------------------
* [Special variable]
*
Variable in LISP package:
Holds the value of the last top-level form.
-----------------------------------------------------------------------------
SUBSTITUTE-IF [Function]
SUBSTITUTE-IF
Function in LISP package:
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.
-----------------------------------------------------------------------------
BIT-NAND [Function]
BIT-NAND
Function in LISP package:
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.
-----------------------------------------------------------------------------
+ [Function]
-----------------------------------------------------------------------------
+ [Special variable]
+
Variable in LISP package:
Holds the last top-level form.
-----------------------------------------------------------------------------
- [Function]
-----------------------------------------------------------------------------
- [Special variable]
-
Variable in LISP package:
Holds the top-level form that GCL is currently evaluating.
-----------------------------------------------------------------------------
PRINC-TO-STRING [Function]
PRINC-TO-STRING
Function in LISP package:
Args: (object)
Returns as a string the printed representation of OBJECT without escape
characters. Equivalent to
(WRITE-TO-STRING OBJECT :ESCAPE NIL).
-----------------------------------------------------------------------------
PRIN1-TO-STRING [Function]
PRIN1-TO-STRING
Function in LISP package:
Args: (object)
Returns as a string the printed representation of OBJECT in the mostly
readable representation.
Equivalent to (WRITE-TO-STRING OBJECT :ESCAPE T).
-----------------------------------------------------------------------------
FLOOR [Function]
FLOOR
Function in LISP package:
Args: (number &optional (divisor 1))
Returns the largest integer not larger than the NUMBER divided by DIVISOR.
The second returned value is (- NUMBER (* first-value DIVISOR)).
-----------------------------------------------------------------------------
/ [Function]
-----------------------------------------------------------------------------
/ [Special variable]
/
Variable in LISP package:
Holds a list of the values of the last top-level form.
-----------------------------------------------------------------------------
WRITE-TO-STRING [Function]
WRITE-TO-STRING
Function in LISP package:
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.
-----------------------------------------------------------------------------
STRING-LESSP [Function]
STRING-LESSP
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING<, but ignores cases.
-----------------------------------------------------------------------------
ALLOCATE [Function]
ALLOCATE
Function in LISP package:
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.
-----------------------------------------------------------------------------
MULTIPLE-VALUE-LIST [Special form and Macro]
MULTIPLE-VALUE-LIST
Special Form in LISP package:
Syntax: (multiple-value-list form)
Evaluates FORM, and returns a list of multiple values it returned.
-----------------------------------------------------------------------------
PACKAGE-SHADOWING-SYMBOLS [Function]
PACKAGE-SHADOWING-SYMBOLS
Function in LISP package:
Args: (package)
Returns the list of symbols that have been declared as shadowing symbols
in PACKAGE.
-----------------------------------------------------------------------------
MAPCAN [Function]
MAPCAN
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs, NCONCs the results, and returns it.
-----------------------------------------------------------------------------
DELETE-IF [Function]
DELETE-IF
Function in LISP package:
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence formed by removing the elements satisfying TEST
destructively from SEQUENCE.
-----------------------------------------------------------------------------
*DEFAULT-PATHNAME-DEFAULTS* [Special variable]
*DEFAULT-PATHNAME-DEFAULTS*
Variable in LISP package:
The default pathname-defaults pathname.
-----------------------------------------------------------------------------
ATOM [Function]
ATOM
Function in LISP package:
Args: (x)
Returns T if X is not a cons; NIL otherwise.
-----------------------------------------------------------------------------
NSUBLIS [Function]
NSUBLIS
Function in LISP package:
Args: (alist tree &key (test #'eql) test-not (key #'identity))
Substitutes from ALIST for subtrees of TREE.
-----------------------------------------------------------------------------
STRING< [Function]
STRING<
Function in LISP package:
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.
-----------------------------------------------------------------------------
REMOVE-IF [Function]
REMOVE-IF
Function in LISP package:
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.
-----------------------------------------------------------------------------
SIXTH [Function]
-----------------------------------------------------------------------------
SIXTH [Setf]
Defined as: (DEFSETF SIXTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR 5 X) Y) Y))
See the doc of DEFSETF. SIXTH
Function in LISP package: Args: (x) Equivalent to (CADR (CDDDDR X)).
-----------------------------------------------------------------------------
APPLY [Function]
-----------------------------------------------------------------------------
APPLY [Setf]
APPLY
Function in LISP package:
Args: (function arg &rest more-args)
Applies FUNCTION. The arguments to the function consist of all ARGs
except for the last, and all elements of the last ARG.
-----------------------------------------------------------------------------
FIND-ALL-SYMBOLS [Function]
FIND-ALL-SYMBOLS
Function in LISP package:
Args: (string-or-symbol)
Returns a list of all symbols that have the specified name.
-----------------------------------------------------------------------------
MAKE-CONCATENATED-STREAM [Function]
MAKE-CONCATENATED-STREAM
Function in LISP package:
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.
-----------------------------------------------------------------------------
LISTEN [Function]
LISTEN
Function in LISP package:
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.
-----------------------------------------------------------------------------
< [Function]
<
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if its arguments are in strictly increasing order; NIL otherwise.
-----------------------------------------------------------------------------
BOOLE-ANDC2 [Constant]
BOOLE-ANDC2
Variable in LISP package:
Makes BOOLE return LOGANDC2 of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
= [Function]
=
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if all of its arguments are numerically equal; NIL otherwise.
-----------------------------------------------------------------------------
MEMBER [Function]
MEMBER
Function in LISP package:
Args: (item list &key (test #'eql) test-not (key #'identity))
Returns the tail of LIST beginning with the first ITEM.
-----------------------------------------------------------------------------
> [Function]
>
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if its arguments are in strictly decreasing order; NIL otherwise.
OPTIMIZE
If the file misc/warn-slow.lisp is loaded then the compiler emits
warnings about some slow constructs. Additional constructs can
easily be added or deleted by editing the beginning of this file.
-----------------------------------------------------------------------------
CHAR-CODE [Function]
CHAR-CODE
Function in LISP package:
Args: (char)
Returns the code attribute of CHAR.
-----------------------------------------------------------------------------
APPLYHOOK [Function]
APPLYHOOK
Function in LISP package:
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.
-----------------------------------------------------------------------------
INCF [Special form and Macro]
INCF
Special Form in LISP package:
Syntax: (incf place [delta])
Adds the number produced by DELTA (which defaults to 1) to the number
in PLACE.
-----------------------------------------------------------------------------
MAPHASH [Function]
MAPHASH
Function in LISP package:
Args: #'hash-table
For each entry in HASH-TABLE, calls FUNCTION on the key and value of the
entry; returns NIL.
-----------------------------------------------------------------------------
EIGHTH [Function]
-----------------------------------------------------------------------------
EIGHTH [Setf]
Defined as: (DEFSETF EIGHTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR 7 X) Y) Y))
See the doc of DEFSETF. EIGHTH
Function in LISP package:
Args: (x)
Equivalent to (CADDDR (CDDDDR X)).
-----------------------------------------------------------------------------
ARRAY-RANK [Function]
ARRAY-RANK
Function in LISP package:
Args: (array)
Returns the number of dimensions of ARRAY.
-----------------------------------------------------------------------------
GCD [Function]
GCD
Function in LISP package:
Args: (&rest integers)
Returns the greatest common divisor of INTEGERs.
-----------------------------------------------------------------------------
ACOSH [Function]
ACOSH
Function in LISP package:
Args: (number)
Returns the hyperbolic arc cosine of NUMBER.
-----------------------------------------------------------------------------
LDB [Function]
-----------------------------------------------------------------------------
LDB [Setf]
LDB
Function in LISP package:
Args: (bytespec integer)
Extracts and right-justifies the specified byte of INTEGER, and returns the
result.
-----------------------------------------------------------------------------
FUNCTIONP [Function]
FUNCTIONP
Function in LISP package:
Args: (x)
Returns T if X is a function, suitable for use by FUNCALL or APPLY. Returns
NIL otherwise.
-----------------------------------------------------------------------------
VECTOR-POP [Function]
VECTOR-POP
Function in LISP package:
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.
-----------------------------------------------------------------------------
INTERSECTION [Function]
INTERSECTION
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the intersection of List1 and List2.
-----------------------------------------------------------------------------
NOTANY [Function]
NOTANY
Function in LISP package:
Args: (predicate sequence &rest more-sequences)
Returns T if none of the elements in SEQUENCEs satisfies PREDICATE; NIL
otherwise.
-----------------------------------------------------------------------------
BIT-ANDC1 [Function]
BIT-ANDC1
Function in LISP package:
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.
-----------------------------------------------------------------------------
CAAAR [Function]
-----------------------------------------------------------------------------
CAAAR [Setf]
Defined as: (DEFSETF CAAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CAAR X) Y) Y))
See the doc of DEFSETF. CAAAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CAR X))).
-----------------------------------------------------------------------------
SET-CHAR-BIT [Function]
SET-CHAR-BIT
Function in LISP package:
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.
-----------------------------------------------------------------------------
+++ [Special variable]
+++
Variable in LISP package:
Gets the previous value of ++ when KCL evaluates a top-level form.
-----------------------------------------------------------------------------
MAKUNBOUND [Function]
MAKUNBOUND
Function in LISP package:
Args: (symbol)
Makes empty the value slot of SYMBOL. Returns SYMBOL.
-----------------------------------------------------------------------------
PATHNAME-VERSION [Function]
PATHNAME-VERSION
Function in LISP package:
Args: (pathname)
Returns the version slot of PATHNAME.
-----------------------------------------------------------------------------
CHAR-CONTROL-BIT [Constant]
CHAR-CONTROL-BIT
Variable in LISP package:
The bit that indicates a control character.
-----------------------------------------------------------------------------
DPB [Function]
DPB
Function in LISP package:
Args: (newbyte bytespec integer)
Returns an integer computed by replacing the specified byte of INTEGER with
NEWBYTE.
-----------------------------------------------------------------------------
*ERROR-OUTPUT* [Special variable]
*ERROR-OUTPUT*
Variable in LISP package:
Holds the output stream for error messages.
-----------------------------------------------------------------------------
USE-PACKAGE [Function]
USE-PACKAGE
Function in LISP package:
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.
-----------------------------------------------------------------------------
CDAR [Function]
-----------------------------------------------------------------------------
CDAR [Setf]
Defined as: (DEFSETF CDAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CAR X) Y) Y))
See the doc of DEFSETF. CDAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR X)).
-----------------------------------------------------------------------------
*RANDOM-STATE* [Special variable]
*RANDOM-STATE*
Variable in LISP package:
The default random-state object used by RAMDOM.
-----------------------------------------------------------------------------
MULTIPLE-VALUE-PROG1 [Special form]
MULTIPLE-VALUE-PROG1
Special Form in LISP package:
Syntax: (multiple-value-prog1 form {form}*)
Evaluates the first FORM, saves all the values produced, then evaluates
the other FORMs. Returns the saved values.
-----------------------------------------------------------------------------
T [Constant]
T
Variable in LISP package:
Holds T.
-----------------------------------------------------------------------------
REMF [Macro]
REMF
Macro in LISP package:
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.
-----------------------------------------------------------------------------
DOLIST [Special form and Macro]
DOLIST
Special Form in LISP package:
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(s) of RESULT (which defaults to NIL).
-----------------------------------------------------------------------------
ENOUGH-NAMESTRING [Function]
ENOUGH-NAMESTRING
Function in LISP package:
Args: (pathname &optional (defaults *default-pathname-defaults*))
Returns a string which uniquely identifies PATHNAME with respect to
DEFAULTS.
-----------------------------------------------------------------------------
SEARCH [Function]
SEARCH
Function in LISP package:
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.
-----------------------------------------------------------------------------
FIND-SYMBOL [Function]
FIND-SYMBOL
Function in LISP package: 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.
-----------------------------------------------------------------------------
ADJUST-ARRAY [Function]
ADJUST-ARRAY
Function in LISP package:
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 value
of INITIAL-ELEMENT depends on ELEMENT-TYPE.
-----------------------------------------------------------------------------
STRING= [Function]
STRING=
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHAR [Function]
-----------------------------------------------------------------------------
CHAR [Setf]
Defined as: (DEFSETF CHAR CHAR-SET)
See the doc of DEFSETF. CHAR
Function in LISP package:
Args: (string index)
Returns the INDEX-th character in STRING.
-----------------------------------------------------------------------------
COMPLEX [Function]
COMPLEX
Function in LISP package:
Args: (realpart &optional (imagpart 0))
Returns a complex number with the given real and imaginary parts.
-----------------------------------------------------------------------------
TANH [Function]
TANH
Function in LISP package:
Args: (number)
Returns the hyperbolic tangent of NUMBER.
-----------------------------------------------------------------------------
COUNT [Function]
COUNT
Function in LISP package:
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.
-----------------------------------------------------------------------------
SYMBOL-VALUE [Function]
-----------------------------------------------------------------------------
SYMBOL-VALUE [Setf]
Defined as: (DEFSETF SYMBOL-VALUE SET)
See the doc of DEFSETF. SYMBOL-VALUE
Function in LISP package:
Args: (symbol)
Returns the current value of the dynamic (special) variable named by SYMBOL.
-----------------------------------------------------------------------------
CONSP [Function]
CONSP
Function in LISP package:
Args: (x)
Returns T if X is a cons; NIL otherwise.
-----------------------------------------------------------------------------
TRUNCATE [Function]
TRUNCATE
Function in LISP package:
Args: (number &optional (divisor 1))
Values: (quotient remainder)
Returns NUMBER/DIVISOR as an integer, rounded toward 0. The second returned
value is the remainder.
-----------------------------------------------------------------------------
DISASSEMBLE [Function]
Args: (COMPILER::NAME &AUX COMPILER::TEM COMPILER::FORM) DISASSEMBLE
Function in LISP package:
Args: (thing)
Compiles the form specified by THING and prints the intermediate C language
code for that form. But does NOT install the result of compilation.
If THING is a symbol that names a not-yet-compiled function, the function
definition is disassembled.
If THING is a lambda expression, it is disassembled as a function definition.
Otherwise, THING itself is disassembled as a top-level form.
-----------------------------------------------------------------------------
BOTH-CASE-P [Function]
BOTH-CASE-P
Function in LISP package:
Args: (char)
Returns T if CHAR is an alphabetic character; NIL otherwise. Equivalent to
ALPHA-CHAR-P.
-----------------------------------------------------------------------------
LOWER-CASE-P [Function]
LOWER-CASE-P
Function in LISP package:
Args: (char)
Returns T if CHAR is a lower-case character; NIL otherwise.
-----------------------------------------------------------------------------
BOOLE-XOR [Constant]
BOOLE-XOR
Variable in LISP package:
Makes BOOLE return LOGXOR of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
WITH-OPEN-STREAM [Macro]
WITH-OPEN-STREAM
Macro in LISP package:
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.
-----------------------------------------------------------------------------
CHAR-DOWNCASE [Function]
CHAR-DOWNCASE
Function in LISP package:
Args: (char)
Returns the lower-case equivalent of CHAR, if any.
If not, simply returns CHAR.
-----------------------------------------------------------------------------
MOD [Function]
-----------------------------------------------------------------------------
MOD [Type]
Defined as: (DEFTYPE MOD (N) (LIST 'INTEGER 0 (1- N)))
See the doc of DEFTYPE. MOD
Function in LISP package:
Args: (number divisor)
Returns the second result of (FLOOR NUMBER DIVISOR).
-----------------------------------------------------------------------------
ODDP [Function]
ODDP
Function in LISP package:
Args: (integer)
Returns T if INTEGER is odd; NIL otherwise.
-----------------------------------------------------------------------------
/// [Special variable]
///
Variable in LISP package:
Gets the previous value of // when KCL evaluates a top-level form.
-----------------------------------------------------------------------------
MAKE-DISPATCH-MACRO-CHARACTER [Function]
MAKE-DISPATCH-MACRO-CHARACTER
Function in LISP package:
Args: (char &optional (non-terminating-p nil) (readtable *readtable*))
Causes the character CHAR to be a dispatching macro character in READTABLE.
-----------------------------------------------------------------------------
PROCLAIM [Function]
PROCLAIM
Function in LISP package:
Args: (decl-spec)
Puts the declaration given by DECL-SPEC into effect globally. See the doc of
DECLARE for possible DECL-SPECs.
-----------------------------------------------------------------------------
DEFUN [Special form and Macro]
DEFUN
Special Form in LISP package:
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).
-----------------------------------------------------------------------------
SECOND [Function]
-----------------------------------------------------------------------------
SECOND [Setf]
Defined as: (DEFSETF SECOND (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDR X) Y) Y))
See the doc of DEFSETF. SECOND
Function in LISP package:
Args: (x)
Equivalent to (CADR X).
-----------------------------------------------------------------------------
ASH [Function]
ASH
Function in LISP package:
Args: (integer count)
Shifts INTEGER left by COUNT places. Shifts right if COUNT is negative.
-----------------------------------------------------------------------------
MACHINE-INSTANCE [Function]
Args: NIL MACHINE-INSTANCE
Function in LISP package:
Args: ()
Returns a string that identifies the machine instance of the machine
on which KCL is currently running.
-----------------------------------------------------------------------------
FILL [Function]
FILL
Function in LISP package:
Args: (sequence item &key (start 0) (end (length sequence)))
Replaces the specified elements of SEQUENCE all with ITEM.
-----------------------------------------------------------------------------
CDR [Function]
-----------------------------------------------------------------------------
CDR [Setf]
Defined as: (DEFSETF CDR (X) (Y) (LIST 'PROGN (LIST 'RPLACD X Y) Y))
See the doc of DEFSETF. CDR
Function in LISP package:
Args: (list)
Returns the cdr of LIST. Returns NIL if LIST is NIL.
-----------------------------------------------------------------------------
MAP [Function]
MAP
Function in LISP package:
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.
-----------------------------------------------------------------------------
FUNCALL [Function]
FUNCALL
Function in LISP package:
Args: (function &rest arguments)
Applies FUNCTION to the ARGUMENTs
-----------------------------------------------------------------------------
ENDP [Function]
ENDP
Function in LISP package:
Args: (x)
Returns T if X is NIL. Returns NIL if X is a cons. Otherwise, signals an
error.
-----------------------------------------------------------------------------
CHAR-BIT [Function]
-----------------------------------------------------------------------------
CHAR-BIT [Setf]
CHAR-BIT
Function in LISP package:
Args: (char name)
Returns T if the named bit is on in the character CHAR; NIL otherwise.
In KCL, this function always returns NIL.
-----------------------------------------------------------------------------
SINH [Function]
SINH
Function in LISP package:
Args: (number)
Returns the hyperbolic sine of NUMBER.
-----------------------------------------------------------------------------
BIT-IOR [Function]
BIT-IOR
Function in LISP package:
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.
-----------------------------------------------------------------------------
MAPL [Function]
MAPL
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs. Returns the first LIST.
-----------------------------------------------------------------------------
INTEGER-DECODE-FLOAT [Function]
INTEGER-DECODE-FLOAT
Function in LISP package:
Args: (float)
Returns, as three values, the integer interpretation of significand F,
the exponent E, and the sign S of the given float, so that
E
FLOAT = S * F * B where B = (FLOAT-RADIX FLOAT)
F is a non-negative integer, E is an integer, and S is either 1 or -1.
-----------------------------------------------------------------------------
SPECIAL-FORM-P [Function]
SPECIAL-FORM-P
Function in LISP package:
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*
-----------------------------------------------------------------------------
NIL [Constant]
NIL
Variable in LISP package:
Holds NIL.
-----------------------------------------------------------------------------
BIT-EQV [Function]
BIT-EQV
Function in LISP package:
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.
-----------------------------------------------------------------------------
** [Special variable]
**
Variable in LISP package:
Gets the previous value of * when KCL evaluates a top-level form.
-----------------------------------------------------------------------------
PATHNAME-HOST [Function]
PATHNAME-HOST
Function in LISP package:
Args: (pathname)
Returns the host slot of PATHNAME.
-----------------------------------------------------------------------------
ASSOC [Function]
ASSOC
Function in LISP package:
Args: (item alist &key (test #'eql) test-not)
Returns the first pair in ALIST whose car is equal (in the sense of TEST) to
ITEM.
-----------------------------------------------------------------------------
LEAST-POSITIVE-LONG-FLOAT [Constant]
LEAST-POSITIVE-LONG-FLOAT
Variable in LISP package:
The positive long-float closest in value to zero.
-----------------------------------------------------------------------------
LEAST-POSITIVE-DOUBLE-FLOAT [Constant]
LEAST-POSITIVE-DOUBLE-FLOAT
Variable in LISP package:
Same as LEAST-POSITIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
LEAST-POSITIVE-SINGLE-FLOAT [Constant]
LEAST-POSITIVE-SINGLE-FLOAT
Variable in LISP package:
Same as LEAST-POSITIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
LEAST-POSITIVE-SHORT-FLOAT [Constant]
LEAST-POSITIVE-SHORT-FLOAT
Variable in LISP package:
The positive short-float closest in value to zero.
-----------------------------------------------------------------------------
CADAAR [Function]
-----------------------------------------------------------------------------
CADAAR [Setf]
Defined as: (DEFSETF CADAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDAAR X) Y) Y))
See the doc of DEFSETF. CADAAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CAR (CAR X)))).
-----------------------------------------------------------------------------
*LOAD-VERBOSE* [Special variable]
*LOAD-VERBOSE*
Variable in LISP package:
The default for the VERBOSE argument to LOAD.
-----------------------------------------------------------------------------
GRAPHIC-CHAR-P [Function]
GRAPHIC-CHAR-P
Function in LISP package:
Args: (char)
Returns T if CHAR is a printing character, i.e., #\Space through #\~;
NIL otherwise.
-----------------------------------------------------------------------------
EQL [Function]
EQL
Function in LISP package:
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.
-----------------------------------------------------------------------------
ASIN [Function]
ASIN
Function in LISP package:
Args: (number)
Returns the arc sine of NUMBER.
-----------------------------------------------------------------------------
UNWIND-PROTECT [Special form]
UNWIND-PROTECT
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
GET-OUTPUT-STREAM-STRING [Function]
GET-OUTPUT-STREAM-STRING
Function in LISP package:
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 [Function]
-----------------------------------------------------------------------------
GET [Setf]
Defined as: (DEFSETF GET PUT-AUX)
See the doc of DEFSETF. GET
Function in LISP package:
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.
-----------------------------------------------------------------------------
CDDAAR [Function]
-----------------------------------------------------------------------------
CDDAAR [Setf]
Defined as: (DEFSETF CDDAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDAAR X) Y) Y))
See the doc of DEFSETF. CDDAAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CAR (CAR X)))).
-----------------------------------------------------------------------------
PATHNAME [Function]
PATHNAME
Function in LISP package:
Args: (x)
Turns X into a pathname. X may be a string, symbol, stream, or pathname.
-----------------------------------------------------------------------------
*READ-DEFAULT-FLOAT-FORMAT* [Special variable]
*READ-DEFAULT-FLOAT-FORMAT*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
BIT [Function]
-----------------------------------------------------------------------------
BIT [Type]
Defined as: (DEFTYPE BIT () '(INTEGER 0 1))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
BIT [Setf]
Defined as: (DEFSETF BIT ASET)
See the doc of DEFSETF. BIT
Function in LISP package:
Args: (bit-array &rest subscripts)
Returns the bit from BIT-ARRAY at SUBSCRIPTS.
-----------------------------------------------------------------------------
REMOVE [Function]
REMOVE
Function in LISP package:
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.
-----------------------------------------------------------------------------
EVAL-WHEN [Special form]
EVAL-WHEN
Special Form in LISP package:
Syntax: (eval-when ({situation}*) {form}*)
A situation must be either COMPILE, LOAD, or EVAL. The interpreter evaluates
only when EVAL is specified. If COMPILE is specified, FORMs are evaluated
at compile time. If LOAD is specified, the compiler arranges so that FORMs
be evaluated when the compiled code is loaded.
-----------------------------------------------------------------------------
UNION [Function]
UNION
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the union of LIST1 and LIST2.
-----------------------------------------------------------------------------
LET [Special form]
LET
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
CONJUGATE [Function]
CONJUGATE
Function in LISP package:
Args: (number)
Returns the complex conjugate of NUMBER.
-----------------------------------------------------------------------------
FLOATP [Function]
FLOATP
Function in LISP package:
Args: (x)
Returns T if X is a floating-point number; NIL otherwise.
-----------------------------------------------------------------------------
BOOLE-1 [Constant]
BOOLE-1
Variable in LISP package:
Makes BOOLE return INTEGER1.
-----------------------------------------------------------------------------
MAX [Function]
MAX
Function in LISP package:
Args: (number &rest more-numbers)
Returns the greatest of its arguments.
-----------------------------------------------------------------------------
SET [Function]
SET
Function in LISP package:
Args: (symbol value)
Assigns the value of VALUE to the dynamic variable named by SYMBOL, and
returns the value assigned.
-----------------------------------------------------------------------------
STRING> [Function]
STRING>
Function in LISP package:
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.
-----------------------------------------------------------------------------
ASSOC-IF [Function]
ASSOC-IF
Function in LISP package:
Args: (test alist)
Returns the first pair in ALIST whose car satisfies TEST.
-----------------------------------------------------------------------------
LDIFF [Function]
LDIFF
Function in LISP package:
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.
-----------------------------------------------------------------------------
LOGAND [Function]
LOGAND
Function in LISP package:
Args: (&rest integers)
Returns the bit-wise AND of its arguments.
-----------------------------------------------------------------------------
RETURN-FROM [Special form]
RETURN-FROM
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE-NOR [Constant]
BOOLE-NOR
Variable in LISP package:
Makes BOOLE return LOGNOR of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
LONG-SITE-NAME [Function]
Args: NIL LONG-SITE-NAME
Function in LISP package:
Args: ()
Returns a string that identifies the physical location of the current KCL.
-----------------------------------------------------------------------------
POP [Special form and Macro]
POP
Special Form in LISP package:
Syntax: (pop place)
Pops one item off the front of the list in PLACE and returns it.
-----------------------------------------------------------------------------
NULL [Function]
NULL
Function in LISP package:
Args: (x)
Returns T if X is NIL; NIL otherwise.
-----------------------------------------------------------------------------
*MACROEXPAND-HOOK* [Special variable]
*MACROEXPAND-HOOK*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
UPPER-CASE-P [Function]
UPPER-CASE-P
Function in LISP package:
Args: (char)
Returns T if CHAR is an upper-case character; NIL otherwise.
-----------------------------------------------------------------------------
MINUSP [Function]
MINUSP
Function in LISP package:
Args: (number)
Returns T if NUMBER < 0; NIL otherwise.
-----------------------------------------------------------------------------
*LINK-ARRAY* [Special variable]
-----------------------------------------------------------------------------
STRING-CHAR-P [Function]
STRING-CHAR-P
Function in LISP package:
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.
-----------------------------------------------------------------------------
EVENP [Function]
EVENP
Function in LISP package: Args: (integer) Returns T
if INTEGER is even. Returns NIL if INTEGER is odd.
-----------------------------------------------------------------------------
RENAME-PACKAGE [Function]
RENAME-PACKAGE
Function in LISP package:
Args: (package new-name &optional (new-nicknames nil))
Replaces the old name and nicknames of PACKAGE with NEW-NAME and
NEW-NICKNAMES.
-----------------------------------------------------------------------------
NOT [Function]
NOT
Function in LISP package:
Args: (x)
Returns T if X is NIL; NIL otherwise.
-----------------------------------------------------------------------------
*MODULES* [Special variable]
*MODULES*
Variable in LISP package:
A list of names of the modules that have been loaded into KCL.
-----------------------------------------------------------------------------
MAKE-LIST [Function]
MAKE-LIST
Function in LISP package:
Args: (size &key (initial-element nil))
Creates and returns a list containing SIZE elements, each of which is
initialized to INITIAL-ELEMENT.
-----------------------------------------------------------------------------
POSITION-IF [Function]
POSITION-IF
Function in LISP package:
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.
-----------------------------------------------------------------------------
COUNT-IF [Function]
COUNT-IF
Function in LISP package:
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the number of elements in SEQUENCE satisfying TEST.
-----------------------------------------------------------------------------
MISMATCH [Function]
MISMATCH
Function in LISP package:
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.
-----------------------------------------------------------------------------
LAMBDA-PARAMETERS-LIMIT [Constant]
LAMBDA-PARAMETERS-LIMIT
Variable in LISP package:
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.
-----------------------------------------------------------------------------
BOUNDP [Function]
BOUNDP
Function in LISP package:
Args: (symbol)
Returns T if the global variable named by SYMBOL has a value; NIL otherwise.
-----------------------------------------------------------------------------
MAKE-BROADCAST-STREAM [Function]
MAKE-BROADCAST-STREAM
Function in LISP package:
Args: (&rest streams)
Returns an output stream which sends its output to all of the given streams.
-----------------------------------------------------------------------------
CHAR-BITS-LIMIT [Constant]
CHAR-BITS-LIMIT
Variable in LISP package:
The upper exclusive bound on values produced by CHAR-BITS.
-----------------------------------------------------------------------------
LOGIOR [Function]
LOGIOR
Function in LISP package:
Args: (&rest integers)
Returns the bit-wise INCLUSIVE OR of its arguments.
-----------------------------------------------------------------------------
REALPART [Function]
REALPART
Function in LISP package:
Args: (number)
Extracts the real part of NUMBER.
-----------------------------------------------------------------------------
RATIONAL [Function]
RATIONAL
Function in LISP package:
Args: (number)
Converts NUMBER into rational accurately and returns it.
-----------------------------------------------------------------------------
APROPOS [Function]
APROPOS
Function in LISP package:
Args: (string &optional (package nil))
Prints those symbols whose print-names contain STRING as substring.
If PACKAGE is non-NIL, then only the specified package is searched.
-----------------------------------------------------------------------------
KEYWORDP [Function]
KEYWORDP
Function in LISP package:
Args: (x)
Returns T if X is a symbol and it belongs to the KEYWORD package; NIL
otherwise.
-----------------------------------------------------------------------------
COMPILED-FUNCTION-P [Function]
COMPILED-FUNCTION-P
Function in LISP package:
Args: (x)
Returns T if X is a compiled function; NIL otherwise.
-----------------------------------------------------------------------------
COPY-LIST [Function]
COPY-LIST
Function in LISP package:
Args: (list)
Returns a new copy of LIST.
-----------------------------------------------------------------------------
CHAR<= [Function]
CHAR<=
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-decreasing order; NIL
otherwise.
-----------------------------------------------------------------------------
MAKE-ARRAY [Function]
MAKE-ARRAY
Function in LISP package:
Args: (dimensions
&key (element-type t) initial-element (initial-contents nil)
(adjustable nil) (fill-pointer nil) (displaced-to nil)
(displaced-index-offset 0) static)
Creates an array of the specified DIMENSIONS. The default for INITIAL-
ELEMENT depends on ELEMENT-TYPE.
MAKE-ARRAY will always try to find the `best' array to
accommodate the element-type specified. For example on a SUN element-type
(mod 1) --> bit
(integer 0 10) --> unsigned-char
(integer -3 10) --> signed-char
si::best-array-element-type is the function doing this. It
is also used by the compiler, for coercing array element types.
If you are going to declare an array you should use the same
element type as was used in making it. eg
(setq my-array (make-array 4 :element-type '(integer 0 10)))
(the (array (integer 0 10)) my-array)
When wanting to optimize references to an array you need to
declare the array eg: (the (array (integer -3 10)) my-array) if ar
were constructed using the (integer -3 10) element-type. You could of
course have used signed-char, but since the ranges may be
implementation dependent it is better to use -3 10 range. MAKE-ARRAY
needs to do some calculation with the element-type if you don't
provide a primitive data-type. One way of doing this in a machine
independent fashion:
(defvar *my-elt-type* #.
(array-element-type (make-array 1 :element-type '(integer -3 10))))
Then calls to (make-array n :element-type *my-elt-type*) will not have to go
through a type inclusion computation. The keyword STATIC (KCL specific) if non
nil, will cause the array body to be non relocatable.
-----------------------------------------------------------------------------
BOOLE-2 [Constant]
BOOLE-2
Variable in LISP package:
Makes BOOLE return INTEGER2.
-----------------------------------------------------------------------------
ENCODE-UNIVERSAL-TIME [Function]
ENCODE-UNIVERSAL-TIME
Function in LISP package:
Args: (second minute hour date month year &optional (timezone -9))
Does the inverse operation of DECODE-UNIVERSAL-TIME.
-----------------------------------------------------------------------------
CHAR-FONT-LIMIT [Constant]
CHAR-FONT-LIMIT
Variable in LISP package:
The upper exclusive bound on values produced by CHAR-FONT.
-----------------------------------------------------------------------------
CHAR-CODE-LIMIT [Constant]
CHAR-CODE-LIMIT
Variable in LISP package:
The upper exclusive bound on values produced by CHAR-CODE.
-----------------------------------------------------------------------------
CCASE [Macro]
CCASE
Macro in LISP package:
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(s) of the last FORM. If not, signals a correctable error.
-----------------------------------------------------------------------------
UNINTERN [Function]
UNINTERN
Function in LISP package:
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.
-----------------------------------------------------------------------------
GET-SETF-METHOD [Function]
GET-SETF-METHOD
Function in LISP package:
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.
-----------------------------------------------------------------------------
ECASE [Macro]
ECASE
Macro in LISP package:
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(s) of the last FORM. If not, signals an error.
-----------------------------------------------------------------------------
PROG* [Special form and Macro]
PROG*
Special Form in LISP package:
Syntax: (prog* ({var | (var [init])}*) {decl}* {tag | statement}*)
Creates a NIL block, binds VARs sequentially, and then executes STATEMENTs.
-----------------------------------------------------------------------------
MERGE-PATHNAMES [Function]
MERGE-PATHNAMES
Function in LISP package:
Args: (pathname
&optional (defaults *default-pathname-defaults*) default-version)
Fills in unspecified slots of PATHNAME from DEFAULTS. DEFAULT-VERSION
is ignored in KCL.
-----------------------------------------------------------------------------
PACKAGE-USED-BY-LIST [Function]
PACKAGE-USED-BY-LIST
Function in LISP package:
Args: (package)
Returns the list of packages that use PACKAGE.
-----------------------------------------------------------------------------
PACKAGE-USE-LIST [Function]
PACKAGE-USE-LIST
Function in LISP package:
Args: (package)
Returns the list of packages used by PACKAGE.
-----------------------------------------------------------------------------
MAKE-SEQUENCE [Function]
MAKE-SEQUENCE
Function in LISP package:
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.
-----------------------------------------------------------------------------
REVERSE [Function]
REVERSE
Function in LISP package:
Args: (sequence)
Returns a new sequence containing the same elements as SEQUENCE but in
reverse order.
-----------------------------------------------------------------------------
*IGNORE-MAXIMUM-PAGES* [Special variable]
*IGNORE-MAXIMUM-PAGES*
Variable in LISP package:
GCL specific: Tells the GCL memory manager whether (non-NIL) or not (NIL) it
should expand memory whenever the maximum allocatable pages have been used
up.
-----------------------------------------------------------------------------
BIT-ORC1 [Function]
BIT-ORC1
Function in LISP package:
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.
-----------------------------------------------------------------------------
CDDDR [Function]
-----------------------------------------------------------------------------
CDDDR [Setf]
Defined as: (DEFSETF CDDDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDDR X) Y) Y))
See the doc of DEFSETF. CDDDR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CDR X))).
-----------------------------------------------------------------------------
ARRAY-DIMENSION [Function]
ARRAY-DIMENSION
Function in LISP package:
Args: (array axis-number)
Returns the length of AXIS-NUMBER of ARRAY.
-----------------------------------------------------------------------------
STRING-CAPITALIZE [Function]
STRING-CAPITALIZE
Function in LISP package:
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.
-----------------------------------------------------------------------------
MAKE-ECHO-STREAM [Function]
MAKE-ECHO-STREAM
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHAR-LESSP [Function]
CHAR-LESSP
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly increasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
-----------------------------------------------------------------------------
OUTPUT-STREAM-P [Function]
OUTPUT-STREAM-P
Function in LISP package:
Args: (stream)
Returns non-nil if STREAM can handle output operations; NIL otherwise.
-----------------------------------------------------------------------------
MULTIPLE-VALUE-CALL [Special form]
MULTIPLE-VALUE-CALL
Special Form in LISP package:
Syntax: (multiple-value-call function {form}*)
Calls FUNCTION with all the values of FORMs as arguments.
-----------------------------------------------------------------------------
ED [Function]
Args: (&OPTIONAL LISP::FILENAME) ED
Function in LISP package:
Args: (&optional x)
Invokes the editor. The action depends on the version of KCL. See the
KCL Report for details.
-----------------------------------------------------------------------------
MAKE-PATHNAME [Function]
MAKE-PATHNAME
Function in LISP package:
Args: (&key (defaults (parse-namestring ""
(pathname-host *default-pathname-defaults*)))
(host (pathname-host defaults))
(device (pathname-device defaults))
(directory (pathname-directory defaults))
(name (pathname-name defaults))
(type (pathname-type defaults))
(version (pathname-version defaults)))
Create a pathname from HOST, DEVICE, DIRECTORY, NAME, TYPE and VERSION.
-----------------------------------------------------------------------------
NUMBERP [Function]
NUMBERP
Function in LISP package:
Args: (x)
Returns T if X is any kind of number; NIL otherwise.
-----------------------------------------------------------------------------
MAKE-RANDOM-STATE [Function]
MAKE-RANDOM-STATE
Function in LISP package:
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.
-----------------------------------------------------------------------------
HASH-TABLE-P [Function]
HASH-TABLE-P
Function in LISP package: Args: (x) Returns T if X is a hash table object; NIL
otherwise.
-----------------------------------------------------------------------------
BOOLE-C1 [Constant]
BOOLE-C1
Variable in LISP package:
Makes BOOLE return the complement of INTEGER1.
-----------------------------------------------------------------------------
PROG [Special form and Macro]
PROG
Special Form in LISP package:
Syntax: (prog ({var | (var [init])}*) {decl}* {tag | statement}*)
Creates a NIL block, binds VARs in parallel, and then executes STATEMENTs.
-----------------------------------------------------------------------------
BYTE [Function]
BYTE
Function in LISP package:
Args: (size position)
Returns a byte specifier. In KCL, a byte specifier is represented by
a dotted pair ( . ).
-----------------------------------------------------------------------------
SIGNED-CHAR [Type]
Defined as: (DEFTYPE SIGNED-CHAR () (LIST 'SIGNED-BYTE CHAR-SIZE))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
GET-INTERNAL-REAL-TIME [Function]
GET-INTERNAL-REAL-TIME
Function in LISP package:
Args: ()
Returns the real time in the internal time format. This is useful for
finding elapsed time.
-----------------------------------------------------------------------------
GET-INTERNAL-RUN-TIME [Function]
GET-INTERNAL-RUN-TIME
Function in LISP package:
Args: ()
Returns the run time in the internal time format. This is useful for
finding CPU usage. If the operating system allows, a second value
containing CPU usage of child processes is returned.
-----------------------------------------------------------------------------
ACOS [Function]
ACOS
Function in LISP package:
Args: (number)
Returns the arc cosine of NUMBER.
-----------------------------------------------------------------------------
IF [Special form]
IF
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
TYPECASE [Macro]
TYPECASE
Macro in LISP package:
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.
-----------------------------------------------------------------------------
SUBLIS [Function]
SUBLIS
Function in LISP package:
Args: (alist tree &key (test #'eql) test-not (key #'identity))
Substitutes from ALIST for subtrees of TREE nondestructively.
-----------------------------------------------------------------------------
DEFSTRUCT [Macro]
DEFSTRUCT
Macro in LISP package:
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 | (:static { nil | t})
(: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).
STATIC is gcl specific and makes the body non relocatable.
See the files misc/rusage.lsp misc/cstruct.lsp, for examples of making
a lisp structure correspond to a C structure.
-----------------------------------------------------------------------------
HOST-NAMESTRING [Function]
HOST-NAMESTRING
Function in LISP package:
Args: (pathname)
Returns the host part of PATHNAME as a string.
-----------------------------------------------------------------------------
PRIN1 [Function]
PRIN1
Function in LISP package:
Args: (object &optional (stream *standard-output*))
Prints OBJECT in the mostly readable representation. Returns OBJECT.
Equivalent to (WRITE OBJECT :STREAM STREAM :ESCAPE T).
-----------------------------------------------------------------------------
PACKAGE-NAME [Function]
PACKAGE-NAME
Function in LISP package:
Args: (package)
Returns the string that names the specified PACKAGE.
-----------------------------------------------------------------------------
CAAADR [Function]
-----------------------------------------------------------------------------
CAAADR [Setf]
Defined as: (DEFSETF CAAADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CAADR X) Y) Y))
See the doc of DEFSETF. CAAADR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CAR (CDR X)))).
-----------------------------------------------------------------------------
SUBSEQ [Function]
-----------------------------------------------------------------------------
SUBSEQ [Setf]
Defined as: (DEFSETF SUBSEQ (SEQUENCE1 START1 &OPTIONAL END1)
(SEQUENCE2)
(LIST 'REPLACE SEQUENCE1 SEQUENCE2 :START1 START1 :END1
END1))
See the doc of DEFSETF. SUBSEQ
Function in LISP package:
Args: (sequence start &optional (end (length sequence)))
Returns a copy of a subsequence of SEQUENCE between START (inclusive) and
END (exclusive).
-----------------------------------------------------------------------------
DEFINE-SETF-METHOD [Macro]
DEFINE-SETF-METHOD
Macro in LISP package:
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).
-----------------------------------------------------------------------------
CDAADR [Function]
-----------------------------------------------------------------------------
CDAADR [Setf]
Defined as: (DEFSETF CDAADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CAADR X) Y) Y))
See the doc of DEFSETF. CDAADR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CAR (CDR X)))).
-----------------------------------------------------------------------------
CERROR [Function]
CERROR
Function in LISP package:
Args: (continue-format-string error-format-string &rest args)
Signals a correctable error.
-----------------------------------------------------------------------------
MACROEXPAND-1 [Function]
MACROEXPAND-1
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHAR-GREATERP [Function]
CHAR-GREATERP
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly decreasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
-----------------------------------------------------------------------------
MAPCAR [Function]
MAPCAR
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs and returns the results as a list.
-----------------------------------------------------------------------------
STRINGP [Function]
STRINGP
Function in LISP package:
Args: (x)
Returns T if X is a string; NIL otherwise.
-----------------------------------------------------------------------------
ARRAY-DIMENSION-LIMIT [Constant]
ARRAY-DIMENSION-LIMIT
Variable in LISP package:
The exclusive upper bound of the array dimension.
-----------------------------------------------------------------------------
ARRAY-ROW-MAJOR-INDEX [Function]
ARRAY-ROW-MAJOR-INDEX
Function in LISP package:
Args: (array &rest subscripts)
Returns the index into the data vector of ARRAY for the element of ARRAY
specified by SUBSCRIPTS.
-----------------------------------------------------------------------------
ERROR [Function]
ERROR
Function in LISP package:
Args: (control-string &rest args)
Signals a fatal error.
-----------------------------------------------------------------------------
STRING-NOT-GREATERP [Function]
STRING-NOT-GREATERP
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING<=, but ignores cases.
*EVAL-WHEN-COMPILE*
Variable in LISP package:
KCL specific: Tells the KCL compiler whether (non-NIL) or not (NIL) the
compiler should process top-level forms in compile-time-too mode.
-----------------------------------------------------------------------------
PATHNAME-NAME [Function]
PATHNAME-NAME
Function in LISP package:
Args: (pathname)
Returns the name slot of PATHNAME.
-----------------------------------------------------------------------------
CEILING [Function]
CEILING
Function in LISP package:
Args: (number &optional (divisor 1))
Returns the smallest integer not less than or NUMBER/DIVISOR. Returns the
remainder as the second value.
-----------------------------------------------------------------------------
MEMBER-IF [Function]
MEMBER-IF
Function in LISP package:
Args: (test list &key (key #'identity))
Returns the tail of LIST beginning with the first element satisfying TEST.
-----------------------------------------------------------------------------
LISP-IMPLEMENTATION-VERSION [Function]
LISP-IMPLEMENTATION-VERSION
Function in LISP package:
Args: ()
Returns a string that tells you when the current KCL implementation is
brought up.
-----------------------------------------------------------------------------
FILE-AUTHOR [Function]
FILE-AUTHOR
Function in LISP package:
Args: (file)
Returns the author name of the specified file, as a string.
FILE may be a string or a stream
-----------------------------------------------------------------------------
SCALE-FLOAT [Function]
SCALE-FLOAT
Function in LISP package:
Args: (float integer)
Returns (* FLOAT (expt (float-radix FLOAT) INTEGER)).
-----------------------------------------------------------------------------
VECTOR-PUSH [Function]
VECTOR-PUSH
Function in LISP package:
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.
-----------------------------------------------------------------------------
CLOSE [Function]
CLOSE
Function in LISP package:
Args: (stream &key (abort nil))
Closes STREAM. A non-NIL value of :ABORT indicates an abnormal termination.
-----------------------------------------------------------------------------
FILE-WRITE-DATE [Function]
FILE-WRITE-DATE
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHARACTERP [Function]
CHARACTERP
Function in LISP package:
Args: (x)
Returns T if X is a character; NIL otherwise.
-----------------------------------------------------------------------------
CHARACTER [Function]
CHARACTER
Function in LISP package:
Args: (x)
Coerces X into a character object if possible.
-----------------------------------------------------------------------------
NSUBSTITUTE-IF [Function]
NSUBSTITUTE-IF
Function in LISP package:
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.
-----------------------------------------------------------------------------
LOGORC1 [Function]
LOGORC1
Function in LISP package:
Args: (integer1 integer2)
Returns the logical OR of (LOGNOT INTEGER1) and INTEGER2.
-----------------------------------------------------------------------------
INSPECT [Function]
INSPECT
Function in LISP package:
Args: (x)
Shows the information about the object X in an interactive manner
-----------------------------------------------------------------------------
OR [Special form and Macro]
OR
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
TYPE-OF [Function]
TYPE-OF
Function in LISP package:
Args: (x)
Returns the type of X.
-----------------------------------------------------------------------------
VALUES-LIST [Function]
VALUES-LIST
Function in LISP package:
Args: (list)
Returns all of the elements of LIST in order, as values.
-----------------------------------------------------------------------------
READTABLEP [Function]
READTABLEP
Function in LISP package:
Args: (x)
Returns T if X is a readtable object; NIL otherwise.
-----------------------------------------------------------------------------
PARSE-NAMESTRING [Function]
PARSE-NAMESTRING
Function in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE-EQV [Constant]
BOOLE-EQV
Variable in LISP package:
Makes BOOLE return LOGEQV of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
CADAR [Function]
-----------------------------------------------------------------------------
CADAR [Setf]
Defined as: (DEFSETF CADAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDAR X) Y) Y))
See the doc of DEFSETF. CADAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CAR X))).
-----------------------------------------------------------------------------
PROCLAMATION [Function]
PROCLAMATION
Function in LISP package:
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.
-----------------------------------------------------------------------------
*PRINT-RADIX* [Special variable]
*PRINT-RADIX*
Variable in LISP package:
Whether the KCL printer should print the radix indicator when printing
integers and rationals.
-----------------------------------------------------------------------------
CHAR-META-BIT [Constant]
CHAR-META-BIT
Variable in LISP package:
The bit that indicates a meta character.
-----------------------------------------------------------------------------
VALUES [Function]
VALUES
Function in LISP package:
Args: (&rest args)
Returns ARGs in order, as values.
-----------------------------------------------------------------------------
STABLE-SORT [Function]
STABLE-SORT
Function in LISP package:
Args: (sequence predicate &key (key #'identity))
Destructively sorts SEQUENCE. PREDICATE should return non-NIL if its first
argument is to precede its second argument.
-----------------------------------------------------------------------------
MAPCON [Function]
MAPCON
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs, NCONCs the results, and returns it.
-----------------------------------------------------------------------------
CDDR [Function]
-----------------------------------------------------------------------------
CDDR [Setf]
Defined as: (DEFSETF CDDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDR X) Y) Y))
See the doc of DEFSETF. CDDR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR X)).
-----------------------------------------------------------------------------
*TERMINAL-IO* [Special variable]
*TERMINAL-IO*
Variable in LISP package:
The terminal I/O stream.
-----------------------------------------------------------------------------
GETF [Function]
-----------------------------------------------------------------------------
GETF [Setf]
GETF
Function in LISP package:
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.
-----------------------------------------------------------------------------
EVAL [Function]
EVAL
Function in LISP package:
Args: (exp)
Evaluates EXP and returns the result(s).
-----------------------------------------------------------------------------
COUNT-IF-NOT [Function]
COUNT-IF-NOT
Function in LISP package: Args: (test
sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the number of elements in SEQUENCE not satisfying TEST.
-----------------------------------------------------------------------------
THE [Special form]
-----------------------------------------------------------------------------
THE [Setf]
THE
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
LOGANDC2 [Function]
LOGANDC2
Function in LISP package:
Args: (integer1 integer2)
Returns the logical AND of INTEGER1 and (LOGNOT INTEGER2).
-----------------------------------------------------------------------------
MOST-POSITIVE-LONG-FLOAT [Constant]
MOST-POSITIVE-LONG-FLOAT
Variable in LISP package:
The long-float closest in value to positive infinity.
-----------------------------------------------------------------------------
MOST-POSITIVE-DOUBLE-FLOAT [Constant]
MOST-POSITIVE-DOUBLE-FLOAT
Variable in LISP package:
Same as MOST-POSITIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
MOST-POSITIVE-SINGLE-FLOAT [Constant]
MOST-POSITIVE-SINGLE-FLOAT
Variable in LISP package:
Same as MOST-POSITIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
MOST-POSITIVE-SHORT-FLOAT [Constant]
MOST-POSITIVE-SHORT-FLOAT
Variable in LISP package:
The short-float closest in value to positive infinity.
-----------------------------------------------------------------------------
RATIONALIZE [Function]
RATIONALIZE
Function in LISP package:
Args: (number)
Converts NUMBER into rational approximately and returns it.
-----------------------------------------------------------------------------
*PRINT-ARRAY* [Special variable]
*PRINT-ARRAY*
Variable in LISP package:
Whether the KCL printer should print array elements.
-----------------------------------------------------------------------------
FLOAT [Function]
FLOAT
Function in LISP package:
Args: (number &optional other)
Converts a non-complex number to a floating-point number. If NUMBER is
already a float, FLOAT simply returns NUMBER. Otherwise, the format of
the returned float depends on OTHER; If OTHER is not provided, FLOAT returns
a SINGLE-FLOAT. If OTHER is provided, the result is in the same float format
as OTHER's.
-----------------------------------------------------------------------------
BIT-VECTOR [Type]
Defined as: (DEFTYPE BIT-VECTOR (&OPTIONAL (SIZE '*))
(LIST 'VECTOR 'BIT SIZE))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
POSITION-IF-NOT [Function]
POSITION-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
NOTEVERY [Function]
NOTEVERY
Function in LISP package:
Args: (predicate sequence &rest more-sequences)
Returns T if at least one of the elements in SEQUENCEs does not satisfy
PREDICATE; NIL otherwise.
-----------------------------------------------------------------------------
APROPOS-LIST [Function]
APROPOS-LIST
Function in LISP package:
Args: (string &optional (package nil))
Returns, as a list, all symbols whose print-names contain STRING as substring.
If PACKAGE is non-NIL, then only the specified package is searched.
-----------------------------------------------------------------------------
PARSE-INTEGER [Function]
PARSE-INTEGER
Function in LISP package:
Args: (string
&key (start 0) (end (length string)) (radix 10) (junk-allowed nil))
Parses STRING for an integer and returns it.
-----------------------------------------------------------------------------
LOG [Function]
LOG
Function in LISP package:
Args: (number &optional base)
Returns the logarithm of NUMBER in the base BASE. BASE defaults to the base
of natural logarithms.
-----------------------------------------------------------------------------
DO-EXTERNAL-SYMBOLS [Macro]
DO-EXTERNAL-SYMBOLS
Macro in LISP package:
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(s).
-----------------------------------------------------------------------------
ARRAY-HAS-FILL-POINTER-P [Function]
ARRAY-HAS-FILL-POINTER-P
Function in LISP package:
Args: (array)
Returns T if ARRAY has a fill pointer; NIL otherwise.
-----------------------------------------------------------------------------
LONG-FLOAT-NEGATIVE-EPSILON [Constant]
LONG-FLOAT-NEGATIVE-EPSILON
Variable in LISP package:
The smallest positive long-float that satisfies
(not (= (float 1 e) (- (float 1 e) e))).
-----------------------------------------------------------------------------
LONG-FLOAT-EPSILON [Constant]
LONG-FLOAT-EPSILON
Variable in LISP package:
The smallest positive long-float that satisfies
(not (= (float 1 e) (+ (float 1 e) e))).
-----------------------------------------------------------------------------
CHECK-TYPE [Macro]
CHECK-TYPE
Macro in LISP package:
Syntax: (check-type place typespec [string])
Signals an error, if the contents of PLACE are not of the specified type.
-----------------------------------------------------------------------------
BUTLAST [Function]
BUTLAST
Function in LISP package:
Args: (list &optional (n 1))
Creates and returns a list with the same elements as LIST but without the
last N elements.
-----------------------------------------------------------------------------
*FEATURES* [Special variable]
*FEATURES*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
SETF [Special form and Macro]
SETF
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
*PACKAGE* [Special variable]
*PACKAGE*
Variable in LISP package:
The current package.
-----------------------------------------------------------------------------
PROGV [Special form]
PROGV
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
LOGORC2 [Function]
LOGORC2
Function in LISP package:
Args: (integer1 integer2)
Returns the logical OR of INTEGER1 and (LOGNOT INTEGER2).
-----------------------------------------------------------------------------
DRIBBLE [Function]
DRIBBLE
Function in LISP package:
Args: (&optional pathname)
If PATHNAME is given, begins to record the interaction to the specified file.
If PATHNAME is not given, ends the recording.
-----------------------------------------------------------------------------
CLEAR-INPUT [Function]
CLEAR-INPUT
Function in LISP
package: Args: (&optional (stream *standard-input*)) Clears the input
stream STREAM.
-----------------------------------------------------------------------------
CHAR-BITS [Function]
CHAR-BITS
Function in LISP package:
Args: (char)
Returns the bits attribute (which is always 0 in KCL) of CHAR.
-----------------------------------------------------------------------------
ADJUSTABLE-ARRAY-P [Function]
ADJUSTABLE-ARRAY-P
Function in LISP package:
Args: (array)
Returns T if ARRAY is adjustable; NIL otherwise.
-----------------------------------------------------------------------------
UNTRACE [Macro]
UNTRACE
Macro in LISP package:
Syntax: (untrace {function-name}*)
Removes tracing from the specified functions. With no FUNCTION-NAMEs,
untraces all functions.
-----------------------------------------------------------------------------
SINGLE-FLOAT-NEGATIVE-EPSILON [Constant]
SINGLE-FLOAT-NEGATIVE-EPSILON
Variable in LISP package:
Same as LONG-FLOAT-NEGATIVE-EPSILON.
-----------------------------------------------------------------------------
SINGLE-FLOAT-EPSILON [Constant]
SINGLE-FLOAT-EPSILON
Variable in LISP package:
Same as LONG-FLOAT-EPSILON.
-----------------------------------------------------------------------------
RASSOC-IF [Function]
RASSOC-IF
Function in LISP package:
Args: (predicate alist)
Returns the first cons in ALIST whose cdr satisfies PREDICATE.
-----------------------------------------------------------------------------
ARRAY-RANK-LIMIT [Constant]
ARRAY-RANK-LIMIT
Variable in LISP package:
The exclusive upper bound on the rank of an array.
-----------------------------------------------------------------------------
UNUSE-PACKAGE [Function]
UNUSE-PACKAGE
Function in LISP package:
Args: (packages-to-unuse &optional (package *package*))
Removes PACKAGES-TO-UNUSE from the use list for PACKAGE.
-----------------------------------------------------------------------------
FTRUNCATE [Function]
FTRUNCATE
Function in LISP package:
Args: (number &optional (divisor 1))
Values: (quotient remainder)
Same as TRUNCATE, but returns first value as a float.
-----------------------------------------------------------------------------
CIS [Function]
CIS
Function in LISP package:
Args: (radians)
Returns e raised to i*RADIANS.
-----------------------------------------------------------------------------
ARRAY-DIMENSIONS [Function]
ARRAY-DIMENSIONS
Function in LISP package:
Args: (array)
Returns a list whose elements are the dimensions of ARRAY
-----------------------------------------------------------------------------
MULTIPLE-VALUES-LIMIT [Constant]
MULTIPLE-VALUES-LIMIT
Variable in LISP package:
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.
-----------------------------------------------------------------------------
RPLACD [Function]
RPLACD
Function in LISP package:
Args: (x y)
Replaces the cdr of X with Y, and returns the modified X.
-----------------------------------------------------------------------------
CHAR-NOT-LESSP [Function]
CHAR-NOT-LESSP
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-increasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
-----------------------------------------------------------------------------
SCHAR [Function]
-----------------------------------------------------------------------------
SCHAR [Setf]
Defined as: (DEFSETF SCHAR SCHAR-SET)
See the doc of DEFSETF. SCHAR
Function in LISP package:
Args: (simple-string index)
Returns the character object representing the INDEX-th character in STRING.
This is faster than CHAR.
-----------------------------------------------------------------------------
ATANH [Function]
ATANH
Function in LISP package: Args: (number)
Returns the hyperbolic arc tangent of NUMBER.
-----------------------------------------------------------------------------
CHAR-SUPER-BIT [Constant]
CHAR-SUPER-BIT
Variable in LISP package:
The bit that indicates a super character.
-----------------------------------------------------------------------------
MOST-POSITIVE-FIXNUM [Constant]
MOST-POSITIVE-FIXNUM
Variable in LISP package:
The fixnum closest in value to positive infinity.
-----------------------------------------------------------------------------
FUNCTION [Special form]
FUNCTION
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
SOFTWARE-TYPE [Function]
Args: NIL SOFTWARE-TYPE
Function in LISP package:
Args: ()
Returns a string that identifies the software type of the software
under which KCL is currently running.
-----------------------------------------------------------------------------
FLET [Special form]
FLET
Special Form in LISP package:
Syntax: (flet ({(name lambda-list {decl | doc}* {form}*)}*) . body)
Evaluates BODY as a PROGN, with local function definitions in effect. BODY is
the scope of each local function definition. Since the scope does not include
the function definitions themselves, the local function can reference
externally defined functions of the same name. See the doc of DEFUN for the
complete syntax of a lambda-list. Doc-strings for local functions are simply
ignored.
-----------------------------------------------------------------------------
DIGIT-CHAR [Function]
DIGIT-CHAR
Function in LISP package:
Args: (digit &optional (radix 10) (font 0))
Returns a character object that represents the DIGIT in the specified RADIX.
Returns NIL if no such character exists.
-----------------------------------------------------------------------------
CHAR>= [Function]
CHAR>=
Function in LISP package:
Args: (char &rest more-chars)
Returns T if the codes of CHARs are in strictly non-increasing order; NIL
otherwise.
-----------------------------------------------------------------------------
*PRINT-LEVEL* [Special variable]
*PRINT-LEVEL*
Variable in LISP package:
How many levels deep the KCL printer should print. Unlimited if NIL.
-----------------------------------------------------------------------------
*QUERY-IO* [Special variable]
*QUERY-IO*
Variable in LISP package:
The query I/O stream.
-----------------------------------------------------------------------------
TAILP [Function]
TAILP
Function in LISP package:
Args: (sublist list)
Returns T if SUBLIST is one of the conses in LIST; NIL otherwise.
-----------------------------------------------------------------------------
RASSOC-IF-NOT [Function]
RASSOC-IF-NOT
Function in LISP package:
Args: (predicate alist)
Returns the first cons in ALIST whose cdr does not satisfy PREDICATE.
-----------------------------------------------------------------------------
COMPILER-LET [Special form]
COMPILER-LET
Special Form in LISP package:
Syntax: (compiler-let ({var | (var [value])}*) {form}*)
When interpreted, this form works just like a LET form with all VARs declared
special. When compiled, FORMs are processed with the VARs bound at compile
time, but no bindings occur when the compiled code is executed.
-----------------------------------------------------------------------------
CHAR-HYPER-BIT [Constant]
CHAR-HYPER-BIT
Variable in LISP package:
The bit that indicates a hyper character.
-----------------------------------------------------------------------------
COS [Function]
COS
Function in LISP package:
Args: (radians)
Returns the cosine of RADIANS.
-----------------------------------------------------------------------------
NSET-DIFFERENCE [Function]
NSET-DIFFERENCE
Function in LISP package:
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.
-----------------------------------------------------------------------------
SBIT [Function]
-----------------------------------------------------------------------------
SBIT [Setf]
Defined as: (DEFSETF SBIT ASET)
See the doc of DEFSETF. SBIT
Function in LISP package:
Args: (simple-bit-array &rest subscripts)
Returns the bit from SIMPLE-BIT-ARRAY at SUBSCRIPTS.
-----------------------------------------------------------------------------
CADADR [Function]
-----------------------------------------------------------------------------
CADADR [Setf]
Defined as: (DEFSETF CADADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDADR X) Y) Y))
See the doc of DEFSETF. CADADR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CAR (CDR X)))).
-----------------------------------------------------------------------------
STRING-GREATERP [Function]
STRING-GREATERP
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING>, but ignores cases.
-----------------------------------------------------------------------------
BIT-VECTOR-P [Function]
BIT-VECTOR-P
Function in LISP package:
Args: (x)
Returns T if X is a bit vector; NIL otherwise.
-----------------------------------------------------------------------------
INTEGER-LENGTH [Function]
INTEGER-LENGTH
Function in LISP package:
Args: (integer)
Returns the number of significant bits in the absolute value of INTEGER.
-----------------------------------------------------------------------------
DECLARE [Special form]
DECLARE
Special Form in LISP package:
Syntax: (declare {decl-spec}*)
Gives a declaration. Possible DECL-SPECs are:
(SPECIAL {var}*)
(TYPE 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
'TYPE' may also be a list containing one of the above symbols as
its first element and more specific information later in the list.
eg: (vector long-float 80) ; vector of 80 long-floats.
(array long-float *) ; array of long-floats
(array fixnum) ; array of fixnums
(array * 30) ; an array of length 30 but unspecified type
A list of 1 element may be replaced by the symbol alone, and a list ending
in '*' may drop the the final '*'.
(OBJECT {var}*)
(FTYPE type {function-name}*)
eg: ;; function of two required args and optional args and one value:
(ftype (function (t t *) t) sort reduce)
;; function with 1 arg of general type returning 1 fixnum as value.
(ftype (function (t) fixnum) length)
(FUNCTION function-name ({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}*)
(:DYNAMIC-EXTENT {var}*) ;kcl-specific.
.
-----------------------------------------------------------------------------
CDDADR [Function]
-----------------------------------------------------------------------------
CDDADR [Setf]
Defined as: (DEFSETF CDDADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDADR X) Y) Y))
See the doc of DEFSETF. CDDADR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CAR (CDR X)))).
-----------------------------------------------------------------------------
WITH-INPUT-FROM-STRING [Macro]
WITH-INPUT-FROM-STRING
Macro in LISP package:
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.
-----------------------------------------------------------------------------
NSTRING-DOWNCASE [Function]
NSTRING-DOWNCASE
Function in LISP package:
Args: (string &key
(start 0) (end (length string))) Returns STRING with all upper case
characters converted to lowercase.
-----------------------------------------------------------------------------
SIMPLE-VECTOR-P [Function]
SIMPLE-VECTOR-P
Function in LISP package:
Args: (x)
Returns T if X is a simple vector; NIL otherwise.
-----------------------------------------------------------------------------
SHADOWING-IMPORT [Function]
SHADOWING-IMPORT
Function in LISP package:
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.
-----------------------------------------------------------------------------
LIST* [Function]
LIST*
Function in LISP package:
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.
-----------------------------------------------------------------------------
GET-PROPERTIES [Function]
GET-PROPERTIES
Function in LISP package:
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.
-----------------------------------------------------------------------------
*BREAK-ON-WARNINGS* [Special variable]
*BREAK-ON-WARNINGS*
Variable in LISP package:
When the function WARN is called, control enters to the break loop only
if the value of this varialbe is non-NIL.
-----------------------------------------------------------------------------
FIFTH [Function]
-----------------------------------------------------------------------------
FIFTH [Setf]
Defined as: (DEFSETF FIFTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDDDR X) Y) Y))
See the doc of DEFSETF. FIFTH
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDDDDR X)).
-----------------------------------------------------------------------------
FLOAT-DIGITS [Function]
FLOAT-DIGITS
Function in LISP package:
Args: (float)
Returns the number of radix-B digits used to represent the significand F of
the floating-point number, where B = (FLOAT-RADIX FLOAT).
-----------------------------------------------------------------------------
STRING-TRIM [Function]
STRING-TRIM
Function in LISP package:
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from both
ends.
-----------------------------------------------------------------------------
LAST [Function]
LAST
Function in LISP package:
Args: (list)
Returns the last cons in LIST
-----------------------------------------------------------------------------
SUBSTITUTE [Function]
SUBSTITUTE
Function in LISP package:
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.
-----------------------------------------------------------------------------
SYMBOL-PACKAGE [Function]
SYMBOL-PACKAGE
Function in LISP package:
Args: (symbol)
Returns the contents of the package cell of the symbol SYMBOL.
-----------------------------------------------------------------------------
ACONS [Function]
ACONS
Function in LISP package:
Args: (key datum alist)
Constructs a new alist by adding the pair (KEY . DATUM) to ALIST.
-----------------------------------------------------------------------------
FOURTH [Function]
-----------------------------------------------------------------------------
FOURTH [Setf]
Defined as: (DEFSETF FOURTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDDR X) Y) Y))
See the doc of DEFSETF. FOURTH
Function in LISP package:
Args: (x)
Equivalent to (CADDDR X).
-----------------------------------------------------------------------------
READ-FROM-STRING [Function]
READ-FROM-STRING
Function in LISP package:
Args: (string &optional (eof-error-p t) (eof-value nil)
&key (start 0) (end (length string)) (preserve-whitespace nil))
Reads an object from STRING.
-----------------------------------------------------------------------------
ASSERT [Macro]
ASSERT
Macro in LISP package:
Syntax: (assert test-form [({place}*) [string {arg}*]])
Signals an error if the value of TEST-FORM is NIL. STRING is an format string
used as the error message. ARGs are arguments to the format string.
-----------------------------------------------------------------------------
CASE [Special form and Macro]
CASE
Special Form in LISP package:
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(s) of the last FORM. If not, simply returns NIL.
-----------------------------------------------------------------------------
EVALHOOK [Function]
EVALHOOK
Function in LISP package:
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.
-----------------------------------------------------------------------------
FIND-IF-NOT [Function]
FIND-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
STREAMP [Function]
STREAMP
Function in LISP package:
Args: (x)
Returns T if X is a stream object; NIL otherwise.
-----------------------------------------------------------------------------
INT-CHAR [Function]
INT-CHAR
Function in LISP package:
Args: (integer)
Performs the inverse of CHAR-INT. Equivalent to CODE-CHAR in GCL.
-----------------------------------------------------------------------------
ARRAYP [Function]
ARRAYP
Function in LISP package:
Args: (x)
Returns T if X is an array; NIL otherwise.
-----------------------------------------------------------------------------
WRITE-LINE [Function]
WRITE-LINE
Function in LISP package:
Args: (string &optional (stream *standard-output*)
&key (start 0) (end (length string)))
Outputs STRING and then outputs a newline character. Returns STRING.
-----------------------------------------------------------------------------
VECTORP [Function]
VECTORP
Function in LISP package:
Args: (x)
Returns T if X is a vector; NIL otherwise.
-----------------------------------------------------------------------------
STREAM-ELEMENT-TYPE [Function]
STREAM-ELEMENT-TYPE
Function in LISP package:
Args: (stream)
Returns a type specifier for the kind of object returned by STREAM.
-----------------------------------------------------------------------------
SIGNED-SHORT [Type]
Defined as: (DEFTYPE SIGNED-SHORT () (LIST 'SIGNED-BYTE SHORT-SIZE))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
SHORT-FLOAT-NEGATIVE-EPSILON [Constant]
SHORT-FLOAT-NEGATIVE-EPSILON
Variable in LISP package:
The smallest positive short-float that satisfies
(not (= (float 1 e) (- (float 1 e) e))).
-----------------------------------------------------------------------------
SHORT-FLOAT-EPSILON [Constant]
SHORT-FLOAT-EPSILON
Variable in LISP package:
The smallest positive short-float that satisfies
(not (= (float 1 e) (+ (float 1 e) e))).
-----------------------------------------------------------------------------
REST [Function]
-----------------------------------------------------------------------------
REST [Setf]
Defined as: (DEFSETF REST (X) (Y) (LIST 'PROGN (LIST 'RPLACD X Y) Y))
See the doc of DEFSETF. REST
Function in LISP package:
Args: (x)
Equivalent to (CDR X).
-----------------------------------------------------------------------------
LIST [Function]
LIST
Function in LISP package:
Args: (&rest args)
Returns a list of its arguments
-----------------------------------------------------------------------------
NSUBSTITUTE [Function]
NSUBSTITUTE
Function in LISP package:
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.
-----------------------------------------------------------------------------
FBOUNDP [Function]
FBOUNDP
Function in LISP package:
Args: (symbol)
Returns T if SYMBOL has a global function definition or if SYMBOL names a
special form or a macro; NIL otherwise.
-----------------------------------------------------------------------------
COMMONP [Function]
COMMONP
Function in LISP package:
Args: (x)
Returns T if X is a Common Lisp object; NIL otherwise.
-----------------------------------------------------------------------------
PACKAGEP [Function]
PACKAGEP
Function in LISP package:
Args: (x)
Returns T if X is a package; NIL otherwise.
-----------------------------------------------------------------------------
COPY-ALIST [Function]
COPY-ALIST
Function in LISP
package: Args: (alist) Returns a new copy of ALIST.
-----------------------------------------------------------------------------
CAADR [Function]
-----------------------------------------------------------------------------
CAADR [Setf]
Defined as: (DEFSETF CAADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CADR X) Y) Y))
See the doc of DEFSETF. CAADR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CDR X))).
-----------------------------------------------------------------------------
DO-ALL-SYMBOLS [Macro]
DO-ALL-SYMBOLS
Macro in LISP package:
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(s).
-----------------------------------------------------------------------------
DO* [Special form and Macro]
DO*
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
SUBST [Function]
SUBST
Function in LISP package:
Args: (new old tree &key (test #'eql) test-not (key #'identity))
Substitutes NEW for subtrees of TREE that match OLD.
-----------------------------------------------------------------------------
FIXNUM [Type]
Defined as: (DEFTYPE FIXNUM ()
(LIST 'INTEGER MOST-NEGATIVE-FIXNUM MOST-POSITIVE-FIXNUM))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
PUSHNEW [Macro]
PUSHNEW
Macro in LISP package:
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.
-----------------------------------------------------------------------------
NREVERSE [Function]
NREVERSE
Function in LISP package:
Args: (sequence)
Returns a sequence of the same elements as SEQUENCE but in reverse order.
SEQUENCE may be destroyed.
-----------------------------------------------------------------------------
NAMESTRING [Function]
NAMESTRING
Function in LISP package:
Args: (pathname)
Returns the full form of PATHNAME as a string.
-----------------------------------------------------------------------------
GET-DECODED-TIME [Function]
Args: NIL GET-DECODED-TIME
Function in LISP package:
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.
-----------------------------------------------------------------------------
STRING [Function]
-----------------------------------------------------------------------------
STRING [Type]
Defined as: (DEFTYPE STRING (&OPTIONAL (SIZE '*))
(LIST 'VECTOR 'STRING-CHAR SIZE))
See the doc of DEFTYPE. STRING
Function in LISP package:
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.
-----------------------------------------------------------------------------
ETYPECASE [Macro]
ETYPECASE
Macro in LISP package:
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(s) of the last FORM. If not, signals an error.
-----------------------------------------------------------------------------
CTYPECASE [Macro]
CTYPECASE
Macro in LISP package:
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(s) of the last FORM. If not, signals a correctable error.
-----------------------------------------------------------------------------
TENTH [Function]
-----------------------------------------------------------------------------
TENTH [Setf]
Defined as: (DEFSETF TENTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR 9 X) Y) Y))
See the doc of DEFSETF. TENTH
Function in LISP package:
Args: (x)
Equivalent to (CADR (CDDDDR (CDDDDR X))).
-----------------------------------------------------------------------------
NINTH [Function]
-----------------------------------------------------------------------------
NINTH [Setf]
Defined as: (DEFSETF NINTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR 8 X) Y) Y))
See the doc of DEFSETF. NINTH
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDDDDR (CDDDDR X))).
-----------------------------------------------------------------------------
FIRST [Function]
-----------------------------------------------------------------------------
FIRST [Setf]
Defined as: (DEFSETF FIRST (X) (Y) (LIST 'PROGN (LIST 'RPLACA X Y) Y))
See the doc of DEFSETF. FIRST
Function in LISP package:
Args: (x)
Equivalent to (CAR X).
-----------------------------------------------------------------------------
ALPHANUMERICP [Function]
ALPHANUMERICP
Function in LISP package:
Args: (char)
Returns T if CHAR is either numeric or alphabetic; NIL otherwise.
-----------------------------------------------------------------------------
STRING-NOT-EQUAL [Function]
STRING-NOT-EQUAL
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING=, but ignores cases.
-----------------------------------------------------------------------------
MERGE [Function]
MERGE
Function in LISP package:
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.
-----------------------------------------------------------------------------
DIRECTORY-NAMESTRING [Function]
DIRECTORY-NAMESTRING
Function in LISP package:
Args: (pathname)
Returns the directory part of PATHNAME as a string.
-----------------------------------------------------------------------------
*PRINT-PRETTY* [Special variable]
*PRINT-PRETTY*
Variable in LISP package:
Whether the KCL printer should pretty-print. See the function doc of PPRINT
for more information about pretty-printing.
-----------------------------------------------------------------------------
*EVALHOOK* [Special variable]
*EVALHOOK*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
LEAST-NEGATIVE-LONG-FLOAT [Constant]
LEAST-NEGATIVE-LONG-FLOAT
Variable in LISP package:
The negative long-float closest in value to zero.
-----------------------------------------------------------------------------
LEAST-NEGATIVE-DOUBLE-FLOAT [Constant]
LEAST-NEGATIVE-DOUBLE-FLOAT
Variable in LISP package:
Same as LEAST-NEGATIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
LEAST-NEGATIVE-SINGLE-FLOAT [Constant]
LEAST-NEGATIVE-SINGLE-FLOAT
Variable in LISP package:
Same as LEAST-NEGATIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
LEAST-NEGATIVE-SHORT-FLOAT [Constant]
LEAST-NEGATIVE-SHORT-FLOAT
Variable in LISP package:
The negative short-float closest in value to zero.
-----------------------------------------------------------------------------
SOFTWARE-VERSION [Function]
Args: NIL SOFTWARE-VERSION
Function in LISP package:
Args: ()
Returns a string that identifies the software version of the software
under which KCL is currently running.
-----------------------------------------------------------------------------
FIND-PACKAGE [Function]
FIND-PACKAGE
Function in LISP package:
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.
-----------------------------------------------------------------------------
LOGBITP [Function]
LOGBITP
Function in LISP package:
Args: (index integer)
Returns T if the INDEX-th bit of INTEGER is 1.
-----------------------------------------------------------------------------
NSUBST-IF [Function]
NSUBST-IF
Function in LISP package:
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that satisfy TEST.
-----------------------------------------------------------------------------
CHAR-FONT [Function]
CHAR-FONT
Function in LISP package:
Args: (char)
Returns the font attribute of CHAR.
-----------------------------------------------------------------------------
NSUBST-IF-NOT [Function]
NSUBST-IF-NOT
Function in LISP package:
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that do not satisfy TEST.
-----------------------------------------------------------------------------
COPY-SEQ [Function]
COPY-SEQ
Function in LISP package:
Args: (sequence)
Returns a copy of SEQUENCE.
-----------------------------------------------------------------------------
NSET-EXCLUSIVE-OR [Function]
NSET-EXCLUSIVE-OR
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list with elements which appear but once in LIST1 and LIST2.
-----------------------------------------------------------------------------
CAADAR [Function]
-----------------------------------------------------------------------------
CAADAR [Setf]
Defined as: (DEFSETF CAADAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CADAR X) Y) Y))
See the doc of DEFSETF. CAADAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CDR (CAR X)))).
-----------------------------------------------------------------------------
COPY-SYMBOL [Function]
COPY-SYMBOL
Function in LISP package:
Args: (symbol &optional (copy-props nil))
Returns a new uninterned symbol with the same print name as SYMBOL.
If COPY-PROPS is NIL, the function, the variable, and the property slots
of the new symbol have no value. Otherwise, these slots are given the
values of the corresponding slots of SYMBOL.
-----------------------------------------------------------------------------
CDADAR [Function]
-----------------------------------------------------------------------------
CDADAR [Setf]
Defined as: (DEFSETF CDADAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CADAR X) Y) Y))
See the doc of DEFSETF. CDADAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CDR (CAR X)))).
-----------------------------------------------------------------------------
CHAR-EQUAL [Function]
CHAR-EQUAL
Function in LISP package:
Args: (char &rest more-chars)
Returns T if all of its arguments are the same character; NIL otherwise.
Upper case character and its lower case equivalent are regarded the same.
-----------------------------------------------------------------------------
RETURN [Special form and Macro]
RETURN
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
READ-PRESERVING-WHITESPACE [Function]
READ-PRESERVING-WHITESPACE
Function in LISP package:
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.
-----------------------------------------------------------------------------
DEFVAR [Macro]
DEFVAR
Macro in LISP package:
Syntax: (defvar name [initial-value [doc]])
Declares the variable NAME as a special variable and, optionally, initializes
it. The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be
retrieved by (documentation 'NAME 'variable).
-----------------------------------------------------------------------------
FINISH-OUTPUT [Function]
FINISH-OUTPUT
Function in LISP package:
Args: (&optional (stream *standard-output*))
Attempts to ensure that all output sent to STREAM has reached its destination,
and only then returns.
-----------------------------------------------------------------------------
PAIRLIS [Function]
PAIRLIS
Function in LISP package:
Args: (keys data &optional (alist nil))
Constructs an association list from KEYS and DATA adding to ALIST.
-----------------------------------------------------------------------------
CLINES [Macro]
CLINES
Macro in LISP package:
Syntax: (clines {string}*)
KCL specific: The KCL compiler embeds STRINGs into the intermediate C
language code. The interpreter ignores this form.
-----------------------------------------------------------------------------
ARRAY-IN-BOUNDS-P [Function]
ARRAY-IN-BOUNDS-P
Function in LISP package:
Args: (array
&rest subscripts) Returns T if SUBSCRIPTS are valid subscripts for
ARRAY; NIL otherwise.
-----------------------------------------------------------------------------
DECF [Special form and Macro]
DECF
Special Form in LISP package:
Syntax: (decf place [delta]) Subtracts the number
produced by DELTA (which defaults to 1) from the number in
PLACE.
-----------------------------------------------------------------------------
SUBST-IF [Function]
SUBST-IF
Function in LISP package:
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that satisfy TEST.
-----------------------------------------------------------------------------
WRITE-STRING [Function]
WRITE-STRING
Function in LISP package:
Args: (string &optional (stream *standard-output*)
&key (start 0) (end (length string)))
Outputs STRING and returns it.
-----------------------------------------------------------------------------
*READ-BASE* [Special variable]
*READ-BASE*
Variable in LISP package:
The radix that the KCL reader reads numbers in.
-----------------------------------------------------------------------------
*BREAK-ENABLE* [Special variable]
*BREAK-ENABLE*
Variable in LISP package:
KCL specific: When an error occurrs, control enters to the break loop only
if the value of this variable is non-NIL.
-----------------------------------------------------------------------------
NSTRING-CAPITALIZE [Function]
NSTRING-CAPITALIZE
Function in LISP package:
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.
-----------------------------------------------------------------------------
TREE-EQUAL [Function]
TREE-EQUAL
Function in LISP package:
Args: (x y &key (test #'eql) test-not)
Returns T if X and Y are isomorphic trees with identical leaves.
-----------------------------------------------------------------------------
*PRINT-LENGTH* [Special variable]
*PRINT-LENGTH*
Variable in LISP package:
How many elements the KCL printer should print at each level of nested data
object. Unlimited if NIL.
-----------------------------------------------------------------------------
YES-OR-NO-P [Function]
YES-OR-NO-P
Function in LISP package:
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.
-----------------------------------------------------------------------------
NUMERATOR [Function]
NUMERATOR
Function in LISP package:
Args: (rational)
Returns as an integer the numerator of the given rational number.
-----------------------------------------------------------------------------
PSETF [Macro]
PSETF
Macro in LISP package:
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.
-----------------------------------------------------------------------------
BIT-XOR [Function]
BIT-XOR
Function in LISP package:
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.
-----------------------------------------------------------------------------
TERPRI [Function]
TERPRI
Function in LISP package:
Args: (&optional (stream *standard-output*))
Outputs a newline character.
-----------------------------------------------------------------------------
SIMPLE-BIT-VECTOR-P [Function]
SIMPLE-BIT-VECTOR-P
Function in LISP package:
Args: (x)
Returns T if X is a simple bit-vector; NIL otherwise.
-----------------------------------------------------------------------------
TAGBODY [Special form]
TAGBODY
Special Form in LISP package:
Syntax: (tagbody {tag | statement}*)
Executes STATEMENTs and returns NIL if it falls off the end.
-----------------------------------------------------------------------------
ROOM [Function]
Args: (&OPTIONAL LISP::X) ROOM
Function in LISP package:
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.
-----------------------------------------------------------------------------
COMPILE-FILE [Function]
Args: (&REST COMPILER::ARGS &AUX (*PRINT-PRETTY* NIL)
(*PACKAGE* *PACKAGE*)
(COMPILER::*SPLIT-FILES* COMPILER::*SPLIT-FILES*)
(*PRINT-CIRCLE* NIL) (*PRINT-RADIX* NIL) (*PRINT-ARRAY* T)
(*PRINT-LEVEL* NIL) (*PRINT-PRETTY* T)
(*PRINT-LENGTH* NIL) (*PRINT-GENSYM* T)
(*PRINT-CASE* :UPCASE) (*PRINT-BASE* 10)
(*PRINT-ESCAPE* T)
(COMPILER::SECTION-LENGTH COMPILER::*SPLIT-FILES*)
COMPILER::TEM) COMPILE-FILE
Function in LISP package:
Args: (input-pathname
&key output-file (load nil) (message-file nil)
;GCL specific keywords:
system-p c-debug c-file h-file data-file)
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
COMPILER::*COMPILE-PRINT* forces the compiler to indicate the form currently
being compiled. More keyword parameters are accepted, depending on the
version. Most versions of GCL can receive :O-FILE, :C-FILE, :H-FILE, and
:DATA-FILE keyword parameters, with which you can control the intermediate
files generated by the GCL compiler. Also :C-DEBUG will pass the -g flag to
the C compiler.
By top level forms in a file, we mean the value of *top-level-forms* after
doing (TF form) for each form read from a file. We define TF as follows:
(defun TF (x)
(when (consp x)
(setq x (macroexpand x))
(when (consp x)
(cond ((member (car x) '(progn eval-when))
(mapcar 'tf (cdr x)))
(t (push x *top-level-forms*))))))
Among the common lisp special forms only DEFUN and DEFMACRO will cause actual
native machine code to be generated. The rest will be specially treated in an
init section of the .data file. This is done so that things like putprop,setq,
and many other forms would use up space which could not be usefully freed, if
we were to compile to native machine code. If you have other `ordinary' top
level forms which you need to have compiled fully to machine code you may
either set compiler::*COMPILE-ORDINARIES* to t, or put them inside a
(PROGN 'COMPILE ...forms-which-need-to-be-compiled)
The compiler will take each of them and make a temporary function which will be
compiled and invoked once. It is permissible to wrap a (PROGN 'COMPILE ..)
around the whole file. Currently this construction binds the
compiler::*COMPILE-ORDINARIES* flag to t. Setting this flag globally to a non
nil value to cause all top level forms to generate machine code. This might be
useful in a system such as PCL, where a number of top level lambda expressions
are given. Note that most common lisps will simply ignore the top level atom
'compile, since it has no side effects.
Defentry, clines, and defcfun also result in machine code being generated.
Evaluation at Compile time:
--------------------------
In GCL the eval-when behaviour was changed in order to allow
more efficient init code, and also to bring it into line with the resolution
passed by the X3j13 committee. Evaluation at compile time is controlled by
placing eval-when special forms in the code, or by the value of the variable
compiler::*eval-when-defaults* [default value :defaults]. If that variable
has value :defaults, then the following hold:
Eval at Compile Type of Top Level Form
Partial: defstructs, defvar, defparameter
Full: defmacro, defconstant, defsetf, define-setf-method,
deftype, package ops, proclaim
None: defun, others
By `partial' we mean (see the X3J13 Common Lisp document
(doc/compile-file-handling-of-top-level-forms) for more detail), that functions
will not be defined, values will not be set, but other miscellaneous compiler
properties will be set: eg properties to inline expand defstruct accessors and
testers, defstruct properties allowing subsequent defstructs to include this
one, any type hierarch information, special variable information will be set up.
Example:
(defun foo () 3)
(defstruct jo a b)
As a side effect of compiling these two forms, foo would not have its function
cell changed. Neither would jo-a, although it would gain a property which
allows it to expand inline to a structure access. Thus if it had a previous
definition (as commonly happens from previously loading the file), this previous
definition would not be touched, and could well be inconsistent with the
compiler properties. Unfortunately this is what the CL standard says to do,
and I am just trying to follow it.
If you prefer a more intuitive scheme, of evaling all forms in the file, so
that there are no inconsistencies, (previous behaviour of AKCL) you may set
compiler::*eval-when-defaults* to '(compile eval load).
The variable compiler::*FASD-DATA* [default t] controls whether an ascii output
is used for the data section of the object file. The data section will be in
ascii if *fasd-data* is nil or if the system-p keyword is supplied to
compile-file and *fasd-data* is not eq to :system-p.
The old GCL variable *compile-time-too* has disappeared.
See OPTIMIZE on how to enable warnings of slow constructs.
-----------------------------------------------------------------------------
IDENTITY [Function]
IDENTITY
Function in LISP package:
Args: (x)
Simply returns X.
-----------------------------------------------------------------------------
DIGIT-CHAR-P [Function]
DIGIT-CHAR-P
Function in LISP package:
Args: (char &optional (radix 10))
If CHAR represents a digit in RADIX, then returns the weight as an integer.
Otherwise, returns nil.
-----------------------------------------------------------------------------
SHIFTF [Macro]
SHIFTF
Macro in LISP package:
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.
-----------------------------------------------------------------------------
EVERY [Function]
EVERY
Function in LISP package:
Args: (predicate sequence &rest more-sequences)
Returns T if every elements of SEQUENCEs satisfy PREDICATE; NIL otherwise.
-----------------------------------------------------------------------------
PACKAGE-NICKNAMES [Function]
PACKAGE-NICKNAMES
Function in LISP package:
Args: (package)
Returns as a list the nickname strings for the specified PACKAGE.
-----------------------------------------------------------------------------
LABELS [Special form]
LABELS
Special Form in LISP package:
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 their definitions may include recursive references. See the doc
of DEFUN for the complete syntax of a lambda-list. Doc-strings for local
functions are simply ignored.
-----------------------------------------------------------------------------
CONS [Function]
CONS
Function in LISP package:
Args: (x y)
Returns a new cons whose car and cdr are X and Y, respectively.
-----------------------------------------------------------------------------
LDB-TEST [Function]
LDB-TEST
Function in LISP package:
Args: (bytespec integer)
Returns T if at least one of the bits in the specified bytes of INTEGER is 1;
NIL otherwise.
-----------------------------------------------------------------------------
AREF [Function]
-----------------------------------------------------------------------------
AREF [Setf]
Defined as: (DEFSETF AREF ASET)
See the doc of DEFSETF. AREF
Function in LISP package:
Args: (array &rest subscripts)
Returns the element of ARRAY specified by SUBSCRIPTS.
-----------------------------------------------------------------------------
DELETE-DUPLICATES [Function]
DELETE-DUPLICATES
Function in LISP package:
Args: (sequence &key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
Returns a sequence formed by removing duplicated elements destructively from
SEQUENCE.
-----------------------------------------------------------------------------
UNREAD-CHAR [Function]
UNREAD-CHAR
Function in LISP package:
Args: (character &optional (stream *standard-input*))
Puts CHARACTER back on the front of the input stream STREAM.
-----------------------------------------------------------------------------
FILE-LENGTH [Function]
FILE-LENGTH
Function in LISP package:
Args: (file-stream)
Returns the length of the specified file stream.
-----------------------------------------------------------------------------
ARRAY-TOTAL-SIZE [Function]
ARRAY-TOTAL-SIZE
Function in LISP package:
Args: (array)
Returns the total number of elements of ARRAY.
-----------------------------------------------------------------------------
LISP-IMPLEMENTATION-TYPE [Function]
Args: NIL LISP-IMPLEMENTATION-TYPE
Function in LISP package:
Args: ()
Returns a string that tells you that you are using a version of KCL.
-----------------------------------------------------------------------------
FIND [Function]
FIND
Function in LISP package:
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; NIL if no
such element exists.
-----------------------------------------------------------------------------
PSETQ [Special form and Macro]
PSETQ
Special Form in LISP package:
Syntax: (psetq {var form}*)
Similar to SETQ, but evaluates all FORMs first, and then assigns each value to
the corresponding VAR. Returns NIL always.
-----------------------------------------------------------------------------
GETHASH [Function]
-----------------------------------------------------------------------------
GETHASH [Setf]
Defined as: (DEFSETF GETHASH (K H &OPTIONAL D) (V)
(LIST 'HASH-SET K H V))
See the doc of DEFSETF. GETHASH
Function in LISP package:
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.
-----------------------------------------------------------------------------
MOST-NEGATIVE-LONG-FLOAT [Constant]
MOST-NEGATIVE-LONG-FLOAT
Variable in LISP package:
The long-float closest in value to negative infinity.
-----------------------------------------------------------------------------
MOST-NEGATIVE-DOUBLE-FLOAT [Constant]
MOST-NEGATIVE-DOUBLE-FLOAT
Variable in LISP package:
Same as MOST-NEGATIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
MOST-NEGATIVE-SINGLE-FLOAT [Constant]
MOST-NEGATIVE-SINGLE-FLOAT
Variable in LISP package:
Same as MOST-NEGATIVE-LONG-FLOAT.
-----------------------------------------------------------------------------
MOST-NEGATIVE-SHORT-FLOAT [Constant]
MOST-NEGATIVE-SHORT-FLOAT
Variable in LISP package:
The short-float closest in value to negative infinity.
-----------------------------------------------------------------------------
CAAR [Function]
-----------------------------------------------------------------------------
CAAR [Setf]
Defined as: (DEFSETF CAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CAR X) Y) Y))
See the doc of DEFSETF. CAAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR X)).
-----------------------------------------------------------------------------
MAPLIST [Function]
MAPLIST
Function in LISP package:
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs and returns the results as a list.
-----------------------------------------------------------------------------
THIRD [Function]
-----------------------------------------------------------------------------
THIRD [Setf]
Defined as: (DEFSETF THIRD (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDR X) Y) Y))
See the doc of DEFSETF. THIRD
Function in LISP package:
Args: (x)
Equivalent to (CADDR X).
-----------------------------------------------------------------------------
UNLESS [Special form and Macro]
UNLESS
Special Form in LISP package:
Syntax: (unless test {form}*)
If TEST evaluates to NIL, then evaluates FORMs as a PROGN. If not,
simply returns NIL.
-----------------------------------------------------------------------------
CDAAR [Function]
-----------------------------------------------------------------------------
CDAAR [Setf]
Defined as: (DEFSETF CDAAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CAAR X) Y) Y))
See the doc of DEFSETF. CDAAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CAR X))).
-----------------------------------------------------------------------------
AND [Special form and Macro]
AND
Special Form in LISP package:
Syntax: (and {form}*)
Evaluates FORMs in order from left to right. If any FORM evaluates to NIL,
returns immediately with the value NIL. Else, returns the value(s) of the
last FORM.
-----------------------------------------------------------------------------
COMPILE [Function]
Args: (COMPILER::NAME &OPTIONAL COMPILER::DEF &AUX COMPILER::TEM
COMPILER::GAZ (*DEFAULT-PATHNAME-DEFAULTS* #".")) COMPILE
Function in LISP package:
Args: (name &optional (definition 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.
-----------------------------------------------------------------------------
COND [Special form and Macro]
COND
Special Form
in LISP package: Syntax: (cond {(test {form}*)}*) Evaluates each
TEST in order until one evaluates to a non-NIL value. Then evaluates
the associated FORMs in order and returns the value(s) of the last
FORM. If no forms follow the TEST, then returns the value of the
TEST. Returns NIL, if all TESTs evaluate to NIL.
-----------------------------------------------------------------------------
PRINT [Function]
PRINT
Function in LISP package:
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 OBJECT :STREAM STREAM :ESCAPE T)).
-----------------------------------------------------------------------------
LOGCOUNT [Function]
LOGCOUNT
Function in LISP package:
Args: (integer)
If INTEGER is negative, returns the number of 0 bits. Otherwise, returns
the number of 1 bits.
-----------------------------------------------------------------------------
REMOVE-DUPLICATES [Function]
REMOVE-DUPLICATES
Function in LISP package:
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.
-----------------------------------------------------------------------------
PATHNAME-DIRECTORY [Function]
PATHNAME-DIRECTORY
Function in LISP package:
Args: (pathname)
Returns the directory slot of PATHNAME.
-----------------------------------------------------------------------------
DEFPARAMETER [Macro]
DEFPARAMETER
Macro in LISP package:
Syntax: (defparameter name initial-value [doc])
Declares the variable NAME as a special variable and initializes the value.
The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be
retrieved by (documentation 'NAME 'variable).
-----------------------------------------------------------------------------
STRING/= [Function]
STRING/=
Function in LISP package:
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]
STRING>=
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
If STRING1 is lexicographically greater than or equal to STRING2, then returns
the longest common prefix of the strings. Otherwise, returns NIL.
-----------------------------------------------------------------------------
STRING<= [Function]
STRING<=
Function in LISP package:
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.
-----------------------------------------------------------------------------
*READTABLE* [Special variable]
*READTABLE*
Variable in LISP package:
The current readtable.
-----------------------------------------------------------------------------
SIGNED-BYTE [Type]
Defined as: (DEFTYPE SIGNED-BYTE (&OPTIONAL (S '*))
(IF (EQ S '*) '(INTEGER * *)
(LIST 'INTEGER (- (EXPT 2 (1- S)))
(1- (EXPT 2 (1- S))))))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
SUBSTITUTE-IF-NOT [Function]
SUBSTITUTE-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
MAKE-SYMBOL [Function]
MAKE-SYMBOL
Function in LISP package:
Args: (string)
Creates and returns a new uninterned symbol whose print name is STRING.
-----------------------------------------------------------------------------
SIMPLE-VECTOR [Type]
Defined as: (DEFTYPE SIMPLE-VECTOR (&OPTIONAL (SIZE '*))
(LIST 'SIMPLE-ARRAY T (LIST SIZE)))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
HELP* [Function]
Args: (STRING &OPTIONAL (PACKAGE (FIND-PACKAGE "LISP"))) HELP*
Function in LISP package:
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.
-----------------------------------------------------------------------------
BIT-NOR [Function]
BIT-NOR
Function in LISP package:
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.
-----------------------------------------------------------------------------
COMPLEXP [Function]
COMPLEXP
Function in LISP package:
Args: (x)
Returns T if X is a complex number; NIL otherwise.
-----------------------------------------------------------------------------
LIST-LENGTH [Function]
LIST-LENGTH
Function in LISP package:
Args: (list)
Returns the length of LIST, or NIL if LIST is circular.
-----------------------------------------------------------------------------
GET-UNIVERSAL-TIME [Function]
GET-UNIVERSAL-TIME
Function in LISP package:
Args: ()
Returns the current time as a single integer in universal time format.
-----------------------------------------------------------------------------
NAME-CHAR [Function]
NAME-CHAR
Function in LISP package:
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.
-----------------------------------------------------------------------------
MAKE-CHAR [Function]
MAKE-CHAR
Function in LISP package:
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.
-----------------------------------------------------------------------------
NSUBST [Function]
NSUBST
Function in LISP package:
Args: (new old tree &key (test #'eql) test-not (key #'identity))
Substitutes NEW for subtrees in TREE that match OLD.
-----------------------------------------------------------------------------
ATAN [Function]
ATAN
Function in LISP package:
Args: (x &optional (y 1)) Returns the arc tangent of
X/Y.
-----------------------------------------------------------------------------
EXPORT [Function]
EXPORT
Function in LISP package:
Args: (symbols &optional (package *package*))
Makes SYMBOLS external symbols of PACKAGE. SYMBOLS must be a list of symbols
or a symbol.
-----------------------------------------------------------------------------
NRECONC [Function]
NRECONC
Function in LISP package:
Args: (x y)
Equivalent to (NCONC (NREVERSE X) Y).
-----------------------------------------------------------------------------
EQUALP [Function]
EQUALP
Function in LISP package:
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.
-----------------------------------------------------------------------------
STRING-EQUAL [Function]
STRING-EQUAL
Function in LISP package:
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).
-----------------------------------------------------------------------------
PEEK-CHAR [Function]
PEEK-CHAR
Function in LISP package:
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.
-----------------------------------------------------------------------------
READ-CHAR [Function]
READ-CHAR
Function in LISP package:
Args: (&optional (stream *standard-input*) (eof-error-p t)
(eof-value nil) (recursive-p nil))
Reads a character from STREAM.
-----------------------------------------------------------------------------
ASSOC-IF-NOT [Function]
ASSOC-IF-NOT
Function in LISP package:
Args: (test alist)
Returns the first pair in ALIST whose car does not satisfy TEST.
-----------------------------------------------------------------------------
CAR [Function]
-----------------------------------------------------------------------------
CAR [Setf]
Defined as: (DEFSETF CAR (X) (Y) (LIST 'PROGN (LIST 'RPLACA X Y) Y))
See the doc of DEFSETF. CAR
Function in LISP package:
Args: (list)
Returns the car of LIST. Returns NIL if LIST is NIL.
-----------------------------------------------------------------------------
ZEROP [Function]
ZEROP
Function in LISP package: Args: (number) Returns T if NUMBER = 0; NIL
otherwise.
-----------------------------------------------------------------------------
CHAR-UPCASE [Function]
CHAR-UPCASE
Function in LISP package:
Args: (char)
Returns the upper-case equivalent of CHAR, if any.
If not, simply returns CHAR.
-----------------------------------------------------------------------------
MOST-NEGATIVE-FIXNUM [Constant]
MOST-NEGATIVE-FIXNUM
Variable in LISP package:
The fixnum closest in value to negative infinity.
-----------------------------------------------------------------------------
SEVENTH [Function]
-----------------------------------------------------------------------------
SEVENTH [Setf]
Defined as: (DEFSETF SEVENTH (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR 6 X) Y) Y))
See the doc of DEFSETF. SEVENTH
Function in LISP package:
Args: (x)
Equivalent to (CADDR (CDDDDR X)).
-----------------------------------------------------------------------------
INTEGERP [Function]
INTEGERP
Function in LISP package:
Args: (x)
Returns T if X is an integer (fixnum or bignum); NIL otherwise.
-----------------------------------------------------------------------------
RASSOC [Function]
RASSOC
Function in LISP package:
Args: (item alist &key (test #'eql) test-not (key #'identity))
Returns the first cons in ALIST whose cdr is equal to ITEM.
-----------------------------------------------------------------------------
BOOLE-NAND [Constant]
BOOLE-NAND
Variable in LISP package:
Makes BOOLE return LOGNAND of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
MEMBER-IF-NOT [Function]
MEMBER-IF-NOT
Function in LISP package:
Args: (test list &key (key #'identity))
Returns the tail of LIST beginning with the first element not satisfying
TEST.
-----------------------------------------------------------------------------
PROGN [Special form]
PROGN
Special Form in LISP package:
Syntax: (progn {form}*)
Evaluates FORMs in order, and returns whatever the last FORM returns.
-----------------------------------------------------------------------------
ROUND [Function]
ROUND
Function in LISP package:
Args: (number &optional (divisor 1))
Rounds NUMBER/DIVISOR to nearest integer. The second returned value is the
remainder.
-----------------------------------------------------------------------------
TAN [Function]
TAN
Function in LISP package:
Args: (radians)
Returns the tangent of RADIANS.
-----------------------------------------------------------------------------
DELETE-IF-NOT [Function]
DELETE-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
LOGNAND [Function]
LOGNAND
Function in LISP package:
Args: (integer1 integer2)
Returns the complement of the logical AND of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
WHEN [Special form and Macro]
WHEN
Special Form in LISP package:
Syntax: (when test {form}*)
If TEST evaluates to non-NIL, then evaluates FORMs as a PROGN. If not,
simply returns NIL.
-----------------------------------------------------------------------------
LENGTH [Function]
LENGTH
Function in LISP package:
Args: (sequence)
Returns the length of SEQUENCE.
-----------------------------------------------------------------------------
CODE-CHAR [Function]
CODE-CHAR
Function in LISP package:
Args: (code &optional (bits 0) (font 0))
Returns a character object with the specified code, if any.
If not, returns NIL.
-----------------------------------------------------------------------------
HELP [Function]
Args: (&OPTIONAL (SYMBOL NIL LISP::S)) HELP
Function in LISP package:
Args: (&optional symbol)
GCL specific: Prints the documentation associated with SYMBOL. With no
argument, this function prints the greeting message to GCL beginners.
-----------------------------------------------------------------------------
ISQRT [Function]
ISQRT
Function in LISP package:
Args: (integer)
Returns the greatest integer less than or equal to the square root of the
given non-negative integer.
-----------------------------------------------------------------------------
++ [Special variable]
++
Variable in LISP package:
Gets the previous value of + when KCL evaluates a top-level form.
-----------------------------------------------------------------------------
MIN [Function]
MIN
Function in LISP package:
Args: (number &rest more-numbers)
Returns the least of its arguments.
-----------------------------------------------------------------------------
OPEN [Function]
OPEN
Function in LISP package:
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.
DIRECTION is :INPUT, :OUTPUT, :IO or :PROBE.
ELEMENT-TYPE is STRING-CHAR, (UNSIGNED-BYTE n),
UNSIGNED-BYTE, (SIGNED-BYTE n), SIGNED-BYTE, CHARACTER, BIT, (MOD n), or
:DEFAULT.
IF-EXISTS is :ERROR, :NEW-VERSION, :RENAME,
:RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE, or NIL.
IF-DOES-NOT-EXIST is :ERROR, :CREATE, or NIL.
-----------------------------------------------------------------------------
FIND-IF [Function]
FIND-IF
Function in LISP package:
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.
-----------------------------------------------------------------------------
BIT-ANDC2 [Function]
BIT-ANDC2
Function in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE-AND [Constant]
BOOLE-AND
Variable in LISP package:
Makes BOOLE return LOGAND of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
PPRINT [Function]
PPRINT
Function in LISP package:
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.
-----------------------------------------------------------------------------
CADDAR [Function]
-----------------------------------------------------------------------------
CADDAR [Setf]
Defined as: (DEFSETF CADDAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDAR X) Y) Y))
See the doc of DEFSETF. CADDAR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CDR (CAR X)))).
-----------------------------------------------------------------------------
LOGEQV [Function]
LOGEQV
Function in LISP package:
Args: (&rest integers)
Returns the bit-wise EQUIVALENCE of its arguments.
-----------------------------------------------------------------------------
NTH [Function]
-----------------------------------------------------------------------------
NTH [Setf]
Defined as: (DEFSETF NTH (N L) (V)
(LIST 'PROGN (LIST 'RPLACA (LIST 'NTHCDR N L) V) V))
See the doc of DEFSETF. NTH
Function in LISP package:
Args: (n list)
Returns the N-th element of LIST, where the car of LIST is the zeroth
element.
-----------------------------------------------------------------------------
DEFSETF [Macro]
DEFSETF
Macro in LISP package:
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.
-----------------------------------------------------------------------------
UNSIGNED-CHAR [Type]
Defined as: (DEFTYPE UNSIGNED-CHAR () (LIST 'UNSIGNED-BYTE CHAR-SIZE))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
REMOVE-IF-NOT [Function]
REMOVE-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
EQUAL [Function]
EQUAL
Function in LISP package:
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.
-----------------------------------------------------------------------------
CDDDAR [Function]
-----------------------------------------------------------------------------
CDDDAR [Setf]
Defined as: (DEFSETF CDDDAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDDAR X) Y) Y))
See the doc of DEFSETF. CDDDAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CDR (CAR X)))).
-----------------------------------------------------------------------------
SIN [Function]
SIN
Function in LISP package:
Args: (radians)
Returns the sine of RADIANS.
-----------------------------------------------------------------------------
1+ [Function]
1+
Function in LISP package:
Args: (number)
Returns NUMBER + 1.
-----------------------------------------------------------------------------
DECODE-UNIVERSAL-TIME [Function]
DECODE-UNIVERSAL-TIME
Function in LISP package:
Args: (universal-time &optional (timezone -9))
Converts UNIVERSAL-TIME into a decoded time at the TIMEZONE.
Returns nine values: second, minute, hour, date, month (1 - 12), year,
day-of-week (0 - 6), daylight-saving-time-p, and time-zone.
TIMEZONE in KCL defaults to -9, the time zone of Japan.
-----------------------------------------------------------------------------
GENSYM [Function]
GENSYM
Function in LISP package:
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.
-----------------------------------------------------------------------------
1- [Function]
1-
Function in LISP package:
Args: (number)
Returns NUMBER - 1.
-----------------------------------------------------------------------------
// [Special variable]
//
Variable in LISP package:
Gets the previous value of / when KCL evaluates a top-level form.
-----------------------------------------------------------------------------
ELT [Function]
-----------------------------------------------------------------------------
ELT [Setf]
Defined as: (DEFSETF ELT ELT-SET)
See the doc of DEFSETF. ELT
Function in LISP package:
Args: (sequence index)
Returns the INDEX-th element of SEQUENCE.
-----------------------------------------------------------------------------
LAMBDA-LIST-KEYWORDS [Constant]
LAMBDA-LIST-KEYWORDS
Variable in LISP package:
List of all the lambda-list keywords used in GCL.
-----------------------------------------------------------------------------
NTHCDR [Function]
NTHCDR
Function in LISP package:
Args: (n list)
Returns the result of performing the CDR operation N times on LIST.
-----------------------------------------------------------------------------
USE-FAST-LINKS [Function]
USE-FAST-LINKS
Function in LISP package:
Args: (turn-on)
GCL specific: If TURN-ON is not nil, the fast link mechanism is enabled,
so that ordinary function calls will not appear in the invocation stack,
and calls will be much faster. This is the default. If you anticipate
needing to see a stack trace in the debugger, then you should turn this
off.
-----------------------------------------------------------------------------
*READ-SUPPRESS* [Special variable]
*READ-SUPPRESS*
Variable in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE-ANDC1 [Constant]
BOOLE-ANDC1
Variable in LISP package: Makes BOOLE return
LOGANDC1 of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
DELETE [Function]
DELETE
Function in LISP package:
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 removing the specified ITEM destructively from
SEQUENCE.
-----------------------------------------------------------------------------
EXP [Function]
EXP
Function in LISP package:
Args: (number)
Calculates e raised to the power NUMBER, where e is the base of natural
logarithms.
-----------------------------------------------------------------------------
LET* [Special form]
LET*
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
SHADOW [Function]
SHADOW
Function in LISP package:
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.
-----------------------------------------------------------------------------
SYMBOL-FUNCTION [Function]
-----------------------------------------------------------------------------
SYMBOL-FUNCTION [Setf]
Defined as: (DEFSETF SYMBOL-FUNCTION FSET)
See the doc of DEFSETF. SYMBOL-FUNCTION
Function in LISP package:
Args: (symbol)
Returns the current global function definition named by SYMBOL.
-----------------------------------------------------------------------------
*STANDARD-INPUT* [Special variable]
*STANDARD-INPUT*
Variable in LISP package:
The default input stream used by the KCL reader.
-----------------------------------------------------------------------------
FLOAT-SIGN [Function]
FLOAT-SIGN
Function in LISP package:
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.
-----------------------------------------------------------------------------
DOCUMENTATION [Function]
-----------------------------------------------------------------------------
DOCUMENTATION [Setf]
Defined as: (DEFSETF DOCUMENTATION (S D) (V)
(LIST 'CASE D
(LIST 'VARIABLE
(LIST 'PUTPROP S V ''VARIABLE-DOCUMENTATION))
(LIST 'FUNCTION
(LIST 'PUTPROP S V ''FUNCTION-DOCUMENTATION))
(LIST 'STRUCTURE
(LIST 'PUTPROP S V ''STRUCTURE-DOCUMENTATION))
(LIST 'TYPE
(LIST 'PUTPROP S V ''TYPE-DOCUMENTATION))
(LIST 'SETF
(LIST 'PUTPROP S V ''SETF-DOCUMENTATION))
(LIST T
(LIST 'ERROR
"~S is an illegal documentation type."
D))))
See the doc of DEFSETF. DOCUMENTATION
Function in LISP package:
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.
-----------------------------------------------------------------------------
MACHINE-VERSION [Function]
Args: NIL MACHINE-VERSION
Function in LISP package:
Args: ()
Returns a string that identifies the machine version of the machine
on which GCL is currently running.
-----------------------------------------------------------------------------
WITH-OPEN-FILE [Macro]
WITH-OPEN-FILE
Macro in LISP package:
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.
-----------------------------------------------------------------------------
RPLACA [Function]
RPLACA
Function in LISP package:
Args: (x y)
Replaces the car of X with Y, and returns the modified X.
-----------------------------------------------------------------------------
BOOLE-IOR [Constant]
BOOLE-IOR
Variable in LISP package:
Makes BOOLE return LOGIOR of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
TRACE [Macro]
TRACE
Macro in LISP package:
Syntax: (trace {function-name}*)
Traces the specified functions. With no FUNCTION-NAMEs, returns a list of
functions currently being traced.
Additional Keywords are allowed in GCL with the
syntax (trace {fn | (fn {:kw form}*)}*)
For each FN naming a function, traces that function. Each :KW should
be one of the ones listed below, and FORM should have the
corresponding form. No :KW may be given more than once for the same
FN. Returns a list of all FNs now traced which weren't already
traced.
EXAMPLE (Try this with your favorite factorial function FACT):
;; print entry args and exit values
(trace FACT)
;; Break coming out of FACT if the value is bigger than 1000.
(trace (fact :exit
(progn
(if (> (car values) 1000)(break "big result"))
(car values))))
;; Hairy example:
;;make arglist available without the si:: prefix
(import 'si::arglist)
(trace (fact
:DECLARATIONS
((in-string "Here comes input: ")
(out-string "Here comes output: ")
all-values
(silly (+ 3 4)))
:COND
(equal (rem (car arglist) 2) 0)
:ENTRY
(progn
(cond
((equal (car arglist) 8)
(princ "Entering FACT on input 8!! ")
(setq out-string "Here comes output from inside (FACT 8): "))
(t
(princ in-string)))
(car arglist))
:EXIT
(progn
(setq all-values (cons (car values) all-values))
(princ out-string)
(when (equal (car arglist) 8)
;; reset out-string
(setq out-string "Here comes output: "))
(cons 'fact values))
:ENTRYCOND
(not (= (car arglist) 6))
:EXITCOND
(not (= (car values) (* 6 (car arglist))))
:DEPTH
5))
:KW FORM
:DECLARATIONS DEFAULT: NIL
FORM is ((var form ) ... (var form )), where
1 1 n n
the var are symbols distinct from each other and from
i
all symbols which are similarly declared for currently
traced functions. Each form is evaluated immediately.
i
Upon any invocation of a traced function when not already
inside a traced function call, each var is bound to
i
that value of form .
i
:COND DEFAULT: T
Here, FORM is any Lisp form to be evaluated (by EVAL)
upon entering a call of FN, in the environment where si::ARGLIST
is bound to the current list of arguments of FN. Note that
even if the evaluation of FORM changes the value of SI::ARGLIST
(e.g. by evaluation of (SETQ si::ARGLIST ...)), the list of
arguments passed to FN is unchanged. Users may alter args passed
by destructively modifying the list structure of SI::ARGLIST
however. The call is traced
(thus invoking the :ENTRYCOND and :EXITCOND forms, at least)
if and only if FORM does not evaluate to NIL.
:ENTRYCOND DEFAULT: T
This is evaluated (by EVAL) if the :COND form evaluates to
non-NIL, both in an environment where SI::ARGLIST is bound to the
current list of arguments of FN. If non-NIL, the :ENTRY form
is then evaluated and printed with the trace "prompt".
:ENTRY DEFAULT: (CONS (QUOTE x) SI::ARGLIST),
where x is the symbol we call FN
If the :COND and :ENTRYCOND forms evaluate to non-NIL,
then the trace "prompt" is printed and then this FORM is
evaluated (by EVAL) in an environment where SI::ARGLIST is bound
to the current list of arguments of FN. The result is then
printed.
:EXITCOND DEFAULT: T
This is evaluated (by EVAL) in the environment described
below for the :EXIT form. The :EXIT form is then evaluated
and printed with the "prompt" if and only if the result here
is non-NIL.
:EXIT DEFAULT: (CONS (QUOTE x) VALUES),
where x is the symbol we call FN
Upon exit from tracing a given call, this FORM is
evaluated (after the appropriate trace "prompt" is printed),
using EVAL in an environment where SI::ARGLIST is bound to the
current list of arguments of FN and VALUES is bound to the
list of values returned by FN (recalling that Common Lisp
functions may return multiple values).
:DEPTH DEFAULT: No depth limit
FORM is simply a positive integer specifying the maximum
nesting of traced calls of FN, i.e. of calls of FN in which
the :COND form evaluated to non-NIL. For calls of FN in
which this limit is exceeded, even the :COND form is not
evaluated, and the call is not traced.
-----------------------------------------------------------------------------
/= [Function]
/=
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if no two of its arguments are numerically equal; NIL otherwise.
-----------------------------------------------------------------------------
MACROEXPAND [Function]
MACROEXPAND
Function in LISP package:
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.
-----------------------------------------------------------------------------
DEFLA [Macro]
DEFLA
Macro in LISP package:
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.
-----------------------------------------------------------------------------
SYMBOL-NAME [Function]
SYMBOL-NAME
Function in LISP package: Args: (symbol) Returns
the print name of the symbol SYMBOL.
-----------------------------------------------------------------------------
IMAGPART [Function]
IMAGPART
Function in LISP package:
Args: (number)
Extracts the imaginary part of NUMBER.
-----------------------------------------------------------------------------
DO-SYMBOLS [Macro]
DO-SYMBOLS
Macro in LISP package:
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(s).
-----------------------------------------------------------------------------
DEFTYPE [Macro]
DEFTYPE
Macro in LISP package:
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).
-----------------------------------------------------------------------------
DEFCONSTANT [Macro]
DEFCONSTANT
Macro in LISP package:
Syntax: (defconstant name initial-value [doc])
Declares that the variable NAME is a constant whose value is the value of
INITIAL-VALUE. The doc-string DOC, if supplied, is saved as a VARIABLE doc
and can be retrieved by (documentation 'NAME 'variable).
-----------------------------------------------------------------------------
HASH-TABLE-COUNT [Function]
HASH-TABLE-COUNT
Function in LISP package:
Args: (hash-table)
Returns the number of entries in the given Hash-Table.
-----------------------------------------------------------------------------
FFLOOR [Function]
FFLOOR
Function in LISP package:
Args: (number &optional (divisor 1))
Same as FLOOR, but returns a float as the first value.
-----------------------------------------------------------------------------
POSITION [Function]
POSITION
Function in LISP package:
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.
-----------------------------------------------------------------------------
NUNION [Function]
NUNION
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the union of LIST1 and LIST2. LIST1 and/or LIST2 may be destroyed.
-----------------------------------------------------------------------------
LOGNOR [Function]
LOGNOR
Function in LISP package:
Args: (integer1 integer2)
Returns the complement of the logical OR of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
SIMPLE-BIT-VECTOR [Type]
Defined as: (DEFTYPE SIMPLE-BIT-VECTOR (&OPTIONAL (SIZE '*))
(LIST 'SIMPLE-ARRAY 'BIT (LIST SIZE)))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
CONSTANTP [Function]
CONSTANTP
Function in LISP package:
Args: (symbol)
Returns T if the variable named by SYMBOL is a constant; NIL otherwise.
-----------------------------------------------------------------------------
BIT-NOT [Function]
BIT-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
<= [Function]
<=
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if arguments are in strictly non-decreasing order; NIL otherwise.
-----------------------------------------------------------------------------
DEFMACRO [Special form and Macro]
DEFMACRO
Special Form in LISP package:
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 ...) is equivalent to
(DEFMACRO (&REST ) ...).
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.
-----------------------------------------------------------------------------
DEFINE-MODIFY-MACRO [Macro]
DEFINE-MODIFY-MACRO
Macro in LISP package:
Syntax: (define-modify-macro name lambda-list fun [doc])
Defines a read-modify-write macro, like PUSH and 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 FUNCTION doc and can be
retrieved by (documentation 'NAME 'function).
-----------------------------------------------------------------------------
TRUENAME [Function]
TRUENAME
Function in LISP package:
Ar
gs: (pathname)
Returns the pathname for the actual file described by PATHNAME.
-----------------------------------------------------------------------------
RANDOM-STATE-P [Function]
RANDOM-STATE-P
Function in LISP package:
Args: (x)
Returns T if X is a random-state object; NIL otherwise.
-----------------------------------------------------------------------------
>= [Function]
>=
Function in LISP package:
Args: (number &rest more-numbers)
Returns T if arguments are in strictly non-increasing order; NIL otherwise.
-----------------------------------------------------------------------------
CATCH [Special form]
CATCH
Special Form
in LISP package: Syntax: (catch tag {form}*) Sets up a catcher with
that value TAG. Then evaluates FORMs as a PROGN, but may possibly
abort the evaluation by a THROW form that specifies the value EQ to
the catcher tag.
-----------------------------------------------------------------------------
REVAPPEND [Function]
REVAPPEND
Function in LISP package:
Args: (x y)
Equivalent to (APPEND (REVERSE X) Y)
-----------------------------------------------------------------------------
EXPT [Function]
EXPT
Function in LISP package:
Args: (base-number power-number)
Returns BASE-NUMBER raised to the power POWER-NUMBER.
-----------------------------------------------------------------------------
SXHASH [Function]
SXHASH
Function in LISP package:
Args: (object)
Computes a hash code for OBJECT and returns it as an integer.
-----------------------------------------------------------------------------
CADDR [Function]
-----------------------------------------------------------------------------
CADDR [Setf]
Defined as: (DEFSETF CADDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDDR X) Y) Y))
See the doc of DEFSETF. CADDR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR (CDR X))).
-----------------------------------------------------------------------------
SORT [Function]
SORT
Function in LISP package:
Args: (sequence predicate &key (key #'identity)) Destructively sorts SEQUENCE.
PREDICATE should return non-NIL if its first argument is to precede
its second argument.
-----------------------------------------------------------------------------
ALPHA-CHAR-P [Function]
ALPHA-CHAR-P
Function in LISP package:
Args: (char)
Returns T if CHAR is an alphabetic character, A-Z or a-z; NIL otherwise.
-----------------------------------------------------------------------------
COPY-READTABLE [Function]
COPY-READTABLE
Function in LISP package:
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 new readtable.
-----------------------------------------------------------------------------
SAVE [Function]
SAVE
Function in LISP package:
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.
-----------------------------------------------------------------------------
SUBST-IF-NOT [Function]
SUBST-IF-NOT
Function in LISP package:
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that do not satisfy TEST.
-----------------------------------------------------------------------------
STRING-DOWNCASE [Function]
STRING-DOWNCASE
Function in LISP package:
Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all upper case characters converted to
lowercase.
-----------------------------------------------------------------------------
STRING-UPCASE [Function]
STRING-UPCASE
Function in LISP package:
Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all lower case characters converted to
uppercase.
-----------------------------------------------------------------------------
GET-DISPATCH-MACRO-CHARACTER [Function]
GET-DISPATCH-MACRO-CHARACTER
Function in LISP package:
Args: (disp-char sub-char &optional (readtable *readtable*))
Returns the macro-character function for SUB-CHAR under DISP-CHAR.
-----------------------------------------------------------------------------
SET-DISPATCH-MACRO-CHARACTER [Function]
SET-DISPATCH-MACRO-CHARACTER
Function in LISP package:
Args: (disp-char sub-char function &optional (readtable *readtable*))
Causes FUNCTION to be called when the DISP-CHAR followed by SUB-CHAR is
read.
-----------------------------------------------------------------------------
IN-PACKAGE [Function]
IN-PACKAGE
Function in LISP package:
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.
-----------------------------------------------------------------------------
SQRT [Function]
SQRT
Function in LISP package:
Args: (number)
Returns the principal square root of NUMBER.
-----------------------------------------------------------------------------
LOGXOR [Function]
LOGXOR
Function in LISP package:
Args: (&rest integers)
Returns the bit-wise EXCLUSIVE OR of its arguments.
-----------------------------------------------------------------------------
DOUBLE-FLOAT-NEGATIVE-EPSILON [Constant]
DOUBLE-FLOAT-NEGATIVE-EPSILON
Variable in LISP package:
Same as LONG-FLOAT-NEGATIVE-EPSILON.
-----------------------------------------------------------------------------
DOUBLE-FLOAT-EPSILON [Constant]
DOUBLE-FLOAT-EPSILON
Variable in LISP package:
Same as LONG-FLOAT-EPSILON.
-----------------------------------------------------------------------------
RATIONALP [Function]
RATIONALP
Function in LISP package:
Args: (x)
Returns T if X is an integer or a ratio; NIL otherwise.
-----------------------------------------------------------------------------
*DEBUG-IO* [Special variable]
*DEBUG-IO*
Variable in LISP package:
Holds the I/O stream used by the KCL debugger.
-----------------------------------------------------------------------------
STRING-RIGHT-TRIM [Function]
STRING-RIGHT-TRIM
Function in LISP package:
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
right end.
-----------------------------------------------------------------------------
PROBE-FILE [Function]
PROBE-FILE
Function in LISP package:
Args: (file)
Returns the truename of file if the file exists.
Returns NIL otherwise.
-----------------------------------------------------------------------------
CHAR< [Function]
CHAR<
Function in LISP
package: Args: (char &rest more-chars) Returns T if the codes of CHARs
are in strictly increasing order; NIL otherwise.
-----------------------------------------------------------------------------
DEFCFUN [Macro]
DEFCFUN
Macro in LISP package:
Syntax: (defcfun header n {element}*)
GCL 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. Non-negative-integer 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 GCL
interpreter simply ignores this form.
An example which defines a C function list2 of two arguments, but which
calls the 'lisp' function CONS by name, and refers to the constant 'NIL.
(defCfun "object list2(x,y) object x,y;" 0
"object z;"
('NIL z)
((CONS y z) z)
((CONS x z) z)
"return(z);"
)
In lisp the operations in the body would be
(setq z 'nil)
(setq z (cons y z))
(setq z (cons x z))
Syntax: defCfun-form:
(defCfun header non-negative-integer
{ string
| ( function-symbol { value }* )
| (( function-symbol { value }* ) { place }* ) } )
value:
place:
{ C-expr | ( C-type C-expr ) }
C-function-name:
C-expr:
{ string | symbol }
C-type:
{ object | int | char | float | double }
-----------------------------------------------------------------------------
PHASE [Function]
PHASE
Function in LISP package:
Args: (number)
Returns the angle part of the polar representation of a complex number.
For non-complex numbers, this is 0.
-----------------------------------------------------------------------------
THROW [Special form]
THROW
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
CALL-ARGUMENTS-LIMIT [Constant]
CALL-ARGUMENTS-LIMIT
Variable in LISP package:
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.
-----------------------------------------------------------------------------
BLOCK [Special form]
BLOCK
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
NSTRING-UPCASE [Function]
NSTRING-UPCASE
Function in LISP package:
Args: (string &key (start 0) (end (length string)))
Returns STRING with all lower case characters converted to uppercase.
-----------------------------------------------------------------------------
READ [Function]
READ
Function in LISP package:
Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil)
(recursivep nil))
Reads in the next object from STREAM.
-----------------------------------------------------------------------------
SHORT-SITE-NAME [Function]
Args: NIL SHORT-SITE-NAME
Function in LISP package:
Args: ()
Returns a string that identifies the physical location of the current KCL.
-----------------------------------------------------------------------------
MACRO-FUNCTION [Function]
-----------------------------------------------------------------------------
MACRO-FUNCTION [Setf]
Defined as: (DEFSETF MACRO-FUNCTION (S) (V)
(LIST 'PROGN (LIST 'FSET S (LIST 'CONS ''MACRO V)) V))
See the doc of DEFSETF. MACRO-FUNCTION
Function in LISP package:
Args: (symbol)
If SYMBOL globally names a macro, then returns the expansion function.
Returns NIL otherwise.
-----------------------------------------------------------------------------
CHAR-INT [Function]
CHAR-INT
Function in LISP package:
Args: (char)
Returns the font, bits, and code attributes as a single non-negative integer.
Equivalent to CHAR-CODE in GCL.
-----------------------------------------------------------------------------
VECTOR-PUSH-EXTEND [Function]
VECTOR-PUSH-EXTEND
Function in LISP package:
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.
-----------------------------------------------------------------------------
FILE-POSITION [Function]
FILE-POSITION
Function in LISP package:
Args: (file-stream &optional position)
Sets the file pointer of the specified file to POSITION, if POSITION is given.
Otherwise, returns the current file position of the specified file.
-----------------------------------------------------------------------------
SET-EXCLUSIVE-OR [Function]
SET-EXCLUSIVE-OR
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list of elements appearing exactly once in LIST1 and LIST2.
-----------------------------------------------------------------------------
DIRECTORY [Function]
DIRECTORY
Function in LISP package:
Args: (name)
Returns a list of files that match NAME. NAME may be a string, a pathname,
or a file stream.
-----------------------------------------------------------------------------
DEPOSIT-FIELD [Function]
DEPOSIT-FIELD
Function in LISP package:
Args: (newbyte bytespec integer)
Returns an integer computed by replacing the specified byte of INTEGER with
the specified byte of NEWBYTE.
-----------------------------------------------------------------------------
BYTE-POSITION [Function]
BYTE-POSITION
Function in LISP package:
Args: (bytespec)
Returns the position part (in KCL, the cdr part) of the byte specifier.
-----------------------------------------------------------------------------
DO [Special form and Macro]
DO
Special Form in LISP package:
Syntax: (do ({(var [init [step]])}*) (endtest {result}*)
{decl}* {tag | statement}*)
Creates a NIL block, binds each VAR to the value of the corresponding INIT,
and then executes STATEMENTs repeatedly until ENDTEST is satisfied. After
each iteration, assigns to each VAR the value of the corresponding STEP. When
ENDTEST is satisfied, evaluates RESULTs as a PROGN and returns the value(s) of
the last RESULT (or NIL if no RESULTs are supplied). Performs variable
bindings and assignments all at once, just like LET and PSETQ do.
-----------------------------------------------------------------------------
CLEAR-OUTPUT [Function]
CLEAR-OUTPUT
Function in LISP package:
Args: (&optional (stream *standard-output*))
Clears the output stream STREAM.
-----------------------------------------------------------------------------
LIST-ALL-PACKAGES [Function]
LIST-ALL-PACKAGES
Function in LISP package:
Args: ()
Returns a list of all existing packages.
-----------------------------------------------------------------------------
CAADDR [Function]
-----------------------------------------------------------------------------
CAADDR [Setf]
Defined as: (DEFSETF CAADDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CADDR X) Y) Y))
See the doc of DEFSETF. CAADDR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CAR (CDR (CDR X)))).
-----------------------------------------------------------------------------
LOGANDC1 [Function]
LOGANDC1
Function in LISP package:
Args: (integer1 integer2)
Returns the logical AND of (LOGNOT INTEGER1) and INTEGER2.
-----------------------------------------------------------------------------
COPY-TREE [Function]
COPY-TREE
Function in LISP package:
Args: (object)
Recursively copies conses in OBJECT and returns the result.
-----------------------------------------------------------------------------
LOAD [Function]
LOAD
Function in LISP package:
Args: (filename
&key (verbose *load-verbose*) (print nil) (if-does-not-exist :error))
Loads the file named by FILENAME into GCL.
-----------------------------------------------------------------------------
SUBSETP [Function]
SUBSETP
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns T if every element of LIST1 appears in LIST2; NIL otherwise.
-----------------------------------------------------------------------------
FORMAT [Function]
FORMAT
Function in LISP package:
Args: (destination control-string &rest arguments)
Provides various facilities for formatting output.
DESTINATION controls where the result will go. If DESTINATION is T, then
the output is sent to the standard output stream. If it is NIL, then the
output is returned in a string as the value of the call. Otherwise,
DESTINATION must be a stream to which the output will be sent.
CONTROL-STRING is a string to be output, possibly with embedded
formatting directives, which are flagged with the escape character
"~". Directives generally expand into additional text to be output,
usually consuming one or more of ARGUMENTs in the process.
A few useful directives are:
~A, ~nA, ~n@A Prints one argument as if by PRINC
~S, ~nS, ~n@S Prints one argument as if by PRIN1
~D, ~B, ~O, ~X Prints one integer in decimal, binary, octal, and hexa
~% Does TERPRI
~& Does FRESH-LINE
where n is the minimal width of the field in which the object is printed.
~nA and ~nS put padding spaces on the right; ~n@A and ~n@S put on the left.
~R is for printing numbers in various formats.
~nR prints arg in radix n.
~R prints arg as a cardinal english number: two
~:R prints arg as an ordinal english number: third
~@R prints arg as an a Roman Numeral: VII
~:@R prints arg as an old Roman Numeral: IIII
~C prints a character.
~:C represents non printing characters by their pretty names,eg Space
~@C uses the #\ syntax to allow the reader to read it.
~F prints a floating point number arg.
The full form is ~w,d,k,overflowchar,padcharF
w represents the total width of the printed representation (variable if
not present)
d the number of fractional digits to display
(format nil "~,2f" 10010.0314) --> "10010.03"
k arg is multiplied by 10^k before printing it as a decimal number.
overflowchar width w characters copies of the overflow character will
be printed. eg(format t "X>~5,2,,'?F X>?????~10,2,1,'?,'bFX>bbb1000.34 "BIL"
(format nil "~@[x = ~d ~]~a" 8) --> "x = 8 BIL"
-----------------------------------------------------------------------------
GO [Special form]
GO
Special Form in LISP package:
Syntax: (go tag)
Jumps to the specified TAG established by a lexically surrounding TAGBODY.
-----------------------------------------------------------------------------
SYMBOL-PLIST [Function]
-----------------------------------------------------------------------------
SYMBOL-PLIST [Setf]
Defined as: (DEFSETF SYMBOL-PLIST SET-SYMBOL-PLIST)
See the doc of DEFSETF. SYMBOL-PLIST
Function in LISP package:
Args: (symbol)
Returns the property list of SYMBOL.
-----------------------------------------------------------------------------
*PRINT-GENSYM* [Special variable]
*PRINT-GENSYM*
Variable in LISP package:
Whether the KCL printer should prefix symbols with no home package
with "#:".
-----------------------------------------------------------------------------
PI [Constant]
PI
Variable in LISP package:
The floating-point number that is appropriately equal to the ratio of the
circumference of the circle to the diameter.
-----------------------------------------------------------------------------
EQ [Function]
EQ
Function in LISP package:
Args: (x y)
Returns T if X and Y are the same identical object; NIL otherwise.
-----------------------------------------------------------------------------
CDADDR [Function]
-----------------------------------------------------------------------------
CDADDR [Setf]
Defined as: (DEFSETF CDADDR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CADDR X) Y) Y))
See the doc of DEFSETF. CDADDR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CAR (CDR (CDR X)))).
-----------------------------------------------------------------------------
STANDARD-CHAR-P [Function]
STANDARD-CHAR-P
Function in LISP package:
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.
-----------------------------------------------------------------------------
REMPROP [Function]
REMPROP
Function in LISP package:
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 T. If not found, returns NIL with no side effects.
-----------------------------------------------------------------------------
BIT-ORC2 [Function]
BIT-ORC2
Function in LISP package:
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.
-----------------------------------------------------------------------------
GBC [Function]
GBC
Function in LISP package:
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.
-----------------------------------------------------------------------------
SET-SYNTAX-FROM-CHAR [Function]
SET-SYNTAX-FROM-CHAR
Function in LISP package:
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.
-----------------------------------------------------------------------------
DENOMINATOR [Function]
DENOMINATOR
Function in LISP package:
Args: (rational)
Returns the denominator of RATIONAL as an integer.
-----------------------------------------------------------------------------
CONCATENATE [Function]
CONCATENATE
Function in LISP package:
Args: (result-type &rest sequences)
Returns a new sequence of the specified RESULT-TYPE, consisting of all
elements in SEQUENCEs.
-----------------------------------------------------------------------------
LOCALLY [Special form and Macro]
LOCALLY
Special Form in LISP package:
Syntax: (locally {decl}* {form}*)
Gives local pervasive declarations.
-----------------------------------------------------------------------------
ADJOIN [Function]
ADJOIN
Function in LISP package:
Args: (item list &key (test #'eql) test-not (key #'identity))
Adds ITEM to LIST unless ITEM is already a member of LIST.
-----------------------------------------------------------------------------
MAKE-HASH-TABLE [Function]
MAKE-HASH-TABLE
Function in LISP package:
Args: (&key (test 'eql) (size 1024) (rehash-size 1.5) (rehash-threshold 0.7))
Creates and returns a hash table.
-----------------------------------------------------------------------------
FMAKUNBOUND [Function]
FMAKUNBOUND
Function in LISP package:
Args: (symbol)
Discards the global function definition named by SYMBOL. Returns SYMBOL.
-----------------------------------------------------------------------------
Y-OR-N-P [Function]
Y-OR-N-P
Function in LISP package:
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.
-----------------------------------------------------------------------------
*** [Special variable]
***
Variable in LISP package:
Gets the previous value of ** when GCL evaluates a top-level form.
-----------------------------------------------------------------------------
BY [Function]
BY
Function in LISP package:
Args: ()
KCL specific: Exits from KCL.
-----------------------------------------------------------------------------
ARRAY-ELEMENT-TYPE [Function]
ARRAY-ELEMENT-TYPE
Function in LISP package:
Args: (array)
Returns the type of the elements of ARRAY
-----------------------------------------------------------------------------
READ-LINE [Function]
READ-LINE
Function in LISP package:
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.
Note that when using line at a time input under unix,
input forms will always be followed by a #\newline. Thus if you
do
>(read-line)
""
nil
the empty string will be returned. After lisp reads the (read-line)
it then invokes (read-line). This happens before it does anything
else and so happens before the newline character immediately following
(read-line) has been read. Thus read-line immediately encounters a
#\newline and so returns the empty string. If there had been other
characters before the #\newline it would have been different:
>(read-line) how are you
" how are you"
nil
If you want to throw away "" input, you can do that with
the following:
(sloop::sloop while (equal (setq input (read-line)) ""))
You may also want to use character at a time input, but that
makes input editing harder.
nicolas% stty cbreak
nicolas% akcl
AKCL (Austin Kyoto Common Lisp) Version(1.610) Mon Feb 10 18:38:29 CST 1992
Contains Enhancements by W. Schelter
>(let ((ifilename nil))
(format t "~%Input file name: ")
(setq ifilename (read-line)))
Input file name: /tmp/myfile
"/tmp/myfile"
>(bye)Bye.
-----------------------------------------------------------------------------
CHAR-NAME [Function]
CHAR-NAME
Function in LISP package:
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.
-----------------------------------------------------------------------------
ROTATEF [Macro]
ROTATEF
Macro in LISP package:
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.
-----------------------------------------------------------------------------
SYMBOLP [Function]
SYMBOLP
Function in LISP package:
Args: (x)
Returns T if X is a symbol; NIL otherwise.
-----------------------------------------------------------------------------
NINTERSECTION [Function]
NINTERSECTION
Function in LISP package:
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the intersection of LIST1 and LIST2. LIST1 may be destroyed.
-----------------------------------------------------------------------------
BYTE-SIZE [Function]
BYTE-SIZE
Function in LISP package:
Args: (bytespec)
Returns the size part (in KCL, the car part) of the byte specifier.
-----------------------------------------------------------------------------
SETQ [Special form]
SETQ
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
RENAME-FILE [Function]
RENAME-FILE
Function in LISP package:
Args: (file new-name)
Renames the file FILE to NEW-NAME. FILE may be a string, a pathname, or
a stream.
-----------------------------------------------------------------------------
GET-MACRO-CHARACTER [Function]
GET-MACRO-CHARACTER
Function in LISP package:
Args: (char &optional (readtable *readtable*))
Returns the function associated with CHAR and, as a second value, returns
the non-terminating-p flag.
-----------------------------------------------------------------------------
SET-MACRO-CHARACTER [Function]
SET-MACRO-CHARACTER
Function in LISP package:
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.
-----------------------------------------------------------------------------
UNEXPORT [Function]
UNEXPORT
Function in LISP package:
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.
-----------------------------------------------------------------------------
DESCRIBE [Function]
DESCRIBE
Function in LISP package:
Args: (x)
Prints a description of the object X.
-----------------------------------------------------------------------------
TYPEP [Function]
TYPEP
Function in LISP package:
Args: (x type)
Returns T if X is of the type TYPE; NIL otherwise.
-----------------------------------------------------------------------------
DELETE-FILE [Function]
DELETE-FILE
Function in LISP package:
Args: (file) Deletes FILE.
-----------------------------------------------------------------------------
BOOLE-C2 [Constant]
BOOLE-C2
Variable in LISP package:
Makes BOOLE return the complement of INTEGER2.
-----------------------------------------------------------------------------
UNSIGNED-SHORT [Type]
Defined as: (DEFTYPE UNSIGNED-SHORT ()
(LIST 'UNSIGNED-BYTE SHORT-SIZE))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
FCEILING [Function]
FCEILING
Function in LISP package:
Args: (number &optional (divisor 1))
Same as CEILING, but returns a float as the first value.
-----------------------------------------------------------------------------
GENTEMP [Function]
GENTEMP
Function in LISP package:
Args: (&optional (prefix "t") (package *package*))
Creates a new symbol interned in the package PACKAGE with the given PREFIX.
-----------------------------------------------------------------------------
VECTOR [Function]
-----------------------------------------------------------------------------
VECTOR [Type]
Defined as: (DEFTYPE VECTOR (&OPTIONAL (ELEMENT-TYPE '*) (SIZE '*))
(LIST 'ARRAY ELEMENT-TYPE (LIST SIZE)))
See the doc of DEFTYPE. VECTOR
Function in LISP package:
Args: (&rest objects)
Constructs a Simple-Vector from the given objects.
-----------------------------------------------------------------------------
PROVIDE [Function]
PROVIDE
Function in LISP package:
Args: (module-name)
Adds the specified module to the list of modules maintained in *MODULES*.
-----------------------------------------------------------------------------
USER-HOMEDIR-PATHNAME [Function]
Args: NIL USER-HOMEDIR-PATHNAME
Function in LISP package:
Args: (&optional host)
Returns the home directory of the logged in user as a pathname. HOST
is ignored.
-----------------------------------------------------------------------------
CLRHASH [Function]
CLRHASH
Function in LISP package:
Args: (hash-table)
Removes all entries of HASH-TABLE and returns the hash table itself.
-----------------------------------------------------------------------------
IMPORT [Function]
IMPORT
Function in LISP package:
Args: (symbols &optional (package *package*))
Makes SYMBOLS internal symbols of PACKAGE. SYMBOLS must be a list of symbols
or a symbol.
-----------------------------------------------------------------------------
REPLACE [Function]
REPLACE
Function in LISP package:
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.
-----------------------------------------------------------------------------
SIMPLE-STRING [Type]
Defined as: (DEFTYPE SIMPLE-STRING (&OPTIONAL (SIZE '*))
(LIST 'SIMPLE-ARRAY 'STRING-CHAR (LIST SIZE)))
See the doc of DEFTYPE.
-----------------------------------------------------------------------------
CADR [Function]
-----------------------------------------------------------------------------
CADR [Setf]
Defined as: (DEFSETF CADR (X) (Y)
(LIST 'PROGN (LIST 'RPLACA (LIST 'CDR X) Y) Y))
See the doc of DEFSETF. CADR
Function in LISP package:
Args: (x)
Equivalent to (CAR (CDR X)).
-----------------------------------------------------------------------------
CDDAR [Function]
-----------------------------------------------------------------------------
CDDAR [Setf]
Defined as: (DEFSETF CDDAR (X) (Y)
(LIST 'PROGN (LIST 'RPLACD (LIST 'CDAR X) Y) Y))
See the doc of DEFSETF. CDDAR
Function in LISP package:
Args: (x)
Equivalent to (CDR (CDR (CAR X))).
-----------------------------------------------------------------------------
LOGNOT [Function]
LOGNOT
Function in LISP package:
Args: (integer)
Returns the bit-wise logical NOT of INTEGER.
-----------------------------------------------------------------------------
GET-SETF-METHOD-MULTIPLE-VALUE [Function]
GET-SETF-METHOD-MULTIPLE-VALUE
Function in LISP package:
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.
-----------------------------------------------------------------------------
RANDOM [Function]
RANDOM
Function in LISP package:
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.
-----------------------------------------------------------------------------
CHAR= [Function]
CHAR=
Function in LISP package:
Args: (char &rest more-chars)
Returns T if all CHARs are the same character; NIL otherwise.
-----------------------------------------------------------------------------
SIMPLE-STRING-P [Function]
SIMPLE-STRING-P
Function in LISP package:
Args: (x)
Returns T if X is a simple string; NIL otherwise.
-----------------------------------------------------------------------------
*PRINT-CASE* [Special variable]
*PRINT-CASE*
Variable in LISP package:
The case in which the KCL printer should print ordinary symbols.
The value must be one of the keywords :UPCASE, :DOWNCASE, and :CAPITALIZE.
-----------------------------------------------------------------------------
*PRINT-BASE* [Special variable]
*PRINT-BASE*
Variable in LISP package:
The radix in which the GCL printer prints integers and rationals.
The value must be an integer from 2 to 36, inclusive.
-----------------------------------------------------------------------------
*PRINT-ESCAPE* [Special variable]
*PRINT-ESCAPE*
Variable in LISP package:
Whether the KCL printer should put escape characters whenever appropriate.
-----------------------------------------------------------------------------
LOGTEST [Function]
LOGTEST
Function in LISP package:
Args: (integer1 integer2)
Returns T if LOGAND of INTEGER1 and INTEGER2 is not zero; NIL otherwise.
-----------------------------------------------------------------------------
LCM [Function]
LCM
Function in LISP package:
Args: (integer &rest more-integers)
Returns the least common multiple of the arguments.
-----------------------------------------------------------------------------
ABS [Function]
ABS
Function in LISP package:
Args: (number)
Returns the absolute value of NUMBER.
-----------------------------------------------------------------------------
MULTIPLE-VALUE-BIND [Special form and Macro]
MULTIPLE-VALUE-BIND
Special Form in LISP package:
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.
-----------------------------------------------------------------------------
DEFENTRY [Macro]
DEFENTRY
Macro in LISP package:
Syntax: (defentry name arg-types 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. The ARG-TYPES specifies the C types of the
arguments which C-FUNCTION requires. The list of allowed types is (object
char int float double string). Code will be produced to coerce from a lisp
object to the appropriate type before passing the argument to the C-FUNCTION.
The c-function should be of the form (c-result-type c-fname) where
c-result-type is a member of (void object char int float double string).
c-fname may be a symbol (in which case it will be downcased) or a string. If
c-function is not a list, then (object c-function) is assumed.
Sample usage:
--File begin-----
;; JOE takes X a lisp string and Y a fixnum and returns a character.
(clines "#include \"foo.ch\"")
(defentry joe (string int) (char "our_c_fun"))
---File end------
---File foo.ch---
/* C function for extracting the i'th element of a string */
static char our_c_fun(p,i)
char *p;
int i;
{
return p[i];
}
-----File end---
-----------------------------------------------------------------------------
FROUND [Function]
FROUND
Function in LISP package:
Args: (number &optional (divisor 1))
Same as ROUND, but returns first value as a float.
-----------------------------------------------------------------------------
DECODE-FLOAT [Function]
DECODE-FLOAT
Function in LISP package:
Args: (float)
Returns, as three values, the significand F, the exponent E, and the sign S
of the given float, so that
E
FLOAT = S * F * B where B = (FLOAT-RADIX FLOAT)
S and F are floating-point numbers of the same float format as FLOAT, and E
is an integer.
-----------------------------------------------------------------------------
SUBTYPEP [Function]
SUBTYPEP
Function in LISP package:
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.
-----------------------------------------------------------------------------
BYE [Function]
BYE
Function in LISP package:
Args: ()
KCL specific: Exits from KCL.
-----------------------------------------------------------------------------
WRITE-CHAR [Function]
WRITE-CHAR
Function in LISP package:
Args: (char &optional (stream *standard-output*))
Outputs CHAR and returns it.
-----------------------------------------------------------------------------
FILE-NAMESTRING [Function]
FILE-NAMESTRING
Function in LISP package:
Args: (pathname)
Returns the written representation of PATHNAME as a string.
-----------------------------------------------------------------------------
APPEND [Function]
APPEND
Function in LISP package:
Args: (&rest lists)
Constructs a new list by concatenating its arguments.
-----------------------------------------------------------------------------
REM [Function]
REM
Function in LISP package:
Args: (number divisor)
Returns the second value of (TRUNCATE NUMBER DIVISOR).
-----------------------------------------------------------------------------
SIGNUM [Function]
SIGNUM
Function in LISP package:
Args: (number)
If NUMBER is zero, returns NUMBER; else returns (/ NUMBER (ABS NUMBER)).
-----------------------------------------------------------------------------
COSH [Function]
COSH
Function in LISP package:
Args: (number) Returns the hyperbolic cosine of
NUMBER.
-----------------------------------------------------------------------------
INTERNAL-TIME-UNITS-PER-SECOND [Constant]
INTERNAL-TIME-UNITS-PER-SECOND
Variable in LISP package:
The number of internal time units that fit into a second.
-----------------------------------------------------------------------------
PATHNAME-DEVICE [Function]
PATHNAME-DEVICE
Function in LISP package:
Args: (pathname)
Returns the device slot of PATHNAME.
-----------------------------------------------------------------------------
SVREF [Function]
-----------------------------------------------------------------------------
SVREF [Setf]
Defined as: (DEFSETF SVREF SVSET)
See the doc of DEFSETF. SVREF
Function in LISP package:
Args: (simple-vector index)
Returns the INDEX-th element of SIMPLE-VECTOR.
-----------------------------------------------------------------------------
PROG1 [Special form and Macro]
PROG1
Special Form in LISP package:
Syntax: (prog1 first {form}*)
Evaluates FIRST and FORMs in order, and returns the (single) value of FIRST.
-----------------------------------------------------------------------------
NSUBSTITUTE-IF-NOT [Function]
NSUBSTITUTE-IF-NOT
Function in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE [Function]
BOOLE
Function in LISP package:
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.
-----------------------------------------------------------------------------
FLOAT-PRECISION [Function]
FLOAT-PRECISION
Function in LISP package:
Args: (float)
Returns the number of significant radix-B digits used to represent the
significand F of the floating-point number, where B = (FLOAT-RADIX FLOAT).
-----------------------------------------------------------------------------
PLUSP [Function]
PLUSP
Function in LISP package:
Args: (number)
Returns T if NUMBER > 0; NIL otherwise.
-----------------------------------------------------------------------------
STRING-LEFT-TRIM [Function]
STRING-LEFT-TRIM
Function in LISP package:
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
left end.
-----------------------------------------------------------------------------
MAKE-STRING-OUTPUT-STREAM [Function]
MAKE-STRING-OUTPUT-STREAM
Function in LISP package:
Args: ()
Returns an output stream which will accumulate all output given it for
the benefit of the function GET-OUTPUT-STREAM-STRING.
-----------------------------------------------------------------------------
MAKE-STRING-INPUT-STREAM [Function]
MAKE-STRING-INPUT-STREAM
Function in LISP package:
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.
-----------------------------------------------------------------------------
BOOLE-ORC2 [Constant]
BOOLE-ORC2
Variable in LISP package:
Makes BOOLE return LOGORC2 of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
BOOLE-ORC1 [Constant]
BOOLE-ORC1
Variable in LISP package:
Makes BOOLE return LOGORC1 of INTEGER1 and INTEGER2.
-----------------------------------------------------------------------------
STRING-NOT-LESSP [Function]
STRING-NOT-LESSP
Function in LISP package:
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING>=, but ignores cases.
-----------------------------------------------------------------------------
WITH-OUTPUT-TO-STRING [Macro]
WITH-OUTPUT-TO-STRING
Macro in LISP package:
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.
-----------------------------------------------------------------------------
WARN [Function]
WARN
Function in LISP package:
Args: (format-string &rest args)
Formats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message.
-----------------------------------------------------------------------------
STEP [Macro]
STEP
Macro in LISP package:
Syntax: (step form)
Evaluates FORM in the single-step mode and returns the value.
-----------------------------------------------------------------------------
COERCE [Function]
COERCE
Function in LISP package:
Args: (x type)
Coerces X to an object of the type TYPE.
-----------------------------------------------------------------------------
PATHNAMEP [Function]
PATHNAMEP
Function in LISP package:
Args: (x)
Returns T if X is a pathname object; NIL otherwise.
-----------------------------------------------------------------------------
INTERN [Function]
INTERN
Function in LISP package:
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.
-----------------------------------------------------------------------------
CS 51: Introduction to Computer Science II /
lib51@fas.harvard.edu