Common Lisp Package: IT.BESE.ARNESI

The arnesi utility suite.

README:

FUNCTION

Public

BUILD-HASH-TABLE (HASH-SPEC INITAL-CONTENTS)

Create a hash table containing ``INITAL-CONTENTS``.

BUT-HEAD (SEQ &OPTIONAL (HOW-MANY 1))

Returns SEQ with the first HOW-MANY elements removed.

BUT-TAIL (SEQ &OPTIONAL (HOW-MANY 1))

Returns SEQ with the last HOW-MANY elements removed.

COLLECT-TIMING (LAMBDA)

Executes LAMBDA and returns a timing-info object specifying how long execution took and how much memory was used. NB: Not all implementations provide all information. See the various %collect-timing definitions for details.

COMPOSE (F1 &REST FUNCTIONS)

Returns a function which applies the arguments in order. (funcall (compose #'list #'+) 1 2 3) ==> (6)

COPY-ARRAY (ARRAY)

Returns a fresh copy of ARRAY. The returned array will have the same dimensions and element-type, will not be displaced and will have the same fill-pointer as ARRAY. See http://thread.gmane.org/gmane.lisp.allegro/13 for the original implementation and discussion.

COPY-STREAM (INPUT OUTPUT &OPTIONAL (ELEMENT-TYPE (STREAM-ELEMENT-TYPE INPUT)))

Reads data from FROM and writes it to TO. Both FROM and TO must be streams, they will be passed to read-sequence/write-sequence and must have compatable element-types.

CURRY (FUNCTION &REST INITIAL-ARGS)

Returns a function which will call FUNCTION passing it INITIAL-ARGS and then any other args. (funcall (curry #'list 1) 2) ==> (list 1 2)

DECIMAL-FROM-FLOAT (FLOAT &OPTIONAL (PRECISION *PRECISION*) (ROUNDING-METHOD #'ROUND-HALF-UP))

Convert FLOAT to an exact value with precision PRECISION using ROUNDING-METHOD to do any neccessary rounding.

ENABLE-PF-READER

TODO Obsolete, to be removed. Use the enable-pf-syntax macro.

ENABLE-SHARP-L

TODO: Obsolete, to be removed. Use the enable-sharp-l-syntax macro.

ENCODING-KEYWORD-TO-NATIVE (ENCODING)

Convert ENCODING, a keyword, to an object the native list accepts as an encoding. ENCODING can be: :UTF-8, :UTF-16, or :US-ASCII and specify the corresponding encodings. Any other keyword is passed, as is, to the underlying lisp.

ENDS-WITH (SEQ1 SEQ2 &KEY (TEST #'EQL))

Test whether SEQ1 ends with SEQ2. In other words: return true if the last (length seq2) elements of seq1 are equal to seq2.

ENSURE-LIST (THING)

Returns THING as a list. If THING is already a list (as per listp) it is returned, otherwise a one element list containing THING is returned.

ESCAPE-AS-URI (STRING)

Escapes all non alphanumeric characters in STRING following the URI convention. Returns a fresh string.

EXTRACT-ARGUMENT-NAMES (LAMBDA-LIST &KEY ALLOW-SPECIALIZERS)

Returns a list of symbols representing the names of the variables bound by the lambda list LAMBDA-LIST.

FLOAT-FROM-DECIMAL (DECIMAL)

Convert the exact decimal value DECIMAL to a (not neccassily equal) floating point value.

KALL (K &OPTIONAL (PRIMARY-VALUE NIL PRIMARY-VALUE-P) &REST OTHER-VALUES)

Continue the continuation K. This function can be used within the lexical scope of with-call/cc and outside, though it has slightly different semantics.

MAKE-COLLECTOR (&OPTIONAL INITIAL-VALUE)

Create a collector function. A Collector function will collect, into a list, all the values passed to it in the order in which they were passed. If the callector function is called without arguments it returns the current list of values.

MAKE-MATCHER (SPEC)

Create a matcher function from SPEC.

MAKE-PUSHER (&OPTIONAL INITIAL-VALUE)

Create a function which collects values as by PUSH.

MAKE-REDUCER (FUNCTION &OPTIONAL (INITIAL-VALUE NIL INITIAL-VALUE-P))

Create a function which, starting with INITIAL-VALUE, reduces any other values into a single final value. FUNCTION will be called with two values: the current value and the new value, in that order. FUNCTION should return exactly one value. The reducing function can be called with n arguments which will be applied to FUNCTION one after the other (left to right) and will return the new value. If the reducing function is called with no arguments it will return the current value. Example: (setf r (make-reducer #'+ 5)) (funcall r 0) => 5 (funcall r 1 2) => 8 (funcall r) => 8

MATCH (MATCHER TARGET)

Attempt to match MATCHER against TARGET. MATCHER can be either a function or a list.

NOOP (&REST ARGS)

Do nothing.

PARSE-CSV-STRING (LINE &KEY (SEPARATOR ,) '")

Parse a csv line into a list of strings using seperator as the column seperator and quote as the string quoting character.

PARSE-IEEE-DOUBLE (U64)

Given an IEEE 64 bit double representeted as an integer (ie a sequence of 64 bytes), return the coressponding double value

PARTITION (LIST &REST LAMBDAS)

Split LIST into sub lists according to LAMBDAS. Each element of LIST will be passed to each element of LAMBDAS, the first function in LAMBDAS which returns T will cause that element to be collected into the corresponding list. Examples: (partition '(1 2 3) #'oddp #'evenp) => ((1 3) (2)) (partition '(1 2 3) #'oddp t) => ((1 3) (1 2 3)) (partition '(1 2 3) #'oddp #'stringp) => ((1 3) nil)

PRINC-CSV (ITEMS CSV-STREAM &KEY '" (SEPARATOR ,) (IGNORE-NULLS T) (NEWLINE +CR-LF+) (PRINC #'PRINC-TO-STRING))

Write the list ITEMS to csv-stream.

PROPER-LIST-P (OBJECT)

Tests whether OBJECT is properlist. A proper list is a non circular cons chain whose last cdr is eq to NIL.

RANDOM-STRING (&OPTIONAL (LENGTH 32) (ALPHABET +ASCII-ALPHABET+))

Returns a random alphabetic string. The returned string will contain LENGTH characters chosen from the vector ALPHABET.

RCURRY (FUNCTION &REST INITIAL-ARGS)

Returns a function which will call FUNCTION passing it the passed args and then INITIAL-ARGS. (funcall (rcurry #'list 1) 2) ==> (list 2 1)

READ-SEQUENCE* (SEQUENCE STREAM &KEY (START 0) END)

Like READ-SEQUENCE except the sequence is returned as well. The second value returned is READ-SEQUENCE's primary value, the primary value returned by READ-SEQUENCE* is the medified sequence.

READ-STRING-FROM-FILE (PATHNAME &KEY (BUFFER-SIZE 4096) (ELEMENT-TYPE 'CHARACTER) (EXTERNAL-FORMAT US-ASCII))

Return the contents of PATHNAME as a fresh string. The file specified by PATHNAME will be read one ELEMENT-TYPE element at a time, the EXTERNAL-FORMAT and ELEMENT-TYPEs must be compatible. The EXTERNAL-FORMAT parameter will be passed to ENCODING-KEYWORD-TO-NATIVE, see ENCODING-KEYWORD-TO-NATIVE to possible values.

REMOVE-KEYWORDS (PLIST &REST KEYWORDS)

Creates a copy of PLIST without the listed KEYWORDS.

ROUND-CEILING (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards positive infintity

ROUND-DOWN (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards 0.

ROUND-FLOOR (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards negative infinity.

ROUND-HALF-DOWN (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards the nearest legal value. If the current value is exactly half way between two legal values round towards 0.

ROUND-HALF-EVEN (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards the nearest value allowed with the current precision. If the current value is exactly halfway between two legal values round towards the nearest even value.

ROUND-HALF-UP (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round towards the nearest value allowed with the current precision. If the current value is exactly halfway between two logal values round away from 0.

ROUND-UP (NUMBER &OPTIONAL (PRECISION *PRECISION*))

Round away from 0.

SET (SYMBOL NEW-VALUE)

Set SYMBOL's value cell to NEW-VALUE.

STARTS-WITH (SEQUENCE PREFIX &KEY (TEST #'EQL) (RETURN-SUFFIX NIL))

Test whether the first elements of SEQUENCE are the same (as per TEST) as the elements of PREFIX. If RETURN-SUFFIX is T the functions returns, as a second value, a displaced array pointing to the sequence after PREFIX.

STRCAT (&REST ITEMS)

Returns a fresh string consisting of ITEMS concat'd together.

STRCAT* (STRING-DESIGNATORS)

Concatenate all the strings in STRING-DESIGNATORS.

STRING-FROM-ARRAY (ARRAY &KEY (START 0) (END (1- (LENGTH ARRAY))))

Assuming ARRAY is an array of ASCII chars encoded as bytes return the corresponding string. Respect the C convention of null terminating strings. START and END specify the zero indexed offsets of a sub range of ARRAY.

STRING-TO-OCTETS (STRING ENCODING)

Convert STRING, a list string, a vector of bytes according to ENCODING. ENCODING is a keyword representing the desired character encoding. We gurantee that :UTF-8, :UTF-16 and :ISO-8859-1 will work as expected. Any other values are simply passed to the underlying lisp's function and the results are implementation dependant. On CLISP we intern the ENCODING symbol in the CHARSET package and pass that. On SBCL we simply pass the keyword.

TAIL (SEQ &OPTIONAL (HOW-MANY 1))

Returns the last HOW-MANY elements of the sequence SEQ. HOW-MANY is greater than (length SEQ) then all of SEQ is returned.

WALK-FORM (FORM &OPTIONAL (PARENT NIL) (ENV (MAKE-WALK-ENV)))

Walk FORM and return a FORM object.

WITH-PACKAGE (PACKAGE-NAME)

When used as a specifier for the #{ reader locally rebinds, at read time, the current package to PACKAGE-NAME. For example, this: {(with-package :cl-user) t} Will always read cl:t, no matter what the current package actually is.

WITH-SHARP-L-SYNTAX

To be used with the curly reader from arnesi: {with-sharp-l-syntax #L(typep !1 'foo)}

WRITE-STRING-TO-FILE (STRING PATHNAME &KEY (IF-EXISTS ERROR) (IF-DOES-NOT-EXIST ERROR) (EXTERNAL-FORMAT US-ASCII))

Write STRING to PATHNAME. The EXTERNAL-FORMAT parameter will be passed to ENCODING-KEYWORD-TO-NATIVE, see ENCODING-KEYWORD-TO-NATIVE to possible values.

Undocumented

10^ (X)

APPEND1 (LIST X)

APROPOS* (&REST APROPOS-ARGS)

APROPOS-LIST* (STRING &KEY (FBOUND NIL FBOUND-SUPPLIED-P) (BOUND NIL BOUND-SUPPLIED-P) (PACKAGE NIL PACKAGE-SUPPLIED-P) (DISTANCE 0 DISTANCE-SUPPLIED-P))

CIRCULARIZE (&REST ITEMS)

CLASS-NAME-OF (OBJ)

CONJOIN (&REST PREDICATES)

CONTINUE-AS-IS (C)

COPY-FILE (FROM TO &KEY (IF-TO-EXISTS SUPERSEDE) (ELEMENT-TYPE '(UNSIGNED-BYTE 8)))

ENSURE-CONS (THING)

ESCAPE-AS-HTML (STRING &KEY (ESCAPE-WHITESPACE NIL))

FOLD-STRINGS

GET-LOGGER (KEY &OPTIONAL DEFAULT)

SETFGET-LOGGER (VALUE KEY)

GETENV (VAR)

HASH-TABLE-KEYS (HASH-TABLE)

HASH-TABLE-VALUES (HASH-TABLE)

HASH-TO-ALIST (HASH-TABLE)

HTML-ENTITY->CHAR (ENTITY &OPTIONAL (DEFAULT ?))

INTERN-CONCAT (STRING-DESIGNATORS &OPTIONAL (PACKAGE *PACKAGE*))

JOIN-STRINGS (LIST)

LAST1 (L)

LEVENSHTEIN-DISTANCE (SOURCE TARGET &KEY (TEST #'EQL))

MAKE-DISPLACED-ARRAY (ARRAY &OPTIONAL (START 0) (END (LENGTH ARRAY)))

MAKE-FILE-LOG-APPENDER (FILE-NAME)

MAKE-STREAM-LOG-APPENDER (&REST ARGS &KEY (STREAM *DEBUG-IO*) (VERBOSITY 2) &ALLOW-OTHER-KEYS)

MAKE-WALK-ENV (&OPTIONAL LEXICAL-ENV)

MAP-RANGE (LAMBDA MIN MAX &OPTIONAL (STEP 1))

NUNESCAPE-AS-URI (STRING)

OCTETS-TO-STRING (OCTETS ENCODING)

PARSE-FLOAT (FLOAT-STRING &KEY (START 0) (END NIL) (RADIX 10) (JUNK-ALLOWED T) (TYPE 'SINGLE-FLOAT) (DECIMAL-CHARACTER .))

PARTITIONX (LIST &REST LAMBDAS)

QUIT (&OPTIONAL (EXIT-CODE 0))

SINGLEP (LIST)

UNESCAPE-AS-HTML (STRING)

UNESCAPE-AS-URI (STRING)

UNESCAPE-AS-URI-NON-STRICT (STRING)

UNWALK-FORMS (FORMS)

UNWALK-LAMBDA-LIST (ARGUMENTS)

VECTOR-PUSH-EXTEND* (VECTOR &REST ITEMS)

WALK-IMPLICT-PROGN (PARENT FORMS ENV &KEY DOCSTRING DECLARE)

WALK-LAMBDA-LIST (LAMBDA-LIST PARENT ENV &KEY ALLOW-SPECIALIZERS MACRO-P)

WRITE-AS-HTML (STRING &KEY (STREAM T) (ESCAPE-WHITESPACE NIL))

WRITE-AS-URI

Y (LAMBDA)

~A (OBJECT &OPTIONAL STREAM)

~D (NUMBER &OPTIONAL STREAM &KEY MINCOL PAD-CHAR)

~S (OBJECT &OPTIONAL STREAM)

~W (OBJECT &OPTIONAL STREAM)

Private

%COLLECT-TIMING (FUN)

Implementation of collect-timing for SBCL. This code is a cut 'n paste from sbcl/src/code/time.lisp. It uses internal functions, all bets off.

%ENABLE-SHARP-L-READER

Bind SHARPL-READER to the macro character #L. This function overrides (and forgets) and previous value of #L.

%UNESCAPE-AS-URI

URI unescape based on http://www.ietf.org/rfc/rfc2396.txt

BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COPY-STATE (ORIG-STATE &KEY (TARGET NIL TARGET-SUPP) (BINDINGS NIL BINDINGS-SUPP) (MATCHED NIL MATCHED-SUPP))

Make a copy ORIG-STATE.

FIND-WALKER-HANDLER (FORM)

Simple function which tells us what handler should deal with FORM. Signals an error if we don't have a handler for FORM.

LISP1B (BINDS)

Convert an alist of (VAR . FORM) to Lisp-1 style.

LISP1S (FORMS)

Convert a list of forms to Lisp-1 style.

MATCHED (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PPRINT-BYTES (NUM-BYTES &OPTIONAL STREAM)

Writes NUM-BYTES to stream, rounds num-bytes and appends a suffix depending on the size of num-bytes.

SHARPL-READER (STREAM SUBCHAR MIN-ARGS)

Reader macro for simple lambdas. This read macro reads exactly one form and serves to eliminate the 'boiler' plate text from such lambdas and write only the body of the lambda itself. If the form contains any references to variables named !1, !2, !3, !n etc. these are bound to the Nth parameter of the lambda. Examples: #L(foo) ==> (lambda () (foo)). #L(foo !1) ==> (lambda (!1) (foo !1)) #L(foo (bar !2) !1) ==> (lambda (!1 !2) (foo (bar !2) !1)) All arguments are declared ignorable. So if there is a reference to an argument !X but not !(x-1) we still take X arguments, but x - 1 is ignored. Examples: #L(foo !2) ==> (lambda (!1 !2) (declare (ignore !1)) (foo !2)) We can specify exactly how many arguments to take by using the read macro's prefix parameter. NB: this is only neccessary if the lambda needs to accept N arguments but only uses N - 1. Example: #2L(foo !1) ==> (lambda (!1 !2) (declare (ignore !2)) (foo !1)) When #l forms are nested, !X variables are bound to the innermost form. Example: #l#l(+ !1 !2) returns a function that takes no arguments and returns a function that adds its two arguments.

TARGET (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

{-reader (STREAM CHAR)

A utility read macro for modifying the read table. The syntax is: {SPECIFIER ...} SPECIFIER is either a symbol naming a function (available at read time) or a list (SPECIFIER &rest ARGUMENTS). SPECIFIER is applied to ARGUMENTS to produce a function, this is then called and passed another function which reads until the #} character. During the executen of the function *readtable* is bound to a copy of the current read table. See WITH-PACKAGE for an example of a specifier function.

Undocumented

%ENABLE-PF-READER (&OPTIONAL (OPEN-CHARACTER [) (CLOSE-CHARACTER ]))

%ENCODING-KEYWORD-TO-NATIVE (ENCODING)

%MAKE-MATCHER (SPEC)

%OCTETS-TO-STRING (OCTETS ENCODING)

%STRING-TO-OCTETS (STRING ENCODING)

[-reader (STREAM CHAR)

APPLY-LAMBDA/CC/KEYWORD (OPERATOR REMAINING-PARAMETERS REMAINING-ARGUMENTS LEX-ENV DYN-ENV K)

APPLY-LAMBDA/CC/OPTIONAL (OPERATOR REMAINING-PARAMETERS REMAINING-ARGUMENTS LEX-ENV DYN-ENV K)

ARNESI-LOGGER-INSPECTOR-LOOKUP-HOOK (FORM)

BANG-VAR-P (FORM)

BINDING (X BINDS)

SETFBINDINGS (NEW-VALUE INSTANCE)

CATCH-TAG-K (CATCH LEX-ENV DYN-ENV K)

CHECK-REQUIRED (NAME VARS REQUIRED)

CLEAN-ARGUMENT-LIST (LAMBDA-LIST)

CLOSURE-WITH-AFTERS (CLOSURE AFTERS)

CLOSURE-WITH-BEFORES (CLOSURE BEFORES)

CLOSURE-WITH-NEXTMETHOD (CLOSURE NEXT)

CONVERT-TO-GENERIC-LAMBDA-LIST (DEFMETHOD-LAMBDA-LIST)

COPY-MATCH-STATE (INSTANCE)

DO-MAXF (CURRENT OTHER)

DO-MINF (CURRENT OTHER)

DO-PUSH* (LIST &REST ITEMS)

DRIVE-INTERPRETER/CC (CODE)

EVALUATE-APPLY/CC (REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV K)

EVALUATE-ARGUMENTS-THEN-APPLY (HANDLER REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV)

EVALUATE-FUNCALL/CC (ARGUMENTS LEX-ENV DYN-ENV K)

EVALUATE-LET*/CC (BINDINGS BODY LEX-ENV DYN-ENV K)

EVALUATE-LET/CC (REMAINING-BINDINGS EVALUATED-BINDINGS BODY LEX-ENV DYN-ENV K)

EVALUATE-M-V-C (REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV K)

EVALUATE-PROGN/CC (BODY LEX-ENV DYN-ENV K)

EXPORT-SPECIALS (DYN-ENV)

FDEFINITION/CC (FUNCTION-NAME)

SETFFDEFINITION/CC (CLOSURE-OBJECT FUNCTION-NAME &OPTIONAL (TYPE 'DEFUN/CC))

FIND-VAR-REFERENCES (INPUT-FORM)

FLATTEN1 (L)

FMKUNBOUND/CC (FUNCTION-NAME)

GENERATE-DEFCLASS (CLASS-NAME OPTIONS SUPERS SLOTS)

GET-MATCH-HANDLER (KEY &OPTIONAL DEFAULT)

SETFGET-MATCH-HANDLER (VALUE KEY)

HIGHEST-BANG-VAR (FORM ENV)

IMPORT-SPECIALS (MIXIN DYN-ENV)

K-FOR-APPLY-LAMBDA/CC/KEYWORD-DEFAULT-VALUE (OPERATOR REMAINING-PARAMETERS REMAINING-ARGUMENTS LEX-ENV DYN-ENV K)

K-FOR-APPLY/CC (REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV K)

K-FOR-APPLY/CC/OPTIONAL-ARGUMENT-DEFAULT-VALUE (OPERATOR REMAINING-PARAMETERS LEX-ENV DYN-ENV K)

K-FOR-CALL/CC (K)

K-FOR-EVALUATE-ARGUMENTS-THEN-APPLY (HANDLER REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV)

K-FOR-EVALUATE-IF/CC (THEN ELSE LEX-ENV DYN-ENV K)

K-FOR-EVALUATE-LET*/CC (VAR BINDINGS BODY LEX-ENV DYN-ENV K)

K-FOR-EVALUATE-LET/CC (VAR REMAINING-BINDINGS EVALUATED-BINDINGS BODY LEX-ENV DYN-ENV K)

K-FOR-EVALUATE-PROGN/CC (REST-OF-BODY LEX-ENV DYN-ENV K)

K-FOR-FREE-SETQ (VAR LEX-ENV DYN-ENV K)

K-FOR-LOCAL-LEXICAL-SETQ (VAR LEX-ENV DYN-ENV K)

K-FOR-LOCAL-SETQ (VAR LEX-ENV DYN-ENV K)

K-FOR-M-V-C (REMAINING-ARGUMENTS EVALUATED-ARGUMENTS LEX-ENV DYN-ENV K)

KONTINUE (K &OPTIONAL (PRIMARY-VALUE NIL PRIMARY-VALUE-P) &REST OTHER-VALUES)

LIST-MATCH (X Y &OPTIONAL BINDS)

LOG-LEVEL-NAME-OF (LEVEL)

LOOKUP (ENVIRONMENT TYPE NAME &KEY (ERROR-P NIL) (DEFAULT-VALUE NIL))

SETFLOOKUP (VALUE ENVIRONMENT TYPE NAME &KEY (ERROR-P NIL))

LOOKUP-WALK-ENV (ENV TYPE NAME &KEY (ERROR-P NIL) (DEFAULT-VALUE NIL))

MACROEXPAND-ALL (FORM &OPTIONAL ENV)

MAKE-GREEDY-STAR (M)

MAKE-HTML-ENTITIES

MAKE-LOOKUP-NAME (NAME &REST PARTS)

MAKE-MATCH-STATE (&KEY ((TARGET DUM28) NIL) ((BINDINGS DUM29) NIL) ((MATCHED DUM30) NIL))

MAKE-SHARPL-ARG (PACKAGE NUMBER)

MAKE-SINGLE-FASL (SYSTEM-NAME &KEY (OP (MAKE-INSTANCE 'LOAD-OP)) OUTPUT-FILE)

MATCH-STATE-P (OBJECT)

SETFMATCHED (NEW-VALUE INSTANCE)

NEXT-TARGET

PARSE-DECLARATION (DECLARATION ENVIRONMENT PARENT)

PARSE-MACRO-DEFINITION (NAME LAMBDA-LIST BODY ENV)

PPRINT-MILLISECONDS (MILLISECONDS &OPTIONAL STREAM)

PRINC-CSV-TO-STRING (ITEMS)

RADIX-VALUES (RADIX)

REGISTER (ENVIRONMENT TYPE NAME DATUM &REST OTHER-DATUM)

REGISTER-WALK-ENV (ENV TYPE NAME DATUM &REST OTHER-DATUM)

REM-LOGGER (KEY)

REM-MATCH-HANDLER (KEY)

SPECIAL-VAR-P (VAR DECLARES-MIXIN)

SPLIT-BODY (BODY ENV &KEY PARENT (DOCSTRING T) (DECLARE T))

TAGBODY-K (K)

SETFTARGET (NEW-VALUE INSTANCE)

THROW-TAG-K (THROW LEX-ENV DYN-ENV K)

TOPLEVEL-K

TRY-OTHER-ENCODING (C ENCODING)

UNWALK-DECLARATIONS (DECLS)

VARS (MATCH-SPEC)

VARSYMP (X)

WALK-KEYWORD-ARGUMENT (FORM PARENT ENV)

WALK-LAMBDA (FORM PARENT ENV)

WALK-OPTIONAL-ARGUMENT (FORM PARENT ENV)

WALK-REQUIRED-ARGUMENT (FORM PARENT ENV)

WALK-REST-ARGUMENT (FORM PARENT ENV)

WALK-SPECIALIZED-ARGUMENT-FORM (FORM PARENT ENV)

MACRO

Public

ACOND (&REST CLAUSES)

Just like cond-bind except the var is automatically IT.

AIF (TEST THEN &OPTIONAL ELSE)

Just like IF-BIND but the var is always IT.

AIF2 (TEST THEN &OPTIONAL ELSE)

Just like IF-BIND but the var is always IT. Very useful with functions like GETHASH.

AWHEN (TEST &BODY BODY)

Just like when expect the symbol IT will be bound to the result of TEST in BODY.

AWHILE (TEST &BODY BODY)

Just like WHILE, but the result of TEST is bound to IT. You may exit the loop with (RETURN-FROM AWHILE).

COND-BIND (VAR &BODY CLAUSES)

Just like COND but VAR will be bound to the result of the condition in the clause when executing the body of the clause.

CSWITCH ((OBJ &KEY (TEST #'EQL)) &BODY BODY)

Like SWITCH but signals a continuable error if no clause matches.

DEF-SPECIAL-ENVIRONMENT (NAME (&KEY ACCESSOR BINDER BINDER*) &REST VARS)

Define two macros for dealing with groups or related special variables. ACCESSOR is defined as a macro: (defmacro ACCESSOR (VARS &rest BODY)). Each element of VARS will be bound to the current (dynamic) value of the special variable. BINDER is defined as a macro for introducing (and binding new) special variables. It is basically a readable LET form with the prorpe declarations appended to the body. The first argument to BINDER must be a form suitable as the first argument to LET. ACCESSOR defaults to a new symbol in the same package as NAME which is the concatenation of "WITH-" NAME. BINDER is built as "BIND-" and BINDER* is BINDER "*".

DEFCLASS-STRUCT (NAME-AND-OPTIONS SUPERS &REST SLOTS)

DEFCLASS with a DEFSTRUCT api. NAME-AND-OPTIONS: name-symbol | ( name-symbol [ (:conc-name conc-name ) ] [ (:predicate predicate-name ) ] class-option* ) SUPERS - a list of super classes passed directly to DEFCLASS. SLOTS - a list of slot forms: name | ( name [ init-arg ] [ slot-options* ] )

DEFGENERIC/CC (NAME ARGS &REST OPTIONS)

Trivial wrapper around defgeneric designed to alert readers that these methods are cc methods.

DEFINE-CONSTANT (NAME VALUE DOC-STRING &OPTIONAL EXPORT-P)

DEFCONSTANT with extra EXPORT-P argument.

DEFLOOKUP-TABLE (NAME &KEY (VAR (MAKE-LOOKUP-NAME NAME * NAME *)) (READER (MAKE-LOOKUP-NAME NAME GET- NAME)) (WRITER (MAKE-LOOKUP-NAME NAME GET- NAME)) (REM-ER (MAKE-LOOKUP-NAME NAME REM- NAME)) (AT-REDEFINITION WARN) (DOCUMENTATION (FORMAT NIL Global var for the ~S lookup table NAME)) (TEST 'EQL) (INITIAL-CONTENTS NIL))

Creates a hash table and the associated accessors.

DEFMETHOD1 (NAME (&REST ARGS) &BODY BODY)

Define a method with BODY written in Lisp-1 style. This is just like DEFMETHOD.

DEFPRINT-OBJECT ((SELF CLASS-NAME &KEY (IDENTITY T) (TYPE T) WITH-PACKAGE (MUFFLE-ERRORS T)) &BODY BODY)

Define a print-object method using print-unreadable-object. An example: (defprint-object (self parenscript-dispatcher) (when (cachep self) (princ "cached") (princ " ")) (princ (parenscript-file self)))

DEFUN1 (NAME (&REST ARGS) &BODY BODY)

Define a function with BODY written in Lisp-1 style. This is just like DEFUN.

DELETEF (ITEM SEQUENCE &REST DELETE-ARGS &ENVIRONMENT E)

Delete ITEM from SEQUENCE, using cl:delete, and update SEQUENCE. DELETE-ARGS are passed directly to cl:delete.

DIVF (PLACE B &ENVIRONMENT ENV)

SETF NUM to the result of (/ NUM B).

DOLIST* ((ITERATOR LIST &OPTIONAL RETURN-VALUE) &BODY BODY)

Like DOLIST but destructuring-binds the elements of LIST. If ITERATOR is a symbol then dolist* is just like dolist EXCEPT that it creates a fresh binding.

DOTREE ((NAME TREE &OPTIONAL RET-VAL) &BODY BODY)

Evaluate BODY with NAME bound to every element in TREE. Return RET-VAL.

ENABLE-BRACKET-READER

TODO Obsolete, use the enable-bracket-syntax macro.

ENABLE-BRACKET-SYNTAX

Enable bracket reader for the rest of the file (being loaded or compiled). Be careful when using in different situations, because it modifies *readtable*.

ENABLE-PF-SYNTAX (&OPTIONAL (OPEN-CHARACTER [) (CLOSE-CHARACTER ]))

Enable bracket reader for the rest of the file (being loaded or compiled). Be careful when using in different situations, because it modifies *readtable*.

ESWITCH ((OBJ &KEY (TEST #'EQL)) &BODY BODY)

Like switch but signals an error if no clause succeeds.

IF-BIND (VAR TEST &BODY THEN/ELSE)

Anaphoric IF control structure. VAR (a symbol) will be bound to the primary value of TEST. If TEST returns a true value then THEN will be executed, otherwise ELSE will be executed.

IF2-BIND (VAR TEST &BODY THEN/ELSE)

Anaphoric IF control structure for multiple values. VAR (a symbol) will be bound to the primary value of TEST. If TEST's second value is true then THEN will be executed, otherwise ELSE will be executed.

LAMBDA-REC (NAME ARGS &BODY BODY)

Just like lambda except BODY can make recursive calls to the lambda by calling the function NAME.

MATCH-CASE (FORM &REST CLAUSES)

NB: the clauses wil be compiled at macro expansion time.

MAXF (PLACE OTHER &ENVIRONMENT ENV)

Sets the place to new-value if new-value is #'> the current value

MINF (PLACE OTHER &ENVIRONMENT ENV)

Sets the place to new-value if new-value is #'< the current value

MULF (PLACE B &ENVIRONMENT ENV)

SETF NUM to the result of (* NUM B).

PPM1 (FORM)

(pprint (macroexpand-1 ',form)). NB: C-RET is even shorter.

PUSH* (PLACE &REST ITEMS &ENVIRONMENT ENV)

Pushes every element of ITEMS onto LIST. Equivalent to calling PUSH with each element of ITEMS.

REBINDING (BINDINGS &BODY BODY)

Bind each var in BINDINGS to a gensym, bind the gensym to var's value via a let, return BODY's value wrapped in this let. Evaluates a series of forms in the lexical environment that is formed by adding the binding of each VAR to a fresh, uninterned symbol, and the binding of that fresh, uninterned symbol to VAR's original value, i.e., its value in the current lexical environment. The uninterned symbol is created as if by a call to GENSYM with the string denoted by PREFIX - or, if PREFIX is not supplied, the string denoted by VAR - as argument. The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

REMF-KEYWORDS (PLACE &REST KEYWORDS &ENVIRONMENT ENV)

Creates a copy of PLIST without the properties identified by KEYWORDS.

SWITCH ((OBJ &KEY (TEST #'EQL)) &BODY CLAUSES)

Evaluate the first clause whose car satisfies (funcall test car obj).

WHEN-BIND (VAR TEST &BODY BODY)

Just like when except VAR will be bound to the result of TEST in BODY.

WHICHEVER (&REST POSSIBILITIES)

Evaluates one (and only one) of its args, which one is chosen at random

WITH-CALL/CC (&ENVIRONMENT E &BODY BODY)

Execute BODY with delimited partial continuations. Within the code of BODY almost all common lisp forms maintain their normal semantics. The following special forms are allowed: (call/cc LAMBDA) - LAMBDA, a one argument function, will be passed a continuation. This object may then be passed to the function KALL which will cause execution to resume around the call/cc form.

WITH-COLLECTOR ((NAME &OPTIONAL INITIAL-VALUE FROM-END) &BODY BODY)

Bind NAME to a collector function and execute BODY. If FROM-END is true the collector will actually be a pusher, (see MAKE-PUSHER), otherwise NAME will be bound to a collector, (see MAKE-COLLECTOR).

WITH-COLLECTORS (NAMES &BODY BODY)

Bind multiple collectors. Each element of NAMES should be a list as per WITH-COLLECTOR's first orgument.

WITH-INPUT-FROM-FILE ((STREAM-NAME FILE-NAME &REST ARGS &KEY (DIRECTION NIL DIRECTION-PROVIDED-P) EXTERNAL-FORMAT &ALLOW-OTHER-KEYS) &BODY BODY)

Evaluate BODY with STREAM-NAME bound to an input-stream from file FILE-NAME. ARGS is passed directly to open.

WITH-LISP1 (FORM)

Execute FORM as if it were run in a Lisp-1.

WITH-LOGGER-LEVEL (LOGGER-NAME NEW-LEVEL &BODY BODY)

Set the level of the listed logger(s) to NEW-LEVEL and restore the original value in an unwind-protect.

WITH-OUTPUT-TO-FILE ((STREAM-NAME FILE-NAME &REST ARGS &KEY (DIRECTION NIL DIRECTION-PROVIDED-P) EXTERNAL-FORMAT &ALLOW-OTHER-KEYS) &BODY BODY)

Evaluate BODY with STREAM-NAME to an output stream on the file named FILE-NAME. ARGS is sent as is to the call te open.

WITH-PRECISION (PREC &BODY BODY)

Evalute BODY with *precision* bound to PREC.

WITH-REDUCER ((NAME FUNCTION &OPTIONAL (INITIAL-VALUE NIL)) &BODY BODY)

Locally bind NAME to a reducing function. The arguments FUNCTION and INITIAL-VALUE are passed directly to MAKE-REDUCER.

WITH-UNIQUE-NAMES ((&REST BINDINGS) &BODY BODY)

Evaluate BODY with BINDINGS bound to fresh unique symbols. Syntax: WITH-UNIQUE-NAMES ( [ var | (var x) ]* ) declaration* form* Executes a series of forms with each VAR bound to a fresh, uninterned symbol. The uninterned symbol is as if returned by a call to GENSYM with the string denoted by X - or, if X is not supplied, the string denoted by VAR - as argument. The variable bindings created are lexical unless special declarations are specified. The scopes of the name bindings and declarations do not include the Xs. The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

XOR (&REST DATUMS)

Evaluates the args one at a time. If more than one arg returns true evaluation stops and NIL is returned. If exactly one arg returns true that value is returned.

Undocumented

AAND (&REST FORMS)

AND-BIND (VAR &REST FORMS)

DEFALIAS (FUNCTION REDEFINITION)

DEFLOGGER (NAME ANCESTORS &KEY COMPILE-TIME-LEVEL LEVEL APPENDER APPENDERS DOCUMENTATION)

DEFMACALIAS (MACRO REDEFINITION)

DEFMETHOD/CC (NAME &REST ARGS)

DEFUN/CC (NAME ARGUMENTS &BODY BODY)

DEFUNWALKER-HANDLER (CLASS (&REST SLOTS) &BODY BODY)

DEFVARALIAS (VARIABLE REDEFINITION)

DEFWALKER-HANDLER (NAME (FORM PARENT LEXICAL-ENV) &BODY BODY)

DO-RANGE ((INDEX &OPTIONAL MIN MAX STEP RETURN-VALUE) &BODY BODY)

ENABLE-SHARP-L-SYNTAX

EVAL-ALWAYS (&BODY BODY)

FUN (&REST ARGS-286)

LET/CC (K &BODY BODY)

LET1 (VAR VAL &BODY BODY)

LIST-MATCH-CASE (TARGET &BODY CLAUSES)

PPM (FORM)

REBIND (BINDINGS &BODY BODY)

WITH* (&BODY BODY)

Private

DEFLISP1-WALKER (CLASS (&REST SLOTS) &BODY BODY)

Define a Lisp-1 to Lisp-2 walker. It takes the class of a CL form object, and its slots as arguments. It also captures the variable FORM for convenience.

UNTIL (TEST &BODY BODY)

Repeat BODY until TEST is false. You may exit the loop with (RETURN-FROM UNTIL).

WHILE (TEST &BODY BODY)

Repeat BODY while TEST is true. You may exit the loop with (RETURN-FROM WHILE).

WITH-ACCESSORS* (ACCESSOR-NAMES OBJECT &BODY BODY)

Just like WITH-ACCESSORS, but if the slot-entry is a symbol assume the variable and accessor name are the same.

WITH-BOUND-FUNS (FUNS &BODY BODY)

Execute BODY with FUNS added to the function namespace and FUNS removed from the variable namespace. This should only be used when code-walking.

WITH-BOUND-VARS (VARS &BODY BODY)

Execute BODY with VARS added to the variable namespace and VARS removed from the function namespace. This should only be used when code-walking.

WITH-CLASS-SLOTS ((OBJECT CLASS-NAME &KEY EXCEPT) &BODY BODY)

Execute BODY as if in a with-slots form containig _all_ the slots of (find-clas CLASS-NAME). This macro, which is something of an ugly hack, inspects the class named by CLASS-NAME at macro expansion time. Should the class CLASS-NAME change form containing WITH-CLASS-SLOTS must be recompiled. Should the class CLASS-NAME not be available at macro expansion time WITH-CLASS-SLOTS will fail.

Undocumented

ACOND2 (&REST CLAUSES)

APPLY-KEY (KEY ELEMENT)

DEF-MATCHER (NAME ARGS &BODY BODY)

DEF-MATCHER-MACRO (NAME ARGS &BODY BODY)

DEFK (NAME ARGS K-ARGS &BODY BODY)

DO-ALL-ELEMENTS ((ELEMENT QUEUE &OPTIONAL INDEX) &BODY BODY)

EXTEND (ENVIRONMENT TYPE NAME DATUM &REST OTHER-DATUM)

EXTEND-WALK-ENV (ENV TYPE NAME DATUM &REST OTHER-DATUM)

INCF-MOD (PLACE DIVISOR)

KLAMBDA ((&OPTIONAL (VALUE (GENSYM) VALUEP) (OTHER-VALUES (GENSYM) OTHER-VALUES-P)) &BODY BODY)

MULTIPLE-VALUE-SETF (PLACES FORM)

REDEFUN/CC (NAME ARGS &BODY BODY)

RETK

SHARPL-EXPANDER (PACKAGE BODY MIN-ARGS &ENVIRONMENT ENV)

TRACE-STATEMENT (FORMAT-CONTROL &REST FORMAT-ARGS)

WITH-FORM-OBJECT ((VARIABLE TYPE &REST INITARGS) &BODY BODY)

WITH-LOGGING-IO (&BODY BODY)

GENERIC-FUNCTION

Public

HANDLE (CATEGORY MESSAGE LEVEL)

Message is either a string or a list. When it's a list and the first element is a string then it's processed as args to cl:format.

LISP1 (FORM)

Translate FORM from Lisp-1 to Lisp-2. Define methods on this generic function with DEFLISP1-WALKER.

UNWALK-FORM (FORM)

Unwalk FORM and return a list representation.

Undocumented

APPEND-MESSAGE (CATEGORY LOG-APPENDER MESSAGE LEVEL)

DEQUEUE (QUEUE &OPTIONAL (DEFAULT-VALUE))

ENQUEUE (QUEUE VALUE)

LOG.COMPILE-TIME-LEVEL (CAT)

SETFLOG.COMPILE-TIME-LEVEL (NEW-LEVEL CAT &OPTIONAL (RECURSIVE))

LOG.LEVEL (CAT)

SETFLOG.LEVEL (NEW-LEVEL CAT &OPTIONAL (RECURSIVE))

NEW (CLASS &REST INITARGS &ALLOW-OTHER-KEYS)

PEEK-QUEUE (QUEUE)

QUEUE->LIST (QUEUE)

QUEUE-COUNT (QUEUE)

QUEUE-EMPTY-P (QUEUE)

RANDOM-QUEUE-ELEMENT (QUEUE)

Private

ENVIRONMENT-P (ENVIRONMENT)

Returns T if ENVIRONMENT is a lexical environment object (something suitable for passing to macroexpand-1 or similar)

LEXICAL-FUNCTIONS (ENVIRONMENT)

Returns the names of all the local functions in ENVIRONMENT. Names may be symbols of lists of the form (setf name).

LEXICAL-MACROS (ENVIRONMENT)

Returns the lexical macro definitions in ENVIRONMENT. The return value is a list of elements of form (SYMBOL . MACRO-FUNCTION. MACRO-FUNCTION can be called like functions returned by macro-function.

LEXICAL-SYMBOL-MACROS (ENVIRONMENT)

Returns the lexical symbol macro definitions in ENVIRONMENT. The return value is a list of elements of form (SYMBOL . EXPANSION).

LEXICAL-VARIABLES (ENVIRONMENT)

Return the names of all the local variables in ENVIRONMENT. Does not return neither symbol-macrolets nor ignared variables.

Undocumented

APPLY-LAMBDA/CC (OPERATOR EFFECTIVE-ARGUMENTS DYN-ENV K)

AUGMENT-WITH-FUNCTION (ENV FUN)

AUGMENT-WITH-MACRO (ENV MAC DEF)

AUGMENT-WITH-SYMBOL-MACRO (ENV SYMMAC DEF)

AUGMENT-WITH-VARIABLE (ENV VAR)

BLOCK-NAME (CONDITION)

SETFBLOCK-NAME (NEW-VALUE CONDITION)

CALL-FOR-ALL-ELEMENTS-WITH-INDEX (QUEUE CALLBACK)

COMPILE-TIME-ENABLED-P (CAT LEVEL)

EFFECTIVE-KEYWORD-NAME (K)

ENABLED-P (CAT LEVEL)

ENCLOSING-CODE (CONDITION)

SETFENCLOSING-CODE (NEW-VALUE CONDITION)

ENQUEUE-OR-MOVE-TO-FRONT (QUEUE ELEMENT &KEY (TEST #'EQL) (KEY #'IDENTITY))

EVALUATE/CC (FORM LEXICAL-ENVIRONMENT DYNAMIC-ENVIRONMENT K)

GO-TAG-FORM-P (OBJECT)

GROW-QUEUE (QUEUE)

HTML-ESCAPE-ERROR.WHAT (CONDITION)

SETFHTML-ESCAPE-ERROR.WHAT (NEW-VALUE CONDITION)

MOVE-HEAD (QUEUE)

MOVE-TAIL (QUEUE)

PROCESS-STEP (OP COMP OUTPUT-FILE)

QUEUE-FULL-P (QUEUE)

REQUIRED-FUNCTION-ARGUMENT-FORM-P (OBJECT)

URI-PARSE-ERROR.WHAT (CONDITION)

SLOT-ACCESSOR

Public

ANCESTORS (OBJECT)

The log categories this category inherits from.

SETFANCESTORS (NEW-VALUE OBJECT)

The log categories this category inherits from.

APPENDERS (OBJECT)

A list of appender objects this category sholud send messages to.

SETFAPPENDERS (NEW-VALUE OBJECT)

A list of appender objects this category sholud send messages to.

CHILDREN (OBJECT)

The log categories which inherit from this category.

SETFCHILDREN (NEW-VALUE OBJECT)

The log categories which inherit from this category.

Undocumented

ARGUMENTS (OBJECT)

SETFARGUMENTS (NEW-VALUE OBJECT)

BINDS (OBJECT)

SETFBINDS (NEW-VALUE OBJECT)

BODY (OBJECT)

SETFBODY (NEW-VALUE OBJECT)

CLEANUP-FORM (OBJECT)

SETFCLEANUP-FORM (NEW-VALUE OBJECT)

CODE (OBJECT)

SETFCODE (NEW-VALUE OBJECT)

CONSEQUENT (OBJECT)

SETFCONSEQUENT (NEW-VALUE OBJECT)

DECLARES (OBJECT)

SETFDECLARES (NEW-VALUE OBJECT)

DEFAULT-VALUE (OBJECT)

SETFDEFAULT-VALUE (NEW-VALUE OBJECT)

ENCLOSING-TAGBODY (OBJECT)

SETFENCLOSING-TAGBODY (NEW-VALUE OBJECT)

EVAL-WHEN-TIMES (OBJECT)

SETFEVAL-WHEN-TIMES (NEW-VALUE OBJECT)

FIRST-FORM (OBJECT)

SETFFIRST-FORM (NEW-VALUE OBJECT)

FUNC (OBJECT)

SETFFUNC (NEW-VALUE OBJECT)

KEYWORD-NAME (OBJECT)

SETFKEYWORD-NAME (NEW-VALUE OBJECT)

NAME (CONDITION)

SETFNAME (NEW-VALUE CONDITION)

OPERATOR (OBJECT)

SETFOPERATOR (NEW-VALUE OBJECT)

OPTIMIZE-SPEC (OBJECT)

SETFOPTIMIZE-SPEC (NEW-VALUE OBJECT)

OTHER-FORMS (OBJECT)

SETFOTHER-FORMS (NEW-VALUE OBJECT)

PARENT (OBJECT)

SETFPARENT (NEW-VALUE OBJECT)

PROTECTED-FORM (OBJECT)

SETFPROTECTED-FORM (NEW-VALUE OBJECT)

READ-ONLY-P (OBJECT)

SETFREAD-ONLY-P (NEW-VALUE OBJECT)

RESULT (OBJECT)

SETFRESULT (NEW-VALUE OBJECT)

SOURCE (OBJECT)

SETFSOURCE (NEW-VALUE OBJECT)

SUPPLIED-P-PARAMETER (OBJECT)

SETFSUPPLIED-P-PARAMETER (NEW-VALUE OBJECT)

TAG (OBJECT)

SETFTAG (NEW-VALUE OBJECT)

TARGET-BLOCK (OBJECT)

SETFTARGET-BLOCK (NEW-VALUE OBJECT)

TARGET-PROGN (OBJECT)

SETFTARGET-PROGN (NEW-VALUE OBJECT)

THEN (OBJECT)

SETFTHEN (NEW-VALUE OBJECT)

TYPE-FORM (OBJECT)

SETFTYPE-FORM (NEW-VALUE OBJECT)

VALUE (OBJECT)

SETFVALUE (NEW-VALUE OBJECT)

VALUES-FORM (OBJECT)

SETFVALUES-FORM (NEW-VALUE OBJECT)

VAR (OBJECT)

SETFVAR (NEW-VALUE OBJECT)

VARS-FORM (OBJECT)

SETFVARS-FORM (NEW-VALUE OBJECT)

Private

BYTES-CONSED (OBJECT)

Number of bytes allocated.

SETFBYTES-CONSED (NEW-VALUE OBJECT)

Number of bytes allocated.

COMPILE-TIME-LEVEL (OBJECT)

This category's compile time log level. Any log expression below this level will macro-expand to NIL.

SETFCOMPILE-TIME-LEVEL (NEW-VALUE OBJECT)

This category's compile time log level. Any log expression below this level will macro-expand to NIL.

GC-TIME (OBJECT)

GC time. Expressed in milliseconds.

SETFGC-TIME (NEW-VALUE OBJECT)

GC time. Expressed in milliseconds.

LEVEL (OBJECT)

This category's log level.

SETFLEVEL (NEW-VALUE OBJECT)

This category's log level.

LOG-FILE (OBJECT)

Name of the file to write log messages to.

SETFLOG-FILE (NEW-VALUE OBJECT)

Name of the file to write log messages to.

PAGE-FAULTS (OBJECT)

Number of page faults.

SETFPAGE-FAULTS (NEW-VALUE OBJECT)

Number of page faults.

REAL-TIME (OBJECT)

Real time (also known as wall time) consumed. Expressed in milliseconds.

SETFREAL-TIME (NEW-VALUE OBJECT)

Real time (also known as wall time) consumed. Expressed in milliseconds.

SYSTEM-TIME (OBJECT)

System time. Expressed in milliseconds.

SETFSYSTEM-TIME (NEW-VALUE OBJECT)

System time. Expressed in milliseconds.

USER-TIME (OBJECT)

User time. Expressed in milliseconds.

SETFUSER-TIME (NEW-VALUE OBJECT)

User time. Expressed in milliseconds.

Undocumented

BUFFER (OBJECT)

SETFBUFFER (NEW-VALUE OBJECT)

ELSE (OBJECT)

SETFELSE (NEW-VALUE OBJECT)

ENV (OBJECT)

SETFENV (NEW-VALUE OBJECT)

FOR-OP (OBJECT)

SETFFOR-OP (NEW-VALUE OBJECT)

HEAD-INDEX (OBJECT)

SETFHEAD-INDEX (NEW-VALUE OBJECT)

LOG-STREAM (OBJECT)

SETFLOG-STREAM (NEW-VALUE OBJECT)

SPECIALIZER (OBJECT)

SETFSPECIALIZER (NEW-VALUE OBJECT)

TAIL-INDEX (OBJECT)

SETFTAIL-INDEX (NEW-VALUE OBJECT)

VERBOSITY-OF (OBJECT)

SETFVERBOSITY-OF (NEW-VALUE OBJECT)

VARIABLE

Public

*DEBUG-EVALUATE/CC*

When non NIL the evaluator will print, at each evaluation step, what it's evaluating and the value passed in from the previous step. If set to :FULL then at each step we print the form, the environment and the continuation. If set to T we just print the form being evaluated.

*PRECISION*

Default precision.

*TRACE-CC*

Variable which controls the tracing of WITH-CALL/CC code. When not NIL the interepreter will report what code it is evaluating and what it returns.

*WARN-UNDEFINED*

When non-NIL any references to undefined functions or variables will signal a warning.

+ALPHANUMERIC-ASCII-ALPHABET+

All the letters and numbers in 7 bit ASCII.

+ASCII-ALPHABET+

All letters in 7 bit ASCII.

+BASE64-ALPHABET+

All the characters allowed in base64 encoding.

+CR-LF+

A string containing the two characters CR and LF.

+LOWER-CASE-ASCII-ALPHABET+

All the lower case letters in 7 bit ASCII.

+UPPER-CASE-ASCII-ALPHABET+

All the upper case letters in 7 bit ASCII.

~%

A string containing a single newline

~T

A string containing a single tab character.

Undocumented

*CALL/CC-RETURNS*

Private

*BOUND-FUNS*

When walking code, this variable contains a list of variables (represented by symbols) which have been bound in the function namespace. In essence these variables must be sharp-quoted.

*BOUND-VARS*

When walking code, this variable contains a list of variables (represented by symbols) which have been bound in the variable namespace. In essence these variables do not have to be sharp-quoted.

*LOGGER*

Global var for the LOGGER lookup table

*MATCH-HANDLER*

Table mapping symbol names to the matching function

Undocumented

*CC-FUNCTIONS*

*HTML-ENTITES*

*LOG-LEVEL-NAMES*

*MAX-CATEGORY-NAME-LENGTH*

*TOPLEVEL-K*

*URI-ESCAPING-OK-TABLE*

*WALKER-HANDLERS*

+ATOM-MARKER+

CLASS

Public

BRIEF-STREAM-LOG-APPENDER

A subclass of stream-log-appender with minimal 'overhead' text in log messages. This amounts to: not printing the package names of log categories and log levels and a more compact printing of the current time.

CLEAN-OP

Removes any files generated by an asdf component.

FILE-LOG-APPENDER

Logs to a file. the output of the file logger is not meant to be read directly by a human.

LOCAL-LEXICAL-VARIABLE-REFERENCE

A reference to a local variable defined in the lexical environment outside of the form passed to walk-form.

LRU-QUEUE

A queue which never grows. When an element is enqueued and the buffer is full we simply drop the last element.

STREAM-LOG-APPENDER

Human readable to the console logger.

VERBOSE-STREAM-LOG-APPENDER

A subclass of stream-log-appender which attempts to be as precise as possible, category names and log level names are printed with a package prefix and the time is printed in long format.

Undocumented

ALLOW-OTHER-KEYS-FUNCTION-ARGUMENT-FORM

APPLICATION-FORM

BINDING-FORM-MIXIN

BLOCK-FORM

CATCH-FORM

CONSTANT-FORM

DECLARATION-FORM

EVAL-WHEN-FORM

FLET-FORM

FORM

FREE-APPLICATION-FORM

FREE-FUNCTION-OBJECT-FORM

FREE-VARIABLE-REFERENCE

FUNCTION-ARGUMENT-FORM

FUNCTION-BINDING-FORM

FUNCTION-FORM

FUNCTION-OBJECT-FORM

GO-FORM

GO-TAG-FORM

IF-FORM

IMPLICIT-PROGN-MIXIN

IMPLICIT-PROGN-WITH-DECLARE-MIXIN

KEYWORD-FUNCTION-ARGUMENT-FORM

LABELS-FORM

LAMBDA-APPLICATION-FORM

LAMBDA-FUNCTION-FORM

LET*-FORM

LET-FORM

LEXICAL-APPLICATION-FORM

LEXICAL-FUNCTION-OBJECT-FORM

LOCAL-APPLICATION-FORM

LOCAL-FUNCTION-OBJECT-FORM

LOCAL-VARIABLE-REFERENCE

LOCALLY-FORM

LOG-CATEGORY

MACROLET-FORM

MULTIPLE-VALUE-CALL-FORM

MULTIPLE-VALUE-PROG1-FORM

OPTIONAL-FUNCTION-ARGUMENT-FORM

PROGN-FORM

PROGV-FORM

QUEUE

REQUIRED-FUNCTION-ARGUMENT-FORM

REST-FUNCTION-ARGUMENT-FORM

RETURN-FROM-FORM

SETQ-FORM

SPECIALIZED-FUNCTION-ARGUMENT-FORM

SYMBOL-MACROLET-FORM

TAGBODY-FORM

THE-FORM

THROW-FORM

UNWIND-PROTECT-FORM

VARIABLE-BINDING-FORM

VARIABLE-REFERENCE

Private

TIMING-INFO

Specificer for collect-timing info. Every slot is either a number (with the exact meanining depending on the slot) or the keyword :not-available in the case the lisp doesn't provide this information.

Undocumented

APPENDER

CLOSURE/CC

DYNAMIC-EXTENT-DECLARATION-FORM

FTYPE-DECLARATION-FORM

FUNCTION-DECLARATION-FORM

FUNCTION-IGNORABLE-DECLARATION-FORM

IGNORABLE-DECLARATION-FORM-MIXIN

LOAD-TIME-VALUE-FORM

MATCH-STATE

NOTINLINE-DECLARATION-FORM

OPTIMIZE-DECLARATION-FORM

SPECIAL-DECLARATION-FORM

TYPE-DECLARATION-FORM

VARIABLE-DECLARATION-FORM

VARIABLE-IGNORABLE-DECLARATION-FORM

CONDITION

Public

Undocumented

EXPECTED-DIGIT-URI-PARSE-ERROR

RETURN-FROM-UNKNOWN-BLOCK

UNDEFINED-FUNCTION-REFERENCE

UNDEFINED-REFERENCE

UNDEFINED-VARIABLE-REFERENCE

URI-PARSE-ERROR

Private

Undocumented

HTML-ESCAPE-ERROR

UNKNOWN-CHAR-ESCAPE

UNKNOWN-HTML-ENTITY

UNTERMINATED-HTML-ENTITY

CONSTANT

Public

Undocumented

+DEBUG+

+DRIBBLE+

+ERROR+

+FATAL+

+INFO+

+WARN+