[slime-devel] Re: Automatic "semantic" indentation

[Bill_Clementson at peoplesoft.com]

Luke Gorrie <luke at bluetail.com> writes:

> Bill_Clementson at peoplesoft.com writes:
>
> > Here is the documentation for excl:arglist:
> > arglist
> > Arguments: function
> >
> > Returns two values: if the the argument list of the operator (function,
> > generic function, or macro) specified by the argument is known, it and
t
> > are returned. If the argument list is not known (that information can
be
> > discarded to save space), nil and nil are returned. Note that some
argument
> > lists may be uninformative (perhaps simply &rest args) when a function
does
> > all argument processing within its body. Also, the compiler may have
> > simplified the argument list for its purposes. This function is
designed to
> > assist only.
>
> I'm guessing this is a case where the compiler has simplified the
> argument list for its purposes. One fix would be to scan the arglist
> to make sure it's properly terminated, and otherwise ignore it. But
> maybe that way we would miss some useful information.
>
> Could you please post the (voluminous) output of this, just to see if
> we can pick a meaningful pattern in their arglist formats?
>
>   (let ((arglists '()))
>     (do-all-symbols (sym)
>       (when (macro-function sym)
>         (push (list sym (arglist sym)) arglists)))
>     arglists)

Sorry for the tardy response. I had to modify this a bit for ACL - here is
the output.

CL-USER> (let ((arglists '()))
    (do-all-symbols (sym)
      (when (macro-function sym)
        (push (list sym (if (ignore-errors (arglist sym)) (arglist sym)
:not-function-or-macro)) arglists)))
    arglists)
((TOP-LEVEL:ALIAS (TOP-LEVEL::NAME TOP-LEVEL::ARGS &REST
                   TOP-LEVEL::BODY))
 (TOP-LEVEL:SETQ-DEFAULT (TOP-LEVEL::VAR TOP-LEVEL::VALUE))
 (TOP-LEVEL::DO-WITH-VENV
   ((TOP-LEVEL::VENV SYMBOL TOP-LEVEL::VALUE &OPTIONAL TOP-LEVEL::INDEX
     TOP-LEVEL::RESULT-FORM)
    &REST TOP-LEVEL::BODY))
 (TOP-LEVEL::DEAD-LOCAL-P (TOP-LEVEL::NAME))
 (TOP-LEVEL::DO-WITH-VENV-PAIR
   ((TOP-LEVEL::VENV TOP-LEVEL::PAIR &OPTIONAL TOP-LEVEL::INDEX
     TOP-LEVEL::RESULT-FORM)
    &REST TOP-LEVEL::BODY))
 (SYSTEM:WITH-COMMAND-LINE-ARGUMENTS
   ((&REST SYSTEM::OPTION-LISTS)
    (SYSTEM::RESTVAR &KEY SYSTEM:COMMAND-LINE-ARGUMENTS SYSTEM::USAGE
     SYSTEM::POSIXLY-CORRECT SYSTEM::LONG-ABBREV)
    &BODY SYSTEM::BODY))
 (SYSTEM:RECORD-CODE-VECTORS
   ((SYSTEM::FILE &KEY SYSTEM::VERBOSE) &BODY SYSTEM::BODY))
 (SYSTEM:DEFPATCH (EXCL::ID EXCL::VERSION EXCL::DESC &REST EXCL::ARGS
                   &KEY EXCL::COMPILE-FEATURE EXCL::SUPERSEDED
                   EXCL::WITHDRAWN &ALLOW-OTHER-KEYS))
 (SYSTEM:RECORD-STRINGS (SYSTEM::FILE &BODY SYSTEM::BODY))
 (SYSTEM::TARGET-MDPARAM (SYSTEM::NAME &REST SYSTEM::ARGS))
 (SYSTEM::WITH-HOST-AS-TARGET (&BODY SYSTEM::BODY))
 (SYSTEM::PRESTO-FLC-FILENAME (SYSTEM::N))
 (SWANK-BACKEND::DEFXREF
   (SWANK-BACKEND::NAME SWANK-BACKEND::RELATION SWANK-BACKEND::NAME1
    SWANK-BACKEND::NAME2))
 (SWANK-BACKEND::WITH-COMPILATION-HOOKS
   ((&REST IGNORE) &BODY SWANK-BACKEND::BODY))
 (SWANK-BACKEND::DEFIMPLEMENTATION
   (SWANK-BACKEND::NAME SWANK-BACKEND::ARGS &BODY SWANK-BACKEND::BODY))
 (SWANK-BACKEND::DEFINTERFACE
   (SWANK-BACKEND::NAME SWANK-BACKEND::ARGS DOCUMENTATION &BODY
    SWANK-BACKEND::DEFAULT-BODY))
 (SWANK::DESTRUCTURE-CASE (SWANK::VALUE &REST SWANK::PATTERNS))
 (SWANK::DEFSLIMEFUN (SWANK::NAME SWANK-BACKEND:ARGLIST &BODY REST))
 (SWANK::WITHOUT-INTERRUPTS (&BODY SWANK::BODY))
 (SWANK::WITH-IO-REDIRECTION ((SWANK::CONNECTION) &BODY SWANK::BODY))
 (SWANK::WITH-TEMP-PACKAGE (SWANK::VAR &BODY SWANK::BODY))
 (SWANK::WITH-READER-ERROR-HANDLER
   ((SWANK::CONNECTION) &BODY SWANK::BODY))
 (SWANK::WITH-CONNECTION ((SWANK::CONNECTION) &BODY SWANK::BODY))
 (PROFILER:SAVE-CURRENT-PROFILE (VARIABLE))
 (PROFILER:WITH-PROFILING
   ((&KEY TYPE PROFILER::EXCEPT-STACK-GROUPS PROFILER::EXCEPT-PROCESSES
     COUNT PROFILER::COUNT-LIST PROFILER::VERBOSE
     PROFILER::START-SAMPLING-P PROFILER::INTERPRET-CLOSURES)
    &BODY PROFILER::BODY))
 (PROFILER:WITH-SAMPLING
   ((&KEY PROFILER::VERBOSE) &BODY PROFILER::BODY))
 (PROFILER::PREPARING-ANALYSIS
   ((PROFILER::CURRENT-PROFILE PROFILER::VERBOSE) &BODY
    PROFILER::BODY))
 (PROFILER::PREPARING-PROFILE-ANALYSIS
   ((PROFILER::PROFILE PROFILER::VERBOSE PROFILER::FLAT) &BODY
    PROFILER::BODY))
 (NET.URI:DO-ALL-URIS ((NET.URI::VAR &OPTIONAL NET.URI:URI-SPACE
                        NET.URI::RESULT-FORM)
                       &REST NET.URI::FORMS))
 (MULTIPROCESSING:PROCESS-IMPLEMENTATION (MULTIPROCESSING:PROCESS))
 (MULTIPROCESSING:WITH-PROCESS-LOCK
   ((MULTIPROCESSING::LOCK &KEY MULTIPROCESSING::TIMEOUT
     MULTIPROCESSING::NORECURSIVE MULTIPROCESSING::SEIZED
     MULTIPROCESSING::WHOSTATE)
    &BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING:WITHOUT-SCHEDULING (&BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING:WITH-TIMEOUT
   ((MULTIPROCESSING::SECONDS &BODY MULTIPROCESSING::TIMEOUT-BODY)
    &BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING:WAITING-FOR-INPUT-AVAILABLE
   ((MULTIPROCESSING::STREAM-OR-FD) &BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING::PROCESS-THROW :NOT-FUNCTION-OR-MACRO)
 (MULTIPROCESSING::WITH-CLOCK-ENABLED
   (MULTIPROCESSING:PROCESS &BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING::THREAD-THROW :NOT-FUNCTION-OR-MACRO)
 (MULTIPROCESSING::PPFORMAT
   (MULTIPROCESSING::F MULTIPROCESSING::S &REST MULTIPROCESSING::ARGS))
 (MULTIPROCESSING::WITHOUT-MESSAGE-INTERRUPTS
   (&BODY MULTIPROCESSING::BODY))
 (MULTIPROCESSING::WITHOUT-SCHEDULING-INTERNAL
   (&BODY MULTIPROCESSING::BODY))
 (LEP:DEFINE-REPLY (LEP::NAME LEP::TYPES &OPTIONAL LEP::ARGS &BODY
                    LEP::BODY))
 (LEP:WITH-OUTPUT-TO-TEMP-BUFFER
   ((STREAM LEP::BUFFER-NAME &REST LEP::OPTIONS) &BODY LEP::BODY))
 (LEP:WITH-EDITOR-LISTENER-STREAM
   ((STREAM &REST LEP::OPTIONS) &BODY LEP::BODY))
 (LEP:DEFINE-QUERY (FUNCTION LEP::LAMBDA-LIST
                             LEP::TYPES
                             (&REST LEP::OPTIONS &KEY LEP::REPLYP
                              &ALLOW-OTHER-KEYS)
                             LEP::ELISP-FUNCTION-AND-ARGUMENTS))
 (LEP:WITH-EDITOR-OUTPUT
   ((STREAM LEP::BUFFER-NAME &REST LEP::OPTIONS) &BODY LEP::BODY))
 (LEP::WITH-OUTPUT-TO-SESSION ((STREAM LEP::SESSION) &BODY LEP::BODY))
 (LEP::REQUEST-CASE ((LEP::SESSION &KEY TYPE) &REST LEP::CLAUSES))
 (LEP::WITH-BACKGROUND-EVAL-STREAMS
   ((&OPTIONAL STREAM &REST LEP::OPTIONS) &BODY LEP::BODY))
 (LEP::WITH-CONNECTION ((LEP::CONNECTION) &BODY LEP::BODY))
 (LEP::WITH-SESSION-ERROR-HANDLING
   ((LEP::SESSION LEP::ARGS) &BODY LEP::BODY))
 (LEP::WITH-OUTPUT-TO-CONNECTION
   ((STREAM LEP::CONNECTION) &BODY LEP::BODY))
 (LEP::WITH-OUTPUT-TO-HIDDEN-BUFFER
   ((STREAM LEP::BUFFER-NAME &REST LEP::OPTIONS) &BODY LEP::BODY))
 (LEP::WITH-KEYWORDS ((EXCL::NEW EXCL::OLD LEP::KEYWORDS) &BODY
                      LEP::BODY))
 (LEP::WITH-SESSION ((LEP::SESSION &REST LEP::INITARGS) &BODY
                     LEP::BODY))
 (INSPECT::INSPECT-INIT :NOT-FUNCTION-OR-MACRO)
 (FOREIGN-FUNCTIONS:DEFCSTRUCT (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FOREIGN-FUNCTIONS:DEF-FOREIGN-CALL
   (FOREIGN-FUNCTIONS::NAME-AND-OPTIONS FOREIGN-FUNCTIONS::ARGS &KEY
    FOREIGN-FUNCTIONS::CALL-DIRECT FOREIGN-FUNCTIONS::CALLBACK
    FOREIGN-FUNCTIONS::CONVENTION FOREIGN-FUNCTIONS::RETURNING
    FOREIGN-FUNCTIONS::METHOD-INDEX FOREIGN-FUNCTIONS::RELEASE-HEAP
    FOREIGN-FUNCTIONS::RELEASE-HEAP-IGNORABLE
    FOREIGN-FUNCTIONS::ARG-CHECKING
    FOREIGN-FUNCTIONS::OPTIMIZE-FOR-SPACE
    FOREIGN-FUNCTIONS::STRINGS-CONVERT FOREIGN-FUNCTIONS::ERROR-VALUE))
 (FOREIGN-FUNCTIONS:DEF-FOREIGN-TYPE
   (FOREIGN-FUNCTIONS::NAME FOREIGN-FUNCTIONS::DEFINITION))
 (FOREIGN-FUNCTIONS:WITH-STACK-FOBJECT
   ((FOREIGN-FUNCTIONS::VAR TYPE &REST FOREIGN-FUNCTIONS::ETC) &REST
    FOREIGN-FUNCTIONS::BODY))
 (FOREIGN-FUNCTIONS:DEFUN-C-CALLABLE
   (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FOREIGN-FUNCTIONS:DEFUN-FOREIGN-CALLABLE
   (FOREIGN-FUNCTIONS::NAME ARGLIST &REST FOREIGN-FUNCTIONS::BODY))
 (FOREIGN-FUNCTIONS:DEF-FOREIGN-VARIABLE
   (FOREIGN-FUNCTIONS::NAME-AND-OPTIONS &KEY TYPE
    FOREIGN-FUNCTIONS::CONVENTION))
 (FOREIGN-FUNCTIONS:DEF-C-TYPEDEF (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FOREIGN-FUNCTIONS:DEF-C-TYPE (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FOREIGN-FUNCTIONS:WITH-STACK-FOBJECTS
   (FOREIGN-FUNCTIONS::BIND-CLAUSES &REST FOREIGN-FUNCTIONS::BODY))
 (FOREIGN-FUNCTIONS:DEFFOREIGN (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FOREIGN-FUNCTIONS::DEF-PRIM-TYPE
   (FOREIGN-FUNCTIONS::NAME FOREIGN-FUNCTIONS::BYTES
    FOREIGN-FUNCTIONS::ACCESS-KEY FOREIGN-FUNCTIONS::ALIGN))
 (FOREIGN-FUNCTIONS::FAST-FOREIGN-POINTER-ADDRESS
   (FOREIGN-FUNCTIONS::FP))
 (EXCL.SCM::WITH-CACHED-OPEN-FILE
   ((EXCL.SCM::FILENAME &REST EXCL.SCM::OPTIONS) &BODY EXCL.SCM::BODY))
 (NAMED-FUNCTION (EXCL::FUNCTION-SPEC EXCL::LAMBDA-EXPRESSION))
 (CREATE-NEWLINE-EF (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (REMOVE-STREAM-INSTANCE-FLAGS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DEFSYSTEM (DEFSYSTEM:SYSTEM-NAME DEFSYSTEM::OPTIONS &BODY
              DEFSYSTEM:MODULES))
 (ICS-TARGET-CASE (&BODY EXCL::CLAUSES))
 (WITH-STACK-LIST* ((EXCL::VAR &REST EXCL::ELEMENTS) &BODY EXCL::BODY))
 (WHILE (CONDITION &REST EXCL::FORMS))
 (SM (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITHOUT-INTERRUPTS (&BODY EXCL::BODY))
 (DEF-OCTETS-TO-CHAR-MACRO (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (CALL-NEXT-FWRAPPER :NOT-FUNCTION-OR-MACRO)
 (DEF-EF-SWITCH-TO-RUNTIME (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITH-OUTPUT-TO-BUFFER
   ((EXCL::VAR EXCL::BUFFER &KEY EXTERNAL-FORMAT) &BODY EXCL::BODY))
 (WITH-BREAKPOINTS-INSTALLED (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITHOUT-REDEFINITION-WARNINGS (&BODY EXCL::BODY))
 (COMPOSE-EXTERNAL-FORMATS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITH-INPUT-FROM-BUFFER
   ((EXCL::VAR EXCL::BUFFER &KEY EXCL::INDEX EXCL::START EXCL::END
     EXTERNAL-FORMAT)
    &BODY EXCL::BODY))
 (DEFUN-PROTO (EXCL::NAME EXCL::VARLIST &REST EXCL::BODY))
 (WITH-SIGNAL-HANDLER ((EXCL::SIGNO FUNCTION) &REST EXCL::BODY))
 (DEF-LOCALE (EXCL::NAME &REST EXCL::ARGS))
 (ADD-STREAM-INSTANCE-FLAGS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FUNCALL-STM-HANDLER (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITH-STREAM-CLASS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITH-NAMED-READTABLE ((EXCL::NAME) &BODY EXCL::BODY))
 (ADVISE (EXCL::FSPEC CLASS EXCL::NAME POSITION &REST EXCL::FORMS))
 (UNADVISE (&OPTIONAL EXCL::FSPEC CLASS EXCL::NAME))
 (IF* (&REST EXCL::ARGS))
 (DEF-EXTERNAL-FORMAT (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (CHAR-TO-OCTETS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DEF-STREAM-CLASS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DEF-FWRAPPER (EXCL::NAME ARGLIST &REST EXCL::BODY))
 (DEF-CHAR-TO-OCTETS-MACRO (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (FUNCALL-STM-HANDLER-2 (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DEFADVICE (EXCL::FSPEC EXCL::WHERE &REST EXCL::FORMS))
 (UNDEFSYSTEM (DEFSYSTEM:SYSTEM-NAME)) (TENURING (&BODY EXCL::BODY))
 (UNTIL (CONDITION &REST EXCL::FORMS))
 (DEF-FUNCTION-SPEC-HANDLER (SYMBOL ARGLIST &BODY EXCL::BODY))
 (PRELOAD-FORMS :NOT-FUNCTION-OR-MACRO)
 (ERRORSET (EXCL::FORM &OPTIONAL EXCL::ANNOUNCE EXCL::CATCH-BREAKS))
 (WITH-STACK-LIST ((EXCL::VAR &REST EXCL::ELEMENTS) &BODY EXCL::BODY))
 (WITHOUT-PACKAGE-LOCKS (&BODY EXCL::BODY))
 (LOAD-APPLICATION (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (OCTETS-TO-CHAR (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (WITH-NATIVE-STRING ((EXCL::NATIVE-STRING-VAR EXCL::STRING-EXP &KEY
                       EXCL::START EXCL::END EXCL::NATIVE-LENGTH-VAR
                       EXTERNAL-FORMAT)
                      &BODY EXCL::BODY))
 (EXCL::DEFAUTOCONSTRUCTOR (EXCL::NAME CLASS))
 (EXCL::WITH-STRING-CONCAT (&REST EXCL::BODY))
 (EXCL::COPY-USB8-UP (EXCL::FROM-VECTOR EXCL::FROM-START
                      EXCL::TO-VECTOR EXCL::TO-START COUNT))
 (EXCL::STD-INSTANCE-SLOTS (EXCL::X))
 (EXCL::DEFINEF (EXCL::NAME EXCL::FORM))
 (EXCL::LOOP-COLLECT-RPLACD
   ((EXCL::HEAD-VAR EXCL::TAIL-VAR &OPTIONAL EXCL::USER-HEAD-VAR)
    EXCL::FORM))
 (EXCL::DEFSETF-CXXR (EXCL::NAME EXCL::ACCESS EXCL::GET-FCN
                      EXCL::SET-FCN))
 (EXCL::RESTART-CASE-IF (EXCL::PREDICATE EXCL::EXPRESSION &BODY
                         EXCL::CLAUSES))
 (EXCL::LOOP-COPYLIST* (EXCL::L))
 (EXCL::WITH-LOOP-LIST-COLLECTION-HEAD
   ((EXCL::HEAD-VAR EXCL::TAIL-VAR &OPTIONAL EXCL::USER-HEAD-VAR) &BODY
    EXCL::BODY))
 (EXCL::FSC-INSTANCE-SLOTS (EXCL::FIN))
 (EXCL::TREF (EXCL::TRIE EXCL::KEY))
 (EXCL::LOOP-ACCUMULATE-MINIMAX-VALUE
   (EXCL::LM EXCL::OPERATION EXCL::FORM))
 (EXCL::WRAPPER-STATE (EXCL::WRAPPER))
 (EXCL::INSTANCE-READ (EXCL::PV-OFFSET EXCL::PARAMETER POSITION
                       EXCL::SLOT-NAME))
 (EXCL::EFFECTIVE-METHOD-PRELOAD-FORM :NOT-FUNCTION-OR-MACRO)
 (EXCL::PPRINT-POP+ (EXCL::ARGS EXCL::XP))
 (EXCL::WRAPPER-INSTANCE-SLOTS-LAYOUT (EXCL::WRAPPER))
 (EXCL::INCF-COMPLEX (EXCL::%REFERENCE &OPTIONAL EXCL::DELTA))
 (EXCL::COMPILER-DO-XREF (EXCL::NAME EXCL::RELATION))
 (EXCL::REQUIRED-TOP-LEVEL-BINDING (VARIABLE EXCL::FORM-TO-EVAL))
 (EXCL::WRAPPER-SPECIFIED-IN-MOP-P (EXCL::WRAPPER))
 (EXCL::INTERNAL-ECASE (EXCL::KEYFORM &REST EXCL::CASES))
 (EXCL::STREAM-BUILD-EF-MACROS (STREAM EXTERNAL-FORMAT))
 (EXCL::SLOT-VALUE-USING-CLASS-NAME
   (&WHOLE EXCL::WHOLE CLASS-NAME EXCL::OBJECT EXCL::SLOTD-NAME
    &OPTIONAL EXCL::NAMING-SYMBOL))
 (EXCL::WRAPPER-CLASS (EXCL::WRAPPER))
 (EXCL::WALKER-ENVIRONMENT-BIND
   ((EXCL::VAR EXCL::ENV &REST EXCL::KEY-ARGS) &BODY EXCL::BODY))
 (EXCL::WRAPPER-CLASS-SLOTS (EXCL::WRAPPER))
 (EXCL::ICS-TARGET-ECASE (EXCL::CLAUSES))
 (EXCL::GET-WALKER-TEMPLATE-INTERNAL (EXCL::X))
 (EXCL::WITH-MINIMAX-VALUE (EXCL::LM &BODY EXCL::BODY))
 (EXCL::DEFINE-COMPLEX-PARSER (EXCL::WHAT &OPTIONAL FUNCTION))
 (EXCL::WITH-AUGMENTED-ENVIRONMENT
   ((EXCL::NEW-ENV EXCL::OLD-ENV &KEY EXCL::FUNCTIONS EXCL::MACROS
     EXCL::SYMBOL-MACROS)
    &BODY EXCL::BODY))
 (EXCL::DEF-AUTOLOAD-GENERIC-FUNCTION
   (EXCL::NAME EXCL::FILE EXCL::FORMALS EXCL::ACTUALS))
 (EXCL::STD-INSTANCE-LOC (EXCL::X))
 (EXCL::DEFUN-PROTO-1 :NOT-FUNCTION-OR-MACRO)
 (EXCL::STD-INSTANCE-CLASS (EXCL::INSTANCE))
 (EXCL::DEFCONSTRUCTOR (EXCL::NAME CLASS EXCL::LAMBDA-LIST &REST
                        EXCL::KEYWORDS-AND-VALUES))
 (EXCL::MACHINE-CASE (EXCL::HOST-OR-TARGET &REST EXCL::CASES))
 (EXCL::DEF-WALK-HANDLER (EXCL::HANDLES &REST EXCL::BODY))
 (EXCL::HANDLER-BIND-IF (EXCL::PREDICATE EXCL::BINDINGS &BODY
                         EXCL::BODY))
 (EXCL::DEFRESOURCE (EXCL::NAME &KEY EXCL::CONSTRUCTOR
                     EXCL::INITIALIZER EXCL::REINITIALIZER
                     EXCL::DEALLOCATOR))
 (EXCL::RESTART-BIND-IF (EXCL::PREDICATE EXCL::BINDINGS &BODY
                         EXCL::FORMS))
 (EXCL::CASE-TRIE-LOOKUP (EXCL::TRIE EXCL::CODE))
 (EXCL::DEFINE-WALKER-TEMPLATE (EXCL::NAME &OPTIONAL EXCL::TEMPLATE))
 (EXCL::FORCE-DOCUMENTATION-STORE :NOT-FUNCTION-OR-MACRO)
 (EXCL::NO-TRANSFORM :NOT-FUNCTION-OR-MACRO) (EXCL::MINCF (EXCL::SYM))
 (EXCL::DISCRIMINATOR-PRELOAD-FORM :NOT-FUNCTION-OR-MACRO)
 (EXCL::FOBJECT-WRAPPER-XFORM (EXCL::FW))
 (EXCL::PRECACHE-GENERIC-FUNCTIONS (&OPTIONAL EXCL::PACKAGES))
 (EXCL::INSTANCE-BOUNDP (EXCL::PV-OFFSET EXCL::PARAMETER POSITION
                         EXCL::SLOT-NAME))
 (EXCL::FOBJECT-WRAPPER-LISP (EXCL::FW))
 (EXCL::WITH-KEYWORD-PAIRS
   ((EXCL::NAMES EXCL::EXPRESSION &OPTIONAL EXCL::KEYWORDS-VAR) &BODY
    EXCL::FORMS))
 (EXCL::REQUIRED-STACK-GROUP-BINDING (VARIABLE EXCL::FORM-TO-EVAL))
 (EXCL::SVDATA-PTR (EXCL::SV))
 (EXCL::HANDLING-PRINTER-ERRORS
   ((EXCL::STM EXCL::OBJ) &BODY EXCL::BODY))
 `(EXCL::X)
 (EXCL::LOOP-STORE-TABLE-DATA (SYMBOL EXCL::TABLE EXCL::DATUM))
 (EXCL::INSTANCE-WRITE (EXCL::PV-OFFSET EXCL::PARAMETER POSITION
                        EXCL::NEW-VALUE EXCL::SLOT-NAME))
 (EXCL::SAFE (&REST EXCL::BODY))
 (EXCL::DEF-GRAY-STREAM-CLASS (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (EXCL::_TEMPLATED-CONSTANT (EXCL::X))
 (EXCL::FSC-INSTANCE-WRAPPER (EXCL::FIN))
 (EXCL::PRESERVE-CNM-ARGS (EXCL::BODY))
 (EXCL::ERRORSET-LIST (EXCL::FORM &OPTIONAL EXCL::ANNOUNCE
                       EXCL::CATCH-BREAKS))
 (EXCL::DEF-TR-GENERIC-HANDLER
   (COMPILER::FCNNAME ARGLIST &REST COMPILER::BODY))
 (EXCL::WRAPPER-REF (EXCL::WRAPPER EXCL::N))
 (EXCL::WITH-RESOURCE ((EXCL::OBJECT-VAR EXCL::RESOURCE-NAME &REST
                        EXCL::INITARGS)
                       &BODY EXCL::BODY))
 (EXCL::FOBJECT-WRAPPER-MAGIC (EXCL::FW))
 (EXCL::DECF-COMPLEX (EXCL::%REFERENCE &OPTIONAL EXCL::DELTA))
 (EXCL::REGEXP-CHAR-LIMIT :NOT-FUNCTION-OR-MACRO)
 (EXCL::STD-INSTANCE-WRAPPER (EXCL::X))
 (EXCL::DEFINE-SIMPLE-PARSER
   (EXCL::WHAT &OPTIONAL FUNCTION TYPE EXCL::VISIBLE-TYPES))
 (EXCL::WITH-DYNAMIC-EXTENT-USB8-ARRAY
   ((EXCL::ARRAY-VAR EXCL::SIZE) &BODY EXCL::BODY))
 (EXCL::FOBJECT-WRAPPER-CLASS (EXCL::FW))
 (EXCL::PPRINT-LOGICAL-BLOCK+
   ((EXCL::VAR EXCL::ARGS EXCL::PREFIX EXCL::SUFFIX EXCL::PER-LINE?
     EXCL::CIRCLE-CHECK? EXCL::ATSIGN?)
    &BODY EXCL::BODY))
 (EXCL::WRAPPER-CLASS-HAS-SLOT-VALUE-METHODS-P (EXCL::WRAPPER))
 (EXCL::DEF-AUTOLOAD-FUNCTION (EXCL::NAME EXCL::FILE))
 (EXCL::WRAPPER-NUMBER (EXCL::WRAPPER))
 (EXCL::UNFORCE-DOCUMENTATION-STORE :NOT-FUNCTION-OR-MACRO)
 (EXCL::PRELOAD-CONSTRUCTORS (&OPTIONAL EXCL::PACKAGES))
 (EXCL::LISTIFY-FWRAPPER-ARGLIST :NOT-FUNCTION-OR-MACRO)
 (EXCL::DEF-TR-GENERIC (EXCL::FCNNAME EXCL::TRANSFORMING EXCL::EXTRA))
 (EXCL::WRAPPER-VALID-INITARGS (EXCL::WRAPPER))
 (EXCL::LOOP-REALLY-DESETQ (&REST EXCL::VAR-VAL-PAIRS))
 (EXCL::WALK-MACROLET (EXCL::FORM))
 (EXCL::SIMPLE-EFFECTIVE-METHOD-PRELOAD-FORM :NOT-FUNCTION-OR-MACRO)
 (EXCL::DEF-AUTOLOAD-MACRO (EXCL::NAME EXCL::FILE))
 (EXCL::FOBJECT-WRAPPER-SIZE (EXCL::FW))
 (EXCL::ATOMICALLY (&BODY EXCL::BODY))
 (EXCL::AUSB8 (EXCL::VEC EXCL::INDEX))
 (EXCL::WRAPPER-FLAGS (EXCL::WRAPPER))
 (EXCL::PRESERVING-INTERRUPTS (EXCL::FORM))
 (EXCL::TARGET-CLASS-CASE (&REST EXCL::CLAUSES))
 (EXCL::FAST (&REST EXCL::BODY))
 (EXCL::COPY-USB8 (EXCL::FROM-VECTOR EXCL::FROM-START EXCL::TO-VECTOR
                   EXCL::TO-START COUNT))
 (EXCL::WITH-UNDERLYING-SIMPLE-VECTOR
   ((ARRAY EXCL::SIMPLE-VECTOR-VAR &OPTIONAL EXCL::DISPLACEMENT-VAR
     EXCL::LENGTH-VAR EXCL::EXPLICIT-END)
    &BODY EXCL::BODY))
 (EXCL::REHASH-IF-NEEDED (HASH-TABLE))
 (EXCL::LOOP-COLLECT-ANSWER
   (EXCL::HEAD-VAR &OPTIONAL EXCL::USER-HEAD-VAR))
 `(&REST EXCL::X) (CROSS-REFERENCE:WITH-XREF (CROSS-REFERENCE::BODY))
 (CROSS-REFERENCE::DEFINE-SIMPLE-RELATION (CROSS-REFERENCE::NAME))
 (CROSS-REFERENCE::DEFINE-COMPLEX-RELATION
   (CROSS-REFERENCE::NAME &REST CROSS-REFERENCE::SUBRELATIONS))
 (CROSS-REFERENCE::DEFINE-EXHAUSTIVE-RELATION (CROSS-REFERENCE::NAME))
 (CROSS-REFERENCE::GET-RELATION-INSTANCE
   (CROSS-REFERENCE::RELATION-NAME))
 (CROSS-REFERENCE::SET-RELATION-INSTANCE
   (CROSS-REFERENCE::RELATION-NAME))
 (CROSS-REFERENCE::ADD-RELATION-PAIR
   (CROSS-REFERENCE::RELATION-NAME CROSS-REFERENCE::RELATION-INSTANCE))
 (CROSS-REFERENCE::GET-RELATION-PAIR (CROSS-REFERENCE::RELATION-NAME))
 (COMPILER::ICS-DYN-TARGET-ECASE (&BODY COMPILER::CASES))
 (COMPILER::DO-REVERSED-QUAD-LIST
   ((COMPILER::VAR COMPILER::PREV LIST) . COMPILER::BODY))
 (COMPILER::LS-ADDR (COMPILER::STRUCT-NAME COMPILER::FIELD VARIABLE))
 (COMPILER::IQE-EV (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::IQE-COMMENT (&REST COMPILER::ARGS))
 (COMPILER::SIMPLE-CASE (&REST EXCL::FORMS))
 (COMPILER::REMOVE-QUAD (COMPILER::QUAD))
 (COMPILER::INC-LOC (COMPILER::V)) (COMPILER::CON-CLASS (COMPILER::X))
 (COMPILER::LS-NOCHECK (COMPILER::STRUCT-NAME COMPILER::FIELD
                        VARIABLE))
 (COMPILER::DEF-I386-INSTR
   (COMPILER::NAME COMPILER::LAP-TO-ASM COMPILER::ASM-NAME
                   COMPILER::IQIA-HANDLER &REST COMPILER::FLAGS))
 (COMPILER::LS (COMPILER::STRUCT-NAME COMPILER::FIELD VARIABLE))
 (COMPILER::INTO-CONTOUR-FORM (&REST COMPILER::BODY))
 (COMPILER::QEP (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::CON-TREG (COMPILER::X))
 (COMPILER::DO-QUAD-LIST
   ((COMPILER::VAR COMPILER::NEXT LIST) . COMPILER::BODY))
 (COMPILER::CON-TYPE (COMPILER::X))
 (COMPILER::IQ-WITH-MD-COMP-BINDINGS (&REST COMPILER::BODY))
 (COMPILER::Q-ERROR-1 (COMPILER::ERROR-NAME COMPILER::ARG))
 (COMPILER::Q-KILL-FCW-P (COMPILER::QUAD))
 (COMPILER::IQE-DEAD-LAP :NOT-FUNCTION-OR-MACRO)
 (COMPILER::BIGNUM-SIGN (NUMBER))
 (COMPILER::Q-FSCRATCHP (COMPILER::QUAD))
 (COMPILER::DEF-I386-NATURAL-INSTR (COMPILER::NAME COMPILER::VAL))
 (COMPILER::PUT-QUAD (COMPILER::QUAD COMPILER::PLACE))
 (COMPILER::IQ-WITH-MULTI-VALUE (&REST COMPILER::BODY))
 (COMPILER::DEF-IA-PROC (COMPILER::NAME &REST COMPILER::BODY))
 (COMPILER::INSERT-QUAD-AFTER (COMPILER::QUAD COMPILER::PLACE))
 (COMPILER::DEF-TR (COMPILER::FCNNAME COMPILER::TRANSFORMING ARGLIST
                    &REST COMPILER::BODY))
 (COMPILER::Q-LINKP (COMPILER::QUAD))
 (COMPILER::DEF-QC (COMPILER::NAME COMPILER::NODE &BODY
                                   COMPILER::BODY))
 (COMPILER::QE (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::DEF-QC-IMMED
   (COMPILER::NAME COMPILER::NODE &BODY COMPILER::BODY))
 (COMPILER::LAPERROR (&REST COMPILER::ARGS))
 (COMPILER::INSERT-QUAD-BEFORE (COMPILER::QUAD COMPILER::PLACE))
 (COMPILER::INTO-BIND-FORM (&REST COMPILER::BODY))
 (COMPILER::IQE (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::DEF-SYN (COMPILER::NAME COMPILER::TRANSFORMED-TO))
 (COMPILER::Q-KILLP (COMPILER::QUAD &OPTIONAL COMPILER::FULL))
 (COMPILER::VALID-FIRST-D (COMPILER::D))
 (COMPILER::DEF-CONSTRAINT-IQ
   (COMPILER::NAME COMPILER::F-CON-LIST COMPILER::R-CON-LIST &REST
                   COMPILER::ARGS))
 (COMPILER::IQ-WITH-MULTI-VALUE-SEF (&REST COMPILER::BODY))
 (COMPILER::QE-EV (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::DEF-MD (COMPILER::TARGET-TAG COMPILER::REALNAME
                    COMPILER::MDNAME &REST COMPILER::BODY))
 (COMPILER::DEF-PA (COMPILER::FCN-NAME COMPILER::HANDLES ARGLIST &REST
                    COMPILER::BODY))
 (COMPILER::DEF-QUAD-I386
   (COMPILER::NAME COMPILER::QUAD-NAME COMPILER::ARGS &REST
                   COMPILER::BODY))
 (COMPILER::DEF-MD-IQ (&REST COMPILER::ARGS))
 (COMPILER::QEP-EV (COMPILER::OP &REST COMPILER::ARGS))
 (COMPILER::DEF-QC-LL-FCN-IMMED
   (COMPILER::NAME COMPILER::FCN &BODY COMPILER::BODY))
 (COMPILER::DO-QUAD-U-REG
   (COMPILER::VAR COMPILER::QUAD &REST COMPILER::BODY))
 (COMPILER::DEF-QC-LL-FCN
   (COMPILER::NAME COMPILER::FCN &BODY COMPILER::BODY))
 (COMPILER::DO-QUAD-ANY-REG
   (COMPILER::EXTRACTOR COMPILER::VAR COMPILER::QUAD COMPILER::BODY))
 (COMPILER::DEF-QC-FCN (COMPILER::NAME COMPILER::FCN
                                       COMPILER::ARG-COUNT &BODY
                                       COMPILER::BODY))
 (COMPILER::DO-QUAD-LIST-TO-END
   ((COMPILER::VAR COMPILER::NEXT LIST) . COMPILER::BODY))
 (COMPILER::IQ-WITH-ONE-VALUE (&REST COMPILER::BODY))
 (COMPILER::DO-QUAD-D-REG
   (COMPILER::VAR COMPILER::QUAD &REST COMPILER::BODY))
 (COMPILER::Q-WITH-NORMAL-COMPILER-BINDINGS (COMPILER::FORM))
 (COMPILER::BB-BBSORT (COMPILER::BB))
 (COMPILER::IQ-WITH-ONE-VALUE-SEF (&REST COMPILER::BODY))
 (COMPILER::DEF-QC-FCN-IMMED
   (COMPILER::NAME COMPILER::FCN &BODY COMPILER::BODY))
 (UNLESS (EXCL::TEST &REST EXCL::FORMS))
 (LAMBDA (&WHOLE EXCL::LAMBDA-EXPRESSION EXCL::LAMBDA-LIST &BODY
          EXCL::BODY))
 (WITH-CONDITION-RESTARTS
   (EXCL::CONDITION-FORM EXCL::RESTARTS-FORM &BODY EXCL::FORMS))
 (DEFMACRO (&REST EXCL::FORM)) (DECLAIM (&REST EXCL::DECL-SPECS))
 (DOTIMES ((EXCL::VAR EXCL::COUNTFORM &OPTIONAL EXCL::RESULTFORM) &BODY
           EXCL::BODY))
 (WITH-OUTPUT-TO-STRING ((EXCL::VAR &OPTIONAL STRING &KEY
                          EXCL::ELEMENT-TYPE)
                         &BODY EXCL::BODY))
 (MULTIPLE-VALUE-BIND ((&REST EXCL::BINDINGS) EXCL::VALUES-FORM &BODY
                       EXCL::BODY))
 (TRACE (&REST EXCL::SPECS))
 (WITH-OPEN-STREAM ((EXCL::VAR STREAM) &BODY EXCL::BODY))
 (DEFPARAMETER (EXCL::VAR EXCL::VAL &OPTIONAL EXCL::DOC))
 (DO ((&REST EXCL::BIND-AND-ITERATE-LIST)
      (EXCL::END-TEST &BODY EXCL::RESULT-BODY)
      &BODY
      EXCL::BODY))
 (CHECK-TYPE (EXCL::PLACE TYPE &OPTIONAL EXCL::TYPE-STRING))
 (WITH-STANDARD-IO-SYNTAX (&BODY EXCL::BODY))
 (CTYPECASE (EXCL::KEYPLACE &REST EXCL::CASES))
 (ETYPECASE (EXCL::KEYFORM &REST EXCL::CASES))
 (DECF (EXCL::REF &OPTIONAL EXCL::DELTA))
 (DEFINE-SETF-EXPANDER (EXCL::ACCESS-FN EXCL::LAMBDA-LIST &BODY
                        EXCL::BODY))
 (RETURN (&OPTIONAL EXCL::RESULT)) (AND (&REST EXCL::FORMS))
 (REMF (EXCL::PLACE EXCL::INDICATOR))
 (WITH-PACKAGE-ITERATOR
   ((EXCL::NEXT-FN EXCL::PACKAGE-LIST &REST EXCL::SYMBOL-TYPES) &BODY
    EXCL::BODY))
 (HANDLER-CASE (EXCL::FORM &REST EXCL::CASES))
 (SETF (&REST EXCL::ARGS)) (CCASE (EXCL::KEYPLACE &REST EXCL::CASES))
 (LOOP-FINISH :NOT-FUNCTION-OR-MACRO)
 (ECASE (EXCL::KEYFORM &REST EXCL::CASES))
 (DEFINE-COMPILER-MACRO (&REST EXCL::FORM))
 (PUSH (EXCL::VALUE EXCL::PLACE)) (POP (EXCL::PLACE))
 (MULTIPLE-VALUE-LIST (EXCL::FORM))
 (WITH-SIMPLE-RESTART ((RESTART-NAME EXCL::FORMAT-CONTROL &REST
                                     EXCL::FORMAT-ARGUMENTS)
                       &BODY EXCL::FORMS))
 (WHEN (EXCL::TEST &REST EXCL::FORMS))
 (RESTART-CASE (EXCL::EXPRESSION &BODY EXCL::CLAUSES))
 (ROTATEF (&REST EXCL::PLACES))
 (PROG1 (EXCL::FIRST-FORM &BODY EXCL::BODY))
 (DEFGENERIC (EXCL::FUNCTION-SPECIFIER EXCL::LAMBDA-LIST &BODY
              EXCL::OPTIONS))
 (PRINT-UNREADABLE-OBJECT
   ((EXCL::OBJECT STREAM &KEY TYPE IDENTITY) &BODY EXCL::BODY))
 (PUSHNEW (EXCL::VALUE EXCL::PLACE &REST EXCL::KEYS &KEY EXCL::KEY
           EXCL::TEST EXCL::TEST-NOT))
 (DEFINE-SYMBOL-MACRO (SYMBOL EXCL::EXPANSION)) (FORMATTER (STRING))
 (PROG* ((&REST EXCL::BINDINGS) &BODY EXCL::BODY))
 (DEFPACKAGE (EXCL::NAME &REST EXCL::OPTIONS))
 (DO* ((&REST EXCL::BIND-AND-ITERATE-LIST)
       (EXCL::END-TEST &BODY EXCL::RESULT-BODY)
       &BODY
       EXCL::BODY))
 (RESTART-BIND (EXCL::BINDINGS &BODY EXCL::FORMS))
 (DESTRUCTURING-BIND (ARGLIST EXCL::EXPR &REST EXCL::BODY))
 (DEFTYPE (EXCL::NAME ARGLIST &REST EXCL::BODY))
 (DEFINE-CONDITION (EXCL::NAME EXCL::SUPER-CLASS-LIST EXCL::SLOT-SPECS
                    &REST EXCL::OPTIONS))
 (WITH-OPEN-FILE ((EXCL::VAR &REST EXCL::OPEN-ARGS) &BODY EXCL::BODY))
 (PROG ((&REST EXCL::BINDINGS) &BODY EXCL::BODY))
 (DEFSTRUCT (EXCL::NAME-AND-OPTIONS &REST EXCL::SLOT-DESCRIPTIONS))
 (PROG2 (EXCL::FIRST-FORM EXCL::SECOND-FORM &BODY EXCL::BODY))
 (HANDLER-BIND (EXCL::BINDINGS &BODY EXCL::BODY))
 (IN-PACKAGE (EXCL::NAME &KEY EXCL::NICKNAMES EXCL::USE))
 (WITH-COMPILATION-UNIT
   ((&KEY EXCL::OVERRIDE EXCL::WARNINGS-HOOK) &BODY EXCL::BODY))
 (WITH-SLOTS (EXCL::SLOTS EXCL::INSTANCE &BODY EXCL::BODY))
 (DEFUN (EXCL::NAME EXCL::VARLIST &REST EXCL::BODY))
 (WITH-ACCESSORS (EXCL::SLOTS EXCL::INSTANCE &BODY EXCL::BODY))
 (SHIFTF (&REST EXCL::PLACES)) (DEFSETF (EXCL::ACCESS-FN &REST REST))
 (DEFCLASS (EXCL::NAME EXCL::DIRECT-SUPERS EXCL::DIRECT-SLOTS &REST
            EXCL::OPTIONS))
 (IGNORE-ERRORS (&REST EXCL::FORMS)) (CASE (&REST EXCL::FORM))
 (STEP (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DEFMETHOD (&REST EXCL::ARGS))
 (MULTIPLE-VALUE-SETQ ((&REST EXCL::VARIABLES) EXCL::FORM))
 (DEFCONSTANT (EXCL::VAR EXCL::VAL &OPTIONAL EXCL::DOC))
 (DO-SYMBOLS ((EXCL::VAR &OPTIONAL PACKAGE EXCL::RESULT-FORM) &REST
              EXCL::FORMS))
 (DEFINE-MODIFY-MACRO (EXCL::NAME EXCL::LAMBDA-LIST FUNCTION &OPTIONAL
                       EXCL::DOC-STRING))
 (ASSERT (EXCL::TEST-FORM &OPTIONAL EXCL::PLACES EXCL::DATUM &REST
          EXCL::ARGUMENTS))
 (WITH-HASH-TABLE-ITERATOR
   ((EXCL::NEXT-FN HASH-TABLE) &BODY EXCL::BODY))
 (DEFINE-METHOD-COMBINATION (&WHOLE EXCL::FORM &REST EXCL::ARGS))
 (DO-ALL-SYMBOLS ((EXCL::VAR &OPTIONAL EXCL::RESULT-FORM) &REST
                  EXCL::FORMS))
 (PSETQ (&REST EXCL::LIST-OF-VARS-AND-VALUES))
 (DEFVAR (EXCL::VAR &OPTIONAL EXCL::VAL EXCL::DOC))
 (INCF (EXCL::REF &OPTIONAL EXCL::DELTA))
 (NTH-VALUE (EXCL::N EXCL::FORM))
 (DO-EXTERNAL-SYMBOLS ((EXCL::VAR &OPTIONAL PACKAGE EXCL::RESULT-FORM)
                       &REST EXCL::FORMS))
 (UNTRACE (&REST EXCL::FUNCTION-SPECS))
 (PPRINT-LOGICAL-BLOCK ((EXCL::STREAM-SYMBOL LIST &KEY EXCL::PREFIX
                         EXCL::PER-LINE-PREFIX EXCL::SUFFIX)
                        &BODY EXCL::BODY))
 (PSETF (&REST EXCL::ARGS))
 (WITH-INPUT-FROM-STRING ((EXCL::VAR STRING &KEY EXCL::INDEX
                           EXCL::START EXCL::END)
                          &BODY EXCL::BODY))
 (COND (&REST EXCL::CLAUSES)) (OR (&REST EXCL::FORMS))
 (TIME (EXCL::FORM)) (LOOP (&REST EXCL::KEYWORDS-AND-FORMS))
 (DOLIST ((EXCL::VAR EXCL::LISTFORM &OPTIONAL EXCL::RESULTFORM) &BODY
          EXCL::BODY))
 (TYPECASE (EXCL::OBJ &REST EXCL::CLAUSES))
 (ACL-SOCKET:WITH-PENDING-CONNECT (&REST ACL-SOCKET::BODY))
 (ACL-SOCKET::BOGUS-DNS-RECORD :NOT-FUNCTION-OR-MACRO)
 (ACL-SOCKET::WAIT-FOR-INPUT (ACL-SOCKET::SOCKET-FD)))
CL-USER>