--- /srv/rebuilderd/tmp/rebuilderdmutvkh/inputs/buildapp_1.5.6-5_i386.deb +++ /srv/rebuilderd/tmp/rebuilderdmutvkh/out/buildapp_1.5.6-5_i386.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2025-11-20 21:39:21.000000 debian-binary │ -rw-r--r-- 0 0 0 800 2025-11-20 21:39:21.000000 control.tar.xz │ --rw-r--r-- 0 0 0 8433060 2025-11-20 21:39:21.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 8437368 2025-11-20 21:39:21.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./control │ │ │ @@ -1,12 +1,12 @@ │ │ │ Package: buildapp │ │ │ Version: 1.5.6-5 │ │ │ Architecture: i386 │ │ │ Maintainer: Debian Common Lisp Team │ │ │ -Installed-Size: 26872 │ │ │ +Installed-Size: 26988 │ │ │ Depends: libc6 (>= 2.38), libzstd1 (>= 1.5.5), sbcl │ │ │ Section: lisp │ │ │ Priority: optional │ │ │ Homepage: https://www.xach.com/lisp/buildapp/ │ │ │ Description: application to create common lisp images │ │ │ Buildapp is an application for SBCL that configures and saves an │ │ │ executable Common Lisp image. It is similar to cl-launch and │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── file list │ │ │ @@ -1,11 +1,11 @@ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/bin/ │ │ │ --rwxr-xr-x 0 root (0) root (0) 27479340 2025-11-20 21:39:21.000000 ./usr/bin/buildapp │ │ │ +-rwxr-xr-x 0 root (0) root (0) 27598300 2025-11-20 21:39:21.000000 ./usr/bin/buildapp │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/doc/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/doc/buildapp/ │ │ │ -rw-r--r-- 0 root (0) root (0) 924 2025-11-20 21:39:21.000000 ./usr/share/doc/buildapp/changelog.Debian.gz │ │ │ -rw-r--r-- 0 root (0) root (0) 1607 2025-11-20 16:58:04.000000 ./usr/share/doc/buildapp/copyright │ │ │ -rw-r--r-- 0 root (0) root (0) 19096 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/index.html │ │ │ -rw-r--r-- 0 root (0) root (0) 1168 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/style.css │ │ ├── ./usr/bin/buildapp │ │ │┄ File has been modified after NT_GNU_BUILD_ID has been applied. │ │ │ ├── strings --all --bytes=8 {} │ │ │ │ @@ -1718,47 +1718,43 @@ │ │ │ │ .got.plt │ │ │ │ .gnu_debuglink │ │ │ │ hostname-id-1762874790 │ │ │ │ Warning condition related to definition of obsolete OPERATION objects. │ │ │ │ Error condition related to definition of incorrect OPERATION objects. │ │ │ │ Warning class for issues related to upgrading or loading ASDF. │ │ │ │ condition signaled when a system is detected as being out of date │ │ │ │ ->d>l@|A@BL │ │ │ │ -KlKpLLMd │ │ │ │ -3)4Y3a7]5 │ │ │ │ -U[WKXgYG │ │ │ │ +[f]B[J^.` │ │ │ │ +(I)_)-+s │ │ │ │ A pair of operation and component uniquely identifies a node in the dependency graph │ │ │ │ of steps to be performed while building a system. │ │ │ │ -(I)_)-+s │ │ │ │ An operation designates itself. NIL designates a context-dependent current operation, │ │ │ │ and a class-name or class designates the canonical instance of the designated class. │ │ │ │ This pathname is merged with the output parameter to produce the │ │ │ │ final output executable name. It's meant to automatically include │ │ │ │ the executable suffix .EXE on Windows. │ │ │ │ +default element-type for open (depends on the current CL implementation) │ │ │ │ Default :external-format argument to pass to CL:OPEN and also │ │ │ │ CL:LOAD or CL:COMPILE-FILE to best process a UTF-8 encoded file. │ │ │ │ On modern implementations, this will decode UTF-8 code points as CL characters. │ │ │ │ On legacy implementations, it may fall back on some 8-bit encoding, │ │ │ │ with non-ASCII code points being read as several CL characters; │ │ │ │ hopefully, if done consistently, that won't affect program behavior too much. │ │ │ │ -default element-type for open (depends on the current CL implementation) │ │ │ │ +How should ASDF react if it encounters a warning when compiling a file? │ │ │ │ +Valid values are :error, :warn, and :ignore. │ │ │ │ +How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) │ │ │ │ +when compiling a file, which includes any non-style-warning warning. │ │ │ │ +Valid values are :error, :warn, and :ignore. │ │ │ │ +Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling. │ │ │ │ Hook for output translations. │ │ │ │ This function needs to be idempotent, so that actions can work │ │ │ │ whether their inputs were translated or not, │ │ │ │ which they will be if we are composing operations. e.g. if some │ │ │ │ create-lisp-op creates a lisp file from some higher-level input, │ │ │ │ you need to still be able to use compile-op on that lisp file. │ │ │ │ The default plan class to use when building with ASDF │ │ │ │ -How should ASDF react if it encounters a warning when compiling a file? │ │ │ │ -Valid values are :error, :warn, and :ignore. │ │ │ │ -How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) │ │ │ │ -when compiling a file, which includes any non-style-warning warning. │ │ │ │ -Valid values are :error, :warn, and :ignore. │ │ │ │ -Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling. │ │ │ │ -3333%3333 │ │ │ │ %@S6zOw6_ │ │ │ │ M+LKPsN#Q │ │ │ │ \|Z4]\\\ │ │ │ │ A list that controls the ways that ASDF looks for system definitions. │ │ │ │ It contains symbols to be funcalled in order, with a requested system name as argument, │ │ │ │ until one returns a non-NIL result (if any), which must then be a fully initialized system object │ │ │ │ with that name. │ │ │ │ @@ -1832,35 +1828,37 @@ │ │ │ │ Is this an interactive Lisp environment, or is it batch processing? │ │ │ │ Functions to call (in order) before an image is dumped │ │ │ │ Command-line arguments │ │ │ │ a form to evaluate, or string containing forms to read and evaluate │ │ │ │ when the image is restarted, but before the entry point is called. │ │ │ │ a form to evaluate, or string containing forms to read and evaluate │ │ │ │ before the image dump hooks are called and before the image is dumped. │ │ │ │ -This is a hash table whose keys are strings -- the names of systems -- │ │ │ │ -and whose values are systems. │ │ │ │ -A system is referred to as "registered" if it is present in this table. │ │ │ │ A hash-set (equal hash-table mapping keys to T) of systems that are immutable, │ │ │ │ i.e. already loaded in memory and not to be refreshed from the filesystem. │ │ │ │ They will be treated specially by find-system, and passed as :force-not argument to make-plan. │ │ │ │ For instance, to can deliver an image with many systems precompiled, that *will not* check the │ │ │ │ filesystem for them every time a user loads an extension, what more risk a problematic upgrade │ │ │ │ or catastrophic downgrade, before you dump an image, you may use: │ │ │ │ (map () 'asdf:register-immutable-system (asdf:already-loaded-systems)) │ │ │ │ Note that direct access to this variable from outside ASDF is not supported. │ │ │ │ Please call REGISTER-IMMUTABLE-SYSTEM to add new immutable systems, and │ │ │ │ contact maintainers if you need a stable API to do more than that. │ │ │ │ +This is a hash table whose keys are strings -- the names of systems -- │ │ │ │ +and whose values are systems. │ │ │ │ +A system is referred to as "registered" if it is present in this table. │ │ │ │ +3333%3333 │ │ │ │ 3333%3333 │ │ │ │ !Q 1$q$1 │ │ │ │ -Registration table for preloaded systems. │ │ │ │ -SYS:make-target-2-load.lisp │ │ │ │ +Z][B\N] ^^^ │ │ │ │ The list of system virtual slot names. │ │ │ │ +Registration table for preloaded systems. │ │ │ │ The standard readtable, implementing the syntax specified by the CLHS. │ │ │ │ It must never be modified, though only good implementations will even enforce that. │ │ │ │ Has the image been restored? A boolean, or :in-progress while restoring, :in-regress while dumping │ │ │ │ +SYS:make-target-2-load.lisp │ │ │ │ '5(j)6*r │ │ │ │ r0r(sKt~u │ │ │ │ DUMPER134 │ │ │ │ MAYBE-MUFFLE │ │ │ │ Short for _operate on system_ and an alias for the OPERATE function. │ │ │ │ Operate does mainly four things for the user: │ │ │ │ 1. Resolves the OPERATION designator into an operation object. │ │ │ │ @@ -5698,20 +5696,24 @@ │ │ │ │ GC-RUN-TIME │ │ │ │ PROCESS-P │ │ │ │ %EXIT-CODE │ │ │ │ PRIORITY-QUEUE-P │ │ │ │ CONTENTS │ │ │ │ CATCH-UP │ │ │ │ EXPIRE-TIME │ │ │ │ -ADDITIONAL-INPUT-FILES │ │ │ │ +CONTEXT-ARGUMENTS │ │ │ │ +CONTEXT-FORMAT │ │ │ │ +ANCESTOR │ │ │ │ BUILD-OPERATION │ │ │ │ +ADDITIONAL-INPUT-FILES │ │ │ │ +WEAKLY-DEPENDS-ON │ │ │ │ DEPENDS-ON │ │ │ │ REQUIRED-BY │ │ │ │ REQUIRES │ │ │ │ -WEAKLY-DEPENDS-ON │ │ │ │ +CLASS-NAME │ │ │ │ EXTERNAL-SYMBOLS │ │ │ │ MRU-TABLE-INDEX │ │ │ │ %SHADOWING-SYMBOLS │ │ │ │ %USED-BY │ │ │ │ RI-INITARGS │ │ │ │ MI-INITARGS │ │ │ │ SLOT-ACCESSOR │ │ │ │ @@ -6072,15 +6074,14 @@ │ │ │ │ SLOTD-INITIALIZATION-ERROR-VALUE │ │ │ │ INITARG-ERROR-INITARGS │ │ │ │ INITARG-ERROR-CLASS │ │ │ │ INVALID-SUPERCLASS-CLASS │ │ │ │ INVALID-SUPERCLASS-SUPERCLASS │ │ │ │ CLASS-OF │ │ │ │ CPL-PROTOCOL-VIOLATION-CLASS │ │ │ │ -CLASS-NAME │ │ │ │ CPL-PROTOCOL-VIOLATION-CPL │ │ │ │ FIND-CLASS-FROM-CELL │ │ │ │ OBSOLETE-STRUCTURE-DATUM │ │ │ │ INVALID-METHOD-INITARG-METHOD │ │ │ │ NEW-VALUE-SPECIALIZATION-METHOD │ │ │ │ PROTOCOL-UNIMPLEMENTED-OPERATION │ │ │ │ INST-NUMBER │ │ │ │ @@ -6180,24 +6181,21 @@ │ │ │ │ END-BREAKPOINT │ │ │ │ ENCAPSULATED │ │ │ │ EXPANDERS │ │ │ │ SYMBOL-EXPANSIONS │ │ │ │ FUNCTIONALITY │ │ │ │ INTERACTIVE-THREAD │ │ │ │ OTHER-THREADS │ │ │ │ -CONTEXT-FORMAT │ │ │ │ -CONTEXT-ARGUMENTS │ │ │ │ CORE-DUMPED │ │ │ │ SERVE-EVENT-PIPE │ │ │ │ CLOSED-P │ │ │ │ STATUS-HOOK │ │ │ │ REPEAT-INTERVAL │ │ │ │ INTERRUPT-FUNCTION │ │ │ │ CANCEL-FUNCTION │ │ │ │ -ANCESTOR │ │ │ │ PARAMETERS │ │ │ │ ACTIONS-R │ │ │ │ DEP-COMPONENT │ │ │ │ MAKE-DEBUG-SOURCE │ │ │ │ %MAKE-PACKAGE │ │ │ │ DEFINE-ALIEN-TYPE-TRANSLATOR │ │ │ │ FMAKUNBOUND │ │ │ │ @@ -17948,26 +17946,26 @@ │ │ │ │ COMPILE-CONDITION-CONTEXT-ARGUMENTS │ │ │ │ COMPILE-CONDITION-DESCRIPTION │ │ │ │ CONDITION-LOCATION │ │ │ │ CONDITION-FORMAT │ │ │ │ CONDITION-ARGUMENTS │ │ │ │ DUPLICATE-NAMES-NAME │ │ │ │ CLASS-SLOT-CELLS │ │ │ │ +MAKE-COUNTER │ │ │ │ +MAKE-PROFILE-INFO │ │ │ │ +MAKE-OVERHEAD │ │ │ │ +MAKE-TIME-INFO │ │ │ │ OPERATION-DESIGNATOR │ │ │ │ COUNTER-WORD │ │ │ │ COUNTER-OVERFLOW │ │ │ │ PROFILE-INFO-NAME │ │ │ │ PROFILE-INFO-ENCAPSULATED-FUN │ │ │ │ PROFILE-INFO-ENCAPSULATION-FUN │ │ │ │ PROFILE-INFO-READ-STATS-FUN │ │ │ │ PROFILE-INFO-CLEAR-STATS-FUN │ │ │ │ -MAKE-COUNTER │ │ │ │ -MAKE-PROFILE-INFO │ │ │ │ -MAKE-OVERHEAD │ │ │ │ -MAKE-TIME-INFO │ │ │ │ OVERHEAD-CALL │ │ │ │ OVERHEAD-INTERNAL │ │ │ │ OVERHEAD-TOTAL │ │ │ │ TIME-INFO-NAME │ │ │ │ TIME-INFO-CALLS │ │ │ │ TIME-INFO-SECONDS │ │ │ │ TIME-INFO-CONSING │ │ │ │ @@ -18056,20 +18054,14 @@ │ │ │ │ USE-CACHING-DFUN-P │ │ │ │ MAKE-CACHING-DFUN │ │ │ │ UPDATE-DFUN │ │ │ │ MAKE-CHECKING-DFUN │ │ │ │ DEBUGGER-DISABLED-HOOK │ │ │ │ VALID-WRAPPER-OF │ │ │ │ FIND-SLOT-CELL │ │ │ │ -SLOT-DEFINITION-ALWAYS-BOUND-P │ │ │ │ -SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION │ │ │ │ -SLOT-DEFINITION-NAME │ │ │ │ -SET-FUN-NAME │ │ │ │ -CHECK-WRAPPER-VALIDITY │ │ │ │ -SLOT-DEFINITION-INFO │ │ │ │ WALK-UNEXPECTED-DECLARE │ │ │ │ UNIX-STAT │ │ │ │ RU-NIVCSW │ │ │ │ UNIX-KILL │ │ │ │ ST-NLINK │ │ │ │ SIGVTALRM │ │ │ │ UNIX-POLL │ │ │ │ @@ -18162,14 +18154,20 @@ │ │ │ │ MAKE-STRUCTURE-SLOT-MAKUNBOUND-FUNCTION │ │ │ │ CAN-MAKUNBOUND │ │ │ │ CANNOT-MAKUNBOUND │ │ │ │ MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-MAKUNBOUND-METHOD-FUNCTION │ │ │ │ +SLOT-DEFINITION-ALWAYS-BOUND-P │ │ │ │ +SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION │ │ │ │ +SLOT-DEFINITION-NAME │ │ │ │ +SET-FUN-NAME │ │ │ │ +CHECK-WRAPPER-VALIDITY │ │ │ │ +SLOT-DEFINITION-INFO │ │ │ │ TYPES-FROM-ARGS │ │ │ │ COMPUTE-APPLICABLE-METHODS-USING-TYPES │ │ │ │ INACTIVE │ │ │ │ FORTHCOMING-DEFCLASS-TYPE │ │ │ │ CALL-OTHER-METHOD │ │ │ │ INCOMPATIBLE │ │ │ │ UNINITIALIZED │ │ │ │ @@ -18179,29 +18177,29 @@ │ │ │ │ *OVERHEAD* │ │ │ │ FAST-METHOD │ │ │ │ SLOW-METHOD │ │ │ │ INTERACTIVE │ │ │ │ INITIATE │ │ │ │ LOGICAL-BLOCK-CIRCULAR │ │ │ │ TEMPORARY │ │ │ │ -SPECIFIED │ │ │ │ -MARK-REGION-GC │ │ │ │ +PRETTY-OUT │ │ │ │ +PRETTY-SOUT │ │ │ │ +PRETTY-MISC │ │ │ │ SMALLNUM-PLUS-P │ │ │ │ %BIGNUM-0-OR-PLUSP │ │ │ │ BYTE-POS │ │ │ │ SIGN-DIGIT │ │ │ │ ROUND-DOUBLE-FLOAT-TO-BIGNUM-DIV │ │ │ │ NEXT-DIGIT │ │ │ │ CARRY-DIGIT │ │ │ │ DIGIT-SIZE │ │ │ │ ROUND-DOUBLE-FLOAT-TO-BIGNUM │ │ │ │ -PRETTY-OUT │ │ │ │ -PRETTY-SOUT │ │ │ │ -PRETTY-MISC │ │ │ │ INITIAL-BUFFER-SIZE │ │ │ │ +MARK-REGION-GC │ │ │ │ +SPECIFIED │ │ │ │ ENQUEUE-NEWLINE │ │ │ │ FORCE-PRETTY-OUTPUT │ │ │ │ START-LOGICAL-BLOCK │ │ │ │ END-LOGICAL-BLOCK │ │ │ │ ENQUEUE-INDENT │ │ │ │ ENSURE-NON-STANDARD-CLASS │ │ │ │ NOTIFY-DEPRECATED-FUNCTION │ │ │ │ @@ -18237,14 +18235,17 @@ │ │ │ │ MAKE-GF-HASHSET │ │ │ │ SESSION-CACHE │ │ │ │ OPERATE-LEVEL │ │ │ │ ASDF-UPGRADED-P │ │ │ │ LONG-DESCRIPTION │ │ │ │ IF-FEATURE │ │ │ │ IN-ORDER-TO │ │ │ │ +REG-REG/MEM-DIR │ │ │ │ +REG/MEM-IMM │ │ │ │ +ACCUM-IMM │ │ │ │ AROUND-COMPILE │ │ │ │ PROPERTIES │ │ │ │ ENCODING │ │ │ │ DEFAULT-COMPONENT-CLASS │ │ │ │ MAINTAINER │ │ │ │ HOMEPAGE │ │ │ │ BUG-TRACKER │ │ │ │ @@ -18252,17 +18253,14 @@ │ │ │ │ SOURCE-CONTROL │ │ │ │ BUILTIN-SYSTEM-P │ │ │ │ BUILD-PATHNAME │ │ │ │ ENTRY-POINT │ │ │ │ DEFSYSTEM-DEPENDS-ON │ │ │ │ PERFORMABLE-P │ │ │ │ FORCED-NOT │ │ │ │ -REG-REG/MEM-DIR │ │ │ │ -REG/MEM-IMM │ │ │ │ -ACCUM-IMM │ │ │ │ ALIEN-CALLBACKS │ │ │ │ C-STACK-IS-CONTROL-STACK │ │ │ │ COMPARE-AND-SWAP-VOPS │ │ │ │ CYCLE-COUNTER │ │ │ │ FP-AND-PC-STANDARD-SAVE │ │ │ │ GENERATIONAL │ │ │ │ LARGEFILE │ │ │ │ @@ -18327,97 +18325,257 @@ │ │ │ │ EMIT-CHECKING │ │ │ │ INTERRUPTED-FRAME │ │ │ │ PRINT-THREAD │ │ │ │ EMERGENCY-BEST-EFFORT │ │ │ │ *INST-ENCODER* │ │ │ │ *BACKEND-INSTRUCTION-SET-PACKAGE* │ │ │ │ *CURRENT-DESTINATION* │ │ │ │ -OBSOLETE │ │ │ │ -SET-SLOT-VALUE │ │ │ │ STREAM-OPEN-P │ │ │ │ *SBCL-HOMEDIR-PATHNAME* │ │ │ │ *SOFTWARE-VERSION* │ │ │ │ +SET-SLOT-VALUE │ │ │ │ +OBSOLETE │ │ │ │ CALL-NO-NEXT-METHOD │ │ │ │ +.NEXT-METHOD-CALL. │ │ │ │ +FUN-START │ │ │ │ CLASS-FINALIZED-P │ │ │ │ CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P │ │ │ │ FINALIZE-INHERITANCE │ │ │ │ %FORCE-CACHE-FLUSHES │ │ │ │ -.NEXT-METHOD-CALL. │ │ │ │ -FUN-START │ │ │ │ -INITIALIZATION │ │ │ │ SLOT-READER-NAME │ │ │ │ SLOT-BOUNDP-NAME │ │ │ │ SLOT-MAKUNBOUND-NAME │ │ │ │ SLOT-WRITER-NAME │ │ │ │ GENERIC-FUNCTION-METHOD-CLASS │ │ │ │ +INITIALIZATION │ │ │ │ PPRINT-LENGTH-CHECK* │ │ │ │ EQL-SPECIALIZER-P │ │ │ │ EQL-SPECIALIZER-OBJECT │ │ │ │ MAKE-SEQUENCE-ITERATOR │ │ │ │ SIGINT-HANDLER │ │ │ │ %INSTALL-HANDLER │ │ │ │ SIGTERM-HANDLER │ │ │ │ -NO-CONSTRUCTOR-DEFUN │ │ │ │ SIGILL-HANDLER │ │ │ │ SIGURG-HANDLER │ │ │ │ SIGCHLD-HANDLER │ │ │ │ SIGBUS-HANDLER │ │ │ │ ENSURE-CLASS-FINALIZED │ │ │ │ CLASS-PROTOTYPE │ │ │ │ +NO-CONSTRUCTOR-DEFUN │ │ │ │ +ABSOLUTE │ │ │ │ +RELATIVE │ │ │ │ +WILD-INFERIORS │ │ │ │ ENSURE-ACCESSOR │ │ │ │ NORMALIZED-P │ │ │ │ DEFINITION-SOURCE │ │ │ │ GENERIC-FUNCTION-NAME │ │ │ │ ENSURE-SPACE-IN-BUFFER │ │ │ │ -ABSOLUTE │ │ │ │ -RELATIVE │ │ │ │ -WILD-INFERIORS │ │ │ │ METACLASS │ │ │ │ REGISTERED │ │ │ │ -*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ -FOREIGN-FUNCTION │ │ │ │ -SET-FUNCALLABLE-INSTANCE-FUNCTION │ │ │ │ SESSION-OPERATE-LEVEL │ │ │ │ +SET-FUNCALLABLE-INSTANCE-FUNCTION │ │ │ │ RELATIVE-TO │ │ │ │ +*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ +FOREIGN-FUNCTION │ │ │ │ INVALID-KEYS │ │ │ │ SMALL-SAFE │ │ │ │ +SETF-SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ NON-LOCAL-ENTRY │ │ │ │ SINGLE-VALUE-RETURN │ │ │ │ CALL-SITE │ │ │ │ NON-LOCAL-EXIT │ │ │ │ UNKNOWN-RETURN │ │ │ │ -SETF-SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ SIGNALED │ │ │ │ *THE-CLASS-STANDARD-METHOD* │ │ │ │ *STANDARD-METHOD-COMBINATION* │ │ │ │ SLOT-DEFINITION-LOCATION │ │ │ │ SLOT-DEFINITION-WRITERS │ │ │ │ SLOT-DEFINITION-READERS │ │ │ │ SPECIALIZER-CLASS │ │ │ │ SPECIALIZER-OBJECT │ │ │ │ ACCESSOR-METHOD-SLOT-NAME │ │ │ │ OBJECT-PLIST │ │ │ │ BIDIR-STREAM │ │ │ │ ERROR-OUTPUT-STREAM │ │ │ │ SIGNAL-CODE │ │ │ │ +EMIT-BYTES │ │ │ │ +IF-AFTER │ │ │ │ +PROCESS-BACK-PATCHES │ │ │ │ +COMPACT-SEGMENT-BUFFER │ │ │ │ +OPCODES1 │ │ │ │ + │ │ │ │ +STATEMENT │ │ │ │ +%EMIT-SKIP │ │ │ │ +%DEFPATTERN │ │ │ │ +SECTION. │ │ │ │ +MORE-LABELS │ │ │ │ +LABEL-NAME-P │ │ │ │ +.END-WITHOUT-SCHEDULING │ │ │ │ +BYTE-SPECS │ │ │ │ +GET-ALLOCATION-POINTS │ │ │ │ +COMPRESS-OUTPUT │ │ │ │ +.BEGIN-WITHOUT-SCHEDULING │ │ │ │ +PERFORM-OPERAND-LOWERING │ │ │ │ +*ASM-PATTERN-MATCHERS* │ │ │ │ +DECODE-PREFIX │ │ │ │ +%EMIT-POSTIT │ │ │ │ +%EMIT-FILLER │ │ │ │ +FINALIZE-POSITIONS │ │ │ │ +%MARK-USED-LABELS │ │ │ │ +N-ENTRIES │ │ │ │ +APPLICATOR │ │ │ │ +EMIT-ANNOTATION │ │ │ │ +DUMP-SYMBOLIC-ASM │ │ │ │ +OPCODES2 │ │ │ │ +INSERT-STMT │ │ │ │ +%EMIT-LABEL │ │ │ │ +..INHERITED-LABELS.. │ │ │ │ +TOTAL-BITS │ │ │ │ +TRACE-INST │ │ │ │ +*CURRENT-VOP* │ │ │ │ +SEGMENT-CURRENT-INDEX │ │ │ │ +ADJUST-ALIGNMENT-AFTER-CHOOSER │ │ │ │ +FIND-ALIGNMENT │ │ │ │ +EXTRACT-PREFIX-KEYWORDS │ │ │ │ +INSTRUCTION-HOOKS │ │ │ │ +%ASSEMBLE │ │ │ │ +%EMIT-ALIGNMENT │ │ │ │ +FOP-PUSH │ │ │ │ +FOP-LISP-SYMBOL-SAVE │ │ │ │ +FOP-EMPTY-LIST │ │ │ │ +FOP-BASE-STRING │ │ │ │ +CHECK-FASL-HEADER │ │ │ │ +FOP-COMPLEX │ │ │ │ +READ-WORD-ARG │ │ │ │ +OLD-VECTOR │ │ │ │ +.FASL-INPUT. │ │ │ │ +FASL-GROUP-END │ │ │ │ +PKG-INDEX │ │ │ │ +LOAD-AS-FASL │ │ │ │ +FOP-RECORD-CODE-COVERAGE │ │ │ │ +NAMED-CONSTANT-SET │ │ │ │ +FOP-STACK-POP-N │ │ │ │ +READ-CHAR-STRING-AS-VARINTS │ │ │ │ +FOP-COPY-SYMBOL-SAVE │ │ │ │ +FOP-STRUCT │ │ │ │ +FOP-INT-CONST2 │ │ │ │ +FOP-BYTE-INTEGER │ │ │ │ +FOP-STRUCTSET │ │ │ │ +FOP-MOVE-TO-TABLE │ │ │ │ +FOP-NOTE-FULL-CALLS │ │ │ │ +TABLE-SIZE │ │ │ │ +TBL-SLOT │ │ │ │ +LOAD-FRESH-LINE │ │ │ │ +*CURRENT-FASL-GROUP* │ │ │ │ +READ-STRING-AS-BYTES │ │ │ │ +LOAD-S-INTEGER │ │ │ │ +FOP-LAYOUT-OF-STRUCTURE-OBJECT │ │ │ │ +*FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT* │ │ │ │ +FOP-SYMBOL-IN-PACKAGE-SAVE │ │ │ │ +READ-SYMBOL-NAME │ │ │ │ +PUSH-FOP-STACK │ │ │ │ +FOP-TRUTH │ │ │ │ +LOAD-STREAM-1 │ │ │ │ +ABORT-BUILD │ │ │ │ +FOP-INSTANCE │ │ │ │ +FOP-SPEC-VECTOR │ │ │ │ +MAYBE-ANNOUNCE-LOAD │ │ │ │ +FOP-LIST │ │ │ │ +FOP-LAYOUT-OF-DEBUG-SOURCE │ │ │ │ +NUKE-FOP-VECTOR │ │ │ │ +FOP-NAMED-PACKAGE-SAVE │ │ │ │ +FOP-KNOWN-FUN │ │ │ │ +FOP-KEYWORD-SYMBOL-SAVE │ │ │ │ +FOP-COMPLEX-SINGLE-FLOAT │ │ │ │ +FOP-ALTER-CODE │ │ │ │ +FOP-ARRAY │ │ │ │ +FOP-LAYOUT-OF-T │ │ │ │ +FOP-LOAD-CODE │ │ │ │ +GROW-FOP-VECTOR │ │ │ │ +FOP-MISC-TRAP │ │ │ │ +FOP-NOTE-PARTIAL-SOURCE-INFO │ │ │ │ +LENGTH+FLAG │ │ │ │ +FOP-FUNCALL │ │ │ │ +FOP-RATIO │ │ │ │ +FOP-LAYOUT-OF-COMPILED-DEBUG-INFO │ │ │ │ +FOP-LIST* │ │ │ │ +AUX-FOP-INTERN │ │ │ │ +FOP-RPLACA │ │ │ │ +PROBE-LOAD-DEFAULTS │ │ │ │ +FOP-INT-CONST0 │ │ │ │ +CALL-WITH-LOAD-BINDINGS │ │ │ │ +CONDITION-HERALD │ │ │ │ +READ-VARINT │ │ │ │ +PUSH-FOP-TABLE │ │ │ │ +READ-BASE-STRING-AS-BYTES │ │ │ │ +FOP-COMPLEX-DOUBLE-FLOAT │ │ │ │ +FOP-CHARACTER │ │ │ │ +FOP-INT-CONST-NEG1 │ │ │ │ +FOP-LAYOUT-OF-DEFSTRUCT-DESCRIPTION │ │ │ │ +FOP-FUNCALL* │ │ │ │ +LOAD-FASL-GROUP │ │ │ │ +FOP-RPLACD │ │ │ │ +STRING-FROM-STREAM │ │ │ │ +FOP-INTEGER │ │ │ │ +FOP-LAYOUT-OF-CONDITION │ │ │ │ +FOP-MSET │ │ │ │ +FOP-WORD-POINTER │ │ │ │ +FOP-SINGLE-FLOAT │ │ │ │ +N-CODE-BYTES │ │ │ │ +UNSUFFIX │ │ │ │ +FOP-LAYOUT-OF-DEFSTRUCT-SLOT-DESCRIPTION │ │ │ │ +FOP-SYMBOL-IN-PACKAGE-INTERNAL-SAVE │ │ │ │ +*SHOW-FOPS-P* │ │ │ │ +FOP-FSET │ │ │ │ +EVAL-FORM │ │ │ │ +FOP-SVSET │ │ │ │ +FOP-UNINTERNED-SYMBOL-SAVE │ │ │ │ +FOP-ASSEMBLER-CODE │ │ │ │ +READ-UNSIGNED-BYTE-32-ARG │ │ │ │ +N-FIXUP-ELTS │ │ │ │ +FOP-SLOTSET │ │ │ │ +STREAM-WE-ARE-LOADING-FROM │ │ │ │ +TABLE-INDEX │ │ │ │ +FOP-END-GROUP │ │ │ │ +FOP-WORD-INTEGER │ │ │ │ +FOP-LAYOUT-OF-DEFINITION-SOURCE-LOCATION │ │ │ │ +FOP-PACKAGE │ │ │ │ +FOP-FUN-ENTRY │ │ │ │ +*SHOW-NEW-CODE* │ │ │ │ +MAYBE-SKIP-SHEBANG-LINE │ │ │ │ +FOP-LAYOUT │ │ │ │ +FOP-LAYOUT-OF-DEBUG-INFO │ │ │ │ +FASL-HEADER-P │ │ │ │ +POSSIBLY-LOG-NEW-CODE │ │ │ │ +FOP-FUNCALL-FOR-EFFECT │ │ │ │ +FASL-INPUT-STREAM │ │ │ │ +FOP-DOUBLE-FLOAT │ │ │ │ +FOP-CHARACTER-STRING │ │ │ │ +*LOAD-DEPTH* │ │ │ │ +LOAD-STREAM │ │ │ │ +FOP-INT-CONST1 │ │ │ │ +FOP-NAMED-CONSTANT-SET │ │ │ │ +FOP-VECTOR │ │ │ │ +FOP-NTHCDR │ │ │ │ +FOP-FDEFN │ │ │ │ PREFIX-LISP-OBJECT-FILES │ │ │ │ POSTFIX-LISP-OBJECT-FILES │ │ │ │ EXTRA-OBJECT-FILES │ │ │ │ EXTRA-BUILD-ARGS │ │ │ │ PACKAGE-STRING │ │ │ │ SYMBOL-STRING │ │ │ │ +***HERE*** │ │ │ │ +AMBIGUOUS │ │ │ │ BINARY-NAME │ │ │ │ DISPATCHED-ENTRIES │ │ │ │ ASDF-DIRECTIVES │ │ │ │ LOAD-PATHS │ │ │ │ DUMPFILE-COPY │ │ │ │ CORE-ONLY │ │ │ │ COMPRESS-CORE │ │ │ │ -***HERE*** │ │ │ │ -AMBIGUOUS │ │ │ │ INTERPRET │ │ │ │ INTERRUPTED │ │ │ │ ISO-8859-8 │ │ │ │ ISO-8859-6 │ │ │ │ EXISTENCE │ │ │ │ ISO-8859-3 │ │ │ │ UTF-32BE │ │ │ │ @@ -18437,15 +18595,14 @@ │ │ │ │ ISO-8859-11 │ │ │ │ ISO-8859-10 │ │ │ │ UNINTERNED │ │ │ │ ISO-8859-5 │ │ │ │ UTF-16LE │ │ │ │ ISO-8859-13 │ │ │ │ ISO-8859-2 │ │ │ │ -*STANDARD-PPRINT-DISPATCH-TABLE* │ │ │ │ WRITER-METHOD-CLASS │ │ │ │ UPDATE-DEPENDENT │ │ │ │ STANDARD-INSTANCE-ACCESS │ │ │ │ SPECIALIZER-DIRECT-METHODS │ │ │ │ SPECIALIZER-DIRECT-GENERIC-FUNCTIONS │ │ │ │ SLOT-DEFINITION-TYPE │ │ │ │ SLOT-DEFINITION-INITFUNCTION │ │ │ │ @@ -18489,50 +18646,49 @@ │ │ │ │ CLASS-DIRECT-SLOTS │ │ │ │ CLASS-DIRECT-DEFAULT-INITARGS │ │ │ │ CLASS-DEFAULT-INITARGS │ │ │ │ ADD-DIRECT-SUBCLASS │ │ │ │ ADD-DIRECT-METHOD │ │ │ │ ADD-DEPENDENT │ │ │ │ DIVIDE-BY-ZERO │ │ │ │ +*STANDARD-PPRINT-DISPATCH-TABLE* │ │ │ │ PARTIAL-MACROEXPANDER │ │ │ │ AS-FILES │ │ │ │ WAIT-FOR-INPUT │ │ │ │ READ-ERROR │ │ │ │ UTF-16BE │ │ │ │ -STANDARD-INSTANCE │ │ │ │ MAKE-CACHE │ │ │ │ %STRUCT-TYPECASE-MISS │ │ │ │ ASSUMED-TYPE │ │ │ │ WIRED-TLS │ │ │ │ WALKER-TEMPLATE │ │ │ │ MACRO-EXPANSION │ │ │ │ TRANSLATOR │ │ │ │ PREDICATE-FOR │ │ │ │ PREDICATE-TRUTH-CONSTRAINT │ │ │ │ FORWARD-REFERENCES │ │ │ │ ALIEN-INFO │ │ │ │ TYPED-STRUCTURE │ │ │ │ RANDOM-DOCUMENTATION │ │ │ │ SYMBOL-MACRO │ │ │ │ -SET-FILE-POSITION │ │ │ │ +STANDARD-INSTANCE │ │ │ │ REMAINING │ │ │ │ -CAPITALIZE-FIRST │ │ │ │ SECTION-RELATIVE │ │ │ │ +CAPITALIZE-FIRST │ │ │ │ LINE-RELATIVE │ │ │ │ +SET-FILE-POSITION │ │ │ │ PER-LINE-PREFIX │ │ │ │ -*CURRENT-FASL-GROUP* │ │ │ │ FULL-CALL-NO-RETURN │ │ │ │ PROGRESS │ │ │ │ STRUCTURE-ALLOC │ │ │ │ PRE-IR2-OPTIMIZE │ │ │ │ RECEIVE-PENDING-INTERRUPT │ │ │ │ SYNTHETIC │ │ │ │ SEQUENCE-TYPE │ │ │ │ *SYMBOL-MACRO* │ │ │ │ -*CURRENT-VOP* │ │ │ │ ARG-CHECK │ │ │ │ EVENTUALLY │ │ │ │ ARG-LVARS │ │ │ │ KNOWN-FUN │ │ │ │ PENTIUM4 │ │ │ │ ALIGNED-STACK │ │ │ │ CODE-OBJECT │ │ │ │ @@ -18557,23 +18713,37 @@ │ │ │ │ *INITFUNCTIONS-FOR-THIS-DEFCLASS* │ │ │ │ *READERS-FOR-THIS-DEFCLASS* │ │ │ │ *WRITERS-FOR-THIS-DEFCLASS* │ │ │ │ *SLOT-NAMES-FOR-THIS-DEFCLASS* │ │ │ │ LOAD-DEFCLASS │ │ │ │ *THE-CLASS-STRUCTURE-CLASS* │ │ │ │ LOAD-SHORT-DEFCOMBIN │ │ │ │ +UNSUPPLIED │ │ │ │ +NO-ERROR │ │ │ │ USE-LABELS │ │ │ │ RENAME-AND-DELETE │ │ │ │ NEW-VERSION │ │ │ │ IGNORE-THIS-ARG │ │ │ │ -UNSUPPLIED │ │ │ │ -NO-ERROR │ │ │ │ UNTRACE-1 │ │ │ │ UNTRACE-PACKAGE │ │ │ │ %DEFMETHOD-EXPANDER │ │ │ │ +PROCESS-GROUP │ │ │ │ +PTY-PROCESS-GROUP │ │ │ │ +*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ +*DISASSEM-INST-SPACE* │ │ │ │ +ACCEPT-RUNTIME-OPTIONS │ │ │ │ +*OLD-DEBUGGER-HOOK* │ │ │ │ +PSEUDO-STATIC │ │ │ │ +DENORMALIZED-OPERAND │ │ │ │ +UNDERFLOW │ │ │ │ +TRACE-CALL │ │ │ │ +ABBREVIATED │ │ │ │ +EXIT-IF-NULL │ │ │ │ +INTERRUPTION │ │ │ │ +ALLOW-FORMS │ │ │ │ GENERIC-FUNCTION-P │ │ │ │ EARLY-CLASS-PRECEDENCE-LIST │ │ │ │ EARLY-METHOD-STANDARD-ACCESSOR-P │ │ │ │ EARLY-METHOD-SPECIALIZERS │ │ │ │ EARLY-SLOT-DEFINITION-LOCATION │ │ │ │ FIND-SLOT-DEFINITION │ │ │ │ SLOT-ACCESSOR-STD-P │ │ │ │ @@ -18591,203 +18761,15 @@ │ │ │ │ MAKE-DISPATCH-DFUN │ │ │ │ MAKE-CONSTANT-VALUE-DFUN │ │ │ │ CACHING-MISS │ │ │ │ REMOVE-METHODS │ │ │ │ USE-DEFAULT-METHOD-ONLY-DFUN-P │ │ │ │ CHECKING-MISS │ │ │ │ PRINT-BACKTRACE │ │ │ │ -INSTRUCTION-HOOKS │ │ │ │ -PERFORM-OPERAND-LOWERING │ │ │ │ -TRACE-INST │ │ │ │ -EXTRACT-PREFIX-KEYWORDS │ │ │ │ -%OBSOLETE-INSTANCE-TRAP │ │ │ │ -PROCESS-GROUP │ │ │ │ -PTY-PROCESS-GROUP │ │ │ │ -*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ -*DISASSEM-INST-SPACE* │ │ │ │ -ACCEPT-RUNTIME-OPTIONS │ │ │ │ -*OLD-DEBUGGER-HOOK* │ │ │ │ -PSEUDO-STATIC │ │ │ │ -EXIT-IF-NULL │ │ │ │ -DENORMALIZED-OPERAND │ │ │ │ -UNDERFLOW │ │ │ │ -TRACE-CALL │ │ │ │ -ABBREVIATED │ │ │ │ -INTERRUPTION │ │ │ │ -ALLOW-FORMS │ │ │ │ -EMIT-N-N-MAKUNBOUNDS │ │ │ │ -EMIT-N-N-READERS │ │ │ │ -EMIT-N-N-WRITERS │ │ │ │ -EMIT-N-N-BOUNDPS │ │ │ │ -EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ -EMIT-ONE-INDEX-READERS │ │ │ │ -EMIT-ONE-INDEX-WRITERS │ │ │ │ -EMIT-ONE-INDEX-BOUNDPS │ │ │ │ -EMIT-TWO-CLASS-MAKUNBOUND │ │ │ │ -EMIT-TWO-CLASS-READER │ │ │ │ -EMIT-TWO-CLASS-WRITER │ │ │ │ -EMIT-TWO-CLASS-BOUNDP │ │ │ │ -EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ -EMIT-ONE-CLASS-READER │ │ │ │ -EMIT-ONE-CLASS-WRITER │ │ │ │ -EMIT-ONE-CLASS-BOUNDP │ │ │ │ -EMIT-BYTES │ │ │ │ -IF-AFTER │ │ │ │ -PROCESS-BACK-PATCHES │ │ │ │ -COMPACT-SEGMENT-BUFFER │ │ │ │ -OPCODES1 │ │ │ │ - │ │ │ │ -STATEMENT │ │ │ │ -%EMIT-SKIP │ │ │ │ -%DEFPATTERN │ │ │ │ -SECTION. │ │ │ │ -MORE-LABELS │ │ │ │ -LABEL-NAME-P │ │ │ │ -.END-WITHOUT-SCHEDULING │ │ │ │ -BYTE-SPECS │ │ │ │ -GET-ALLOCATION-POINTS │ │ │ │ -COMPRESS-OUTPUT │ │ │ │ -.BEGIN-WITHOUT-SCHEDULING │ │ │ │ -*ASM-PATTERN-MATCHERS* │ │ │ │ -DECODE-PREFIX │ │ │ │ -%EMIT-POSTIT │ │ │ │ -%EMIT-FILLER │ │ │ │ -FINALIZE-POSITIONS │ │ │ │ -%MARK-USED-LABELS │ │ │ │ -N-ENTRIES │ │ │ │ -APPLICATOR │ │ │ │ -EMIT-ANNOTATION │ │ │ │ -DUMP-SYMBOLIC-ASM │ │ │ │ -OPCODES2 │ │ │ │ -INSERT-STMT │ │ │ │ -%EMIT-LABEL │ │ │ │ -..INHERITED-LABELS.. │ │ │ │ -TOTAL-BITS │ │ │ │ -SEGMENT-CURRENT-INDEX │ │ │ │ -ADJUST-ALIGNMENT-AFTER-CHOOSER │ │ │ │ -FIND-ALIGNMENT │ │ │ │ -%ASSEMBLE │ │ │ │ -%EMIT-ALIGNMENT │ │ │ │ -FOP-PUSH │ │ │ │ -FOP-LISP-SYMBOL-SAVE │ │ │ │ -FOP-EMPTY-LIST │ │ │ │ -FOP-BASE-STRING │ │ │ │ -CHECK-FASL-HEADER │ │ │ │ -FOP-COMPLEX │ │ │ │ -READ-WORD-ARG │ │ │ │ -OLD-VECTOR │ │ │ │ -.FASL-INPUT. │ │ │ │ -FASL-GROUP-END │ │ │ │ -PKG-INDEX │ │ │ │ -LOAD-AS-FASL │ │ │ │ -FOP-RECORD-CODE-COVERAGE │ │ │ │ -NAMED-CONSTANT-SET │ │ │ │ -FOP-STACK-POP-N │ │ │ │ -READ-CHAR-STRING-AS-VARINTS │ │ │ │ -FOP-COPY-SYMBOL-SAVE │ │ │ │ -FOP-STRUCT │ │ │ │ -FOP-INT-CONST2 │ │ │ │ -FOP-BYTE-INTEGER │ │ │ │ -FOP-STRUCTSET │ │ │ │ -FOP-MOVE-TO-TABLE │ │ │ │ -FOP-NOTE-FULL-CALLS │ │ │ │ -TABLE-SIZE │ │ │ │ -TBL-SLOT │ │ │ │ -LOAD-FRESH-LINE │ │ │ │ -READ-STRING-AS-BYTES │ │ │ │ -LOAD-S-INTEGER │ │ │ │ -FOP-LAYOUT-OF-STRUCTURE-OBJECT │ │ │ │ -*FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT* │ │ │ │ -FOP-SYMBOL-IN-PACKAGE-SAVE │ │ │ │ -READ-SYMBOL-NAME │ │ │ │ -PUSH-FOP-STACK │ │ │ │ -FOP-TRUTH │ │ │ │ -LOAD-STREAM-1 │ │ │ │ -ABORT-BUILD │ │ │ │ -FOP-INSTANCE │ │ │ │ -FOP-SPEC-VECTOR │ │ │ │ -MAYBE-ANNOUNCE-LOAD │ │ │ │ -FOP-LIST │ │ │ │ -FOP-LAYOUT-OF-DEBUG-SOURCE │ │ │ │ -NUKE-FOP-VECTOR │ │ │ │ -FOP-NAMED-PACKAGE-SAVE │ │ │ │ -FOP-KNOWN-FUN │ │ │ │ -FOP-KEYWORD-SYMBOL-SAVE │ │ │ │ -FOP-COMPLEX-SINGLE-FLOAT │ │ │ │ -FOP-ALTER-CODE │ │ │ │ -FOP-ARRAY │ │ │ │ -FOP-LAYOUT-OF-T │ │ │ │ -FOP-LOAD-CODE │ │ │ │ -GROW-FOP-VECTOR │ │ │ │ -FOP-MISC-TRAP │ │ │ │ -FOP-NOTE-PARTIAL-SOURCE-INFO │ │ │ │ -LENGTH+FLAG │ │ │ │ -FOP-FUNCALL │ │ │ │ -FOP-RATIO │ │ │ │ -FOP-LAYOUT-OF-COMPILED-DEBUG-INFO │ │ │ │ -FOP-LIST* │ │ │ │ -AUX-FOP-INTERN │ │ │ │ -FOP-RPLACA │ │ │ │ -PROBE-LOAD-DEFAULTS │ │ │ │ -FOP-INT-CONST0 │ │ │ │ -CALL-WITH-LOAD-BINDINGS │ │ │ │ -CONDITION-HERALD │ │ │ │ -READ-VARINT │ │ │ │ -PUSH-FOP-TABLE │ │ │ │ -READ-BASE-STRING-AS-BYTES │ │ │ │ -FOP-COMPLEX-DOUBLE-FLOAT │ │ │ │ -FOP-CHARACTER │ │ │ │ -FOP-INT-CONST-NEG1 │ │ │ │ -FOP-LAYOUT-OF-DEFSTRUCT-DESCRIPTION │ │ │ │ -FOP-FUNCALL* │ │ │ │ -LOAD-FASL-GROUP │ │ │ │ -FOP-RPLACD │ │ │ │ -STRING-FROM-STREAM │ │ │ │ -FOP-INTEGER │ │ │ │ -FOP-LAYOUT-OF-CONDITION │ │ │ │ -FOP-MSET │ │ │ │ -FOP-WORD-POINTER │ │ │ │ -FOP-SINGLE-FLOAT │ │ │ │ -N-CODE-BYTES │ │ │ │ -UNSUFFIX │ │ │ │ -FOP-LAYOUT-OF-DEFSTRUCT-SLOT-DESCRIPTION │ │ │ │ -FOP-SYMBOL-IN-PACKAGE-INTERNAL-SAVE │ │ │ │ -*SHOW-FOPS-P* │ │ │ │ -FOP-FSET │ │ │ │ -EVAL-FORM │ │ │ │ -FOP-SVSET │ │ │ │ -FOP-UNINTERNED-SYMBOL-SAVE │ │ │ │ -FOP-ASSEMBLER-CODE │ │ │ │ -READ-UNSIGNED-BYTE-32-ARG │ │ │ │ -N-FIXUP-ELTS │ │ │ │ -FOP-SLOTSET │ │ │ │ -STREAM-WE-ARE-LOADING-FROM │ │ │ │ -TABLE-INDEX │ │ │ │ -FOP-END-GROUP │ │ │ │ -FOP-WORD-INTEGER │ │ │ │ -FOP-LAYOUT-OF-DEFINITION-SOURCE-LOCATION │ │ │ │ -FOP-PACKAGE │ │ │ │ -FOP-FUN-ENTRY │ │ │ │ -*SHOW-NEW-CODE* │ │ │ │ -MAYBE-SKIP-SHEBANG-LINE │ │ │ │ -FOP-LAYOUT │ │ │ │ -FOP-LAYOUT-OF-DEBUG-INFO │ │ │ │ -FASL-HEADER-P │ │ │ │ -POSSIBLY-LOG-NEW-CODE │ │ │ │ -FOP-FUNCALL-FOR-EFFECT │ │ │ │ -FASL-INPUT-STREAM │ │ │ │ -FOP-DOUBLE-FLOAT │ │ │ │ -FOP-CHARACTER-STRING │ │ │ │ -*LOAD-DEPTH* │ │ │ │ -LOAD-STREAM │ │ │ │ -FOP-INT-CONST1 │ │ │ │ -FOP-NAMED-CONSTANT-SET │ │ │ │ -FOP-VECTOR │ │ │ │ -FOP-NTHCDR │ │ │ │ -FOP-FDEFN │ │ │ │ +*LOOP-ANSI-UNIVERSE* │ │ │ │ *STANDARD-SLOT-MAKUNBOUND-USING-CLASS-METHOD* │ │ │ │ COMBINED-METHOD │ │ │ │ TYPE-FROM-SPECIALIZER │ │ │ │ SLOT-NAME-LISTS-FROM-SLOTS │ │ │ │ VAR-NAME │ │ │ │ REAL-MAKE-METHOD-LAMBDA │ │ │ │ ACCESSOR-MISS │ │ │ │ @@ -18852,14 +18834,15 @@ │ │ │ │ EMIT-DLAP │ │ │ │ ADD-WRITER-METHOD │ │ │ │ *THE-CLASS-FUNCALLABLE-STANDARD-OBJECT* │ │ │ │ REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/CONS │ │ │ │ CACHING-DFUN-COST │ │ │ │ DIRECT-SLOTDS │ │ │ │ CONSTANT-SYMBOL-P │ │ │ │ +EMIT-ONE-INDEX-READERS │ │ │ │ STRUCTURE-INSTANCE │ │ │ │ GF-DFUN-INFO │ │ │ │ OPTIMIZED-SLOT-VALUE │ │ │ │ MAYBE-ENCAPSULATE-DISCRIMINATING-FUNCTION │ │ │ │ GENERATE-SLOTD-TYPECHECK │ │ │ │ ENSURE-CACHED-CTOR │ │ │ │ METHOD-CLASS-NAME │ │ │ │ @@ -18906,14 +18889,15 @@ │ │ │ │ ENSURE-CTOR-ARGS │ │ │ │ CLOSURE-VARIABLES │ │ │ │ CLASS-DEFSTRUCT-FORM │ │ │ │ APPLICABLE-METHODS │ │ │ │ SORT-METHODS │ │ │ │ PROPERLY-NAMED-P │ │ │ │ CONSTANT-VALUE-OR-NIL │ │ │ │ +EMIT-N-N-READERS │ │ │ │ *PV-TABLES* │ │ │ │ COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL │ │ │ │ UPDATE-ALL-C-A-M-GF-INFO │ │ │ │ MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION │ │ │ │ MAKE-STRUCTURE-CLASS-DEFSTRUCT-FORM │ │ │ │ DISCARDED │ │ │ │ WRAP-WITH-APPLICABLE-KEYWORD-CHECK │ │ │ │ @@ -18937,14 +18921,15 @@ │ │ │ │ SHORT-COMBINE-METHODS │ │ │ │ PROPERTY-LIST │ │ │ │ EFFECTIVE-METHOD-GENSYM-3 │ │ │ │ DEAL-WITH-ARGS-OPTION │ │ │ │ CPL-OR-NIL │ │ │ │ .METHOD-COMBINATION. │ │ │ │ SAUT-NOT │ │ │ │ +EMIT-N-N-MAKUNBOUNDS │ │ │ │ FN-VARIABLE │ │ │ │ METHOD-GROUP-SPECIFIERS │ │ │ │ NOTE-READER │ │ │ │ RESOLVE-CLASS │ │ │ │ EXISTING-CLASS │ │ │ │ INSTANCE-INIT │ │ │ │ CHECK-INITARGS-1 │ │ │ │ @@ -19001,23 +18986,26 @@ │ │ │ │ SORT-SLOTS │ │ │ │ COMPUTE-APPLICABLE-METHODS-FUNCTION │ │ │ │ MISS-TAG │ │ │ │ DEFAULT-TEST-CONVERTER │ │ │ │ GET-EFFECTIVE-METHOD-FUNCTION1 │ │ │ │ .ARGS-TAIL. │ │ │ │ SAFE-METHOD-QUALIFIERS │ │ │ │ +EMIT-TWO-CLASS-WRITER │ │ │ │ METHOD-TRACE-NAME │ │ │ │ +EMIT-ONE-INDEX-WRITERS │ │ │ │ MEC-ALL-CLASSES-INTERNAL │ │ │ │ OBJECT-CLASS │ │ │ │ TRY-UPDATE-CACHE │ │ │ │ .IGNORE. │ │ │ │ %CNM-CHECKER-LAMBDA-LIST │ │ │ │ ACCESSOR-VALUES-INTERNAL │ │ │ │ ENSURE-CACHED-ALLOCATOR │ │ │ │ MAP-ALL-ORDERS │ │ │ │ +EMIT-ONE-CLASS-READER │ │ │ │ SPECIALIZER-CACHE │ │ │ │ CHECK-INITARGS-VALUES │ │ │ │ .PV-OFFSET. │ │ │ │ SLOT-INIT-FORMS │ │ │ │ STRUCTURE-CLASS-P │ │ │ │ LMF-OPTIONS │ │ │ │ %CHANGE-CLASS │ │ │ │ @@ -19043,14 +19031,15 @@ │ │ │ │ FIND-CLASS* │ │ │ │ COMPUTE-TEST │ │ │ │ .METH-LIST. │ │ │ │ AUGMENT-TYPE │ │ │ │ ALL-APPLICABLE-P │ │ │ │ .FUNCTION. │ │ │ │ ADD-SLOT-ACCESSORS │ │ │ │ +EMIT-ONE-CLASS-BOUNDP │ │ │ │ ORDER-MATTERS-TEST │ │ │ │ MAKE-OPTIMIZED-STD-SLOT-MAKUNBOUND-USING-CLASS-METHOD-FUNCTION │ │ │ │ SPECIALIZER-APPLICABLE-USING-TYPE-P │ │ │ │ MAKE-FINAL-DFUN-INTERNAL │ │ │ │ MEMF-TEST-CONVERTER │ │ │ │ INTERCEPT │ │ │ │ GET-ACCESSOR-METHOD-FUNCTION │ │ │ │ @@ -19225,17 +19214,19 @@ │ │ │ │ MAKE-EFFECTIVE-METHOD-FUNCTION │ │ │ │ INSTANCE-MAKUNBOUND-CUSTOM │ │ │ │ ALL-DSLOTDS-AUX │ │ │ │ MAKE-WRITER-METHOD-FUNCTION │ │ │ │ %SET-SLOT-VALUE-CHECKING-TYPE │ │ │ │ WRAPPED-BODY │ │ │ │ ACCESSES-STANDARD-CLASS-SLOT-P │ │ │ │ +EMIT-N-N-WRITERS │ │ │ │ METHODS-CONVERTER │ │ │ │ INSTANCE-READ-STANDARD │ │ │ │ REAL-UNPARSE-SPECIALIZER-USING-CLASS │ │ │ │ +EMIT-TWO-CLASS-MAKUNBOUND │ │ │ │ EMIT-ONE-OR-N-INDEX-READER/WRITER │ │ │ │ SPECIALIZERS-FORM │ │ │ │ DIRECT-SLOTS-P │ │ │ │ *CASE-TABLE-LIMIT* │ │ │ │ PROTO-GENERIC-FUNCTION │ │ │ │ SET-CONDITION-SVUC-METHOD │ │ │ │ .CM-ARGS. │ │ │ │ @@ -19274,14 +19265,15 @@ │ │ │ │ CHECK-INITARGS-2-LIST │ │ │ │ INSTANCE-WRITE-STANDARD │ │ │ │ STANDARD-COMPUTE-EFFECTIVE-METHOD │ │ │ │ INSTANCE-BOUNDP-STANDARD │ │ │ │ ALLOCATE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ .MORE-COUNT. │ │ │ │ REAL-BODY │ │ │ │ +EMIT-N-N-BOUNDPS │ │ │ │ GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION │ │ │ │ CONDITION-TYPE-P │ │ │ │ GROUP-COND-CLAUSE │ │ │ │ PV-WRAPPERS-FROM-PV-ARGS │ │ │ │ ARG-NUMBER │ │ │ │ SAUT-AND │ │ │ │ PARAMETER-SPECIALIZER-DECLARATION-IN-DEFMETHOD │ │ │ │ @@ -19347,14 +19339,15 @@ │ │ │ │ MAKE-METHOD-INITARGS-FORM-INTERNAL1 │ │ │ │ SLOT-VALUE-FOR-PRINTING │ │ │ │ COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS │ │ │ │ NEXT-CACHE-INDEX │ │ │ │ CAN-OPTIMIZE-ACCESS │ │ │ │ PARSE-SPECIALIZERS │ │ │ │ GET-DISPATCH-FUNCTION │ │ │ │ +EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ MAKE-SLOT-TABLE │ │ │ │ METHOD-ALIST │ │ │ │ EFFECTIVE-METHOD-GENSYM-6 │ │ │ │ DECLARED-SPECIALS │ │ │ │ SETF-FIND-CLASS │ │ │ │ *REBOUND-EFFECTIVE-METHOD-GENSYMS* │ │ │ │ COMPUTE-CONSTANTS │ │ │ │ @@ -19534,23 +19527,25 @@ │ │ │ │ MAKE-METHOD-SPEC │ │ │ │ %INVALIDATE-WRAPPER │ │ │ │ .REST-ARG. │ │ │ │ *EMF-CALL-TRACE* │ │ │ │ EMIT-SLOT-READ-FORM │ │ │ │ INSTANCE-MAKUNBOUND-STANDARD │ │ │ │ DISPATCH-DFUN-COST │ │ │ │ +EMIT-TWO-CLASS-BOUNDP │ │ │ │ DIRECT-SUPERCLASSES-P │ │ │ │ SLOT-DEFINITION-INTERNAL-READER-FUNCTION │ │ │ │ %UPDATE-CPL │ │ │ │ SHORT-METHOD-COMBINATION-P │ │ │ │ CALL-NEXT-METHOD-P │ │ │ │ PARAMETER-NAME │ │ │ │ SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL │ │ │ │ GET-OR-PUT-CTOR │ │ │ │ CHANGE-CLASS-TO-METAOBJECT-VIOLATION │ │ │ │ +EMIT-ONE-INDEX-BOUNDPS │ │ │ │ CALL-NEXT-METHOD-N │ │ │ │ EMIT-CONSTANT-VALUE │ │ │ │ DEFAULT-SECONDARY-DISPATCH-FUNCTION │ │ │ │ SHORT-METHOD-COMBINATION-QUALIFIER-P │ │ │ │ NEW-CUSTOM-SLOTDS │ │ │ │ INSTANCE-BOUNDP-CUSTOM │ │ │ │ COMPUTE-PV │ │ │ │ @@ -19568,23 +19563,25 @@ │ │ │ │ STANDARD-SORT-METHODS │ │ │ │ REAL-MAKE-A-METHOD │ │ │ │ FIND-SUPERCLASS-CHAIN │ │ │ │ OLD-CTOR │ │ │ │ INSTALL-OPTIMIZED-CONSTRUCTOR │ │ │ │ MAKE-FALLBACK-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-CTOR-INLINE-CACHE-FORM │ │ │ │ +%OBSOLETE-INSTANCE-TRAP │ │ │ │ SAFE-GENERIC-FUNCTION-METHODS │ │ │ │ FIND-IN-SUPERCLASSES │ │ │ │ %SLOT-DEFINITION-DOCUMENTATION │ │ │ │ WEAK-HASHSET-MEMBERP │ │ │ │ LL-KEYP-OR-RESTP │ │ │ │ *TYPECHECK-STACK* │ │ │ │ REMOVE-WRITER-METHOD │ │ │ │ MAKE-CTOR-PARAMETER-LIST │ │ │ │ ADD-SOURCE-LOCATION │ │ │ │ +EMIT-TWO-CLASS-READER │ │ │ │ METHODS-IN-COMPILATION-UNIT │ │ │ │ READER/WRITER │ │ │ │ LAYOUT-VARS │ │ │ │ OPTIMIZING-ALLOCATOR-GENERATOR │ │ │ │ DFUN-ARG-SYMBOL │ │ │ │ GET-METHOD-FUNCTION │ │ │ │ ALL-CPDS │ │ │ │ @@ -19619,14 +19616,15 @@ │ │ │ │ UPDATE-STD-SLOT-METHODS │ │ │ │ NET-CONSTANT-CONVERTER │ │ │ │ *DFUN-ARG-SYMBOLS* │ │ │ │ CREATE-GF-LAMBDA-LIST │ │ │ │ ALLOCATE-STANDARD-INSTANCE │ │ │ │ FAST-CALL-NEXT-METHOD-BODY │ │ │ │ SET-BITMAP-AND-FLAGS │ │ │ │ +EMIT-ONE-CLASS-WRITER │ │ │ │ .NOT-THERE. │ │ │ │ *LONG-METHOD-COMBINATION-FUNCTIONS* │ │ │ │ GF-REQUIRES-EMF-KEYWORD-CHECKS │ │ │ │ *THE-CLASS-FORWARD-REFERENCED-CLASS* │ │ │ │ REAL-MAKE-METHOD-INITARGS-FORM │ │ │ │ STD-COMPUTE-SLOTS │ │ │ │ .CONSTANT. │ │ │ │ @@ -19643,14 +19641,15 @@ │ │ │ │ DEFER-FTYPE-COMPUTATION │ │ │ │ %UPDATE-SLOTS │ │ │ │ EFFECTIVE-METHOD-GENSYM-7 │ │ │ │ REAL-SPECIALIZER-TYPE-SPECIFIER/CLASS │ │ │ │ EMIT-MISS │ │ │ │ DEFAULT-INIT-VAR-NAME │ │ │ │ *SLOT-NAME-LISTS* │ │ │ │ +EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ LONG-METHOD-COMBINATION-FUNCTION │ │ │ │ %ACCESSOR-SLOT-VALUE │ │ │ │ MAKE-METHOD-LAMBDA-INTERNAL │ │ │ │ ENSURE-CTOR-NAME │ │ │ │ DO-METHODS │ │ │ │ MAKE-DLAP-LAMBDA-LIST │ │ │ │ REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/SYMBOL │ │ │ │ @@ -19834,15 +19833,15 @@ │ │ │ │ OUTPUT-PRETTY-OBJECT │ │ │ │ NOTE-SIGNIFICANT-SPACE │ │ │ │ KEEP-OPERATION │ │ │ │ KEEP-COMPONENT │ │ │ │ PRINT-REG │ │ │ │ PRINT-REG/MEM │ │ │ │ PRINT-SIZED-REG/MEM │ │ │ │ -*LOOP-ANSI-UNIVERSE* │ │ │ │ +ELSEWHERE │ │ │ │ LFL-INSERT/T │ │ │ │ SO-FIND/STRING │ │ │ │ SO-FINDER │ │ │ │ %SO-DELETE/ADDR │ │ │ │ LFL-SEARCH/FIXNUM │ │ │ │ SO-INSERTER │ │ │ │ *DESIRED-ELTS-PER-BIN* │ │ │ │ @@ -20601,31 +20600,34 @@ │ │ │ │ FUNCTION-SPEC │ │ │ │ TIMESTAMPS │ │ │ │ ELEMENT< │ │ │ │ SEPARATORP │ │ │ │ UTILITY-FILE │ │ │ │ ELSE-FORM │ │ │ │ FROB-SUBSTRINGS │ │ │ │ +US-ASCII │ │ │ │ +ANSI_X3.4-1968 │ │ │ │ +ISO-646-US │ │ │ │ +ISO-8859-1 │ │ │ │ +ISO8859-1 │ │ │ │ +x-mac-cyrillic │ │ │ │ SESSION-ANCESTOR │ │ │ │ %COMPONENT-ENCODING │ │ │ │ %ADDITIONAL-INPUT-FILES │ │ │ │ PROLOGUE-CODE │ │ │ │ EPILOGUE-CODE │ │ │ │ -ELSEWHERE │ │ │ │ STATUS-BITS │ │ │ │ STATUS-LEVEL │ │ │ │ MODULE-COMPONENTS-BY-NAME │ │ │ │ REQUIRED-MODULE │ │ │ │ -US-ASCII │ │ │ │ -ANSI_X3.4-1968 │ │ │ │ -ISO-646-US │ │ │ │ -ISO-8859-1 │ │ │ │ -ISO8859-1 │ │ │ │ -x-mac-cyrillic │ │ │ │ PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ +LOAD-TOPLEVEL │ │ │ │ +COMPILER │ │ │ │ +DATA-DEPENDENCY │ │ │ │ +!MAKE-FOREIGN-THREAD │ │ │ │ iso-8859-2 │ │ │ │ iso-8859-3 │ │ │ │ iso-8859-4 │ │ │ │ iso-8859-5 │ │ │ │ iso-8859-6 │ │ │ │ iso-8859-7 │ │ │ │ iso-8859-8 │ │ │ │ @@ -20653,53 +20655,55 @@ │ │ │ │ WINDOWS-1258 │ │ │ │ windows-1258 │ │ │ │ mac-roman │ │ │ │ MacRoman │ │ │ │ MACINTOSH │ │ │ │ macintosh │ │ │ │ Shift_JIS │ │ │ │ -LOAD-TOPLEVEL │ │ │ │ -COMPILER │ │ │ │ -DATA-DEPENDENCY │ │ │ │ -!MAKE-FOREIGN-THREAD │ │ │ │ GET-FILE-POSITION │ │ │ │ INTERACTIVE-P │ │ │ │ RESET-UNICODE-P │ │ │ │ NORMALIZE-STRING │ │ │ │ MACROEXPAND-ALL │ │ │ │ F-STREAM- │ │ │ │ SYMBOL-MACRO77 │ │ │ │ -IMMOBILE-SYMBOL │ │ │ │ COVERAGE-MARKS │ │ │ │ +IMMOBILE-SYMBOL │ │ │ │ UNICODE-CHAR->NAME │ │ │ │ UNICODE-1-CHAR->NAME │ │ │ │ RESULT-REFS │ │ │ │ VARIANT-COST │ │ │ │ ARG-REFS │ │ │ │ DOUBLE-FLOAT-BITS │ │ │ │ -MISER-WIDTH │ │ │ │ +KEY-OR-VALUE │ │ │ │ +KEY-AND-VALUE │ │ │ │ READABLY │ │ │ │ +MISER-WIDTH │ │ │ │ RIGHT-MARGIN │ │ │ │ SUPPRESS-ERRORS │ │ │ │ -KEY-OR-VALUE │ │ │ │ -KEY-AND-VALUE │ │ │ │ -DEBUGGER-FRAME │ │ │ │ -FINISHED │ │ │ │ -DONT-KNOW │ │ │ │ -ASDF/INTERFACE │ │ │ │ -*IN-MAKE-OPERATION* │ │ │ │ +WALKER-ENVIRONMENT-BIND-1 │ │ │ │ +WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ +WALK-ARGLIST │ │ │ │ +WALK-REPEAT-EVAL │ │ │ │ +WALK-DECLARATIONS │ │ │ │ +NEGATIVE-INFINITY │ │ │ │ +POSITIVE-INFINITY │ │ │ │ +KEY-INDEX- │ │ │ │ VAR-SPECIAL-P │ │ │ │ DEFINE-WALKER-TEMPLATE │ │ │ │ VAR-GLOBALLY-SPECIAL-P │ │ │ │ WALK-FORM │ │ │ │ VAR-LEXICAL-P │ │ │ │ *WALK-FORM-EXPAND-MACROS-P* │ │ │ │ VAR-DECLARATION │ │ │ │ -NEGATIVE-INFINITY │ │ │ │ -POSITIVE-INFINITY │ │ │ │ +DEBUGGER-FRAME │ │ │ │ +FINISHED │ │ │ │ +CONVERT-MACRO-TO-LAMBDA │ │ │ │ +DECOMPOSE-STRING │ │ │ │ +CANONICALLY-COMPOSE │ │ │ │ LOW-SURROGATES │ │ │ │ NCONCING │ │ │ │ NABATAEAN │ │ │ │ UIOP/VERSION │ │ │ │ UPGRADING-P │ │ │ │ HIGH-SURROGATES │ │ │ │ STREAM-EASY-P │ │ │ │ @@ -20750,14 +20754,15 @@ │ │ │ │ ORIGINAL-SOURCE │ │ │ │ UNIFIED-CANADIAN-ABORIGINAL-SYLLABICS │ │ │ │ VARIATION-SELECTORS-SUPPLEMENT │ │ │ │ SUPPLEMENTAL-ARROWS-C │ │ │ │ NAMED-CONSTANT │ │ │ │ JAVA-1.5 │ │ │ │ ARABIC-PRESENTATION-FORMS-A │ │ │ │ +ASDF/INTERFACE │ │ │ │ OS-HAIKU │ │ │ │ LISPWORKS │ │ │ │ LATIN-EXTENDED-G │ │ │ │ BOPOMOFO │ │ │ │ EAT-SPACES │ │ │ │ PALMYRENE │ │ │ │ OTHER-ID-CONTINUE │ │ │ │ @@ -21056,14 +21061,15 @@ │ │ │ │ ARABIC-MATHEMATICAL-ALPHABETIC-SYMBOLS │ │ │ │ REF-KNOWN │ │ │ │ LATIN-EXTENDED-D │ │ │ │ OUTPUT-TRANSLATIONS │ │ │ │ IN-PROGRESS │ │ │ │ CAUCASIAN-ALBANIAN │ │ │ │ PHAISTOS-DISC │ │ │ │ +DONT-KNOW │ │ │ │ COMBINING-DIACRITICAL-MARKS-FOR-SYMBOLS │ │ │ │ MATHEMATICAL-ALPHANUMERIC-SYMBOLS │ │ │ │ SYMBOLS-FOR-LEGACY-COMPUTING │ │ │ │ CJK-SYMBOLS-AND-PUNCTUATION │ │ │ │ ENABLE-USER-CACHE │ │ │ │ ARABIC-EXTENDED-B │ │ │ │ TANGUT-COMPONENTS │ │ │ │ @@ -21250,25 +21256,18 @@ │ │ │ │ MEETEI-MAYEK │ │ │ │ ASDF/PACKAGE-INFERRED-SYSTEM │ │ │ │ INVALID-FORM-REPORTER │ │ │ │ OTHER-DEFAULT-IGNORABLE-CODE-POINT │ │ │ │ UIOP-DIRECTORY │ │ │ │ PAHAWH-HMONG │ │ │ │ UIOP/COMMON-LISP │ │ │ │ -KEY-INDEX- │ │ │ │ -WALKER-ENVIRONMENT-BIND-1 │ │ │ │ -WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ -WALK-ARGLIST │ │ │ │ -WALK-REPEAT-EVAL │ │ │ │ -WALK-DECLARATIONS │ │ │ │ -CONVERT-MACRO-TO-LAMBDA │ │ │ │ -DECOMPOSE-STRING │ │ │ │ -CANONICALLY-COMPOSE │ │ │ │ -COLLECT-DEPENDENCIES │ │ │ │ +%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ +*IN-MAKE-OPERATION* │ │ │ │ SYSTEM-NAME │ │ │ │ +COLLECT-DEPENDENCIES │ │ │ │ NEW-STATUS │ │ │ │ NEW-LEVEL │ │ │ │ LOOP-DESETQ-TEMP │ │ │ │ SPECIAL75 │ │ │ │ NOT-PRESENT78 │ │ │ │ DELETE-PACKAGE* │ │ │ │ SYMBOL-SHADOWING-P │ │ │ │ @@ -21291,20 +21290,18 @@ │ │ │ │ UNREIFY-SYMBOL │ │ │ │ ENSURE-PACKAGE │ │ │ │ ENSURE-PACKAGE-UNUSED │ │ │ │ FIND-SYMBOL* │ │ │ │ HOME-PACKAGE-P │ │ │ │ UNREIFY-PACKAGE │ │ │ │ REIFY-SYMBOL │ │ │ │ -%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ +PROPERTY │ │ │ │ ITERATOR-COPY │ │ │ │ ADJUST-SEQUENCE │ │ │ │ ENTRY-FUNCTION-FORM │ │ │ │ -PROPERTY │ │ │ │ -SERIAL-P │ │ │ │ NEEDS-ASDF-P │ │ │ │ ENTRY-FUNCTION-CHECK-FORM │ │ │ │ ITERATOR-ELEMENT │ │ │ │ ITERATOR-ENDP │ │ │ │ MAKE-SIMPLE-SEQUENCE-ITERATOR │ │ │ │ GATHER-TYPE │ │ │ │ ITERATOR-STEP │ │ │ │ @@ -21315,14 +21312,15 @@ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ +GOOD-BITS+ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-EXPLAIN-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-TRAVERSE-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-PROPERTY-NOTIFIED-P* │ │ │ │ +DONE-BIT+ │ │ │ │ COMMAND-LINE-DEBUGGER │ │ │ │ +SERIAL-P │ │ │ │ +CHARACTER-MISC-DATABASE+ │ │ │ │ *KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ ONE-ITER- │ │ │ │ WALK-DEFINITIONS │ │ │ │ CANONIZE-KEY │ │ │ │ GET-ARGS │ │ │ │ DISPATCHED-ENTRY-FORM │ │ │ │ @@ -21509,26 +21507,37 @@ │ │ │ │ BUNDLE-OUTPUT-FILES │ │ │ │ PATHNAME-TYPE-EQUAL-FUNCTION │ │ │ │ SPACE-FOR-CRLF │ │ │ │ CANONIZE-TEST │ │ │ │ DOWNWARD-OPERATION-DEPENDS-ON │ │ │ │ UPWARD-OPERATION-DEPENDS-ON │ │ │ │ ACTION-OVERRIDE-P │ │ │ │ -N-ARRAY23 │ │ │ │ SELFWARD-OPERATION-DEPENDS-ON │ │ │ │ SIDEWAY-OPERATION-DEPENDS-ON │ │ │ │ BACKWARD-COMPATIBLE-DEPENDS-ON │ │ │ │ CHECK-OPERATION-CONSTRUCTOR │ │ │ │ +N-ARRAY23 │ │ │ │ WALK-FORM-INTERNAL │ │ │ │ WALK-BINDINGS-1 │ │ │ │ LET*-BINDINGS │ │ │ │ NOTE-VAR-BINDING │ │ │ │ WALKED-VAR-DECLARATION-P │ │ │ │ NOTE-DECLARATION │ │ │ │ VARIABLE-SYMBOL-MACRO-P │ │ │ │ +ENV-WALK-FUNCTION │ │ │ │ +ENV-LEXICAL-VARIABLES │ │ │ │ +WALK-TAGBODY-1 │ │ │ │ +HUFFMAN-DECODE │ │ │ │ +ENV-LOCK │ │ │ │ +WALKER-INFO-TO-BOGO-FUN │ │ │ │ +RELIST-INTERNAL │ │ │ │ +RECORD-NEW-SOURCE-PATH │ │ │ │ +DECOMPOSE-CHAR │ │ │ │ +COMBINING-CLASS │ │ │ │ +PRIMARY-COMPOSITION │ │ │ │ CALL-WITHOUT-REDEFINITION-WARNINGS │ │ │ │ OS-HAIKU-P │ │ │ │ FEATURE-SETS │ │ │ │ OS-MEZZANO-P │ │ │ │ FIRST-FEATURE │ │ │ │ *LINK-GUID* │ │ │ │ *LINK-INITIAL-DWORD* │ │ │ │ @@ -21601,50 +21610,39 @@ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-IN-FIRST-DIRECTORY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-IN-USER-CONFIGURATION-DIRECTORY-NOTIFIED-P* │ │ │ │ PROVIDED-VERSION │ │ │ │ OLD-BODY │ │ │ │ GET-WALKER-TEMPLATE │ │ │ │ REAL-ENV │ │ │ │ %VAR-DECLARATION │ │ │ │ -WALKER-INFO-TO-BOGO-FUN │ │ │ │ ENV-VAR-TYPE │ │ │ │ -RECORD-NEW-SOURCE-PATH │ │ │ │ QUASIQUOTE-P │ │ │ │ WALK-TEMPLATE-HANDLE-REPEAT │ │ │ │ WALKER-INFO │ │ │ │ WALK-TEMPLATE-HANDLE-REPEAT-1 │ │ │ │ MAGIC-TAG │ │ │ │ -RELIST-INTERNAL │ │ │ │ REPEAT-TEMPLATE │ │ │ │ *BOGO-FUN-MAGIC-TAG* │ │ │ │ OLD-FORM │ │ │ │ BOGO-FUN │ │ │ │ DOC-STRING-P │ │ │ │ ENVIRONMENT-MACRO │ │ │ │ DESTRUCTURINGP │ │ │ │ -ENV-LOCK │ │ │ │ WALK-LET*-BINDINGS │ │ │ │ -ENV-LEXICAL-VARIABLES │ │ │ │ -ENV-WALK-FUNCTION │ │ │ │ *WALK-FORM-PRESERVE-SOURCE* │ │ │ │ -WALK-TAGBODY-1 │ │ │ │ WALK-TEMPLATE │ │ │ │ STOP-FORM │ │ │ │ BOGO-FUN-TO-WALKER-INFO │ │ │ │ WITH-SEQUENCE-ITERATOR │ │ │ │ WITH-SEQUENCE-ITERATOR-FUNCTIONS │ │ │ │ DOSEQUENCE │ │ │ │ %COMPUTE-OPERATIONS-VALUE │ │ │ │ *OLD-ASDF-SYSTEMS* │ │ │ │ FOUND-SYSTEM │ │ │ │ CHECK-NOT-OLD-ASDF-SYSTEM │ │ │ │ -HUFFMAN-DECODE │ │ │ │ -DECOMPOSE-CHAR │ │ │ │ -COMBINING-CLASS │ │ │ │ -PRIMARY-COMPOSITION │ │ │ │ REPORT-FILE-P │ │ │ │ DEFINE-SYSTEM-VIRTUAL-SLOT-READERS │ │ │ │ SYSTEM-VIRTUAL-SLOT-VALUE │ │ │ │ *SYSTEM-VIRTUAL-SLOTS* │ │ │ │ SYSTEM-DESIGNATOR │ │ │ │ DEFINE-SYSTEM-VIRTUAL-SLOT-READER │ │ │ │ *IMAGE-RESTORED-P* │ │ │ │ @@ -21756,26 +21754,26 @@ │ │ │ │ OVERRIDE-ACCESSOR │ │ │ │ OR-FUNCTION │ │ │ │ FORCE-NOT-P │ │ │ │ POSTLUDEP │ │ │ │ LISP-OBJECT-FILES │ │ │ │ PRELUDEP │ │ │ │ ENTRY-POINT-P │ │ │ │ -LIST-INITARG-0 │ │ │ │ RESULT-WIDTH-NAME- │ │ │ │ +LIST-INITARG-0 │ │ │ │ +!DECODE-FOP │ │ │ │ ARG-FOR-(BYTE 2 6)- │ │ │ │ ARG-FOR-(BYTE 3 3)- │ │ │ │ ARG-FOR-(BYTE 3 0)- │ │ │ │ -!DECODE-FOP │ │ │ │ +!HAIRY-DATA-VECTOR-REFFER-INIT │ │ │ │ EMF-N-59 │ │ │ │ EMF-N-63 │ │ │ │ EMF-N-69 │ │ │ │ EMF-N-95 │ │ │ │ EMF-N-107 │ │ │ │ -!HAIRY-DATA-VECTOR-REFFER-INIT │ │ │ │ .SLOTS.97 │ │ │ │ EMF-N-9598 │ │ │ │ (! $ #(! $(+(! $(,(! $(+(! $(+(! $( │ │ │ │ alloc_list │ │ │ │ call_into_c │ │ │ │ debug_print │ │ │ │ os_get_errno │ │ │ │ @@ -22605,19 +22603,19 @@ │ │ │ │ TIME-INFO- │ │ │ │ PROCESS- │ │ │ │ %PQUEUE- │ │ │ │ Timer type. Do not rely on timers being structs as it may change in │ │ │ │ future versions. │ │ │ │ /build/reproducible-path/buildapp-1.5.6/utils.lisp │ │ │ │ /build/reproducible-path/buildapp-1.5.6/command-line.lisp │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/buildapp.lisp │ │ │ │ Condition ~// was signalled. │ │ │ │ ~@ │ │ │ │ ~@<~// is a macro, not a function.~@:> │ │ │ │ ~@ │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/buildapp.lisp │ │ │ │ DEBUG-SOURCE-EQUALP │ │ │ │ PACKAGE-EQUALP │ │ │ │ This function simply returns what was passed to it. │ │ │ │ ALIEN-RECORD-TYPE-EQUALP │ │ │ │ SYNONYM-STREAM-EQUALP │ │ │ │ ANSI-STREAM-EQUALP │ │ │ │ CTYPE-EQUALP │ │ │ │ @@ -22806,20 +22804,20 @@ │ │ │ │ LVAR-FUNCTION-DESIGNATOR-ANNOTATION-EQUALP │ │ │ │ LVAR-SEQUENCE-BOUNDS-ANNOTATION-EQUALP │ │ │ │ LVAR-TYPE-ANNOTATION-EQUALP │ │ │ │ LVAR-FUNCTION-ANNOTATION-EQUALP │ │ │ │ LVAR-LAMBDA-VAR-ANNOTATION-EQUALP │ │ │ │ NODE-EQUALP │ │ │ │ VALUED-NODE-EQUALP │ │ │ │ +CLOOP-EQUALP │ │ │ │ +CBLOCK-EQUALP │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@<~S fell through ~S expression.~@[ ~:_Wanted one of (~//).~]~:> │ │ │ │ -CLOOP-EQUALP │ │ │ │ -CBLOCK-EQUALP │ │ │ │ COMPONENT-EQUALP │ │ │ │ CLEANUP-EQUALP │ │ │ │ A SB-KERNEL │ │ │ │ B SB-KERNEL0 │ │ │ │ ENVIRONMENT-EQUALP │ │ │ │ TAIL-SET-EQUALP │ │ │ │ A SB-KERNEL │ │ │ │ @@ -22968,26 +22966,26 @@ │ │ │ │ by the compiler that the user might wish to know, but which does not merit │ │ │ │ a STYLE-WARNING (or any more serious condition). │ │ │ │ A condition type signalled when the compiler deletes code that the user │ │ │ │ has written, having proved that it is unreachable. │ │ │ │ TWO-WAY-STREAM-EQUALP │ │ │ │ CONCATENATED-STREAM-EQUALP │ │ │ │ ECHO-STREAM-EQUALP │ │ │ │ +STRING-INPUT-STREAM-EQUALP │ │ │ │ +FINITE-BASE-STRING-OUTPUT-STREAM-EQUALP │ │ │ │ +CASE-FROB-STREAM-EQUALP │ │ │ │ +STUB-STREAM-EQUALP │ │ │ │ ~@<~@(~D~) call~:P to ~// ~2:*~[~;was~:;were~] compiled before a compiler-macro was defined for it. A declaration of NOTINLINE at the call site~:P will eliminate this warning, as will defining the compiler-macro before its first potential use.~@:> │ │ │ │ ~A elements in ~2I~_~:S ~I~_to satisfy lambda list ~2I~_~//: ~I~_ │ │ │ │ ~@<~S ~S causes name-conflicts in ~S between the following symbols: ~2I~@:_~{~//~^, ~}~:@> │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~&Error during printing. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -STRING-INPUT-STREAM-EQUALP │ │ │ │ -FINITE-BASE-STRING-OUTPUT-STREAM-EQUALP │ │ │ │ -CASE-FROB-STREAM-EQUALP │ │ │ │ -STUB-STREAM-EQUALP │ │ │ │ FASL-INPUT-EQUALP │ │ │ │ FASL-GROUP-EQUALP │ │ │ │ A SB-KERNEL0 │ │ │ │ B SB-KERNEL │ │ │ │ DEADLINE-EQUALP │ │ │ │ FORMAT-DIRECTIVE-EQUALP │ │ │ │ FMT-CONTROL-PROXY-EQUALP │ │ │ │ @@ -23209,14 +23207,17 @@ │ │ │ │ operation. │ │ │ │ ~@ │ │ │ │ Base class for all Gray streams. │ │ │ │ Superclass of all Gray input streams. │ │ │ │ +SB-ASSEM │ │ │ │ +private: the assembler, used by the compiler │ │ │ │ +private: stuff related to fasload logic (and GENESIS) │ │ │ │ can't specify both :TEST and :TEST-NOT │ │ │ │ as the argument to FUNCTION │ │ │ │ ~S is not a legal function name. │ │ │ │ !6'( & S │ │ │ │ DS.'$*$$&k │ │ │ │ *L\'+/6/I │ │ │ │ '%,%*"T" │ │ │ │ @@ -23251,17 +23252,14 @@ │ │ │ │ function cannot have both good and bad attributes: ~S │ │ │ │ A list of function designators which are called in an unspecified │ │ │ │ order when SBCL process exits. │ │ │ │ Unused by SBCL itself: reserved for user and applications. │ │ │ │ Using (SB-EXT:EXIT :ABORT T), or calling exit(3) directly circumvents │ │ │ │ these hooks. │ │ │ │ Should the contents of arrays be printed? │ │ │ │ -SB-ASSEM │ │ │ │ -private: the assembler, used by the compiler │ │ │ │ -private: stuff related to fasload logic (and GENESIS) │ │ │ │ semi-public: This package includes useful meta-object protocol │ │ │ │ extensions, but even they are not guaranteed to be present in later │ │ │ │ versions of SBCL, and the other stuff in here is definitely not │ │ │ │ guaranteed to be present in later versions of SBCL. Use of this │ │ │ │ package is deprecated in favour of SB-MOP. │ │ │ │ SYS:SRC;CODE;FUNUTILS.LISP │ │ │ │ SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ @@ -23341,16 +23339,14 @@ │ │ │ │ Shadowing-import ~S, uninterning ~S. │ │ │ │ Make ~S accessible in ~A (uninterning ~S). │ │ │ │ Keep ~S accessible in ~A (shadowing ~S). │ │ │ │ forced to do runtime allocation of alien-value structure │ │ │ │ COND clause is not a ~S: ~S │ │ │ │ Class is not a structure class: ~S │ │ │ │ Class is not yet defined or was undefined: ~S │ │ │ │ -malformed :INITIAL-CONTENTS: ~S should have dimensions ~S │ │ │ │ -Unexpected %MAKE-HAIRY-TYPE │ │ │ │ 0 2)"(/T │ │ │ │ 0 2)"({3 │ │ │ │ COMPLEX-FLOAT-VALUE VOP failure │ │ │ │ │ │ │ │ │ │ │ │ SB-DISASSEM │ │ │ │ private: stuff related to the implementation of the disassembler │ │ │ │ @@ -23376,23 +23372,23 @@ │ │ │ │ Y u W#>$ │ │ │ │ gch7n)p │ │ │ │ +~@ │ │ │ │ +bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ If SYMBOL names a macro in ENV, returns the expansion function, │ │ │ │ else returns NIL. If ENV is unspecified or NIL, use the global environment │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ &Q;)Pu:@ │ │ │ │ -~S can't be converted to type ~//. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ COMMON-LISP │ │ │ │ Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset │ │ │ │ options to MAKE-ARRAY, or NIL and 0 if not a displaced array. │ │ │ │ Return the greatest of its arguments; among EQUALP greatest, return │ │ │ │ the first. │ │ │ │ Return the least of its arguments; among EQUALP least, return │ │ │ │ the first. │ │ │ │ @@ -23503,17 +23499,19 @@ │ │ │ │ fold zero arg │ │ │ │ fold identity operations │ │ │ │ SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ SYS:SRC;CODE;DEFTYPES-FOR-TARGET.LISP │ │ │ │ SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ [^ZR[aaj │ │ │ │ ill-formed handler binding: ~S │ │ │ │ +malformed :INITIAL-CONTENTS: ~S should have dimensions ~S │ │ │ │ +Unexpected %MAKE-HAIRY-TYPE │ │ │ │ +associate //(* /) of constants │ │ │ │ bounding index designator │ │ │ │ SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ -associate //(* /) of constants │ │ │ │ convert to multiplication by reciprocal │ │ │ │ 2=Ya1q)! │ │ │ │ OBJECT SB-KERNEL8 │ │ │ │ ARGUMENTS │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ @@ -23525,17 +23523,17 @@ │ │ │ │ Return a list with SE1 as the CAR and SE2 as the CDR. │ │ │ │ Convert PATHSPEC (a pathname designator) into a pathname. │ │ │ │ Converts the pathspec argument to a logical-pathname and returns it. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ FORMAT-ARGUMENTS │ │ │ │ FORMAT-CONTROL SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ hash-table lock │ │ │ │ COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ CLASSOID │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ NAMESPACE │ │ │ │ REPLACEMENTS │ │ │ │ SOFTWARE │ │ │ │ INSTANCE │ │ │ │ @@ -23570,16 +23568,14 @@ │ │ │ │ Consequences are unspecified if serious conditions occur during EXIT │ │ │ │ excepting errors from *EXIT-HOOKS*, which cause warnings and stop │ │ │ │ execution of the hook that signaled, but otherwise allow the exit │ │ │ │ process to continue normally. │ │ │ │ SYS:SRC;PCL;DOCUMENTATION.LISP │ │ │ │ SYS:SRC;CODE;DESCRIBE.LISP │ │ │ │ SYS:SRC;CODE;INSPECT.LISP │ │ │ │ -SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ -SYS:SRC;CODE;TARGET-RANDOM.LISP │ │ │ │ type intersection │ │ │ │ Topological sort failed due to constraint on ~S. │ │ │ │ ~@ │ │ │ │ @@ -23696,21 +23695,20 @@ │ │ │ │ unrecognized DEFSTRUCT option: ~S │ │ │ │ (:CONSTRUCTOR NIL) combined with other :CONSTRUCTORs │ │ │ │ :TYPE option precludes specification of ~S option │ │ │ │ :PREDICATE cannot be used with :TYPE unless :NAMED is also specified. │ │ │ │ :OFFSET can't be specified unless :TYPE is specified. │ │ │ │ ++$pG_G'G5'PFpG'a's │ │ │ │ K?'tH3{! │ │ │ │ +X[sa]sgc │ │ │ │ +EPXRVddXY\XRbkpX │ │ │ │ Set specified value and use it. │ │ │ │ while restarting unbound variable │ │ │ │ :TYPE'd DEFSTRUCT ~S not found for inclusion. │ │ │ │ -X[sa]sgc │ │ │ │ -EPXRVddXY\XRbkpX │ │ │ │ }F-3#B> ? │ │ │ │ -SYS:SRC;CODE;CLASS.LISP │ │ │ │ SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ ~S is not a defined type class. │ │ │ │ W^abWddaje{]TQkeb^^[ │ │ │ │ Keyword type description is not a two-list: ~S. │ │ │ │ making ~(~A~) class ~S writable │ │ │ │ NOT VALUES too confusing on ~S │ │ │ │ ~A~%BREAK was entered because of *BREAK-ON-SIGNALS* ~ │ │ │ │ @@ -23733,26 +23731,26 @@ │ │ │ │ ;;;; SIGBUS handler not installed │ │ │ │ ~S was previously defined as a macro. │ │ │ │ proclaiming ~S as a function │ │ │ │ * is not permitted as a type specifier │ │ │ │ ~S is too large an index for SETF of NTH. │ │ │ │ malformed :INITIAL-CONTENTS: Dimension of axis ~W is ~W, but ~S is ~W long. │ │ │ │ malformed :INITIAL-CONTENTS: ~S is not a sequence, but ~W more layer~:P needed. │ │ │ │ +UkUOeOU\YU_o[ │ │ │ │ +NUdRVcXa │ │ │ │ +Bad type specifier: ~a │ │ │ │ FWUUUUUUUU │ │ │ │ Key-Info │ │ │ │ Key-Info-Set │ │ │ │ ~&ctype cache metrics: Count LF Seek Hit maxPSL Mask │ │ │ │ ~&Alien: │ │ │ │ ~16a: ~7D ~5,1,2F%~#[~:; ~:[ ~;~:*~8D~] ~:[ ~;~:*~4,1,2f%~]~ │ │ │ │ ~6D ~6X~]~% │ │ │ │ ~16A: ~7D │ │ │ │ r2"%,$(5)2 │ │ │ │ -UkUOeOU\YU_o[ │ │ │ │ -NUdRVcXa │ │ │ │ -Bad type specifier: ~a │ │ │ │ after-GC │ │ │ │ trying to use CHECK-FOR-CIRCULARITY when circularity checking isn't initiated │ │ │ │ unsealing sealed class ~S in order to subclass it │ │ │ │ SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ ~S does not designate a condition class. │ │ │ │ odd-length initializer list: ~S. │ │ │ │ @@ -23780,66 +23778,66 @@ │ │ │ │ bad float format: ~S │ │ │ │ ~S names a special operator. │ │ │ │ ~S names a macro. │ │ │ │ ?@($A#vY5HS │ │ │ │ B/6Wad^d │ │ │ │ Wad^dR_eyonmRbe~Wa │ │ │ │ layout depth conflict: ~S │ │ │ │ -UNPRINTABLE instance of ~W │ │ │ │ -invalid object #x~X │ │ │ │ -~S is not a valid argument to ~S │ │ │ │ IF @ E │ │ │ │ _axx[SXVdY}UP │ │ │ │ Rckld^jSV │ │ │ │ N-SVALUE │ │ │ │ N-EVALUE │ │ │ │ _b ake he h │ │ │ │ _tebb_kahnhnhv[\h]d │ │ │ │ DEFAULTED-END- │ │ │ │ CUMULATIVE-OFFSET- │ │ │ │ W[ZR]bo[WS │ │ │ │ -UPY\upTY[UOWdsbT │ │ │ │ -NCLOSURE │ │ │ │ -RPX_b[e^UO^aRgZXaX │ │ │ │ -_VVbUmWa │ │ │ │ +UNPRINTABLE instance of ~W │ │ │ │ +invalid object #x~X │ │ │ │ +~S is not a valid argument to ~S │ │ │ │ ~S is not an array with a fill pointer. │ │ │ │ ~S has an odd number of items in its property list. │ │ │ │ ~S may not be specified with the :DISPLACED-TO option │ │ │ │ Neither :INITIAL-ELEMENT nor :INITIAL-CONTENTS may be specified with the :DISPLACED-TO option │ │ │ │ Can't supply a value for :FILL-POINTER (~S) that is larger than the~A size of the vector (~S) │ │ │ │ Only vectors can have fill pointers. │ │ │ │ The :DISPLACED-TO array is too small. │ │ │ │ Can't specify both :INITIAL-ELEMENT and :INITIAL-CONTENTS │ │ │ │ Can't specify :DISPLACED-INDEX-OFFSET without :DISPLACED-TO │ │ │ │ (no LAYOUT-INFO) │ │ │ │ +UPY\upTY[UOWdsbT │ │ │ │ +NCLOSURE │ │ │ │ +RPX_b[e^UO^aRgZXaX │ │ │ │ +_VVbUmWa │ │ │ │ inline fixnum arithmetic │ │ │ │ inline (unsigned-byte 32) arithmetic │ │ │ │ inline (signed-byte 32) arithmetic │ │ │ │ -~&~@ │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ Returns the value of the alien variable bound to SYMBOL. Signals an │ │ │ │ error if SYMBOL is not bound to an alien variable, or if the alien │ │ │ │ variable is undefined. │ │ │ │ PKGLIST0" │ │ │ │ COMPLAINT │ │ │ │ REST-ARG │ │ │ │ +Metaobject Protocol │ │ │ │ Output a mostly READable printed representation of OBJECT on the specified │ │ │ │ STREAM. │ │ │ │ Output a conditional newline to STREAM (which defaults to │ │ │ │ *STANDARD-OUTPUT*) if it is a pretty-printing stream, and do │ │ │ │ nothing if not. KIND can be one of: │ │ │ │ :LINEAR - A line break is inserted if and only if the immediately │ │ │ │ containing section cannot be printed on one line. │ │ │ │ @@ -23935,80 +23933,70 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -INSTANCE │ │ │ │ - DEFSTRUCT │ │ │ │ -COMMON-LISP89 │ │ │ │ -INSTANCE │ │ │ │ -INSTANCE │ │ │ │ -INSTANCE │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ f_(5)SJ) │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE8 │ │ │ │ -IST^PY^PVkldmlISTRPYlN_dmj`gVX │ │ │ │ -Quoted type specifier in ~S: ~S │ │ │ │ there is no ~S component. │ │ │ │ Unimplemented │ │ │ │ +IST^PY^PVkldmlISTRPYlN_dmj`gVX │ │ │ │ +Quoted type specifier in ~S: ~S │ │ │ │ cannot use values types here │ │ │ │ data start │ │ │ │ text start │ │ │ │ elsewhere start │ │ │ │ SYS:SRC;COMPILER;MAIN.LISP │ │ │ │ session lock │ │ │ │ -~S is not a valid L-value. │ │ │ │ -Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ /etc/sbclrc │ │ │ │ Setting *READ-SUPPRESS* to NIL to restore toplevel usability. │ │ │ │ found macro name ~S ~A │ │ │ │ The ~(~S~) name ~S was found ~A. │ │ │ │ ~(~a~) ~s where a function is expected │ │ │ │ Not a valid lambda expression: │ │ │ │ -SYS:SRC;PCL;CTOR.LISP │ │ │ │ missing arg │ │ │ │ +SYS:SRC;PCL;CTOR.LISP │ │ │ │ LEXICAL-DEF │ │ │ │ FUNCTIONAL-KIND-EQ │ │ │ │ A cache of free alien callback indices keyed by type specifier. │ │ │ │ +shared object list lock │ │ │ │ Map from Lisp symbols to the alien callable functions they name. │ │ │ │ An array of all callback aliens indexed by their order of creation. │ │ │ │ A hashtable used to detect cycles while comparing record types. │ │ │ │ -shared object list lock │ │ │ │ +Package Table Lock │ │ │ │ Spinlock type. │ │ │ │ A function which is called with the function argument to SB-THREAD:INTERRUPT-THREAD │ │ │ │ when the interrupt is ready to run. │ │ │ │ The default behavior is to use FUNCALL. │ │ │ │ List of available buffers. │ │ │ │ -Package Table Lock │ │ │ │ finalizer │ │ │ │ Scheduler lock │ │ │ │ Package Graph Lock │ │ │ │ -A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ Around spawn(). │ │ │ │ +A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ List of all the currently active handlers for file descriptors │ │ │ │ List of all available output routines. Each element is a list of the │ │ │ │ element-type output, the kind of buffering, the function name, and the number │ │ │ │ of bytes per element. │ │ │ │ List of process structures for all active processes. │ │ │ │ A function of no arguments returning a function of one argument NOPRINT │ │ │ │ that provides the REPL for the system. Assumes that *STANDARD-INPUT* and │ │ │ │ *STANDARD-OUTPUT* are set up. │ │ │ │ -Default number of bytes per buffer. │ │ │ │ Lock for active processes. │ │ │ │ +Default number of bytes per buffer. │ │ │ │ how deep we are into backquotes │ │ │ │ If true, processing of the VALUES declaration is inhibited. │ │ │ │ *REOPTIMIZE-AFTER-TYPE-CHECK-MAX* exceeded. │ │ │ │ Coalesced LTN numbers for a more operand to meet LOCAL-TN-LIMIT. │ │ │ │ control analysis deleted dead block │ │ │ │ Allocate heap value cell for lexical var. │ │ │ │ IR1-OPTIMIZE-UNTIL-DONE called │ │ │ │ @@ -24318,28 +24306,33 @@ │ │ │ │ :TEST and :TEST-NOT were both supplied. │ │ │ │ ~S used on non-constant LVAR ~S │ │ │ │ Cannot move FILE-POSITION beyond the end of WITH-OUTPUT-TO-STRING stream constructed with non-adjustable string. │ │ │ │ A required &KEY or &OPTIONAL argument was not supplied. │ │ │ │ NU1T0'[:# │ │ │ │ unknown SC to SC-CASE for ~S: │ │ │ │ ignoring bogus i387 constant ~A │ │ │ │ -unrecognized instance type │ │ │ │ -Nevermind and recurse. │ │ │ │ -~@<~4IProblem forcing cache flushes. Please report ~ │ │ │ │ - to sbcl-devel.~ │ │ │ │ - ~% Owrapper: ~S~ │ │ │ │ - ~% Wrapper-of: ~S~ │ │ │ │ - ~% Class-wrapper: ~S~%~:@> │ │ │ │ +~S is not a valid L-value. │ │ │ │ +Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ +defaulted │ │ │ │ FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ Evaluate the BODY-FORMS with local function definitions. The bindings do │ │ │ │ not enclose the definitions; any use of NAME in the FORMS will refer to the │ │ │ │ lexically apparent function definition in the enclosing environment. │ │ │ │ +Impossible: fixnum ASH should not be called with │ │ │ │ +constant shift greater than word length │ │ │ │ Place ~S in PSETQ is not a SYMBOL │ │ │ │ Odd number of args to ~S. │ │ │ │ ~S called with too few arguments: ~S │ │ │ │ +unrecognized instance type │ │ │ │ +Nevermind and recurse. │ │ │ │ +~@<~4IProblem forcing cache flushes. Please report ~ │ │ │ │ + to sbcl-devel.~ │ │ │ │ + ~% Owrapper: ~S~ │ │ │ │ + ~% Wrapper-of: ~S~ │ │ │ │ + ~% Class-wrapper: ~S~%~:@> │ │ │ │ shouldn't happen? │ │ │ │ The HOST argument doesn't match the pathname host: │ │ │ │ ~S and ~S. │ │ │ │ A LIST representing a pathname host is not supported in this implementation: │ │ │ │ ~@ │ │ │ │ logical host not yet defined: ~S │ │ │ │ ~S is not defined for ~S │ │ │ │ @@ -24354,41 +24347,49 @@ │ │ │ │ generic-function │ │ │ │ funcallable-instance │ │ │ │ interpreted function │ │ │ │ compiled closure │ │ │ │ The object is a │ │ │ │ Lambda-list │ │ │ │ Closed over values │ │ │ │ -defaulted │ │ │ │ -bad thing to be a type specifier: ~// │ │ │ │ +Changing meta-class of ~S from ~S to ~S. │ │ │ │ ~eSf0 zeG │ │ │ │ ~eSf0 zeG │ │ │ │ Convert ASH of word to %ASH/RIGHT │ │ │ │ Convert ASH of signed word to %ASH/RIGHT │ │ │ │ COMMON-LISP │ │ │ │ [1MN1m"| │ │ │ │ :.9r:&Mr │ │ │ │ Return the product of its arguments. With no args, returns 1. │ │ │ │ -Impossible: fixnum ASH should not be called with │ │ │ │ -constant shift greater than word length │ │ │ │ +Simple equality transform │ │ │ │ +INSTANCE │ │ │ │ +INSTANCE │ │ │ │ +Return the name of the given restart object. │ │ │ │ +Q et-k-9 │ │ │ │ Package Locks │ │ │ │ Idiosyncrasies │ │ │ │ Handling of Types │ │ │ │ standard readtable │ │ │ │ standard pprint dispatch table │ │ │ │ Deprecation Conditions │ │ │ │ -Simple equality transform │ │ │ │ INSTANCE │ │ │ │ + DEFSTRUCT │ │ │ │ +COMMON-LISP89 │ │ │ │ INSTANCE │ │ │ │ -Return the name of the given restart object. │ │ │ │ -Q et-k-9 │ │ │ │ +INSTANCE │ │ │ │ +INSTANCE │ │ │ │ +COMMON-LISP │ │ │ │ +INSTANCE │ │ │ │ +NUMERIC-UNION-TYPE- │ │ │ │ SYS:SRC;COMPILER;X86;FLOAT.LISP │ │ │ │ SYS:SRC;CODE;LATE-EXTENSIONS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-ALIENEVAL.LISP │ │ │ │ SYS:SRC;CODE;COLD-INIT.LISP │ │ │ │ +bad thing to be a type specifier: ~// │ │ │ │ +~@ │ │ │ │ Return the documentation string of Doc-Type for X, or NIL if none │ │ │ │ exists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T. │ │ │ │ Function documentation is stored separately for function names and objects: │ │ │ │ DEFUN, LAMBDA, &co create function objects with the specified documentation │ │ │ │ strings. │ │ │ │ (SETF (DOCUMENTATION NAME 'FUNCTION) STRING) │ │ │ │ sets the documentation string stored under the specified name, and │ │ │ │ @@ -24413,41 +24414,38 @@ │ │ │ │ instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ methods on this generic function specify how extended sequence │ │ │ │ classes act when they are specified as the result type in a │ │ │ │ CL:MERGE call. RESULT-PROTOTYPE may not be fully initialized and │ │ │ │ thus should only be used for dispatch and to determine its class. │ │ │ │ Another difference to CL:MERGE is that PREDICATE is a function, │ │ │ │ not a function designator. │ │ │ │ -NUMERIC-UNION-TYPE- │ │ │ │ CLASSOID-CELL- │ │ │ │ STRUCTURE-CLASSOID- │ │ │ │ UNION-TYPE- │ │ │ │ CONS-TYPE- │ │ │ │ ARRAY-TYPE- │ │ │ │ -BASE+BOUNDS │ │ │ │ +NAMED-TYPE- │ │ │ │ +SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ +BASE+BOUNDS │ │ │ │ INSTANCE │ │ │ │ 4UzA9%y │ │ │ │ -:NAMED option is incompatible with element type ~// │ │ │ │ -Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ -~@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ 5dAUeg 6 │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ sOmJ#2s │ │ │ │ @@ -24480,21 +24478,21 @@ │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ N3*`o:00 │ │ │ │ F$|P6-1{X │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ 6R?,`W:0 │ │ │ │ COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ ENUMERABLE │ │ │ │ COMMON-LISP │ │ │ │ M3v|cszybl │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -24502,34 +24500,26 @@ │ │ │ │ REAL-RESTART0, │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ L+%`o:00 │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -Changing meta-class of ~S from ~S to ~S. │ │ │ │ -Derived type ~s is not a suitable index for ~s. │ │ │ │ -Can't fill ~a into ~a │ │ │ │ -b&&3)!? │ │ │ │ -b&&3)!? │ │ │ │ -b&&3)!? │ │ │ │ -Incompatible :initial-contents ~s for :element-type ~a. │ │ │ │ -:initial-contents has an element ~s incompatible with :element-type ~a. │ │ │ │ -d\bgadRa`\ │ │ │ │ -pjm\F3jdXE3d^dgvod │ │ │ │ -DD-NAMED │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ +:NAMED option is incompatible with element type ~// │ │ │ │ +Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ +~@ │ │ │ │ `G{)!)w9 │ │ │ │ COMMON-LISP │ │ │ │ z#$!, x= │ │ │ │ INSTANCE │ │ │ │ ALIEN-TYPE │ │ │ │ SB-ALIEN-INTERNALS │ │ │ │ @;Q3_W"1 │ │ │ │ @@ -24567,21 +24557,21 @@ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ KV-VECTOR │ │ │ │ CLAUSE-INDEX │ │ │ │ LAYOUT-LISTS │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -NAMED-TYPE- │ │ │ │ -SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ -SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ Return T if X and Y are EQL or if they are structured components whose │ │ │ │ elements are EQUAL. Strings and bit-vectors are EQUAL if they are the same │ │ │ │ length and have identical components. Other arrays must be EQ to be EQUAL. │ │ │ │ ]xI#n$x( │ │ │ │ +DD-NAMED │ │ │ │ +MAX-INDEX │ │ │ │ +EXTRA-ID-WORDS │ │ │ │ FORTHCOMING-INFO │ │ │ │ W'(R$:'u │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ @@ -24619,40 +24609,35 @@ │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ Store NEWVAL as the component of SEQUENCE specified by INDEX. │ │ │ │ INSTANCE │ │ │ │ Enable all the default signals that Lisp knows how to deal with. │ │ │ │ COMMON-LISP │ │ │ │ -MAX-INDEX │ │ │ │ -EXTRA-ID-WORDS │ │ │ │ -VALUES type illegal in this context: │ │ │ │ -Attempt to remove :PRIMITIVE type: ~// │ │ │ │ -Can't displace an array of type ~// into another of type ~// │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ INPUT-TYPES │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ TYPE-SPECIFIER │ │ │ │ INSTANCE │ │ │ │ o4nq@)/J │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -INSTANCE │ │ │ │ -COMMON-LISP0 │ │ │ │ TEST-NOT │ │ │ │ FLET-NAME │ │ │ │ STORE-VARS │ │ │ │ COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +INSTANCE │ │ │ │ +COMMON-LISP0 │ │ │ │ CODE-OBJ0 │ │ │ │ FUN-INDEX │ │ │ │ SB-ALIEN │ │ │ │ OBJECT0' │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0, │ │ │ │ INSTANCE │ │ │ │ @@ -24665,14 +24650,29 @@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +Derived type ~s is not a suitable index for ~s. │ │ │ │ +Can't fill ~a into ~a │ │ │ │ +b&&3)!? │ │ │ │ +b&&3)!? │ │ │ │ +b&&3)!? │ │ │ │ +Incompatible :initial-contents ~s for :element-type ~a. │ │ │ │ +:initial-contents has an element ~s incompatible with :element-type ~a. │ │ │ │ +d\bgadRa`\ │ │ │ │ +pjm\F3jdXE3d^dgvod │ │ │ │ +of the directory segment ~S. │ │ │ │ +user homedir not known~@[ for ~S~]: ~A │ │ │ │ +VALUES type illegal in this context: │ │ │ │ +Attempt to remove :PRIMITIVE type: ~// │ │ │ │ +Can't displace an array of type ~// into another of type ~// │ │ │ │ +SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ /(|N2evK? │ │ │ │ %KuvUa:k │ │ │ │ :NsbQQI- │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ 2K&#`Os24 │ │ │ │ @@ -24707,22 +24707,23 @@ │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ !RJ)eJ2S~WG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -COMMON-LISP │ │ │ │ SYS:SRC;COMPILER;X86;ARITH.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;SYSTEM.LISP │ │ │ │ =8@@64Bb │ │ │ │ INSTANCE │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ k=_/ >hk │ │ │ │ INSTANCE │ │ │ │ @@ -24787,19 +24788,17 @@ │ │ │ │ V4UKb6P5 │ │ │ │ M/Wb^"uiS │ │ │ │ <)PW:03c │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE │ │ │ │ -NRZONTR^ │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ -SYS:SRC;COMPILER;X86;SYSTEM.LISP │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ @@ -24840,14 +24839,15 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +NRZONTR^ │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ "C;[33eUxC │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -24932,30 +24932,22 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +Read the next Lisp value from STREAM, and return it. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -)BICut$SQ │ │ │ │ +CATEGORY │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ inline (unsigned-byte 32) integer-length │ │ │ │ inline (signed-byte 32) integer-length │ │ │ │ -BLOCK name form* │ │ │ │ -Evaluate the FORMS as a PROGN. Within the lexical scope of the body, │ │ │ │ -RETURN-FROM can be used to exit the form. │ │ │ │ -of the directory segment ~S. │ │ │ │ -user homedir not known~@[ for ~S~]: ~A │ │ │ │ a host name │ │ │ │ a directory name │ │ │ │ a file name │ │ │ │ a file type │ │ │ │ a positive integer, * or NEWEST │ │ │ │ expected a positive integer, ~ │ │ │ │ got ~S │ │ │ │ @@ -24976,78 +24968,28 @@ │ │ │ │ ~{~A~^, ~} │ │ │ │ importing symbol~P ~{~A~^, ~} │ │ │ │ no non-whitespace characters in string ~S. │ │ │ │ no digits in string ~S │ │ │ │ junk in string ~S │ │ │ │ Malformed ~A definitions: ~S. │ │ │ │ ~S is a legal function name, and cannot be used as a debug name. │ │ │ │ -%9Hn0$4. │ │ │ │ -,G& D,(#K │ │ │ │ - >&1 $ - o │ │ │ │ -explicit-check list ~S must refer to lambda vars │ │ │ │ -malformed declaration specifier ~S in ~S │ │ │ │ -No ~s variable │ │ │ │ -Unbound function declared DYNAMIC-EXTENT: ~S │ │ │ │ -Ignoring free DYNAMIC-EXTENT declaration: ~S │ │ │ │ -DYNAMIC-EXTENT on macro: ~S │ │ │ │ -DYNAMIC-EXTENT on a weird thing: ~S │ │ │ │ -DYNAMIC-EXTENT on alien-variable: ~S │ │ │ │ -DYNAMIC-EXTENT on symbol-macro: ~S │ │ │ │ -Ignoring DYNAMIC-EXTENT declarations: ~S │ │ │ │ -in an inline or notinline declaration │ │ │ │ -ignoring ~A declaration not at definition of local function: │ │ │ │ -declaring the ftype of ~A │ │ │ │ -in a function type declaration │ │ │ │ -FTYPE declaration │ │ │ │ -ignoring declared FTYPE: ~S (not a function type) │ │ │ │ -no type specified in FTYPE declaration: ~S │ │ │ │ -declaring ~A special │ │ │ │ -The ignored variable ~S is being declared special. │ │ │ │ -~S is a symbol-macro and thus can't be declared special. │ │ │ │ -Can't declare ~(~A~) variable locally special: ~S │ │ │ │ -~S is not a symbol and thus can't be declared special. │ │ │ │ -~A declaration for ~A: ~A │ │ │ │ -a special variable │ │ │ │ -a global lexical variable │ │ │ │ -a global alien variable │ │ │ │ -an unknown variable │ │ │ │ -a variable from outer scope │ │ │ │ -a function from outer scope │ │ │ │ -a global function │ │ │ │ -an unknown function │ │ │ │ -Declaring special variable ~S to be ~A │ │ │ │ -Malformed function or variable name ~S. │ │ │ │ -~S is an alien variable, so its type can't be declared. │ │ │ │ -declaring the type of ~A │ │ │ │ -unrecognized declaration ~S │ │ │ │ -~S is a constant and so can't be declared special. │ │ │ │ -~S is an alien variable and so can't be declared special. │ │ │ │ -The lists of keys and data are of unequal length. │ │ │ │ -method ~S not defined for ~S │ │ │ │ -Axis number ~W is too big; ~S only has ~D dimension~:P. │ │ │ │ -Vector axis is not zero: ~S │ │ │ │ -~W is too big for a fixnum. │ │ │ │ -~S is not a defined storage class. │ │ │ │ -~@ │ │ │ │ -Can't LOAD a directory: ~s. │ │ │ │ -unbinding the symbol ~A │ │ │ │ -Can't make ~A variable unbound: ~S │ │ │ │ -removing the function or macro definition of ~A │ │ │ │ -unknown code location │ │ │ │ -setting the macro-function of ~S │ │ │ │ -~S names a special form. │ │ │ │ -Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ -undefined function │ │ │ │ -bogus stack frame │ │ │ │ -shouldn't get here │ │ │ │ -malformed arguments description │ │ │ │ -; Using form offset instead of character position. │ │ │ │ -; File has been modified since compilation: │ │ │ │ -URYe\Re[UOWdm │ │ │ │ -URPY\Re[UOWd │ │ │ │ +BLOCK name form* │ │ │ │ +Evaluate the FORMS as a PROGN. Within the lexical scope of the body, │ │ │ │ +RETURN-FROM can be used to exit the form. │ │ │ │ +Return the last N conses (not the last element!) of a list. │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +)BICut$SQ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25056,22 +24998,14 @@ │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ -Read the next Lisp value from STREAM, and return it. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -CATEGORY │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -Return the last N conses (not the last element!) of a list. │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ )BJCut$SQ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25342,26 +25276,14 @@ │ │ │ │ L%g#-V%9 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -parameter specializer name │ │ │ │ -Extensible Sequences │ │ │ │ -Saving a Core Image │ │ │ │ -SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ -SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ -SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ -k!w#[&_' │ │ │ │ -SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ -SYS:SRC;CODE;CAS.LISP │ │ │ │ -SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ -SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25369,14 +25291,88 @@ │ │ │ │ L%g#-V%9 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ +parameter specializer name │ │ │ │ +Extensible Sequences │ │ │ │ +Saving a Core Image │ │ │ │ +%9Hn0$4. │ │ │ │ +,G& D,(#K │ │ │ │ + >&1 $ - o │ │ │ │ +explicit-check list ~S must refer to lambda vars │ │ │ │ +malformed declaration specifier ~S in ~S │ │ │ │ +No ~s variable │ │ │ │ +Unbound function declared DYNAMIC-EXTENT: ~S │ │ │ │ +Ignoring free DYNAMIC-EXTENT declaration: ~S │ │ │ │ +DYNAMIC-EXTENT on macro: ~S │ │ │ │ +DYNAMIC-EXTENT on a weird thing: ~S │ │ │ │ +DYNAMIC-EXTENT on alien-variable: ~S │ │ │ │ +DYNAMIC-EXTENT on symbol-macro: ~S │ │ │ │ +Ignoring DYNAMIC-EXTENT declarations: ~S │ │ │ │ +in an inline or notinline declaration │ │ │ │ +ignoring ~A declaration not at definition of local function: │ │ │ │ +declaring the ftype of ~A │ │ │ │ +in a function type declaration │ │ │ │ +FTYPE declaration │ │ │ │ +ignoring declared FTYPE: ~S (not a function type) │ │ │ │ +no type specified in FTYPE declaration: ~S │ │ │ │ +declaring ~A special │ │ │ │ +The ignored variable ~S is being declared special. │ │ │ │ +~S is a symbol-macro and thus can't be declared special. │ │ │ │ +Can't declare ~(~A~) variable locally special: ~S │ │ │ │ +~S is not a symbol and thus can't be declared special. │ │ │ │ +~A declaration for ~A: ~A │ │ │ │ +a special variable │ │ │ │ +a global lexical variable │ │ │ │ +a global alien variable │ │ │ │ +an unknown variable │ │ │ │ +a variable from outer scope │ │ │ │ +a function from outer scope │ │ │ │ +a global function │ │ │ │ +an unknown function │ │ │ │ +Declaring special variable ~S to be ~A │ │ │ │ +Malformed function or variable name ~S. │ │ │ │ +~S is an alien variable, so its type can't be declared. │ │ │ │ +declaring the type of ~A │ │ │ │ +unrecognized declaration ~S │ │ │ │ +~S is a constant and so can't be declared special. │ │ │ │ +~S is an alien variable and so can't be declared special. │ │ │ │ +The lists of keys and data are of unequal length. │ │ │ │ +~W is too big for a fixnum. │ │ │ │ +~S is not a defined storage class. │ │ │ │ +~@ │ │ │ │ +Can't LOAD a directory: ~s. │ │ │ │ +unbinding the symbol ~A │ │ │ │ +Can't make ~A variable unbound: ~S │ │ │ │ +removing the function or macro definition of ~A │ │ │ │ +unknown code location │ │ │ │ +setting the macro-function of ~S │ │ │ │ +~S names a special form. │ │ │ │ +Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ +undefined function │ │ │ │ +bogus stack frame │ │ │ │ +shouldn't get here │ │ │ │ +malformed arguments description │ │ │ │ +; Using form offset instead of character position. │ │ │ │ +; File has been modified since compilation: │ │ │ │ +ARG-~V,'0D │ │ │ │ +foreign function: #x~X │ │ │ │ +foreign function: │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ +SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ +SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ +k!w#[&_' │ │ │ │ +SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ +SYS:SRC;CODE;CAS.LISP │ │ │ │ +SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ +SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25429,14 +25425,35 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +Return two values indicating the relationship between type1 and type2. │ │ │ │ + If values are T and T, type1 definitely is a subtype of type2. │ │ │ │ + If values are NIL and T, type1 definitely is not a subtype of type2. │ │ │ │ + If values are NIL and NIL, it couldn't be determined. │ │ │ │ +MORE-ARG │ │ │ │ +Return all arguments, in order, as values. │ │ │ │ +Return an abbreviated pathname sufficient to identify PATHNAME │ │ │ │ +relative to DEFAULTS. │ │ │ │ +Return a string representation of the name in PATHNAME. │ │ │ │ +Return a string representation of the directory in PATHNAME. │ │ │ │ +Return a string representation of the name of the host in PATHNAME. │ │ │ │ +Construct the full (name)string form PATHNAME. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +&Znk[kY^JPVu │ │ │ │ +qV]6{PuL { │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25491,35 +25508,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -Return two values indicating the relationship between type1 and type2. │ │ │ │ - If values are T and T, type1 definitely is a subtype of type2. │ │ │ │ - If values are NIL and T, type1 definitely is not a subtype of type2. │ │ │ │ - If values are NIL and NIL, it couldn't be determined. │ │ │ │ -MORE-ARG │ │ │ │ -Return all arguments, in order, as values. │ │ │ │ -Return an abbreviated pathname sufficient to identify PATHNAME │ │ │ │ -relative to DEFAULTS. │ │ │ │ -Return a string representation of the name in PATHNAME. │ │ │ │ -Return a string representation of the directory in PATHNAME. │ │ │ │ -Return a string representation of the name of the host in PATHNAME. │ │ │ │ -Construct the full (name)string form PATHNAME. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -&Znk[kY^JPVu │ │ │ │ -qV]6{PuL { │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25697,17 +25693,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ -Evaluate the BODY-FORMS with local function definitions. The bindings enclose │ │ │ │ -the new definitions, so the defined functions can call themselves or each │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25788,14 +25781,16 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25839,16 +25834,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25987,18 +25980,24 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-VALUE │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ +Evaluate the BODY-FORMS with local function definitions. The bindings enclose │ │ │ │ +the new definitions, so the defined functions can call themselves or each │ │ │ │ +called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ +called NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ +SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26256,14 +26255,15 @@ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ Output a newline, the mostly READable printed representation of OBJECT, and │ │ │ │ space to the specified STREAM. │ │ │ │ COMMON-LISP0 │ │ │ │ Return non-NIL if SYMBOL is bound to a value. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26283,18 +26283,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Print a message and invoke the debugger without allowing any possibility │ │ │ │ of condition handling occurring. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ T if OBJECT is a PROCESS, NIL otherwise. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ -called NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Return the integer that makes DEBUG-VAR's name and package unique │ │ │ │ with respect to other DEBUG-VARs in the same function. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26495,48 +26491,45 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -Return an Alien pointer to the data addressed by Expr, which must be a call │ │ │ │ - to SLOT or DEREF, or a reference to an Alien variable. │ │ │ │ OUTPUT-STREAM │ │ │ │ SBCL-HOMEDIR86 │ │ │ │ COMMON-LISP0 │ │ │ │ gYEh:W^. │ │ │ │ Performs the cdr function n times on a list. │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ STRUCTURE │ │ │ │ COMMON-LISP0 │ │ │ │ SYNTAX-CHECKER │ │ │ │ The primary return value indicates whether NAME is a valid function │ │ │ │ name; if it is, the second return value will be a symbol suitable for │ │ │ │ use as a BLOCK name in the function in question. │ │ │ │ -Component name: designator for a string composed of portable pathname characters │ │ │ │ the default value for the :ENCAPSULATE option to TRACE │ │ │ │ the default value for the :REPORT option to TRACE │ │ │ │ Superclass of all Gray streams whose element-type │ │ │ │ is a subtype of unsigned-byte or signed-byte. │ │ │ │ Superclass of all Gray streams whose element-type is a subtype of character. │ │ │ │ Superclass of all Gray output streams. │ │ │ │ Superclass of all Gray input streams whose element-type │ │ │ │ is a subtype of unsigned-byte or signed-byte. │ │ │ │ Superclass of all Gray input streams whose element-type │ │ │ │ is a subtype of character. │ │ │ │ -ARG-~V,'0D │ │ │ │ -foreign function: #x~X │ │ │ │ -foreign function: │ │ │ │ +Component name: designator for a string composed of portable pathname characters │ │ │ │ ** pc-offset ~S not in code obj ~S? │ │ │ │ ??? Can't get name of debug-block's function. │ │ │ │ Source path no longer exists. │ │ │ │ XX[k s+, │ │ │ │ \hXgpRRgt │ │ │ │ +URYe\Re[UOWdm │ │ │ │ +URPY\Re[UOWd │ │ │ │ :FUN-END breakpoints are currently unsupported for the known return convention on low debug. │ │ │ │ cannot make a breakpoint at an unknown code location: ~S │ │ │ │ cannot activate a deleted breakpoint: ~S │ │ │ │ Don't know how to use a DEBUG-SOURCE without a namestring or a form. │ │ │ │ redefining ~A ~S to be: │ │ │ │ can't deposit aliens of type ~S (unknown size) │ │ │ │ ~A: malloc() of ~S bytes failed. │ │ │ │ @@ -26554,56 +26547,57 @@ │ │ │ │ The element value ~S is not an integer. │ │ │ │ The enumeration element ~S is not a symbol. │ │ │ │ can't represent enums needing more than 32 bits │ │ │ │ An enumeration must contain at least one element. │ │ │ │ no method ~S │ │ │ │ X[XdgXde │ │ │ │ OX[XdgXdk{ │ │ │ │ +method ~S not defined for ~S │ │ │ │ ~@<~:IMalformed alien name. Acceptable formats are:~:@_ ("alien_name" LISP-NAME)~:@_ FOO-BAR - equivalent to ("foo_bar" FOO-BAR)~:@_ "foo_bar" - equivalent to ("foo_bar" FOO-BAR)~:@> │ │ │ │ Unsupported callback argument type: ~A │ │ │ │ p\^\Y\Y\ │ │ │ │ Attempt to redefine alien callable with incompatible return type. │ │ │ │ Old type was: │ │ │ │ New type is: │ │ │ │ Create new alien callable (old alien callable gets freed). │ │ │ │ Ignore the error and continue as if closing succeeded. │ │ │ │ dlerror() returned an error while trying to close ~ │ │ │ │ ~:[runtime~;shared object ~:*~S~]: ~S │ │ │ │ Double free of callable alien ~A. │ │ │ │ Trying to free a callable alien ~A not allocated by Lisp. │ │ │ │ -unknown size for alien type ~S │ │ │ │ -aXVUPhYZ │ │ │ │ -KddqWp`fQ[Lkcm^QT │ │ │ │ -can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ -bogus argument style ~S in ~S │ │ │ │ -_OMVV_gn{ │ │ │ │ -QaXONV[RUONY_ │ │ │ │ -cannot make an alien of type ~S out of a SAP │ │ │ │ -VYgmUXR[RVX^ │ │ │ │ -The alignment of ~S is unknown. │ │ │ │ -The size of ~S is unknown. │ │ │ │ -cannot override the size of zero-dimensional arrays │ │ │ │ "[g _\tuX │ │ │ │ attempt to shadow definition of ~A ~S │ │ │ │ Returning structs by value is unsupported on this platform. │ │ │ │ ~&Enter pathname (evaluated): │ │ │ │ ~&Error: invalid pathname. │ │ │ │ Specify a different pathname to load the shared object from. │ │ │ │ Retry loading this shared object. │ │ │ │ Skip this shared object and continue. │ │ │ │ too many indices when DEREF'ing ~S: ~W │ │ │ │ incorrect number of indices when DEREF'ing ~S: ~W │ │ │ │ Passing structs by value is unsupported on this platform. │ │ │ │ +cannot extract ~W-bit integers │ │ │ │ +unknown size for alien type ~S │ │ │ │ +aXVUPhYZ │ │ │ │ +KddqWp`fQ[Lkcm^QT │ │ │ │ +can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ +bogus argument style ~S in ~S │ │ │ │ +_OMVV_gn{ │ │ │ │ +QaXONV[RUONY_ │ │ │ │ +cannot make an alien of type ~S out of a SAP │ │ │ │ +VYgmUXR[RVX^ │ │ │ │ 1.0.53.11 │ │ │ │ 1.0.37.33 │ │ │ │ 1.0.29.17 │ │ │ │ SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ SYS:SRC;CODE;TARGET-CHAR.LISP │ │ │ │ SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ -cannot extract ~W-bit integers │ │ │ │ +The alignment of ~S is unknown. │ │ │ │ +The size of ~S is unknown. │ │ │ │ +cannot override the size of zero-dimensional arrays │ │ │ │ ~S is unsupported as of SBCL 0.8.13. See LOAD-SHARED-OBJECT. │ │ │ │ =7ZAc=c] │ │ │ │ wrong number of arguments for ~S │ │ │ │ expected ~W, got ~W │ │ │ │ ~S is not an alien function. │ │ │ │ ~S is unsupported as of SBCL 0.8.13. Please use LOAD-SHARED-OBJECT. │ │ │ │ Failed to release CAS lock! │ │ │ │ @@ -26622,23 +26616,23 @@ │ │ │ │ main thread │ │ │ │ Resuming thread ~A │ │ │ │ ~& Bin Size Allocated Count Cum% │ │ │ │ ~& ~2d ~10@a ~13d ~9d ~7,2,2f │ │ │ │ ~& Tot ~23d ~9d │ │ │ │ ; ~D unboxed + ~D boxed bytes (~,1,2F% + ~,1,2F%) │ │ │ │ GET-MUTEX won't get a mutex on behalf of a different thread │ │ │ │ -Unknown barrier kind ~S │ │ │ │ -YJPgUUP\\U^PeHfJgQ\mUPFkWpp │ │ │ │ ~S received an improper list of arguments: ~S │ │ │ │ Invalid fill-pointer ~a │ │ │ │ INSTEAD not empty in INPUT-WRAPPER for ~S │ │ │ │ Parameters ~S and ~S must be disjoint but have common elements │ │ │ │ P_VXaay_ │ │ │ │ Cannot use COMPARE-AND-SWAP with structure accessor for a read-only slot: ~S │ │ │ │ Cannot use COMPARE-AND-SWAP with structure accessor for a typed slot: ~S │ │ │ │ +Unknown barrier kind ~S │ │ │ │ +YJPgUUP\\U^PeHfJgQ\mUPFkWpp │ │ │ │ c%Q%W%]% │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ bad fallthrough in floating point reader │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ @@ -26665,15 +26659,14 @@ │ │ │ │ Unexpected blocking in WRITE-OUTPUT-FROM-QUEUE. │ │ │ │ ~S can not be encapsulated │ │ │ │ ~S is undefined │ │ │ │ defining ~A as a type specifier │ │ │ │ illegal to redefine standard type: ~S │ │ │ │ The class ~S is being redefined to be a DEFTYPE. │ │ │ │ couldn't SB-UNIX:UNIX-DUP ~W: ~A │ │ │ │ -^RVm_mX_lXp │ │ │ │ ~S is too hairy for sequence functions. │ │ │ │ The object is a proper list of length ~S.~% │ │ │ │ The object is an improper list of length ~S.~% │ │ │ │ The object is a long list (more than ~S elements).~% │ │ │ │ Element sizes for input (~S:~S) and output (~S:~S) differ? │ │ │ │ could not find any output routine for ~S buffered ~S │ │ │ │ Improper list in REMF. │ │ │ │ @@ -26710,14 +26703,15 @@ │ │ │ │ after TOPLEVEL-REPL │ │ │ │ Exit SBCL (calling #'EXIT, killing the process). │ │ │ │ Skip to toplevel READ/EVAL/PRINT loop. │ │ │ │ Abort script, exiting lisp. │ │ │ │ Ignore missing init file │ │ │ │ The specified ~A file ~A was not found. │ │ │ │ unexpected end of command line options │ │ │ │ +^RVm_mX_lXp │ │ │ │ Couldn't find home directory~@[ for ~S~]. │ │ │ │ #~WA axis ~W is not a sequence:~% ~S │ │ │ │ ~@A nor the ~ │ │ │ │ SBCL-specific form #A(dimensions ~ │ │ │ │ element-type . contents).~@:> │ │ │ │ Comma inside a backquoted array (not a list or general vector.) │ │ │ │ @@ -26739,15 +26733,14 @@ │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ e"d" #!# │ │ │ │ Should not happen │ │ │ │ Corrupt NEXT-chain in ~A. This is probably caused by multiple threads accessing the same hash-table without locking. │ │ │ │ initialization │ │ │ │ [~C~D~@[~*:~2,'0D~@[~*:~2,'0D~]~]] │ │ │ │ -V_VVn_\hkWXa │ │ │ │ /dev/ptmx │ │ │ │ could not find a pty │ │ │ │ /dev/pty │ │ │ │ Vector of length ~D can't be initialized from () │ │ │ │ Vector longer than the specified length: #~S~S. │ │ │ │ Improper list in #(): ~S. │ │ │ │ adding ~A as a local nickname for ~A │ │ │ │ @@ -26759,40 +26752,41 @@ │ │ │ │ Attempt to use ~A as a package local nickname (for ~A) in ~ │ │ │ │ package nicknamed globally ~A. │ │ │ │ ~@ │ │ │ │ Cannot add ~A as local nickname for a deleted package: ~S │ │ │ │ Use ~A as local nickname for ~A instead. │ │ │ │ Keep ~A as local nickname for ~A. │ │ │ │ +V_VVn_\hkWXa │ │ │ │ +SB-PROFILE │ │ │ │ +public: the interface to the profiler │ │ │ │ +SB-WALKER │ │ │ │ +internal: a code walker used by PCL │ │ │ │ +SB-SEQUENCE │ │ │ │ +semi-public: implements something which might eventually │ │ │ │ +be submitted as a CDR │ │ │ │ +SYS:SRC;CODE;EARLY-STEP.LISP │ │ │ │ +SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ +SYS:SRC;CODE;ERROR-ERROR.LISP │ │ │ │ +SYS:SRC;CODE;MODULE.LISP │ │ │ │ +SYS:SRC;CODE;TARGET-HASH-TABLE.LISP │ │ │ │ ~S does not designate a package │ │ │ │ ~S does not designate a string │ │ │ │ Invalid use of ~S after ~S. │ │ │ │ OLD-FLAT-P │ │ │ │ Proceed anyway │ │ │ │ ~@ │ │ │ │ Impossible case reached in PEEK-CHAR │ │ │ │ p+2V2\2\2 │ │ │ │ +2G12M12\5 │ │ │ │ tp+2V2\5 │ │ │ │ +2Gi+2S/ │ │ │ │ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ $$$$$$$ │ │ │ │ !"#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ -SB-PROFILE │ │ │ │ -public: the interface to the profiler │ │ │ │ -SB-WALKER │ │ │ │ -internal: a code walker used by PCL │ │ │ │ -SB-SEQUENCE │ │ │ │ -semi-public: implements something which might eventually │ │ │ │ -be submitted as a CDR │ │ │ │ -SYS:SRC;CODE;EARLY-STEP.LISP │ │ │ │ -SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ -SYS:SRC;CODE;ERROR-ERROR.LISP │ │ │ │ -SYS:SRC;CODE;MODULE.LISP │ │ │ │ -SYS:SRC;CODE;TARGET-HASH-TABLE.LISP │ │ │ │ Expansion: │ │ │ │ ~A names a ~@[primitive~* ~]type-specifier: │ │ │ │ ~A names a deprecated type │ │ │ │ ~A was invoked with RECURSIVE-P being true outside ~ │ │ │ │ of a recursive read operation. │ │ │ │ 1+U4R?&_(D │ │ │ │ 0123456789 │ │ │ │ @@ -26831,17 +26825,17 @@ │ │ │ │ Replacement byte, bytes, character, or string (evaluated): │ │ │ │ Supply a replacement string. │ │ │ │ ~@ │ │ │ │ Jbj8bfYW │ │ │ │ ~S is not acceptable to ~S. │ │ │ │ ~S contains a splicing comma after a dot │ │ │ │ Nothing appears before . in list. │ │ │ │ -YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ no dispatch function defined for ~S │ │ │ │ ~S is not a dispatching macro character. │ │ │ │ +YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ power-vector too short │ │ │ │ 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ │ │ │ │ ~@ │ │ │ │ D / ; │ │ │ │ in #S ~S, the use of non-keywords as slot specifiers is deprecated: ~S. │ │ │ │ a slot name in #S is not a string ~ │ │ │ │ designator: ~S. │ │ │ │ @@ -26922,32 +26916,37 @@ │ │ │ │ a compiled function │ │ │ │ a generic function │ │ │ │ a special operator │ │ │ │ ~A names an undefined function │ │ │ │ Must label something more than just #~D# │ │ │ │ Multiply defined label: #~D= │ │ │ │ Missing label for #= │ │ │ │ -STRING-DISPATCH-FUN │ │ │ │ 1+U4RA&R │ │ │ │ Heap underflow │ │ │ │ ~S ~[have~;has a~:;have~] bad file descriptor~:P. │ │ │ │ Go on, leaving handlers marked as bogus. │ │ │ │ Retry bogus handlers. │ │ │ │ Remove bogus handlers. │ │ │ │ +STRING-DISPATCH-FUN │ │ │ │ +XLzZUzZZnzfgsny^btXYwwa │ │ │ │ +X\asW_ds │ │ │ │ Error opening directory ~S │ │ │ │ 1,$K&!lW'_' │ │ │ │ Ignore failure and continue. │ │ │ │ Unix system call poll() failed │ │ │ │ Help! ERROR-ERROR is │ │ │ │ levels deep. │ │ │ │ Will try to reset the IO streams and disable debugger hooks. │ │ │ │ Will try to THROW this thread to the toplevel. │ │ │ │ Will try to halt this thread as a last resort. │ │ │ │ Maximum error nesting depth exceeded │ │ │ │ Remove ~S │ │ │ │ +SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ +SYS:SRC;CODE;SORT.LISP │ │ │ │ +SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ IYP[YSkK[ekodi │ │ │ │ :BACK cannot be represented in namestrings. │ │ │ │ illegal complex number format: #C~S │ │ │ │ Invalid first argument to ~S: ~S │ │ │ │ Cannot use ~S with structure accessor for a read-only slot: ~S │ │ │ │ ~S requires a slot of type (UNSIGNED-BYTE ~S), not ~S: ~S │ │ │ │ can't happen │ │ │ │ @@ -26962,26 +26961,21 @@ │ │ │ │ R - Redisplay current inspected object. │ │ │ │ U - Move upward/backward to previous inspected object. │ │ │ │ ?, H, Help - Show this help. │ │ │ │ - Evaluate the input as an expression. │ │ │ │ Within the inspector, the special variable SB-EXT:*INSPECTED* is bound │ │ │ │ to the current inspected object, so that it can be referred to in │ │ │ │ evaluated expressions. │ │ │ │ -XLzZUzZZnzfgsny^btXYwwa │ │ │ │ -X\asW_ds │ │ │ │ -SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ -SYS:SRC;CODE;SORT.LISP │ │ │ │ -SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ - │ │ │ │ failed to build ratio │ │ │ │ defining ~S as a hash table test │ │ │ │ Redefining hash table test ~S. │ │ │ │ Cannot register ~S has a hash table test: undefined function. │ │ │ │ ~S is not a well-formed backquote expression │ │ │ │ TIOCPGRP ioctl failed: ~S │ │ │ │ + │ │ │ │ 8'8#5!)% │ │ │ │ can't substitute this into the middle of a word: │ │ │ │ not enough wildcards in FROM pattern to match TO pattern: │ │ │ │ illegal sharp macro character: ~S │ │ │ │ Couldn't find host: ~S │ │ │ │ after REPL │ │ │ │ ~@ │ │ │ │ @@ -27018,24 +27012,24 @@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ failed to build float from ~a │ │ │ │ ~S cannot be represented relative to ~S. │ │ │ │ Bad fallthrough in ~S │ │ │ │ -Ea XYh d │ │ │ │ `OWh%Wh8$$ │ │ │ │ >aj7afIW │ │ │ │ a standard │ │ │ │ ~A names ~A declaration. │ │ │ │ an SBCL-specific │ │ │ │ a user-defined │ │ │ │ The old value of ~S is ~S.~ │ │ │ │ ~%Do you want to supply a new value? │ │ │ │ ~&Type a form to be evaluated: │ │ │ │ +Ea XYh d │ │ │ │ #.(~S '~D :ELEMENT-TYPE ~S) │ │ │ │ inside extended token │ │ │ │ after escape character │ │ │ │ ~S is a bad type specifier for sequences. │ │ │ │ (undocumented) │ │ │ │ Documentation: │ │ │ │ (fbound) │ │ │ │ @@ -27068,14 +27062,15 @@ │ │ │ │ of the ~S component ~S. │ │ │ │ ~S is neither a symbol nor a list of symbols. │ │ │ │ ~S is not a symbol. │ │ │ │ logical namestring character which ~ │ │ │ │ is not alphanumeric or hyphen:~% ~S │ │ │ │ A string of length 0 is not a valid value for any ~ │ │ │ │ component of a logical pathname │ │ │ │ +SYS:SRC;CODE;FORMAT.LISP │ │ │ │ %$%,%4%<% │ │ │ │ W%X%Y%Z%[% │ │ │ │ ]%^%_%`%a% │ │ │ │ f%g%h%i%j% │ │ │ │ fatal error before reaching READ-EVAL-PRINT loop: │ │ │ │ "%f_7117 │ │ │ │ Package ~A does not exist. │ │ │ │ @@ -27090,15 +27085,14 @@ │ │ │ │ abcdefghi │ │ │ │ jklmnopqr │ │ │ │ ~stuvwxyz │ │ │ │ {ABCDEFGHI │ │ │ │ }JKLMNOPQR │ │ │ │ STUVWXYZ │ │ │ │ 0123456789 │ │ │ │ -SYS:SRC;CODE;FORMAT.LISP │ │ │ │ The object is a CONS. │ │ │ │ The loader tried loading the symbol named ~a into the package named ~a, but the package did not get defined, and does not exist. │ │ │ │ hT?rCkWm[^h │ │ │ │ dcRf[j^mw │ │ │ │ Multiple expressions in --eval option: ~S │ │ │ │ Skip rest of --eval and --load options. │ │ │ │ Ignore runtime option --load ~S. │ │ │ │ @@ -27139,77 +27133,93 @@ │ │ │ │ Direct subclasses │ │ │ │ (unboxed) │ │ │ │ Class precedence-list │ │ │ │ illegal character for logical pathname:~% ~S │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ e"d" #!# │ │ │ │ -b^RPXXmjMo^RPXXg │ │ │ │ -\XqXqS_XwdqNLHPUPX_XXXL_^k │ │ │ │ -OkTGzsvkgjtpb^kWkddpw^poXavm │ │ │ │ -kdtihhdsd │ │ │ │ -RPXRTJXm │ │ │ │ -Too many parameters, expected none │ │ │ │ -Unreachable ~S │ │ │ │ -Too many parameters, expected no more than ~W │ │ │ │ -No corresponding close parenthesis │ │ │ │ -No corresponding open parenthesis │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ + seconds │ │ │ │ +~8d ~:{~:[~2*~18@t~;~:* ~2d ~6,2f ~5,1,2f%~] |~} ~a │ │ │ │ Index ~W is out of bounds. It should have been between ~ │ │ │ │ 0 and ~W. │ │ │ │ +can't reconstitute key of deleted finalizer node │ │ │ │ +~&Unhashed: │ │ │ │ +~&Hashed: │ │ │ │ + │ │ │ │ +~D ~X ~S │ │ │ │ +Too many parameters, expected no more than ~W │ │ │ │ +Number too large to print in old Roman numerals: ~:D │ │ │ │ +~S is not of type INTEGER. │ │ │ │ +No corresponding close paren │ │ │ │ +fmt$~36R │ │ │ │ +negative │ │ │ │ ~~; directive not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ +Too many parameters, expected none │ │ │ │ +No corresponding close parenthesis │ │ │ │ +No package named ~S │ │ │ │ +Malformed ~~/ directive │ │ │ │ +Unknown directive ~@[(character: ~A)~] │ │ │ │ @ modifier not allowed in close directive of justification block (i.e. ~~<...~~@>. │ │ │ │ ~D illegal directive~:P found inside justification block │ │ │ │ +No corresponding close brace │ │ │ │ +No corresponding open parenthesis │ │ │ │ + │ │ │ │ No corresponding open bracket │ │ │ │ +6W7eG3/* │ │ │ │ + hundred │ │ │ │ +Can only specify one section │ │ │ │ +Must specify exactly two sections │ │ │ │ +b^RPXXmjMo^RPXXg │ │ │ │ +\XqXqS_XwdqNLHPUPX_XXXL_^k │ │ │ │ +OkTGzsvkgjtpb^kWkddpw^poXavm │ │ │ │ +kdtihhdsd │ │ │ │ +RPXRTJXm │ │ │ │ +Unreachable ~S │ │ │ │ No previous argument │ │ │ │ j r i ve │ │ │ │ mhjQOs{rvkd │ │ │ │ -~S is not of type INTEGER. │ │ │ │ -Can only specify one section │ │ │ │ -Must specify exactly two sections │ │ │ │ Attempt to use ~~:^ outside a ~~:{...~~} construct │ │ │ │ -No corresponding close brace │ │ │ │ No corresponding open brace │ │ │ │ -No corresponding close paren │ │ │ │ no corresponding open paren │ │ │ │ Index ~W is out of bounds. It should have been between 0 and ~W. │ │ │ │ ~~; not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ while processing indirect format string: │ │ │ │ ~S is not of type CHARACTER. │ │ │ │ -' Xk{%1# │ │ │ │ -cmPNkbcRL^[RU^K^rQ │ │ │ │ -T case is not last in SC-CASE. │ │ │ │ -illegal SC-CASE clause: ~S │ │ │ │ -mjYM[XRVebeNRV^ddhh │ │ │ │ -malformed SCs spec: ~S │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ - seconds │ │ │ │ -~8d ~:{~:[~2*~18@t~;~:* ~2d ~6,2f ~5,1,2f%~] |~} ~a │ │ │ │ -can't reconstitute key of deleted finalizer node │ │ │ │ SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ SYS:SRC;COMPILER;X86;CALL.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ SYS:SRC;COMPILER;TN.LISP │ │ │ │ SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ SYS:SRC;COMPILER;X86;PARMS.LISP │ │ │ │ SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ -~&Unhashed: │ │ │ │ -~&Hashed: │ │ │ │ - │ │ │ │ -~D ~X ~S │ │ │ │ -Number too large to print in old Roman numerals: ~:D │ │ │ │ -fmt$~36R │ │ │ │ -negative │ │ │ │ -No package named ~S │ │ │ │ -Malformed ~~/ directive │ │ │ │ -Unknown directive ~@[(character: ~A)~] │ │ │ │ - │ │ │ │ -6W7eG3/* │ │ │ │ - hundred │ │ │ │ +' Xk{%1# │ │ │ │ +cmPNkbcRL^[RU^K^rQ │ │ │ │ +T case is not last in SC-CASE. │ │ │ │ +illegal SC-CASE clause: ~S │ │ │ │ +mjYM[XRVebeNRV^ddhh │ │ │ │ +malformed SCs spec: ~S │ │ │ │ +\\U[~[Pq │ │ │ │ +a source transform │ │ │ │ +FYUU)#:o"^Se │ │ │ │ +Xy[^c~X}T │ │ │ │ +-OPTIMIZER │ │ │ │ +kweXYXXdd\xfzfa │ │ │ │ +scX_hRkii[[ │ │ │ │ +lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ +function name │ │ │ │ +^abe\kwdguX^[| │ │ │ │ +yesm\np[TRfX │ │ │ │ +ySgzpWZTT^` │ │ │ │ +UPzRVUgX │ │ │ │ +dSwsY[Y` │ │ │ │ +[[Xa[_X[dbhm[bhsT[ │ │ │ │ +IR1-CONVERT- │ │ │ │ No corresponding close bracket │ │ │ │ Number too large to print in English: ~:D │ │ │ │ FORMAT-ARG │ │ │ │ Number too large to print in Roman numerals: ~:D │ │ │ │ Unknown format directive ~@[(character: ~A)~] │ │ │ │ ~~> without a matching ~~< │ │ │ │ Misuse of justification and pprint directives │ │ │ │ @@ -27237,39 +27247,23 @@ │ │ │ │ INPUT-FILE and OUTPUT-FILE refer to the same file: ~s │ │ │ │ ~D:~2,'0D:~2,'0D.~3,'0D │ │ │ │ ~&; compilation ~:[finished in~;aborted after~] ~A~& │ │ │ │ note: ~3I~_ │ │ │ │ globally declaring the TYPE of ~A │ │ │ │ Cannot proclaim TYPE of a non-symbol: ~S │ │ │ │ Need ~D fraction bits for divisor ~D and ~D bit dividend │ │ │ │ -\\U[~[Pq │ │ │ │ -a source transform │ │ │ │ -FYUU)#:o"^Se │ │ │ │ -Xy[^c~X}T │ │ │ │ --OPTIMIZER │ │ │ │ -kweXYXXdd\xfzfa │ │ │ │ -scX_hRkii[[ │ │ │ │ -lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ -function name │ │ │ │ -^abe\kwdguX^[| │ │ │ │ -yesm\np[TRfX │ │ │ │ -ySgzpWZTT^` │ │ │ │ -UPzRVUgX │ │ │ │ -dSwsY[Y` │ │ │ │ -[[Xa[_X[dbhm[bhsT[ │ │ │ │ -IR1-CONVERT- │ │ │ │ -UiUPkmd` │ │ │ │ SC ~S has no :UNBOUNDED :SAVE-P NIL alternate SC. │ │ │ │ ~S is not a defined template. │ │ │ │ ~S is not a defined storage base. │ │ │ │ bad EVAL-WHEN situation list: ~S │ │ │ │ ~&; Base: ~x Data: ~x │ │ │ │ Can't disassemble a special operator │ │ │ │ iY{Z N │ │ │ │ __msan_unpoison │ │ │ │ +UiUPkmd` │ │ │ │ │ │ │ │ ~S is not a known argument keyword. │ │ │ │ ~@<~{~S~^, ~} and ~S are not a known argument keywords.~:@> │ │ │ │ can't understand type ~S │ │ │ │ Local alien info isn't constant? │ │ │ │ Perfect hash generator failed on ~X │ │ │ │ Q6aHOq\(EO │ │ │ │ @@ -27290,14 +27284,21 @@ │ │ │ │ Attempt to bind a ~(~A~) variable with SYMBOL-MACROLET: ~S │ │ │ │ malformed symbol/expansion pair: ~S │ │ │ │ [[XOUuk^Wdd │ │ │ │ Definition's declared type for variable ~A: │ │ │ │ conflicts with this type from ~A: │ │ │ │ Redefining vop-info-optimizer for ~S │ │ │ │ ~&; processing ~S │ │ │ │ +SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;XREF.LISP │ │ │ │ +SYS:SRC;COMPILER;SEQTRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ +SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ TOYVvyX\omX\ │ │ │ │ lexically binding global symbol-macro ~A in │ │ │ │ defined constant │ │ │ │ global lexical variable │ │ │ │ special variable │ │ │ │ unknown phase in time specifier: ~S │ │ │ │ malformed time specifier: ~S │ │ │ │ @@ -27379,21 +27380,14 @@ │ │ │ │ KvWagcy[EUXURU[R │ │ │ │ Can't push ~a into ~a │ │ │ │ :0" 6f0F │ │ │ │ YVOtKXm^gZX │ │ │ │ no move function defined to ~:[save~;load~] SC ~S ~:[to~;from~] from SC ~S │ │ │ │ SC ~S has no alternate~:[~; or constant~] SCs, yet it is │ │ │ │ mentioned in the restriction for operand ~S │ │ │ │ -SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;XREF.LISP │ │ │ │ -SYS:SRC;COMPILER;SEQTRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ -SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ │ │ │ │ 3$**=!#& │ │ │ │ 5!oVCV\_ │ │ │ │ ~@ │ │ │ │ function called with ~R argument~:P, but wants at least ~R │ │ │ │ function called with ~R argument~:P, but wants at most ~R │ │ │ │ (during macroexpansion of ~A) │ │ │ │ @@ -27566,14 +27560,34 @@ │ │ │ │ previous declaration │ │ │ │ Bad thing: ~S. │ │ │ │ Bad fixup flavor ~s │ │ │ │ G$**0&&2&8 │ │ │ │ defining ~S as a macro │ │ │ │ ~S is being redefined as a macro when it was previously ~(~A~) to be a function. │ │ │ │ The special operator ~S can't be redefined as a macro. │ │ │ │ +SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ +SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ +SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ +SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ +SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ +SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ +Control whether the compiler should check for constant │ │ │ │ +modification. Defaults to SAFETY. │ │ │ │ +Control the way to perform runtime type checking: │ │ │ │ +0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ +2: fast checks are performed: declared types are weakened to │ │ │ │ + FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ +3: declared types are fully checked (several exceptions exist; │ │ │ │ + see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ + Implementation Limitations for details). │ │ │ │ +Control inline-substitution of used-once local functions. │ │ │ │ +Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ +more reliable bactracing across foreign calls. │ │ │ │ +Enables possibility of returning from stack frames with the debugger. │ │ │ │ +The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ Can't substitute ~a into ~a │ │ │ │ VOP in ~S isn't ~S. │ │ │ │ Read is after write for temp ~S in refs of ~S. │ │ │ │ stray ref with no corresponding temp write: ~S │ │ │ │ stray ref that isn't a READ: ~S │ │ │ │ HE │ │ │ │ 3 │ │ │ │ -T_QYHOHO^dgg │ │ │ │ can't local-call functions with &MORE args │ │ │ │ function called with unknown argument keyword ~S │ │ │ │ non-constant :ALLOW-OTHER-KEYS value │ │ │ │ non-constant keyword in keyword call │ │ │ │ function called with odd number of arguments in keyword portion │ │ │ │ c]'&fch'&i]8= │ │ │ │ The ~:R argument of type ~s cannot be used as a keyword. │ │ │ │ @@ -27617,64 +27630,25 @@ │ │ │ │ know how to dump │ │ │ │ Can't preserve function source - missing MAKE-LOAD-FORM methods? │ │ │ │ '2'*i$A4P │ │ │ │ ~S was seen more than once. │ │ │ │ IR1 block ~D~@[ start c~D~] │ │ │ │ *INLINE-EXPANSION-LIMIT* (~W) was exceeded while inlining ~s │ │ │ │ TN-CONFLICTS │ │ │ │ -SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ -SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ -SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ -SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ -SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ -SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ -Control whether the compiler should check for constant │ │ │ │ -modification. Defaults to SAFETY. │ │ │ │ -Control the way to perform runtime type checking: │ │ │ │ -0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ -2: fast checks are performed: declared types are weakened to │ │ │ │ - FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ -3: declared types are fully checked (several exceptions exist; │ │ │ │ - see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ - Implementation Limitations for details). │ │ │ │ -Control inline-substitution of used-once local functions. │ │ │ │ -Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ -more reliable bactracing across foreign calls. │ │ │ │ -Enables possibility of returning from stack frames with the debugger. │ │ │ │ -The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ -When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ -FOO ...) is considered to be the reference to the function being │ │ │ │ -defined. Calls to FOO are compiled as local. This allows better │ │ │ │ -optimization and type checking, but TRACE will not show recursive │ │ │ │ -calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ -bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ -recursive. │ │ │ │ -When disabled, internal references to a function FOO will be │ │ │ │ -considered ti be a call of a function, bound to the symbol at │ │ │ │ -run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ -case of renaming described above, calls to FOO will not be recursive │ │ │ │ -and will refer to the new function, bound to FOO. │ │ │ │ -Control instrumentation of code, enabling single-stepping through │ │ │ │ -it in the debugger. │ │ │ │ -This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ -When disabled, LET variable, which is never set and is referenced │ │ │ │ -exactly once, is eliminated and the reference is substituted with the │ │ │ │ -initial value. This allows better type inference and some algebraic │ │ │ │ -optimizations. │ │ │ │ -When enabled, the variable is preserved and can be seen in the │ │ │ │ -debugger. │ │ │ │ ,AGrWRz_ │ │ │ │ This shouldn't happen! Bug? │ │ │ │ argument types invalid │ │ │ │ argument primitive types:~% ~S │ │ │ │ argument type assertions:~% ~S │ │ │ │ template guard failed │ │ │ │ The template isn't safe, yet we were counting on it. │ │ │ │ conditional in a non-conditional context │ │ │ │ result types invalid │ │ │ │ +T_QYHOHO^dgg │ │ │ │ +(:#7%%5HU │ │ │ │ PREV in ~S should be ~S. │ │ │ │ The last VOP in ~S should be ~S. │ │ │ │ wrong number of codegen info args in ~S │ │ │ │ BLOCK in ~S should be ~S. │ │ │ │ NTboPXo │ │ │ │ (during EVAL of LOAD-TIME-VALUE) │ │ │ │ defining function ~S when ~S already has a SETF macro │ │ │ │ @@ -27691,15 +27665,14 @@ │ │ │ │ none of the SCs allowed by the operand type ~S can directly be loaded │ │ │ │ into any of the restriction's SCs: │ │ │ │ ~S~:[~; │ │ │ │ [* type operand must allow T's SCs.]~] │ │ │ │ ~:[Result~;Argument~] ~A to VOP ~S │ │ │ │ has SC restriction ~S which is not allowed by the operand type: │ │ │ │ #30<%c0);4S │ │ │ │ -(:#7%%5HU │ │ │ │ @ $"! 0g +.! ?*2&< ;+''< ;< ; │ │ │ │ ~S has VALUE but no ENTRY. │ │ │ │ ~S is not in its ENTRY's EXITS. │ │ │ │ ~S is not the ENCLOSE for its FUN ~S. │ │ │ │ ~S is not in ENTRIES for its home LAMBDA. │ │ │ │ RETURN not at block end: ~S │ │ │ │ JUMP-TABLE not at block end: ~S │ │ │ │ @@ -27812,14 +27785,17 @@ │ │ │ │ attempt to dump reference to obsolete class: ~S │ │ │ │ $$4rm0% │ │ │ │ Redefining modular version ~S of ~S for ~:[un~;~]signed width ~S. │ │ │ │ Control │ │ │ │ IR2Tran │ │ │ │ Disassembly of code for ~S │ │ │ │ ^Nxad\QrU │ │ │ │ +%PRIMITIVE was used with a conditional template. │ │ │ │ +Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ +Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ Lambda list keyword ~S is not supported for modular function lambda lists. │ │ │ │ trampoline │ │ │ │ ~<~@; ~S~:> │ │ │ │ ~&; --> ~{~< │ │ │ │ ; --> ~1:;~A~> ~} │ │ │ │ ~2&; file: ~A │ │ │ │ ~4:;~{ ~:S~}~>~^ =>~} │ │ │ │ @@ -27830,48 +27806,43 @@ │ │ │ │ ~]~@[No move VOPs are defined to coerce to these allowed SCs: │ │ │ │ ~]~@[These move VOPs couldn't be used due to operand type restrictions: │ │ │ │ Current cost info inconsistent with that in effect at compile time. Recompile. │ │ │ │ Compilation order may be incorrect.~] │ │ │ │ Representation selection flamed out for no obvious reason. │ │ │ │ $XXXk#,1 │ │ │ │ expected ~W variant values: ~S │ │ │ │ +globaldb │ │ │ │ ~S is not a legal go tag. │ │ │ │ The tag ~S appears more than once in a tagbody. │ │ │ │ '_bJmThj │ │ │ │ unknown element alignment │ │ │ │ unknown element size │ │ │ │ unable to open code deref of wild pointer type │ │ │ │ too many indices for pointer deref: ~W │ │ │ │ Element alignment is unknown. │ │ │ │ Element size is unknown. │ │ │ │ incorrect number of indices │ │ │ │ ~S not either a pointer or array type. │ │ │ │ +Kc%Y7cN │ │ │ │ Repeated OPTIMIZE qualit~@P. Using ~{~S~^ and ~} │ │ │ │ nYYXY~nYY │ │ │ │ -%PRIMITIVE was used with a conditional template. │ │ │ │ -Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ -Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ optimize │ │ │ │ Unexpected fixup │ │ │ │ 0((((4"& │ │ │ │ ~S is not in ~S. │ │ │ │ bad PREV for ~S, should be ~S │ │ │ │ wrong TAIL for DFO, ~S in ~S │ │ │ │ ~S is malformed. │ │ │ │ strange FREE-VARS entry: ~S │ │ │ │ strange CONSTANTS entry: ~S │ │ │ │ strange FREE-FUNS entry: ~S │ │ │ │ TNs: ~W local, ~W temps, ~W constant, ~W env, ~W comp, ~W global. │ │ │ │ Wired: ~W, Unused: ~W. ~W block~:P, ~W global conflict~:P. │ │ │ │ The slot ~S does not have a suitable default, and no value was provided for it. │ │ │ │ The slot ~S default form ~s doesn't match :type ~s │ │ │ │ -SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;VM.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ Compiling ~A: │ │ │ │ cannot specify :LOAD-IF in a :MORE operand │ │ │ │ cannot specify :TARGET in a :MORE operand │ │ │ │ can only specify :TO in an argument: ~S │ │ │ │ can only specify :FROM in a result: ~S │ │ │ │ unknown keyword in operand specifier: ~S │ │ │ │ The MORE operand isn't the last operand: ~S │ │ │ │ @@ -27895,21 +27866,14 @@ │ │ │ │ DEST for ~S should be ~S. │ │ │ │ Node ~S using ~S is in an unknown block. │ │ │ │ unseen function ~S in ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ concatenate │ │ │ │ Can't ~a ~s into ~s │ │ │ │ -ihYhhmUPt │ │ │ │ -multiple store variables for ~S │ │ │ │ -no &REST context │ │ │ │ -\hq`n[eKXdhQXvra │ │ │ │ - dh d │ │ │ │ -LEndzsn^}k │ │ │ │ -PA-BITS-EA- │ │ │ │ Lisp error during constant folding:~%~A │ │ │ │ Incompatible array element types: ~a and ~a │ │ │ │ The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ !>]hdda[ │ │ │ │ )daghLRa^ │ │ │ │ doing ~A (cost ~W)~@[ from ~S~]~@[ to ~S~] │ │ │ │ couldn't find op? bug! │ │ │ │ @@ -27919,14 +27883,42 @@ │ │ │ │ can't tell whether the ~:R argument is a constant ~S: │ │ │ │ The ~:R argument is not a constant ~S: │ │ │ │ The ~:R argument is a ~S, not a ~S. │ │ │ │ The ~:R argument never returns a value. │ │ │ │ Jg|~Y{XX │ │ │ │ unknown option specifier: ~S │ │ │ │ malformed option specification: ~S │ │ │ │ +When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ +FOO ...) is considered to be the reference to the function being │ │ │ │ +defined. Calls to FOO are compiled as local. This allows better │ │ │ │ +optimization and type checking, but TRACE will not show recursive │ │ │ │ +calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ +bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ +recursive. │ │ │ │ +When disabled, internal references to a function FOO will be │ │ │ │ +considered ti be a call of a function, bound to the symbol at │ │ │ │ +run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ +case of renaming described above, calls to FOO will not be recursive │ │ │ │ +and will refer to the new function, bound to FOO. │ │ │ │ +Control instrumentation of code, enabling single-stepping through │ │ │ │ +it in the debugger. │ │ │ │ +This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ +When disabled, LET variable, which is never set and is referenced │ │ │ │ +exactly once, is eliminated and the reference is substituted with the │ │ │ │ +initial value. This allows better type inference and some algebraic │ │ │ │ +optimizations. │ │ │ │ +When enabled, the variable is preserved and can be seen in the │ │ │ │ +debugger. │ │ │ │ +SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;VM.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ +ihYhhmUPt │ │ │ │ +multiple store variables for ~S │ │ │ │ +no &REST context │ │ │ │ +\hq`n[eKXdhQXvra │ │ │ │ {~{~S~^ ~}} │ │ │ │ ~a is not a subtype of ARRAY. │ │ │ │ #7%% >7X } h │ │ │ │ shouldn't happen! (defined-fun) │ │ │ │ ~:@ │ │ │ │ ~:@ │ │ │ │ ~:@ │ │ │ │ @@ -27943,15 +27935,14 @@ │ │ │ │ ~&; compiling file ~S (written ~A): │ │ │ │ ~:[A possible~;The~] binding of ~S │ │ │ │ Inconsistent :initial-contents rank. │ │ │ │ Inconsistent :initial-contents dimensions. │ │ │ │ Default expression ~S does not match ~S in ~S │ │ │ │ Implement │ │ │ │ Too many result values from c-call. │ │ │ │ -SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ * + │ │ │ │ ( 52 │ │ │ │ stub %SET-CONTEXT-FLOAT-REGISTER │ │ │ │ ~S and ~S don't have the same dimensions. │ │ │ │ unknown float trap kind: ~S │ │ │ │ return-pc not on stack in standard save location? │ │ │ │ ocfp not on stack in standard save location? │ │ │ │ @@ -27963,14 +27954,20 @@ │ │ │ │ Garbage collection is currently │ │ │ │ DISABLED │ │ │ │ There are ~W elements in the :INITIAL-CONTENTS, but the vector length is ~W. │ │ │ │ Summary of space │ │ │ │ bytes, │ │ │ │ Summary total: │ │ │ │ objects. │ │ │ │ + dh d │ │ │ │ +LEndzsn^}k │ │ │ │ +PA-BITS-EA- │ │ │ │ +SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ +X_aeX_a\k │ │ │ │ +ga]gdX_dnf │ │ │ │ Wrong number of subscripts, ~W, for array of rank 1. │ │ │ │ Wrong number of subscripts, ~W, for array of rank ~W. │ │ │ │ Breakdown for │ │ │ │ space total │ │ │ │ bytes for │ │ │ │ ~V:D bytes for ~V:D ~(~A~) object~2:*~P~*~:[~; ~:*(~A)~] │ │ │ │ :INITIAL-CONTENTS is not a proper list. │ │ │ │ @@ -27982,36 +27979,17 @@ │ │ │ │ %:&0l "% │ │ │ │ Code object: │ │ │ │ No debug info. │ │ │ │ **** Page │ │ │ │ , address │ │ │ │ ~S is not a static symbol. │ │ │ │ ~x: ~v,'0x~:[~; = ~@?~] │ │ │ │ -X_aeX_a\k │ │ │ │ -ga]gdX_dnf │ │ │ │ -YbUZbQZdgyU`TZ^ │ │ │ │ -WY[^QZ[y[[U │ │ │ │ -^[UZUZUT │ │ │ │ -DO-REFERENCED-OBJECT usage error │ │ │ │ -PPRINT-EXIT-IF-LIST-EXHAUSTED must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ -PkakYk`L[OU │ │ │ │ Don't know how to ~S ~A. │ │ │ │ ~@ │ │ │ │ -page_table │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PARMS.LISP │ │ │ │ -SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ -TEXT_SPACE_START │ │ │ │ -next_free_page │ │ │ │ -READ_ONLY_SPACE_START │ │ │ │ -text_space_highwatermark │ │ │ │ -DYNAMIC_SPACE_START │ │ │ │ -static_space_free_pointer │ │ │ │ -read_only_space_free_pointer │ │ │ │ -SYS:SRC;CODE;EARLY-CONSTANTS.LISP │ │ │ │ bad place for a wild pathname │ │ │ │ Can't create directory ~A~:[~;,~%a file with ~ │ │ │ │ the same name already exists.~] │ │ │ │ ~&creating directory: ~A │ │ │ │ Retry directory creation. │ │ │ │ sz7o]HJj │ │ │ │ :q4w&*s@x& │ │ │ │ @@ -28021,25 +27999,30 @@ │ │ │ │ Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ (yes or no) │ │ │ │ Can not USE-PACKAGE ~S │ │ │ │ ~S can't use packages │ │ │ │ using package~P ~{~A~^, ~} │ │ │ │ can't adjust vector ~S to a size (~S) smaller than its current fill pointer (~S) │ │ │ │ Expected ~D new dimension~:P for array, but received ~D. │ │ │ │ -unusing package~P ~{~A~^, ~} │ │ │ │ -renaming as ~A~@[ with nickname~*~P ~1@*~{~A~^, ~}~] │ │ │ │ -Another package is already accessible via name ~S │ │ │ │ -Undefined type: ~S │ │ │ │ -nothing to unread │ │ │ │ -(y or n) │ │ │ │ -~S is not accessible in the ~A package. │ │ │ │ -unexporting symbol~P ~{~A~^, ~} │ │ │ │ -/proc/sys/kernel/osrelease │ │ │ │ -~@ │ │ │ │ -~@<~S as EOF-ERROR-P argument to ~S: probable error. Two optional arguments must be provided before the first keyword argument.~:@> │ │ │ │ +page_table │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PARMS.LISP │ │ │ │ +SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ +TEXT_SPACE_START │ │ │ │ +next_free_page │ │ │ │ +READ_ONLY_SPACE_START │ │ │ │ +YbUZbQZdgyU`TZ^ │ │ │ │ +WY[^QZ[y[[U │ │ │ │ +^[UZUZUT │ │ │ │ +DO-REFERENCED-OBJECT usage error │ │ │ │ +text_space_highwatermark │ │ │ │ +DYNAMIC_SPACE_START │ │ │ │ +static_space_free_pointer │ │ │ │ +read_only_space_free_pointer │ │ │ │ +PPRINT-EXIT-IF-LIST-EXHAUSTED must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ +PkakYk`L[OU │ │ │ │ access-function │ │ │ │ y"*"#"#"*"#"2(" │ │ │ │ uVVVl\VVi\Vq │ │ │ │ :SIZE is not a positive integer: ~S │ │ │ │ bogus DEFPACKAGE option: ~S │ │ │ │ ~S expects a single argument. Got ~S │ │ │ │ can't specify ~S more than once. │ │ │ │ @@ -28065,30 +28048,59 @@ │ │ │ │ dn[[a]ah\[p^^WO │ │ │ │ cannot specify values for both PREFIX and PER-LINE-PREFIX. │ │ │ │ O^adXu^R │ │ │ │ \J"L Ys} │ │ │ │ Unnamed restart does not have a report function: ~S │ │ │ │ ill-formed restart binding: ~S │ │ │ │ ~@<~S argument to the short form of ~S must be a string.~:@> │ │ │ │ +unusing package~P ~{~A~^, ~} │ │ │ │ +renaming as ~A~@[ with nickname~*~P ~1@*~{~A~^, ~}~] │ │ │ │ +Another package is already accessible via name ~S │ │ │ │ +SYS:SRC;CODE;EARLY-CONSTANTS.LISP │ │ │ │ +Undefined type: ~S │ │ │ │ +nothing to unread │ │ │ │ +(y or n) │ │ │ │ +~S is not accessible in the ~A package. │ │ │ │ +unexporting symbol~P ~{~A~^, ~} │ │ │ │ +/proc/sys/kernel/osrelease │ │ │ │ +Axis number ~W is too big; ~S only has ~D dimension~:P. │ │ │ │ +Vector axis is not zero: ~S │ │ │ │ +~@ │ │ │ │ +~@<~S as EOF-ERROR-P argument to ~S: probable error. Two optional arguments must be provided before the first keyword argument.~:@> │ │ │ │ +Bogus slot-cell in SLOT-MAKUNBOUND: ~S │ │ │ │ +~S these symbols into the ~A package. │ │ │ │ +~@ │ │ │ │ +exporting symbol~P ~{~A~^, ~} │ │ │ │ +~@ │ │ │ │ +~S can't be created. │ │ │ │ +no translation for ~S │ │ │ │ cannot define a compiler-macro for a special operator: ~S │ │ │ │ X^drex[^bVaaU[g │ │ │ │ ]lTuuK^LrTm}U[Yhm[gnhs │ │ │ │ DEFSTRUCT: ~S is not a symbol. │ │ │ │ Malformed slot entry: ~s, should be (variable-name accessor-name) │ │ │ │ Malformed slot entry: ~s, should be either a symbol or (variable-name slot-name) │ │ │ │ U_^d^aP[Xacyy │ │ │ │ XIV}\UJlNh │ │ │ │ -Bogus slot-cell in SLOT-MAKUNBOUND: ~S │ │ │ │ -~S these symbols into the ~A package. │ │ │ │ -~@ │ │ │ │ -exporting symbol~P ~{~A~^, ~} │ │ │ │ SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ -~@ │ │ │ │ -~S can't be created. │ │ │ │ -no translation for ~S │ │ │ │ +array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ +YbY_fnYYwglbVbV_bb^R\VXepddp │ │ │ │ +KV-VECTOR- │ │ │ │ +TRUw^UP[Xc │ │ │ │ +ROYYhYXp │ │ │ │ +FORM-FUN- │ │ │ │ +normal-return │ │ │ │ +error-return │ │ │ │ +Malformed HANDLER-CASE lambda-list. Should be either () or (symbol), not ~s. │ │ │ │ +UlXi\XddQ\XXda` │ │ │ │ +xV^[`t[PPRkW^todjj │ │ │ │ +a DEFSETF lambda list │ │ │ │ +Ill-formed DEFSETF for ~S │ │ │ │ +a DEFINE-MODIFY-MACRO lambda list │ │ │ │ +UOi__cddgX │ │ │ │ (''!'k#\OD │ │ │ │ Return T │ │ │ │ Syscall ~A failed: ~A │ │ │ │ ~a is not a proper list │ │ │ │ f" 4 & 8 │ │ │ │ tIz ,;!2 │ │ │ │ deleting package ~A │ │ │ │ @@ -28111,50 +28123,53 @@ │ │ │ │ OPEN :IF-DOES-NOT-EXIST ~s ~ │ │ │ │ :IF-EXISTS ~s will always signal an error. │ │ │ │ OPEN :IF-EXISTS :NEW-VERSION is not supported ~ │ │ │ │ when a new version must be created. │ │ │ │ Undefined external-format: ~S │ │ │ │ 137?@R^LL │ │ │ │ ~S doesn't match ~S. │ │ │ │ -array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ -YbY_fnYYwglbVbV_bb^R\VXepddp │ │ │ │ -KV-VECTOR- │ │ │ │ -TRUw^UP[Xc │ │ │ │ -ROYYhYXp │ │ │ │ -FORM-FUN- │ │ │ │ -normal-return │ │ │ │ -error-return │ │ │ │ -Malformed HANDLER-CASE lambda-list. Should be either () or (symbol), not ~s. │ │ │ │ -UlXi\XddQ\XXda` │ │ │ │ -xV^[`t[PPRkW^todjj │ │ │ │ -a DEFSETF lambda list │ │ │ │ -Ill-formed DEFSETF for ~S │ │ │ │ -a DEFINE-MODIFY-MACRO lambda list │ │ │ │ -UOi__cddgX │ │ │ │ +rE)-.@[XY8W │ │ │ │ +There is nothing left to pop. │ │ │ │ +Invalid argument to SLEEP: ~S, should be a non-negative real. │ │ │ │ +~S isn't forced to memory. Something went wrong. │ │ │ │ +[aaRJSaaR │ │ │ │ +unrecognized alien type: ~A │ │ │ │ `T= ]D! │ │ │ │ lKX\Of[kKd │ │ │ │ ~S is an illegal form for a ~S varlist. │ │ │ │ ~S step variable is not a symbol: ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ k [ X\ W │ │ │ │ Y_fnYbIn_btaV_qdXeWRbWpc[J\`W^OWd │ │ │ │ T[EYUTkmd\k │ │ │ │ PPRINT-POP must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ bb n} n| │ │ │ │ -rE)-.@[XY8W │ │ │ │ -globaldb │ │ │ │ -Objects of type ~// can't be dumped into fasl files. │ │ │ │ SYS:SRC;CODE;IRRAT.LISP │ │ │ │ SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ -There is nothing left to pop. │ │ │ │ -Invalid argument to SLEEP: ~S, should be a non-negative real. │ │ │ │ -~S isn't forced to memory. Something went wrong. │ │ │ │ -[aaRJSaaR │ │ │ │ -unrecognized alien type: ~A │ │ │ │ +j\ │ │ │ │ +_eUGsXV[iV\XX │ │ │ │ +unknown option: ~S │ │ │ │ +bad option: │ │ │ │ +slot :DOCUMENTATION argument is not a string: ~S │ │ │ │ +more than one :DOCUMENTATION in ~S │ │ │ │ +more than one :INITFORM in ~S │ │ │ │ +unknown slot option: │ │ │ │ +malformed condition slot spec: │ │ │ │ +Keyword slot name indicates probable syntax error: │ │ │ │ +UU]HPhN[[UPSnL[dNy[mqj\dH~EIJiQi │ │ │ │ +Dotted list ~S in DOLIST. │ │ │ │ +[a{[aaZa │ │ │ │ +ill-formed ~S clause, no lambda-list: │ │ │ │ +UP_QP\_pYNRVWp` │ │ │ │ +U\aRVMPddpd │ │ │ │ +Something is wrong; local-alien-info not found: ~S │ │ │ │ +[kVhUUPgkdXXddX │ │ │ │ +[kVcnXgez │ │ │ │ +[RRO\Yk|gbV[^{UUl │ │ │ │ ~S cannot be casted. │ │ │ │ cannot cast to alien type ~S │ │ │ │ Invalid place to CAS: ~S -> ~S │ │ │ │ Basic qualities: │ │ │ │ Dependent qualities: │ │ │ │ ~S cannot be used with displaced arrays. Use ~S instead. │ │ │ │ t#IU1 1 │ │ │ │ @@ -28173,45 +28188,44 @@ │ │ │ │ SYS:SRC;**;*.*.* │ │ │ │ SYS:CONTRIB;**;*.*.* │ │ │ │ SYS:OUTPUT;**;*.*.* │ │ │ │ SYS:SRC; │ │ │ │ SYS:CONTRIB; │ │ │ │ SYS:OUTPUT; │ │ │ │ ~@<~A does not make sense without ~A.~@:> │ │ │ │ +SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ +SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ +SYS:SRC;COMPILER;LTN.LISP │ │ │ │ +SYS:SRC;CODE;STEP.LISP │ │ │ │ Couldn't change directory to ~S: ~A │ │ │ │ Couldn't execute ~S: ~A │ │ │ │ Couldn't fork child process: ~A │ │ │ │ can't specify :ENV and :ENVIRONMENT simultaneously │ │ │ │ Error creating pipe │ │ │ │ Could not delete directory ~S │ │ │ │ Input is not a proper list of weak pointers. │ │ │ │ Could not stop all threads │ │ │ │ objects, │ │ │ │ candidates, │ │ │ │ Unknown object type #x~x ~s │ │ │ │ -j\ │ │ │ │ -_eUGsXV[iV\XX │ │ │ │ -unknown option: ~S │ │ │ │ -bad option: │ │ │ │ -slot :DOCUMENTATION argument is not a string: ~S │ │ │ │ -more than one :DOCUMENTATION in ~S │ │ │ │ -more than one :INITFORM in ~S │ │ │ │ -unknown slot option: │ │ │ │ -malformed condition slot spec: │ │ │ │ -Keyword slot name indicates probable syntax error: │ │ │ │ -UU]HPhN[[UPSnL[dNy[mqj\dH~EIJiQi │ │ │ │ -Dotted list ~S in DOLIST. │ │ │ │ -[a{[aaZa │ │ │ │ -ill-formed ~S clause, no lambda-list: │ │ │ │ -UP_QP\_pYNRVWp` │ │ │ │ -U\aRVMPddpd │ │ │ │ -Something is wrong; local-alien-info not found: ~S │ │ │ │ -[kVhUUPgkdXXddX │ │ │ │ -[kVcnXgez │ │ │ │ -[RRO\Yk|gbV[^{UUl │ │ │ │ +Abort ~A file ~S. │ │ │ │ +Ignore error and continue ~A file ~S. │ │ │ │ +Retry EVAL of current toplevel form. │ │ │ │ +~&While evaluating the form starting at line ~D, column ~D │ │ │ │ + of ~S: │ │ │ │ +~{~S~^, ~} │ │ │ │ +~& ~@[type ~D~]~@[~{~S ~S~}~] = │ │ │ │ +~s is no longer present in ~s │ │ │ │ +invalid feature expression: ~S │ │ │ │ +too few subexpressions in feature expression: ~S │ │ │ │ +too many subexpressions in feature expression: ~S │ │ │ │ +unknown operator in feature expression: ~S. │ │ │ │ +an ordinary lambda list │ │ │ │ +Q`oM11 1 │ │ │ │ +The package ~S has been deleted. │ │ │ │ PXYqcdW_Wa │ │ │ │ UNLOCKED-PACKAGES- │ │ │ │ aZbV[^{UUl │ │ │ │ [m_aUGjge[eq │ │ │ │ Malformed HASH-FUNCTION: ~S │ │ │ │ Cannot redefine standard hash table test ~S. │ │ │ │ aYLhXWpX │ │ │ │ @@ -28226,35 +28240,14 @@ │ │ │ │ bYYVbVk_YV_kkm^iPGkddgbdY │ │ │ │ Not a parser state: ~S │ │ │ │ \kbVrtwbnVemX │ │ │ │ LUULV^`aYt │ │ │ │ aXa]LI[Lut │ │ │ │ X[d^gmXYtX^ru │ │ │ │ odd^gpwajd │ │ │ │ -SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ -SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ -SYS:SRC;COMPILER;LTN.LISP │ │ │ │ -SYS:SRC;CODE;STEP.LISP │ │ │ │ -WITHOUT-GCING-BODY- │ │ │ │ -SUPPLIED-P-P │ │ │ │ -Abort ~A file ~S. │ │ │ │ -Ignore error and continue ~A file ~S. │ │ │ │ -Retry EVAL of current toplevel form. │ │ │ │ -~&While evaluating the form starting at line ~D, column ~D │ │ │ │ - of ~S: │ │ │ │ -~{~S~^, ~} │ │ │ │ -~& ~@[type ~D~]~@[~{~S ~S~}~] = │ │ │ │ -~s is no longer present in ~s │ │ │ │ -invalid feature expression: ~S │ │ │ │ -too few subexpressions in feature expression: ~S │ │ │ │ -too many subexpressions in feature expression: ~S │ │ │ │ -unknown operator in feature expression: ~S. │ │ │ │ -an ordinary lambda list │ │ │ │ -Q`oM11 1 │ │ │ │ -The package ~S has been deleted. │ │ │ │ ~A: Timezone should be an integer between 0 and 32. │ │ │ │ ~A: Hours should be an non-negative integer. │ │ │ │ ~A: Month should be an integer between 1 and 12. │ │ │ │ ~A: Day should be an integer between 1 and 31. │ │ │ │ ~A: Hours should be an integer between 0 and 23. │ │ │ │ ~A: Minutes should be an integer between 0 and 59. │ │ │ │ ~A: Seconds should be an integer between 0 and 59. │ │ │ │ @@ -28310,14 +28303,33 @@ │ │ │ │ Modify the constant. │ │ │ │ Can't ~@?. │ │ │ │ Nihil ex nihil. (can't ~@?) │ │ │ │ Veritas aeterna. (can't ~@?) │ │ │ │ Can't ~@? │ │ │ │ setting the value of ~S │ │ │ │ Can't ~@? (global variable). │ │ │ │ +~&Enter a form evaluating to a value of type ~a: │ │ │ │ +~s is not of type ~s │ │ │ │ +File descriptor must be opened either for input or output. │ │ │ │ +descriptor ~W │ │ │ │ +Cannot resolve foreign symbol: lost *runtime-dlhandle* │ │ │ │ +/proc/cpuinfo │ │ │ │ +model name │ │ │ │ +Error initializing ~a~@[ ~a~]: │ │ │ │ + │ │ │ │ + Using ~s instead. │ │ │ │ +with the current directory │ │ │ │ +invalid external alien name: ~S │ │ │ │ +Unix system call getrusage failed: ~A. │ │ │ │ +Error opening ~:[runtime~;shared object ~:*~S~]: │ │ │ │ +Invalid direction ~S, must be either :INPUT or :OUTPUT │ │ │ │ +Cancel the deadline and continue. │ │ │ │ +By how many seconds shall the deadline ~ │ │ │ │ + be deferred?: │ │ │ │ +Defer the deadline for SECONDS more. │ │ │ │ bad option: ~S │ │ │ │ $53>8Qs?F>> │ │ │ │ XVdYWdURYeHfJgQ\aUPFkWp │ │ │ │ FS }\ d │ │ │ │ VYbVbV_VV │ │ │ │ tkn_zb_keYYha\qXacXpi[P[ │ │ │ │ F-METHOD- │ │ │ │ @@ -28335,43 +28347,24 @@ │ │ │ │ TIME-LEFT- │ │ │ │ Bad size for ~S type specifier: ~S. │ │ │ │ malformed ONCE-ONLY binding spec: ~S │ │ │ │ ^k ^ wkq │ │ │ │ bY_VYw^tgwh │ │ │ │ ~S is valid only inside ~S. │ │ │ │ Uz[OY^RPe[\Xnhhw^^ldd │ │ │ │ -SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ WITH-PINNED-OBJECTS-THUNK │ │ │ │ vQJJUgZgm │ │ │ │ +WITHOUT-GCING-BODY- │ │ │ │ FF]Xte[Ydd │ │ │ │ -~&Enter a form evaluating to a value of type ~a: │ │ │ │ -~s is not of type ~s │ │ │ │ -File descriptor must be opened either for input or output. │ │ │ │ -descriptor ~W │ │ │ │ -Cannot resolve foreign symbol: lost *runtime-dlhandle* │ │ │ │ -/proc/cpuinfo │ │ │ │ -model name │ │ │ │ -Error initializing ~a~@[ ~a~]: │ │ │ │ - │ │ │ │ - Using ~s instead. │ │ │ │ -with the current directory │ │ │ │ -invalid external alien name: ~S │ │ │ │ -Unix system call getrusage failed: ~A. │ │ │ │ -Error opening ~:[runtime~;shared object ~:*~S~]: │ │ │ │ -Invalid direction ~S, must be either :INPUT or :OUTPUT │ │ │ │ -Cancel the deadline and continue. │ │ │ │ -By how many seconds shall the deadline ~ │ │ │ │ - be deferred?: │ │ │ │ -Defer the deadline for SECONDS more. │ │ │ │ -Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ -Cannot compare-and-swap slot ~S on: ~S │ │ │ │ LLbUpTPXgTd │ │ │ │ [PrYrR\xTdd^[[UX[_ofgJXOXm │ │ │ │ OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ -illegal instruction at #X~X │ │ │ │ +Objects of type ~// can't be dumped into fasl files. │ │ │ │ +SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ +SUPPLIED-P-P │ │ │ │ SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ public: the MetaObject Protocol interface, as defined by │ │ │ │ The Art of the Metaobject Protocol, by Kiczales, des Rivieres and Bobrow: │ │ │ │ ISBN 0-262-61074-4, with exceptions as noted in the User Manual. │ │ │ │ ?&_rMQP │ │ │ │ L)33C$i:3 │ │ │ │ 1d1ghA]~ │ │ │ │ @@ -28413,14 +28406,25 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ :@ff0'm@ │ │ │ │ COMMON-LISP │ │ │ │ G.Pu:033 │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ NEW-VALUE │ │ │ │ +Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ +Cannot compare-and-swap slot ~S on: ~S │ │ │ │ +illegal instruction at #X~X │ │ │ │ +bus error at #X~X │ │ │ │ +automatically-generated makunbound method │ │ │ │ +automatically-generated boundp method │ │ │ │ +automatically-generated writer method │ │ │ │ +automatically-generated reader method │ │ │ │ +3ddm\iddX │ │ │ │ +wjTWh]gsv\eS │ │ │ │ +%PATHNAME- │ │ │ │ gKT@XylQ, │ │ │ │ CLASSES-LIST │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ NEW-CLASS │ │ │ │ ]QuUwwwo │ │ │ │ COMMON-LISP0% │ │ │ │ @@ -28572,15 +28576,14 @@ │ │ │ │ Creates a new uninterned symbol whose name is a prefix string (defaults │ │ │ │ to "G"), followed by a decimal number. Thing, when supplied, will │ │ │ │ alter the prefix if it is a string, or be used for the decimal number │ │ │ │ if it is a number, of this symbol. The default value of the number is │ │ │ │ the current value of *gensym-counter* which is incremented each time │ │ │ │ it is used. │ │ │ │ Return the intersection of LIST1 and LIST2. │ │ │ │ -DESCRIPTOR-IDX │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Return the tail of LIST beginning with first element satisfying EQLity, │ │ │ │ :TEST, or :TEST-NOT with the given ITEM. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ @@ -28589,17 +28592,23 @@ │ │ │ │ directly to the LVAR-DEST of LVAR, which must be a combination. If FUN │ │ │ │ is :ANY, the function name is not checked. │ │ │ │ NOTE-NEXT-INSTRUCTION │ │ │ │ OPTIONAL-ARGS │ │ │ │ NOTE-NEXT-INSTRUCTION VOP Kind │ │ │ │ Similar to NOTE-THIS-LOCATION, except the use the location of the next │ │ │ │ instruction for the code location, wherever the scheduler decided to put │ │ │ │ -7*pO:XUU │ │ │ │ -Set the name of a compiled function object. Return the function. │ │ │ │ -%PATHNAME- │ │ │ │ +DESCRIPTOR-IDX │ │ │ │ +Return an Alien pointer to the data addressed by Expr, which must be a call │ │ │ │ + to SLOT or DEREF, or a reference to an Alien variable. │ │ │ │ +automatically generated writer method │ │ │ │ +automatically generated reader method │ │ │ │ +bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ +redefining DEFTYPE type to be a class: ~// │ │ │ │ +Cannot redefine standard type ~//. │ │ │ │ +bad modulus specified for MOD type specifier: ~// │ │ │ │ PSETQ {var value}* │ │ │ │ Set the variables to the values, like SETQ, except that assignments │ │ │ │ happen in parallel, i.e. no assignments take place until all the │ │ │ │ forms have been evaluated. │ │ │ │ This is to SETF as PSETQ is to SETQ. Args are alternating place │ │ │ │ expressions and values to go into those places. All of the subforms and │ │ │ │ values are determined, left to right, and only then are the locations │ │ │ │ @@ -28622,19 +28631,20 @@ │ │ │ │ argument of is the new value. Note that the system provides no automatic │ │ │ │ atomicity for CAS functions, nor can it verify that they are atomic: it is up │ │ │ │ to the implementor of a CAS function to ensure its atomicity. │ │ │ │ EXPERIMENTAL: Interface subject to change. │ │ │ │ COMMON-LISP │ │ │ │ Return the 1st object in a list or NIL if the list is empty. │ │ │ │ COMMON-LISP0 │ │ │ │ +7*pO:XUU │ │ │ │ +Set the name of a compiled function object. Return the function. │ │ │ │ COMMON-LISP │ │ │ │ ALIGNMENT │ │ │ │ -bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ -COMMON-LISP │ │ │ │ DERIVE-FUN0 │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ Unlocks PACKAGE and returns T. Has no effect if PACKAGE was already │ │ │ │ unlocked. Signals an error if PACKAGE is not a valid package designator. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ Return the type of the elements of the array │ │ │ │ EXTERNAL-FORMAT0 │ │ │ │ @@ -28662,14 +28672,49 @@ │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -28709,118 +28754,89 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ bM/+`o:01 │ │ │ │ q./)4%.5& │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Return the 1st object in a list. │ │ │ │ +COMMON-LISP │ │ │ │ +Return the integer code of CHAR. │ │ │ │ +COMMON-LISP │ │ │ │ +Return all but the first object in a list. │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +Return T if its arguments are in strictly decreasing order, NIL otherwise. │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ +FDEFN SB-KERNEL8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ + NEW-VALUE8 │ │ │ │ +DIVISOR0 │ │ │ │ +COMMON-LISP │ │ │ │ +Return second result of FLOOR. │ │ │ │ +COMMON-LISP │ │ │ │ INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -automatically-generated boundp method │ │ │ │ -automatically generated writer method │ │ │ │ -automatically generated reader method │ │ │ │ +COMMON-LISP0 │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP │ │ │ │ SYS:SRC;COMPILER;X86;CHAR.LISP │ │ │ │ SYS:SRC;COMPILER;X86;PRED.LISP │ │ │ │ Used by FILE-POSITION. Returns or changes the current position within STREAM. │ │ │ │ Is STREAM an interactive stream? │ │ │ │ Return a type specifier for the kind of object returned by the │ │ │ │ STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method │ │ │ │ which returns CHARACTER. │ │ │ │ -automatically-generated reader method │ │ │ │ -automatically-generated writer method │ │ │ │ SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ ]{_f`Rb@d │ │ │ │ SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -FDEFN SB-KERNEL8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ - NEW-VALUE8 │ │ │ │ -INSTANCE8 │ │ │ │ -COMMON-LISP0 │ │ │ │ +OPTIMIZE-DECL │ │ │ │ +SYS:SRC;CODE;CMACROS.LISP │ │ │ │ +SYS:SRC;CODE;TYPEP.LISP │ │ │ │ +inline float truncate │ │ │ │ +SYS:SRC;CODE;STUBS.LISP │ │ │ │ +S$VqY~]Z_ │ │ │ │ +}$c'0+[+ │ │ │ │ +SYS:SRC;CODE;COERCE.LISP │ │ │ │ +SYS:SRC;CODE;TARGET-SXHASH.LISP │ │ │ │ COMMON-LISP8# │ │ │ │ -DIVISOR0 │ │ │ │ -COMMON-LISP │ │ │ │ -Return second result of FLOOR. │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ +BEFORE-USES │ │ │ │ COMMON-LISP │ │ │ │ -Return the integer code of CHAR. │ │ │ │ -COMMON-LISP │ │ │ │ -Return all but the first object in a list. │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -Return T if its arguments are in strictly decreasing order, NIL otherwise. │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ +Given a string and a non-negative integer index less than the length of │ │ │ │ + the string, returns the character object representing the character at │ │ │ │ + that position in the string. │ │ │ │ +CATEGORY │ │ │ │ + NEW-VALUE │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ DIMENSION │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -redefining DEFTYPE type to be a class: ~// │ │ │ │ -Cannot redefine standard type ~//. │ │ │ │ -bad modulus specified for MOD type specifier: ~// │ │ │ │ -The type declarations ~// and ~// for ~S conflict. │ │ │ │ -OPTIMIZE-DECL │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INDEX-TYPE │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -28869,72 +28885,50 @@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ +MORE-ARG │ │ │ │ +Call FUNCTION with the given ARGUMENTS. │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ vw}}(!$f │ │ │ │ RI '(@DP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -Call FUNCTION with the given ARGUMENTS. │ │ │ │ fold division by 1 │ │ │ │ convert integer division to multiplication │ │ │ │ convert division by 2^k to shift │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -inline float truncate │ │ │ │ -SYS:SRC;CODE;TYPEP.LISP │ │ │ │ -SYS:SRC;CODE;CMACROS.LISP │ │ │ │ -SYS:SRC;CODE;STUBS.LISP │ │ │ │ -S$VqY~]Z_ │ │ │ │ -BEFORE-USES │ │ │ │ -}$c'0+[+ │ │ │ │ -SYS:SRC;CODE;COERCE.LISP │ │ │ │ -bus error at #X~X │ │ │ │ -automatically-generated makunbound method │ │ │ │ -3ddm\iddX │ │ │ │ -wjTWh]gsv\eS │ │ │ │ -SYS:SRC;CODE;TARGET-SXHASH.LISP │ │ │ │ -SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ -inline npx function │ │ │ │ -SYS:SRC;COMPILER;ARRAY-TRAN.LISP │ │ │ │ -SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ -bytes_allocated │ │ │ │ -Form associated with the STEP-CONDITION. │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ -Outputs a new line to the Stream if it is not positioned at the │ │ │ │ - beginning of a line. Returns T if it output a new line, nil │ │ │ │ - otherwise. Used by FRESH-LINE. The default method uses │ │ │ │ - STREAM-START-LINE-P and STREAM-TERPRI. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP0 │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP0 │ │ │ │ DEFAULTS │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ +The type declarations ~// and ~// for ~S conflict. │ │ │ │ +SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ +SYS:SRC;COMPILER;ARRAY-TRAN.LISP │ │ │ │ +inline npx function │ │ │ │ +bytes_allocated │ │ │ │ +SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ +Form associated with the STEP-CONDITION. │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ >(E_ R`C │ │ │ │ 58oCh-YFD2 │ │ │ │ -COMMON-LISP │ │ │ │ -Given a string and a non-negative integer index less than the length of │ │ │ │ - the string, returns the character object representing the character at │ │ │ │ - that position in the string. │ │ │ │ -CATEGORY │ │ │ │ - NEW-VALUE │ │ │ │ $)H:p$(U │ │ │ │ \0^0SsnD │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP8 │ │ │ │ ,*`o:pt` │ │ │ │ COMMON-LISP │ │ │ │ @@ -28972,27 +28966,37 @@ │ │ │ │ Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details. │ │ │ │ COMBINATION0 │ │ │ │ CLOSURE SB-KERNEL │ │ │ │ PERMIT-COPY │ │ │ │ NEW-VALUE │ │ │ │ Set NAME's global function definition. │ │ │ │ p]9KU0-M │ │ │ │ +Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ +Repeated labels in ASSEMBLE body │ │ │ │ +Wnvm]t|p$j| │ │ │ │ +~:@(ARG-FOR-~S-~) │ │ │ │ +The byte spec ~S either overlaps another byte spec, or extends past the end. │ │ │ │ +There are holes. │ │ │ │ +~W isn't an even multiple of ~W. │ │ │ │ +Oversized code component? │ │ │ │ +attempt to multiply define ~A ~S │ │ │ │ +Undefined instruction: ~s in │ │ │ │ +Undefined instruction: ~s in~% ~s │ │ │ │ +[m_UpUX~ │ │ │ │ +environment argument present and not null │ │ │ │ +can't open-code test of non-constant type │ │ │ │ +SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ +WITH-PRETTY-STREAM │ │ │ │ +Outputs a new line to the Stream if it is not positioned at the │ │ │ │ + beginning of a line. Returns T if it output a new line, nil │ │ │ │ + otherwise. Used by FRESH-LINE. The default method uses │ │ │ │ + STREAM-START-LINE-P and STREAM-TERPRI. │ │ │ │ Construct an association list from KEYS and DATA (adding to ALIST). │ │ │ │ LUUUig*mM │ │ │ │ TYPE-SPECIFIER SB-KERNEL │ │ │ │ -Return T iff the alien type TYPE1 is a subtype of TYPE2. Currently, the │ │ │ │ - only supported subtype relationships are is that any pointer type is a │ │ │ │ - subtype of (* t), and any array type first dimension will match │ │ │ │ - (array nil ...). Otherwise, the two types have to be │ │ │ │ - ALIEN-TYPE-=. │ │ │ │ -COMMON-LISP │ │ │ │ -AXIS-NUMBER │ │ │ │ -Return the length of dimension AXIS-NUMBER of ARRAY. │ │ │ │ -COMMON-LISP │ │ │ │ -3lG LN@tr │ │ │ │ COMMON-LISP08 │ │ │ │ Count the number of 1 bits if INTEGER is non-negative, │ │ │ │ and the number of 0 bits if INTEGER is negative. │ │ │ │ OPTIONAL-ARGS │ │ │ │ Emit LABEL at this location in the current section. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -29016,72 +29020,47 @@ │ │ │ │ COMMON-LISP9 │ │ │ │ Return a byte specifier which may be used by other byte functions │ │ │ │ (e.g. LDB). │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ L*(pO:XU^q │ │ │ │ Make SYMBOL unbound, removing any value it may currently have. │ │ │ │ +CE#$z-RJ - │ │ │ │ Make NAME have no global function definition. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ For use with ~/: Write SYMBOL to STREAM as if it is not accessible from │ │ │ │ the current package. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ BREAKPOINT │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -CE#$z-RJ - │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ DEBUG-FUN8 │ │ │ │ DEBUG-FUN │ │ │ │ DEBUG-FUN │ │ │ │ DEBUG-FUN8 │ │ │ │ UP-FRAME │ │ │ │ COMMON-LISP │ │ │ │ =-PW:033K │ │ │ │ #UlonI;u"&/ │ │ │ │ SIGNAL-CONTEXT │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ J(%(@D@HZ; │ │ │ │ CODE-OBJ │ │ │ │ PC-OFFSET8 │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ + DEBUG-FUN │ │ │ │ +ieX4f^'~ │ │ │ │ +L,'Pos03) │ │ │ │ + COMPONENT0 │ │ │ │ /build/reproducible-path/buildapp-1.5.6/package.lisp │ │ │ │ -WITH-PRETTY-STREAM │ │ │ │ Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ :TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ (alien (* (array (signed 8) 10))) │ │ │ │ (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ -ALIEN-NAME │ │ │ │ - LISP-NAME │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -O3)pO:|W │ │ │ │ -~// is a built-in alien type. │ │ │ │ -Input type (~//) and output type (~//) are unrelated? │ │ │ │ -could not find any input routine for ~// │ │ │ │ -package nicknames │ │ │ │ -~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ -~@:_Lambda-list: ~// │ │ │ │ -~@:_Declared type: ~// │ │ │ │ -~@:_Derived type: ~// │ │ │ │ -~@:_(~A ~{~S ~}~//) │ │ │ │ -~@:_~:(~A~) type: ~// │ │ │ │ -~@:_A ~(~a~) for ~// │ │ │ │ -~@:_An accessor for ~// │ │ │ │ -~@:_Argument precedence order: ~// │ │ │ │ -ALIEN-NAME │ │ │ │ - LISP-NAME │ │ │ │ -Initialize the alien symbol named by NAME with its alien callable │ │ │ │ -function value. │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP81 │ │ │ │ -,#V$b9gG │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP81 │ │ │ │ -Returns true if the alien is associated with a Lisp-side callback. │ │ │ │ -ALIEN-NAME │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -REF-FUN8 │ │ │ │ -COMMON-LISP │ │ │ │ Load a shared library / dynamic shared object file / similar foreign │ │ │ │ container specified by designated PATHNAME, such as a .so on an ELF platform. │ │ │ │ Locating the shared object follows standard rules of the platform, consult the │ │ │ │ manual page for dlopen(3) for details. Typically paths specified by │ │ │ │ environment variables such as LD_LIBRARY_PATH are searched if the PATHNAME has │ │ │ │ no directory, but on some systems (eg. Mac OS X) search may happen even if │ │ │ │ PATHNAME is absolute. (On Windows LoadLibrary is used instead of dlopen(3).) │ │ │ │ @@ -29428,45 +29413,14 @@ │ │ │ │ (return-from pop-data nil))) │ │ │ │ (pop *data*))) │ │ │ │ ;; Producer │ │ │ │ (defun push-data (data) │ │ │ │ (with-mutex (*lock*) │ │ │ │ (push data *data*) │ │ │ │ (condition-notify *queue*))) │ │ │ │ -Insert a barrier in the code stream, preventing some sort of │ │ │ │ -reordering. │ │ │ │ -KIND should be one of: │ │ │ │ - :COMPILER │ │ │ │ - Prevent the compiler from reordering memory access across the │ │ │ │ - barrier. │ │ │ │ - :MEMORY │ │ │ │ - Prevent the cpu from reordering any memory access across the │ │ │ │ - barrier. │ │ │ │ - Prevent the cpu from reordering any read access across the │ │ │ │ - barrier. │ │ │ │ - :WRITE │ │ │ │ - Prevent the cpu from reordering any write access across the │ │ │ │ - barrier. │ │ │ │ - :DATA-DEPENDENCY │ │ │ │ - Prevent the cpu from reordering dependent memory reads across the │ │ │ │ - barrier (requiring reads before the barrier to complete before any │ │ │ │ - reads after the barrier that depend on them). This is a weaker │ │ │ │ - form of the :READ barrier. │ │ │ │ -FORMS is an implicit PROGN, evaluated before the barrier. BARRIER │ │ │ │ -returns the values of the last form in FORMS. │ │ │ │ -The file "memory-barriers.txt" in the Linux kernel documentation is │ │ │ │ -highly recommended reading for anyone programming at this level. │ │ │ │ -Unwinds from and terminates the current thread, with values from │ │ │ │ -VALUES-FORM as the results visible to JOIN-THREAD. │ │ │ │ -If current thread is the main thread of the process (see │ │ │ │ -MAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as │ │ │ │ -terminating the main thread would terminate the entire process. If │ │ │ │ -ALLOW-EXIT is true, returning from the main thread is equivalent to │ │ │ │ -calling SB-EXT:EXIT with :CODE 0 and :ABORT NIL. │ │ │ │ -See also: ABORT-THREAD and SB-EXT:EXIT. │ │ │ │ Name of the thread. Can be assigned to using SETF. A thread name must be │ │ │ │ a simple-string (not necessarily unique) or NIL. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Returns the current count of the semaphore INSTANCE. │ │ │ │ Returns the main thread of the process. │ │ │ │ Create a waitqueue. │ │ │ │ Create a new thread of NAME that runs FUNCTION with the argument │ │ │ │ @@ -29490,14 +29444,48 @@ │ │ │ │ e~u 3]ET │ │ │ │ +r[r{Ppk │ │ │ │ brGk_S4a │ │ │ │ ?Dl3DDDH │ │ │ │ pE]t->|= │ │ │ │ fmt$6VMOY9 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +Insert a barrier in the code stream, preventing some sort of │ │ │ │ +reordering. │ │ │ │ +KIND should be one of: │ │ │ │ + :COMPILER │ │ │ │ + Prevent the compiler from reordering memory access across the │ │ │ │ + barrier. │ │ │ │ + :MEMORY │ │ │ │ + Prevent the cpu from reordering any memory access across the │ │ │ │ + barrier. │ │ │ │ + Prevent the cpu from reordering any read access across the │ │ │ │ + barrier. │ │ │ │ + :WRITE │ │ │ │ + Prevent the cpu from reordering any write access across the │ │ │ │ + barrier. │ │ │ │ + :DATA-DEPENDENCY │ │ │ │ + Prevent the cpu from reordering dependent memory reads across the │ │ │ │ + barrier (requiring reads before the barrier to complete before any │ │ │ │ + reads after the barrier that depend on them). This is a weaker │ │ │ │ + form of the :READ barrier. │ │ │ │ +FORMS is an implicit PROGN, evaluated before the barrier. BARRIER │ │ │ │ +returns the values of the last form in FORMS. │ │ │ │ +The file "memory-barriers.txt" in the Linux kernel documentation is │ │ │ │ +highly recommended reading for anyone programming at this level. │ │ │ │ +Unwinds from and terminates the current thread, with values from │ │ │ │ +VALUES-FORM as the results visible to JOIN-THREAD. │ │ │ │ +If current thread is the main thread of the process (see │ │ │ │ +MAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as │ │ │ │ +terminating the main thread would terminate the entire process. If │ │ │ │ +ALLOW-EXIT is true, returning from the main thread is equivalent to │ │ │ │ +calling SB-EXT:EXIT with :CODE 0 and :ABORT NIL. │ │ │ │ +See also: ABORT-THREAD and SB-EXT:EXIT. │ │ │ │ +;@MVwl_$$ │ │ │ │ +fWS5PW:0c │ │ │ │ +%:t{_@)H& │ │ │ │ Signals a timeout condition while inhibiting further timeouts due to │ │ │ │ deadlines while the condition is being handled. │ │ │ │ ^h]h]h]h] │ │ │ │ BrZ8U4Ix| │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ gf+-Yto)e │ │ │ │ OPERATION │ │ │ │ @@ -29518,19 +29506,14 @@ │ │ │ │ 95_ry.Jpb │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ COMMON-LISP │ │ │ │ Removes NAME's encapsulation of the specified TYPE if such exists. │ │ │ │ 1*`o:00[*>>k(~>O │ │ │ │ ^h]h]h]h │ │ │ │ 0)Pu:P4J │ │ │ │ +public: algorithms for Unicode data │ │ │ │ +PACKED-INFO- │ │ │ │ :6OD!=9z │ │ │ │ d!K"-`*G │ │ │ │ BrZ8S4Ix| │ │ │ │ +]>c.N>s,n>WZ │ │ │ │ *'`o:p!e │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ 95_ry.Jpb │ │ │ │ @@ -29626,18 +29613,14 @@ │ │ │ │ +%a-p,WTJR │ │ │ │ COMMON-LISP0 │ │ │ │ 95_ry.Jpb │ │ │ │ COMMON-LISP │ │ │ │ 0)Pu:P4J │ │ │ │ =c\YAYX= │ │ │ │ )>15=gOl │ │ │ │ -public: algorithms for Unicode data │ │ │ │ -PACKED-INFO- │ │ │ │ -BITMAP-ALL-TAGGEDP │ │ │ │ -POSSIBLY-RATIONAL │ │ │ │ DEYPl B{ER │ │ │ │ 7-[ZM^[Z5 │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ COMMON-LISP0 │ │ │ │ STRING-DESIGNATORS │ │ │ │ REPLACEMENT-SPEC │ │ │ │ @@ -29686,14 +29669,16 @@ │ │ │ │ REST-ARG │ │ │ │ 0)Pu:P4J │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ rK((pm:|] │ │ │ │ 7-[ZM^[Z5 │ │ │ │ COMMON-LISP │ │ │ │ +BITMAP-ALL-TAGGEDP │ │ │ │ +POSSIBLY-RATIONAL │ │ │ │ 1)`o:00+Pu:0s │ │ │ │ L #a2ZXi │ │ │ │ ARGUMENT-LIST │ │ │ │ COMMON-LISP │ │ │ │ vYZ7Pos0 │ │ │ │ 158E/*5KNy │ │ │ │ + PREDICATE │ │ │ │ +COMMON-LISP │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP8 │ │ │ │ IAAr0'LM │ │ │ │ ESCAPE-CHAR0 │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ U~J?`oc │ │ │ │ Receive pending events on all FD-STREAMS and dispatch to the appropriate │ │ │ │ handler functions. If timeout is specified, server will wait the specified │ │ │ │ @@ -29790,63 +29793,44 @@ │ │ │ │ |2U&KI,5 │ │ │ │ UNIX-TIME0 │ │ │ │ %;d's-DCr" │ │ │ │ fmt$7S4X4M │ │ │ │ fmt$5ZBLT2 │ │ │ │ fmt$8OGHUT │ │ │ │ fmt$31D577 │ │ │ │ - PREDICATE │ │ │ │ -COMMON-LISP │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP8 │ │ │ │ -))pO:|R\U │ │ │ │ -close_current_thread_tlab │ │ │ │ -close_code_region │ │ │ │ -sb_get_os_thread_id │ │ │ │ -wifcontinued │ │ │ │ -wifstopped │ │ │ │ -unlockpt │ │ │ │ -wait_for_exec │ │ │ │ -gc_pathfind │ │ │ │ -gc_and_save │ │ │ │ -~&Evaluation took: │ │ │ │ -~@< ~@;~// of real time │ │ │ │ -~// of total run time (~@// user, ~@// system) │ │ │ │ -~[[ Real times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ -~;~2*~]~[[ Run times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ -~;~2*~]~,2F% CPU │ │ │ │ -~@[~:D form~:P interpreted │ │ │ │ -~]~@[~:D lambda~:P converted │ │ │ │ -~]~@[~:D processor cycles │ │ │ │ -~]~@[~:D page fault~:P │ │ │ │ -~]~:D bytes consed │ │ │ │ -before it was aborted by a non-local transfer of control. │ │ │ │ - NEW-VALUE │ │ │ │ - NEW-VALUE │ │ │ │ g[[[[[[[[[ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ 95_ry.Jpb │ │ │ │ 1!C0I9so │ │ │ │ COMPILER-P │ │ │ │ 1*`o:00+" │ │ │ │ COMMON-LISP │ │ │ │ REPLACEMENT │ │ │ │ -DEFINITION-SOURCE-LOCATION- │ │ │ │ Wm4JmRL)1O │ │ │ │ `pMp0>fX │ │ │ │ db89(`$ │ │ │ │ bt%+(`$ u │ │ │ │ 8\3K/';x │ │ │ │ COMMON-LISP │ │ │ │ s_UU+,: │ │ │ │ COMMON-LISP │ │ │ │ J!2e5?gE │ │ │ │ HASH-FUN-STATE │ │ │ │ COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ e=P"MQ41A │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ TYPE-SPEC │ │ │ │ COMMON-LISP │ │ │ │ fmt$19F7UE │ │ │ │ fmt$3EAFX │ │ │ │ EXTERNAL-FORMAT │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ 9/ce\B>@ │ │ │ │ -~#[~;Use ~// instead.~;Use ~// or ~// instead.~:;Use~@{~#[~; or~] ~//~^,~} instead.~] │ │ │ │ -~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ -~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ -Not a function type: ~// │ │ │ │ ^h]h]h]h] │ │ │ │ OPTIONAL-ARGS │ │ │ │ K-Bi@gx> │ │ │ │ 3{Z+2DLH$Dw │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ 5?9Llk<( │ │ │ │ fmt$ILOT5 │ │ │ │ fmt$2Z388B │ │ │ │ N-BUCKETS │ │ │ │ ?-Pu:03W │ │ │ │ COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ BN0(Pu:P4J │ │ │ │ CAPACITY │ │ │ │ YJXZ&#ay │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ 8XJB_`6w^ │ │ │ │ comma-dot │ │ │ │ comma-at │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ +"O4+Pu:03 │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ PACKAGE-DESIGNATORS │ │ │ │ ARGUMENTS │ │ │ │ REST-ARG │ │ │ │ @@ -29956,19 +29936,23 @@ │ │ │ │ CONTROL-STRING │ │ │ │ REST-ARG │ │ │ │ (pia?"\ │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +~#[~;Use ~// instead.~;Use ~// or ~// instead.~:;Use~@{~#[~; or~] ~//~^,~} instead.~] │ │ │ │ +~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ +~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ +Not a function type: ~// │ │ │ │ +~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ HVssssss │ │ │ │ HASHSET0 │ │ │ │ 95_ry.Jpb │ │ │ │ -"O4+Pu:03 │ │ │ │ AUX-SYMBOL │ │ │ │ p'(`"rNw │ │ │ │ PRIORITY-QUEUE0, │ │ │ │ Return the item in PRIORITY-QUEUE with the largest key. │ │ │ │ 7)`W:00 │ │ │ │ EF-ENTRY │ │ │ │ ^h]h]h]h │ │ │ │ @@ -29981,14 +29965,15 @@ │ │ │ │ fmt$GZKEW │ │ │ │ fmt$OV00O │ │ │ │ fmt$7PE5H5 │ │ │ │ fmt$7COG3Y │ │ │ │ fmt$RV9EI │ │ │ │ dJ22J*f% │ │ │ │ COMMON-LISP │ │ │ │ +DEFINITION-SOURCE-LOCATION- │ │ │ │ COMMON-LISP │ │ │ │ Test for the ANSI concept "stream associated with a file". │ │ │ │ Return NIL or the underlying FILE-STREAM. │ │ │ │ fmt$2BMP9A │ │ │ │ fmt$39IWFF │ │ │ │ COMMON-LISP │ │ │ │ Kwfenu52G │ │ │ │ @@ -30011,21 +29996,14 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ DEFINITION8 │ │ │ │ COMMON-LISP0" │ │ │ │ COMMON-LISP0 │ │ │ │ $9ru~^rt │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -HYe&-?=P% │ │ │ │ -Q=,Pu:pf │ │ │ │ -Gr'XhN3% │ │ │ │ -!\uTfQIA │ │ │ │ - P!fYQi9 │ │ │ │ -yI*gfdjb^ │ │ │ │ -#nO'"dSt │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP │ │ │ │ ORIGINAL │ │ │ │ "* { W-W │ │ │ │ EOF-VAL- │ │ │ │ COMMON-LISP │ │ │ │ READTABLE │ │ │ │ @@ -30033,30 +30011,40 @@ │ │ │ │ READTABLE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE0 │ │ │ │ d^.zrUPY │ │ │ │ COMMON-LISP │ │ │ │ +Q=,Pu:pf │ │ │ │ twentieth │ │ │ │ thirtieth │ │ │ │ fortieth │ │ │ │ fiftieth │ │ │ │ sixtieth │ │ │ │ seventieth │ │ │ │ eightieth │ │ │ │ ninetieth │ │ │ │ thirteen │ │ │ │ fourteen │ │ │ │ seventeen │ │ │ │ eighteen │ │ │ │ nineteen │ │ │ │ + P!fYQi9 │ │ │ │ +yI*gfdjb^ │ │ │ │ +Gr'XhN3% │ │ │ │ E!TS)N)=jO │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +HYe&-?=P% │ │ │ │ +!\uTfQIA │ │ │ │ +#nO'"dSt │ │ │ │ +Define a function at top level. │ │ │ │ +LAMBDA-LIST │ │ │ │ +NEXT-VAR │ │ │ │ U1$}TW-u │ │ │ │ COMMON-LISP │ │ │ │ SYMBOLS8 │ │ │ │ thousand │ │ │ │ million │ │ │ │ billion │ │ │ │ trillion │ │ │ │ @@ -30128,22 +30116,18 @@ │ │ │ │ :TRACE-FILE │ │ │ │ If given, internal data structures are dumped to the specified │ │ │ │ file, or if a value of T is given, to a file of *.trace type │ │ │ │ derived from the input file name. (non-standard) │ │ │ │ :EMIT-CFASL │ │ │ │ (Experimental). If true, outputs the toplevel compile-time effects │ │ │ │ of this file into a separate .cfasl file. │ │ │ │ +SAW-LAST │ │ │ │ +LVAR-SINGLE-VALUE-P │ │ │ │ +FUNCTIONAL-LETLIKE-P │ │ │ │ SOURCE-LOC │ │ │ │ -Define a function at top level. │ │ │ │ -LAMBDA-LIST │ │ │ │ -NEXT-VAR │ │ │ │ -Move SRC into DST unless they are location=. │ │ │ │ - ARGUMENTS │ │ │ │ -GENERIC-FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ NOTE-THIS-LOCATION VOP Kind │ │ │ │ Note that the current code location is an interesting (to the debugger) │ │ │ │ location of the specified Kind. VOP is the VOP responsible for this code. │ │ │ │ This VOP must specify some non-null :SAVE-P value (perhaps :COMPUTE-ONLY) so │ │ │ │ that the live set is computed. │ │ │ │ FALL-THRU-P │ │ │ │ START-LABEL │ │ │ │ @@ -30157,14 +30141,18 @@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ DEPRECATED-NAMES8 │ │ │ │ SITUATIONS │ │ │ │ SC+OFFSET │ │ │ │ OPTIONAL-ARGS │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ 6ikdlXPJ │ │ │ │ +Move SRC into DST unless they are location=. │ │ │ │ + ARGUMENTS │ │ │ │ +GENERIC-FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ E96x_Qt(8o │ │ │ │ @@ -30189,37 +30177,14 @@ │ │ │ │ SB-ALIEN0 │ │ │ │ f,'_iPRn' │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP0 │ │ │ │ CONTEXT0 │ │ │ │ (llACB+Z │ │ │ │ }&(@D`,y │ │ │ │ -~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ -violating package lock on ~// │ │ │ │ -using the lexical binding of the symbol ~//, not the │ │ │ │ -dynamic binding │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -It allows an unknown number of values, consider using │ │ │ │ -Type assertion too complex to check efficiently: │ │ │ │ -It allows a variable number of values, consider using │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -undefined ~(~A~): ~// │ │ │ │ -SAW-LAST │ │ │ │ -LVAR-SINGLE-VALUE-P │ │ │ │ -FUNCTIONAL-LETLIKE-P │ │ │ │ -ELEMENT-CTYPE │ │ │ │ C6xDkZaqx~H │ │ │ │ 8c\9qJD$ul │ │ │ │ tHpVAan[ │ │ │ │ REST-ARG │ │ │ │ fQ<*Pu:0Ef& │ │ │ │ oqGV##^M │ │ │ │ COMPONENT │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +REST-ARG │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +REST-ARG │ │ │ │ +(pHPk< U │ │ │ │ +REST-ARG │ │ │ │ +ELEMENT-CTYPE │ │ │ │ +violating package lock on ~// │ │ │ │ +using the lexical binding of the symbol ~//, not the │ │ │ │ +dynamic binding │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +It allows an unknown number of values, consider using │ │ │ │ +Type assertion too complex to check efficiently: │ │ │ │ +It allows a variable number of values, consider using │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +undefined ~(~A~): ~// │ │ │ │ +The result type from ~A: │ │ │ │ +conflicts with the definition's result type: │ │ │ │ fixnum untagging │ │ │ │ constant load │ │ │ │ integer to untagged word coercion │ │ │ │ fixnum tagging │ │ │ │ signed word to integer coercion │ │ │ │ unsigned word to integer coercion │ │ │ │ word integer move │ │ │ │ @@ -30260,22 +30254,14 @@ │ │ │ │ SAP argument move │ │ │ │ character untagging │ │ │ │ character tagging │ │ │ │ character move │ │ │ │ character arg move │ │ │ │ inline (unsigned-byte 32) logcount │ │ │ │ more-arg-context │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -REST-ARG │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -REST-ARG │ │ │ │ -(pHPk< U │ │ │ │ -REST-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ m#N_b63(sod │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Pii4DHhS"2 │ │ │ │ @@ -30330,25 +30316,25 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ bL,(`o:02 │ │ │ │ CONDITION │ │ │ │ COMMON-LISP8 │ │ │ │ SPECIFIER │ │ │ │ REST-ARG │ │ │ │ -SYS:SRC;COMPILER;LTV.LISP │ │ │ │ L+&`o:010 │ │ │ │ COMMON-LISP │ │ │ │ DS-LAMBDA-LIST0 │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMBINATION0 │ │ │ │ 2_,-s\] │ │ │ │ +SYS:SRC;COMPILER;LTV.LISP │ │ │ │ REST-ARG │ │ │ │ 8MKg0j}J │ │ │ │ "1EDf!Nk │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ │ │ │ │ >73333l_ │ │ │ │ o;0[m │ │ │ │ ENTRY-POINTS0 │ │ │ │ @@ -30389,37 +30373,25 @@ │ │ │ │ %If-a6_? │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ e/+}5OF_ │ │ │ │ 2YDj~mhj │ │ │ │ REST-ARG │ │ │ │ +Automagically generated boolean attribute creation function. │ │ │ │ + See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ %yUk{45Ki │ │ │ │ _\M3,8wB │ │ │ │ Pf5>:\Yp( │ │ │ │ CLOSURE SB-KERNEL0 │ │ │ │ RETURN-PC-PASS8) │ │ │ │ @yr%or&_r' │ │ │ │ -setting the symbol-function of ~A │ │ │ │ -setting the compiler-macro-function of ~A │ │ │ │ -can't SETF COMPILER-MACRO-FUNCTION when ENV is non-NIL │ │ │ │ -Using ~A as the class-name argument in ~ │ │ │ │ - (SETF FIND-CLASS) │ │ │ │ -encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ -4E4i4<4`4 │ │ │ │ -*9@9d979[9. │ │ │ │ -Syscall poll(2) failed: ~A │ │ │ │ -~S is not an early-method. │ │ │ │ -No slot called ~S in ~S. │ │ │ │ -Cannot look up slot-definition for ~S in ~S (too early to finalize.) │ │ │ │ -~@ │ │ │ │ -JMi ? 7 -$ │ │ │ │ COMMON-LISP0 │ │ │ │ COMPONENT │ │ │ │ REST-ARG │ │ │ │ DS-LAMBDA-LIST │ │ │ │ $*|uf,GC │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -30471,36 +30443,39 @@ │ │ │ │ /"(`$ hF │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ bO5+`o:P │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP0" │ │ │ │ REST-ARG │ │ │ │ +~a{.>iB/ │ │ │ │ j:Fc4#26) │ │ │ │ REST-ARG │ │ │ │ N4,Pu:03 │ │ │ │ Extract SIZE lower bits from INTEGER, considering them as a │ │ │ │ 2-complement SIZE-bits representation of a signed integer. │ │ │ │ REST-ARG │ │ │ │ MORE-OPS0 │ │ │ │ SB-ALIEN │ │ │ │ f*Af%sf6 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INTERVAL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ (@F`lu@; │ │ │ │ +ORIGINAL-FUN │ │ │ │ +LVAR-KIND │ │ │ │ +TARGET-ENV │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ NEW-BLOCK │ │ │ │ SB-ALIEN │ │ │ │ NAME-KEY83 │ │ │ │ R/l90)jK │ │ │ │ -~a{.>iB/ │ │ │ │ REST-ARG │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ mz(i&$BB │ │ │ │ @@ -30518,18 +30493,16 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ ZxA2>&]f │ │ │ │ ITEM-TYPE0 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ COMPONENT │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ +SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ REST-ARG │ │ │ │ -degraded │ │ │ │ -ORIGINAL-FUN │ │ │ │ -LVAR-KIND │ │ │ │ REST-ARG │ │ │ │ B,PW:0333S │ │ │ │ Q`k#,/vY │ │ │ │ 1\oV3Ndf) │ │ │ │ COMMON-LISP8O │ │ │ │ REST-ARG │ │ │ │ .k5UUU->::: │ │ │ │ @@ -30539,15 +30512,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ NEW-INLINEP │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ [qxh)j)xh │ │ │ │ *EUN R\M │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -TARGET-ENV │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ H[(tPD@LU │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ @@ -30607,27 +30579,14 @@ │ │ │ │ A:"RTP(m │ │ │ │ \^}Sde9xu%cV │ │ │ │ M1)Pu: W │ │ │ │ REST-ARG │ │ │ │ 'Gl`QMQ.qd │ │ │ │ BRANCH-IF0 │ │ │ │ COMMON-LISP0 │ │ │ │ -The result type from ~A: │ │ │ │ -conflicts with the definition's result type: │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~:[This~;~:*~A~] is not a ~< │ │ │ │ -~9T~:;~//:~> │ │ │ │ -~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ -~9T~:;not a ~//.~> │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~S can't be used to initialize an array of type ~//. │ │ │ │ - ~V@<~//~> │ │ │ │ -The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ CURRENT-FP SB-KERNEL │ │ │ │ @@ -30636,25 +30595,36 @@ │ │ │ │ })o'}V,* │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ SLzAkfqZ~ │ │ │ │ y\Rh]vA- │ │ │ │ PRIMITIVE-TYPE0" │ │ │ │ e/afzbr" │ │ │ │ -without-hashing │ │ │ │ -COMPONENT-LAMBDA │ │ │ │ -COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ -N-SIMPLE-FUNS │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~:[This~;~:*~A~] is not a ~< │ │ │ │ +~9T~:;~//:~> │ │ │ │ +~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ +~9T~:;not a ~//.~> │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~S can't be used to initialize an array of type ~//. │ │ │ │ + ~V@<~//~> │ │ │ │ +The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ REST-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ -SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;CELL.LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8/ │ │ │ │ REST-ARG │ │ │ │ +COMPONENT-LAMBDA │ │ │ │ +COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ +N-SIMPLE-FUNS │ │ │ │ +PREV-KIND │ │ │ │ +degraded │ │ │ │ +without-hashing │ │ │ │ COMMON-LISP │ │ │ │ >-Pu:0W# │ │ │ │ ?L1FMDDhI │ │ │ │ SB-ALIEN │ │ │ │ LTN-POLICY02 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -30666,23 +30636,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ &M(}xc;p │ │ │ │ MORE-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ -Automagically generated boolean attribute setter. See │ │ │ │ - !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ -Automagically generated boolean attribute test function. │ │ │ │ - See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ -CONTEXT0 │ │ │ │ -COMMON-LISP │ │ │ │ -ELIDE-IF │ │ │ │ -SB-ASSEM0 │ │ │ │ -PA-BITS-EA │ │ │ │ CODE-OBJ │ │ │ │ MNPX&+Au │ │ │ │ .O8`2100 │ │ │ │ REST-ARG │ │ │ │ AGe2ZgWh[ │ │ │ │ FOR-VALUE │ │ │ │ FORM SB-KERNEL │ │ │ │ @@ -30690,25 +30651,30 @@ │ │ │ │ V1%:HjSk! │ │ │ │ &WBIiH%! │ │ │ │ 86543210/.d0 │ │ │ │ :JA@DV+ │ │ │ │ MORE-ARG │ │ │ │ ,/z-3?tY* │ │ │ │ Rlx!gc*tF │ │ │ │ +Automagically generated boolean attribute setter. See │ │ │ │ + !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ +Automagically generated boolean attribute test function. │ │ │ │ + See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ +CONTEXT0 │ │ │ │ +COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ TUUGQCpi │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ R)D|gT$M. │ │ │ │ 0a{[xCD; │ │ │ │ FUN-NAME │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -PREV-KIND │ │ │ │ 03((T:HS │ │ │ │ ENVIRONMENT0 │ │ │ │ ~CsAzm6Dw\ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SOURCE-INFO │ │ │ │ @@ -30747,19 +30713,41 @@ │ │ │ │ BYTES-PER-ELEMENT │ │ │ │ DATA-OFFSET │ │ │ │ ELEMENT-SIZE │ │ │ │ WD3""""" │ │ │ │ CONTENT-LENGTH │ │ │ │ COMMON-LISP │ │ │ │ 7 &9 {symbol-name}*) │ │ │ │ + (SHADOW {symbol-name}*) │ │ │ │ + (SHADOWING-IMPORT-FROM {symbol-name}*) │ │ │ │ + (LOCAL-NICKNAMES {(local-nickname actual-package-name)}*) │ │ │ │ + (LOCK boolean) │ │ │ │ + (IMPLEMENT {package-name}*) │ │ │ │ + (DOCUMENTATION doc-string) │ │ │ │ + (INTERN {symbol-name}*) │ │ │ │ + (SIZE ) │ │ │ │ + (NICKNAMES {package-name}*) │ │ │ │ + All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple │ │ │ │ + times. │ │ │ │ +Place may be any place expression acceptable to SETF, and is expected │ │ │ │ + to hold a property list or (). This list is destructively altered to │ │ │ │ + remove the property specified by the indicator. Returns T if such a │ │ │ │ + property was present, NIL if not. │ │ │ │ +(HANDLER-BIND ( {(type handler)}* ) body) │ │ │ │ +Executes body in a dynamic context where the given handler bindings are in │ │ │ │ +effect. Each handler must take the condition being signalled as an argument. │ │ │ │ +The bindings are searched first to last in the event of a signalled │ │ │ │ +condition. │ │ │ │ +defining ~A as a method combination │ │ │ │ +DECLAIM Declaration* │ │ │ │ + Do a declaration or declarations for the global environment. │ │ │ │ +Within the lexical scope of the body forms, MNAME is defined via macrolet │ │ │ │ +such that successive invocations of (MNAME) will return the symbols, one by │ │ │ │ +one, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be any │ │ │ │ +of :INHERITED :EXTERNAL :INTERNAL. │ │ │ │ +Group some output into a logical block. STREAM-SYMBOL should be either a │ │ │ │ + stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer │ │ │ │ + control variable *PRINT-LEVEL* is automatically handled. │ │ │ │ +CONTEXT0 │ │ │ │ +COMMON-LISP │ │ │ │ +Pr&nF20ss │ │ │ │ +(RESTART-BIND ({(case-name function {keyword value}*)}*) forms) │ │ │ │ + Executes forms in a dynamic context where the given bindings are in │ │ │ │ + effect. Users probably want to use RESTART-CASE. A case-name of NIL │ │ │ │ + indicates an anonymous restart. When bindings contain the same │ │ │ │ + restart name, FIND-RESTART will find the first such binding. │ │ │ │ +TYPECASE Keyform {(Type Form*)}* │ │ │ │ + Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ + is true. │ │ │ │ +COMMON-LISP0A │ │ │ │ +Affects compilations that take place within its dynamic extent. It is │ │ │ │ +intended to be eg. wrapped around the compilation of all files in the same system. │ │ │ │ +Following options are defined: │ │ │ │ + :OVERRIDE Boolean-Form │ │ │ │ + One of the effects of this form is to delay undefined warnings until the │ │ │ │ + end of the form, instead of giving them at the end of each compilation. │ │ │ │ + If OVERRIDE is NIL (the default), then the outermost │ │ │ │ + WITH-COMPILATION-UNIT form grabs the undefined warnings. Specifying │ │ │ │ + OVERRIDE true causes that form to grab any enclosed warnings, even if it │ │ │ │ + is enclosed by another WITH-COMPILATION-UNIT. │ │ │ │ + :POLICY Optimize-Declaration-Form │ │ │ │ + Provides dynamic scoping for global compiler optimization qualities and │ │ │ │ + restrictions, limiting effects of subsequent OPTIMIZE proclamations and │ │ │ │ + calls to SB-EXT:RESTRICT-COMPILER-POLICY to the dynamic scope of BODY. │ │ │ │ + If OVERRIDE is false, specified POLICY is merged with current global │ │ │ │ + policy. If OVERRIDE is true, current global policy, including any │ │ │ │ + restrictions, is discarded in favor of the specified POLICY. │ │ │ │ + Supplying POLICY NIL is equivalent to the option not being supplied at │ │ │ │ + all, ie. dynamic scoping of policy does not take place. │ │ │ │ + This option is an SBCL-specific experimental extension: Interface │ │ │ │ + subject to change. │ │ │ │ + :SOURCE-NAMESTRING Namestring-Form │ │ │ │ + Attaches the value returned by the Namestring-Form to the internal │ │ │ │ + debug-source information as the namestring of the source file. Normally │ │ │ │ + the namestring of the input-file for COMPILE-FILE is used: this option │ │ │ │ + can be used to provide source-file information for functions compiled │ │ │ │ + using COMPILE, or to override the input-file of COMPILE-FILE. │ │ │ │ + If both an outer and an inner WITH-COMPILATION-UNIT provide a │ │ │ │ + SOURCE-NAMESTRING, the inner one takes precedence. Unaffected │ │ │ │ + by :OVERRIDE. │ │ │ │ + This is an SBCL-specific extension. │ │ │ │ + :SOURCE-PLIST Plist-Form │ │ │ │ + Attaches the value returned by the Plist-Form to internal debug-source │ │ │ │ + information of functions compiled in within the dynamic extent of BODY. │ │ │ │ + Primarily for use by development environments, in order to eg. associate │ │ │ │ + function definitions with editor-buffers. Can be accessed using │ │ │ │ + SB-INTROSPECT:DEFINITION-SOURCE-PLIST. │ │ │ │ + If an outer WITH-COMPILATION-UNIT form also provide a SOURCE-PLIST, it │ │ │ │ + is appended to the end of the provided SOURCE-PLIST. Unaffected │ │ │ │ + by :OVERRIDE. │ │ │ │ + This is an SBCL-specific extension. │ │ │ │ +Examples: │ │ │ │ + ;; Prevent proclamations from the file leaking, and restrict │ │ │ │ + ;; SAFETY to 3 -- otherwise uses the current global policy. │ │ │ │ + (with-compilation-unit (:policy '(optimize)) │ │ │ │ + (restrict-compiler-policy 'safety 3) │ │ │ │ + (load "foo.lisp")) │ │ │ │ + ;; Using default policy instead of the current global one, │ │ │ │ + ;; except for DEBUG 3. │ │ │ │ + (with-compilation-unit (:policy '(optimize debug) │ │ │ │ + :override t) │ │ │ │ + (load "foo.lisp")) │ │ │ │ + ;; Same as if :POLICY had not been specified at all: SAFETY 3 │ │ │ │ + ;; proclamation leaks out from WITH-COMPILATION-UNIT. │ │ │ │ + (with-compilation-unit (:policy nil) │ │ │ │ + (declaim (optimize safety)) │ │ │ │ + (load "foo.lisp")) │ │ │ │ +Takes any number of SETF-style place expressions. Evaluates all of the │ │ │ │ + expressions in turn, then assigns to each place the value of the form to │ │ │ │ + its right. The rightmost form gets the value of the leftmost. │ │ │ │ + Returns NIL. │ │ │ │ +TRACE {Option Global-Value}* {Name {Option Value}*}* │ │ │ │ +TRACE is a debugging tool that provides information when specified │ │ │ │ +functions are called. In its simplest form: │ │ │ │ + (TRACE NAME-1 NAME-2 ...) │ │ │ │ +The NAMEs are not evaluated. Each may be one of the following: │ │ │ │ + * SYMBOL, denoting a function or macro. │ │ │ │ + * FNAME, a valid function name, denoting a function. │ │ │ │ + * (METHOD FNAME QUALIFIERS* (SPECIALIZERS*)) denoting a method. │ │ │ │ + * (COMPILER-MACRO SYMBOL) denoting a compiler macro. │ │ │ │ + * (LABELS FNAME :IN OUTER-NAME) or (FLET FNAME :IN OUTER-NAME) │ │ │ │ + denoting a local function where OUTER-NAME may be any of the │ │ │ │ + previous names for functions, macros, methods or compiler macros. │ │ │ │ + Tracing local functions may require DEBUG policy 3 to inhibit │ │ │ │ + inlining. │ │ │ │ + * STRING denoting all functions fbound to symbols whose home package │ │ │ │ + is the package with the given name. │ │ │ │ +Options allow modification of the default behavior. Each option is a │ │ │ │ +pair of an option keyword and a value form. Global options are │ │ │ │ +specified before the first name, and affect all functions traced by a │ │ │ │ +given use of TRACE. Options may also be interspersed with function │ │ │ │ +names, in which case they act as local options, only affecting tracing │ │ │ │ +of the immediately preceding function name. Local options override │ │ │ │ +global options. │ │ │ │ +By default, TRACE causes a printout on *TRACE-OUTPUT* each time that │ │ │ │ +one of the named functions is entered or returns. (This is the basic, │ │ │ │ +ANSI Common Lisp behavior of TRACE.) │ │ │ │ +The following options are defined: │ │ │ │ + :REPORT Report-Type │ │ │ │ + If Report-Type is TRACE (the default) then information is │ │ │ │ + reported by printing immediately. If Report-Type is NIL, then │ │ │ │ + the only effect of the trace is to execute other │ │ │ │ + options (e.g. PRINT or BREAK). Otherwise, Report-Type is │ │ │ │ + treated as a function designator and, for each trace event, │ │ │ │ + funcalled with 5 arguments: trace depth (a non-negative │ │ │ │ + integer), a function name or a function object, a │ │ │ │ + keyword (:ENTER, :EXIT or :NON-LOCAL-EXIT), a stack frame, and │ │ │ │ + a list of values (arguments or return values). │ │ │ │ + :CONDITION Form │ │ │ │ + :CONDITION-AFTER Form │ │ │ │ + :CONDITION-ALL Form │ │ │ │ + If :CONDITION is specified, then TRACE does nothing unless Form │ │ │ │ + evaluates to true at the time of the call. :CONDITION-AFTER is │ │ │ │ + similar, but suppresses the initial printout, and is tested when the │ │ │ │ + function returns. :CONDITION-ALL tries both before and after. │ │ │ │ + :BREAK Form │ │ │ │ + :BREAK-AFTER Form │ │ │ │ + :BREAK-ALL Form │ │ │ │ + If specified, and Form evaluates to true, then the debugger is invoked │ │ │ │ + at the start of the function, at the end of the function, or both, │ │ │ │ + according to the respective option. │ │ │ │ + :PRINT Form │ │ │ │ + :PRINT-AFTER Form │ │ │ │ + :PRINT-ALL Form │ │ │ │ + In addition to the usual printout, the result of evaluating Form is │ │ │ │ + printed at the start of the function, at the end of the function, or │ │ │ │ + both, according to the respective option. Multiple print options cause │ │ │ │ + multiple values to be printed. │ │ │ │ + :WHEREIN Names │ │ │ │ + If specified, Names is a function name or list of names. TRACE does │ │ │ │ + nothing unless a call to one of those functions encloses the call to │ │ │ │ + this function (i.e. it would appear in a backtrace.) Anonymous │ │ │ │ + functions have string names like "DEFUN FOO". │ │ │ │ + :ENCAPSULATE {:DEFAULT | T | NIL} │ │ │ │ + If T, the default, tracing is done via encapsulation (redefining the │ │ │ │ + function name) rather than by modifying the function. :DEFAULT is │ │ │ │ + not the default, but means to use encapsulation for interpreted │ │ │ │ + functions and funcallable instances, breakpoints otherwise. When │ │ │ │ + encapsulation is used, forms are *not* evaluated in the function's │ │ │ │ + lexical environment, but SB-DEBUG:ARG can still be used. │ │ │ │ + :METHODS {T | NIL} │ │ │ │ + If T, any function argument naming a generic function will have its │ │ │ │ + methods traced in addition to the generic function itself. │ │ │ │ + :FUNCTION Function-Form │ │ │ │ + This is a not really an option, but rather another way of specifying │ │ │ │ + what function to trace. The Function-Form is evaluated immediately, │ │ │ │ + and the resulting function is traced. │ │ │ │ +:CONDITION, :BREAK and :PRINT forms are evaluated in a context which │ │ │ │ +mocks up the lexical environment of the called function, so that │ │ │ │ +SB-DEBUG:VAR and SB-DEBUG:ARG can be used. │ │ │ │ +The -AFTER and -ALL forms can use also use SB-DEBUG:ARG. In forms │ │ │ │ +which are evaluated after the function call, (SB-DEBUG:ARG N) returns │ │ │ │ +the N-th value returned by the function. │ │ │ │ Return the 10th object in a list or NIL if there is no 10th object. │ │ │ │ Return T if the arguments are in strictly non-increasing alphabetic order. │ │ │ │ Case is ignored. │ │ │ │ Add ITEM to LIST unless it is already a member │ │ │ │ Return the macro character function for SUB-CHAR under DISP-CHAR │ │ │ │ or NIL if there is no associated function. │ │ │ │ Perform a bit-wise LOGNAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, │ │ │ │ @@ -31069,14 +31216,44 @@ │ │ │ │ If HOST is already defined as logical pathname host, no file is loaded and NIL │ │ │ │ is returned. │ │ │ │ The file should contain a single form, suitable for use with │ │ │ │ (SETF LOGICAL-PATHNAME-TRANSLATIONS). │ │ │ │ Note: behaviour of this function is highly implementation dependent, and │ │ │ │ historically it used to be a no-op in SBCL -- the current approach is somewhat │ │ │ │ experimental and subject to change. │ │ │ │ +Specifies that the values returned by FORM conform to the VALUE-TYPE. │ │ │ │ +CLHS specifies that the consequences are undefined if any result is │ │ │ │ +not of the declared type, but SBCL treats declarations as assertions │ │ │ │ +as long as SAFETY is at least 2, in which case incorrect type │ │ │ │ +information will result in a runtime type-error instead of leading to │ │ │ │ +eg. heap corruption. This is however expressly non-portable: use │ │ │ │ +CHECK-TYPE instead of THE to catch type-errors at runtime. THE is best │ │ │ │ +considered an optimization tool to inform the compiler about types it │ │ │ │ +is unable to derive from other declared types. │ │ │ │ +LET* ({(var [value]) | var}*) declaration* form* │ │ │ │ +Similar to LET, but the variables are bound sequentially, allowing each VALUE │ │ │ │ +form to reference any of the previous VARS. │ │ │ │ +CATCH tag form* │ │ │ │ +Evaluate TAG and instantiate it as a catcher while the body forms are │ │ │ │ +evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic │ │ │ │ +scope of the body, then control will be transferred to the end of the body and │ │ │ │ +the thrown values will be returned. │ │ │ │ +MACROLET ({(name lambda-list form*)}*) body-form* │ │ │ │ +Evaluate the BODY-FORMS in an environment with the specified local macros │ │ │ │ +defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style │ │ │ │ +destructuring lambda list, and the FORMS evaluate to the expansion. │ │ │ │ +RETURN-FROM name value │ │ │ │ +Evaluate the VALUE, returning its values from the lexically enclosing │ │ │ │ +block NAME. This is constrained to be used only within the dynamic │ │ │ │ +extent of the block. │ │ │ │ +SYMBOL-MACROLET ({(name expansion)}*) decl* form* │ │ │ │ +Define the NAMES as symbol macros with the given EXPANSIONS. Within the │ │ │ │ +body, references to a NAME will effectively be replaced with the EXPANSION. │ │ │ │ +Transfer control to the named TAG in the lexically enclosing TAGBODY. This is │ │ │ │ +constrained to be used only within the dynamic extent of the TAGBODY. │ │ │ │ COMMON-LISP │ │ │ │ SCHAR returns the character object at an indexed position in a string │ │ │ │ just as CHAR does, except the string must be a simple-string. │ │ │ │ COMMON-LISP │ │ │ │ The argument must be a character object; UPPER-CASE-P returns T if the │ │ │ │ argument is an upper-case character, NIL otherwise. │ │ │ │ Return the element type that will actually be used to implement an array │ │ │ │ @@ -31223,14 +31400,17 @@ │ │ │ │ representation exploiting the assumption that floats are only accurate to │ │ │ │ their precision. RATIONALIZE (and also RATIONAL) preserve the invariant: │ │ │ │ (= x (float (rationalize x) x)) │ │ │ │ Return the write date of the file specified by PATHSPEC. │ │ │ │ An error of type FILE-ERROR is signaled if no such file exists, │ │ │ │ or if PATHSPEC is a wild pathname. │ │ │ │ iOzu)A|h5pmi │ │ │ │ +COMMON-LISP │ │ │ │ +AXIS-NUMBER │ │ │ │ +Return the length of dimension AXIS-NUMBER of ARRAY. │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the car of the cddar of a list. │ │ │ │ Return the elements of LIST1 which are not in LIST2. │ │ │ │ Return the function associated with the specified CHAR which is a macro │ │ │ │ character, or NIL if there is no such function. As a second value, return │ │ │ │ T if CHAR is a macro character which is non-terminating, i.e. which can │ │ │ │ be embedded in a symbol name. │ │ │ │ @@ -31281,301 +31461,23 @@ │ │ │ │ possibly to those with index 1, and so on. Return the first │ │ │ │ non-NIL value encountered, or NIL if the end of any sequence is reached. │ │ │ │ Substitute NEW for subtrees matching OLD. │ │ │ │ Make and return a new uninterned symbol with the same print name │ │ │ │ as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound │ │ │ │ nor fbound and has no properties, else it has a copy of SYMBOL's │ │ │ │ function, value and property list. │ │ │ │ - ACCESS-FN │ │ │ │ -Syntax like DEFMACRO, but creates a setf expander function. The body │ │ │ │ - of the definition must be a form that returns five appropriate values. │ │ │ │ -Defines a new package called PACKAGE. Each of OPTIONS should be one of the │ │ │ │ - following: │ │ │ │ - (USE {package-name}*) │ │ │ │ - (EXPORT {symbol-name}*) │ │ │ │ - (IMPORT-FROM {symbol-name}*) │ │ │ │ - (SHADOW {symbol-name}*) │ │ │ │ - (SHADOWING-IMPORT-FROM {symbol-name}*) │ │ │ │ - (LOCAL-NICKNAMES {(local-nickname actual-package-name)}*) │ │ │ │ - (LOCK boolean) │ │ │ │ - (IMPLEMENT {package-name}*) │ │ │ │ - (DOCUMENTATION doc-string) │ │ │ │ - (INTERN {symbol-name}*) │ │ │ │ - (SIZE ) │ │ │ │ - (NICKNAMES {package-name}*) │ │ │ │ - All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple │ │ │ │ - times. │ │ │ │ -Place may be any place expression acceptable to SETF, and is expected │ │ │ │ - to hold a property list or (). This list is destructively altered to │ │ │ │ - remove the property specified by the indicator. Returns T if such a │ │ │ │ - property was present, NIL if not. │ │ │ │ -(HANDLER-BIND ( {(type handler)}* ) body) │ │ │ │ -Executes body in a dynamic context where the given handler bindings are in │ │ │ │ -effect. Each handler must take the condition being signalled as an argument. │ │ │ │ -The bindings are searched first to last in the event of a signalled │ │ │ │ -condition. │ │ │ │ -DECLAIM Declaration* │ │ │ │ - Do a declaration or declarations for the global environment. │ │ │ │ -Within the lexical scope of the body forms, MNAME is defined via macrolet │ │ │ │ -such that successive invocations of (MNAME) will return the symbols, one by │ │ │ │ -one, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be any │ │ │ │ -of :INHERITED :EXTERNAL :INTERNAL. │ │ │ │ -Group some output into a logical block. STREAM-SYMBOL should be either a │ │ │ │ - stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer │ │ │ │ - control variable *PRINT-LEVEL* is automatically handled. │ │ │ │ -CONTEXT0 │ │ │ │ -COMMON-LISP │ │ │ │ -Pr&nF20ss │ │ │ │ -defining ~A as a method combination │ │ │ │ -(RESTART-BIND ({(case-name function {keyword value}*)}*) forms) │ │ │ │ - Executes forms in a dynamic context where the given bindings are in │ │ │ │ - effect. Users probably want to use RESTART-CASE. A case-name of NIL │ │ │ │ - indicates an anonymous restart. When bindings contain the same │ │ │ │ - restart name, FIND-RESTART will find the first such binding. │ │ │ │ -TYPECASE Keyform {(Type Form*)}* │ │ │ │ - Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ - is true. │ │ │ │ -COMMON-LISP0A │ │ │ │ -Affects compilations that take place within its dynamic extent. It is │ │ │ │ -intended to be eg. wrapped around the compilation of all files in the same system. │ │ │ │ -Following options are defined: │ │ │ │ - :OVERRIDE Boolean-Form │ │ │ │ - One of the effects of this form is to delay undefined warnings until the │ │ │ │ - end of the form, instead of giving them at the end of each compilation. │ │ │ │ - If OVERRIDE is NIL (the default), then the outermost │ │ │ │ - WITH-COMPILATION-UNIT form grabs the undefined warnings. Specifying │ │ │ │ - OVERRIDE true causes that form to grab any enclosed warnings, even if it │ │ │ │ - is enclosed by another WITH-COMPILATION-UNIT. │ │ │ │ - :POLICY Optimize-Declaration-Form │ │ │ │ - Provides dynamic scoping for global compiler optimization qualities and │ │ │ │ - restrictions, limiting effects of subsequent OPTIMIZE proclamations and │ │ │ │ - calls to SB-EXT:RESTRICT-COMPILER-POLICY to the dynamic scope of BODY. │ │ │ │ - If OVERRIDE is false, specified POLICY is merged with current global │ │ │ │ - policy. If OVERRIDE is true, current global policy, including any │ │ │ │ - restrictions, is discarded in favor of the specified POLICY. │ │ │ │ - Supplying POLICY NIL is equivalent to the option not being supplied at │ │ │ │ - all, ie. dynamic scoping of policy does not take place. │ │ │ │ - This option is an SBCL-specific experimental extension: Interface │ │ │ │ - subject to change. │ │ │ │ - :SOURCE-NAMESTRING Namestring-Form │ │ │ │ - Attaches the value returned by the Namestring-Form to the internal │ │ │ │ - debug-source information as the namestring of the source file. Normally │ │ │ │ - the namestring of the input-file for COMPILE-FILE is used: this option │ │ │ │ - can be used to provide source-file information for functions compiled │ │ │ │ - using COMPILE, or to override the input-file of COMPILE-FILE. │ │ │ │ - If both an outer and an inner WITH-COMPILATION-UNIT provide a │ │ │ │ - SOURCE-NAMESTRING, the inner one takes precedence. Unaffected │ │ │ │ - by :OVERRIDE. │ │ │ │ - This is an SBCL-specific extension. │ │ │ │ - :SOURCE-PLIST Plist-Form │ │ │ │ - Attaches the value returned by the Plist-Form to internal debug-source │ │ │ │ - information of functions compiled in within the dynamic extent of BODY. │ │ │ │ - Primarily for use by development environments, in order to eg. associate │ │ │ │ - function definitions with editor-buffers. Can be accessed using │ │ │ │ - SB-INTROSPECT:DEFINITION-SOURCE-PLIST. │ │ │ │ - If an outer WITH-COMPILATION-UNIT form also provide a SOURCE-PLIST, it │ │ │ │ - is appended to the end of the provided SOURCE-PLIST. Unaffected │ │ │ │ - by :OVERRIDE. │ │ │ │ - This is an SBCL-specific extension. │ │ │ │ -Examples: │ │ │ │ - ;; Prevent proclamations from the file leaking, and restrict │ │ │ │ - ;; SAFETY to 3 -- otherwise uses the current global policy. │ │ │ │ - (with-compilation-unit (:policy '(optimize)) │ │ │ │ - (restrict-compiler-policy 'safety 3) │ │ │ │ - (load "foo.lisp")) │ │ │ │ - ;; Using default policy instead of the current global one, │ │ │ │ - ;; except for DEBUG 3. │ │ │ │ - (with-compilation-unit (:policy '(optimize debug) │ │ │ │ - :override t) │ │ │ │ - (load "foo.lisp")) │ │ │ │ - ;; Same as if :POLICY had not been specified at all: SAFETY 3 │ │ │ │ - ;; proclamation leaks out from WITH-COMPILATION-UNIT. │ │ │ │ - (with-compilation-unit (:policy nil) │ │ │ │ - (declaim (optimize safety)) │ │ │ │ - (load "foo.lisp")) │ │ │ │ -Takes any number of SETF-style place expressions. Evaluates all of the │ │ │ │ - expressions in turn, then assigns to each place the value of the form to │ │ │ │ - its right. The rightmost form gets the value of the leftmost. │ │ │ │ - Returns NIL. │ │ │ │ -TRACE {Option Global-Value}* {Name {Option Value}*}* │ │ │ │ -TRACE is a debugging tool that provides information when specified │ │ │ │ -functions are called. In its simplest form: │ │ │ │ - (TRACE NAME-1 NAME-2 ...) │ │ │ │ -The NAMEs are not evaluated. Each may be one of the following: │ │ │ │ - * SYMBOL, denoting a function or macro. │ │ │ │ - * FNAME, a valid function name, denoting a function. │ │ │ │ - * (METHOD FNAME QUALIFIERS* (SPECIALIZERS*)) denoting a method. │ │ │ │ - * (COMPILER-MACRO SYMBOL) denoting a compiler macro. │ │ │ │ - * (LABELS FNAME :IN OUTER-NAME) or (FLET FNAME :IN OUTER-NAME) │ │ │ │ - denoting a local function where OUTER-NAME may be any of the │ │ │ │ - previous names for functions, macros, methods or compiler macros. │ │ │ │ - Tracing local functions may require DEBUG policy 3 to inhibit │ │ │ │ - inlining. │ │ │ │ - * STRING denoting all functions fbound to symbols whose home package │ │ │ │ - is the package with the given name. │ │ │ │ -Options allow modification of the default behavior. Each option is a │ │ │ │ -pair of an option keyword and a value form. Global options are │ │ │ │ -specified before the first name, and affect all functions traced by a │ │ │ │ -given use of TRACE. Options may also be interspersed with function │ │ │ │ -names, in which case they act as local options, only affecting tracing │ │ │ │ -of the immediately preceding function name. Local options override │ │ │ │ -global options. │ │ │ │ -By default, TRACE causes a printout on *TRACE-OUTPUT* each time that │ │ │ │ -one of the named functions is entered or returns. (This is the basic, │ │ │ │ -ANSI Common Lisp behavior of TRACE.) │ │ │ │ -The following options are defined: │ │ │ │ - :REPORT Report-Type │ │ │ │ - If Report-Type is TRACE (the default) then information is │ │ │ │ - reported by printing immediately. If Report-Type is NIL, then │ │ │ │ - the only effect of the trace is to execute other │ │ │ │ - options (e.g. PRINT or BREAK). Otherwise, Report-Type is │ │ │ │ - treated as a function designator and, for each trace event, │ │ │ │ - funcalled with 5 arguments: trace depth (a non-negative │ │ │ │ - integer), a function name or a function object, a │ │ │ │ - keyword (:ENTER, :EXIT or :NON-LOCAL-EXIT), a stack frame, and │ │ │ │ - a list of values (arguments or return values). │ │ │ │ - :CONDITION Form │ │ │ │ - :CONDITION-AFTER Form │ │ │ │ - :CONDITION-ALL Form │ │ │ │ - If :CONDITION is specified, then TRACE does nothing unless Form │ │ │ │ - evaluates to true at the time of the call. :CONDITION-AFTER is │ │ │ │ - similar, but suppresses the initial printout, and is tested when the │ │ │ │ - function returns. :CONDITION-ALL tries both before and after. │ │ │ │ - :BREAK Form │ │ │ │ - :BREAK-AFTER Form │ │ │ │ - :BREAK-ALL Form │ │ │ │ - If specified, and Form evaluates to true, then the debugger is invoked │ │ │ │ - at the start of the function, at the end of the function, or both, │ │ │ │ - according to the respective option. │ │ │ │ - :PRINT Form │ │ │ │ - :PRINT-AFTER Form │ │ │ │ - :PRINT-ALL Form │ │ │ │ - In addition to the usual printout, the result of evaluating Form is │ │ │ │ - printed at the start of the function, at the end of the function, or │ │ │ │ - both, according to the respective option. Multiple print options cause │ │ │ │ - multiple values to be printed. │ │ │ │ - :WHEREIN Names │ │ │ │ - If specified, Names is a function name or list of names. TRACE does │ │ │ │ - nothing unless a call to one of those functions encloses the call to │ │ │ │ - this function (i.e. it would appear in a backtrace.) Anonymous │ │ │ │ - functions have string names like "DEFUN FOO". │ │ │ │ - :ENCAPSULATE {:DEFAULT | T | NIL} │ │ │ │ - If T, the default, tracing is done via encapsulation (redefining the │ │ │ │ - function name) rather than by modifying the function. :DEFAULT is │ │ │ │ - not the default, but means to use encapsulation for interpreted │ │ │ │ - functions and funcallable instances, breakpoints otherwise. When │ │ │ │ - encapsulation is used, forms are *not* evaluated in the function's │ │ │ │ - lexical environment, but SB-DEBUG:ARG can still be used. │ │ │ │ - :METHODS {T | NIL} │ │ │ │ - If T, any function argument naming a generic function will have its │ │ │ │ - methods traced in addition to the generic function itself. │ │ │ │ - :FUNCTION Function-Form │ │ │ │ - This is a not really an option, but rather another way of specifying │ │ │ │ - what function to trace. The Function-Form is evaluated immediately, │ │ │ │ - and the resulting function is traced. │ │ │ │ -:CONDITION, :BREAK and :PRINT forms are evaluated in a context which │ │ │ │ -mocks up the lexical environment of the called function, so that │ │ │ │ -SB-DEBUG:VAR and SB-DEBUG:ARG can be used. │ │ │ │ -The -AFTER and -ALL forms can use also use SB-DEBUG:ARG. In forms │ │ │ │ -which are evaluated after the function call, (SB-DEBUG:ARG N) returns │ │ │ │ -the N-th value returned by the function. │ │ │ │ -CASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If a singleton key is T then the clause is a default clause. │ │ │ │ -FORM SB-KERNEL │ │ │ │ -qlC'XUV4I │ │ │ │ -Define a compiler-macro for NAME. │ │ │ │ -?)t@kV<" │ │ │ │ -DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)} │ │ │ │ - Define the structure type Name. Instances are created by MAKE-, │ │ │ │ - which takes &KEY arguments allowing initial slot values to the specified. │ │ │ │ - A SETF'able function - is defined for each slot to read and │ │ │ │ - write slot values. -p is a type predicate. │ │ │ │ - Popular DEFSTRUCT options (see manual for others): │ │ │ │ - (:CONSTRUCTOR Name) │ │ │ │ - (:PREDICATE Name) │ │ │ │ - Specify the name for the constructor or predicate. │ │ │ │ - (:CONSTRUCTOR Name Lambda-List) │ │ │ │ - Specify the name and arguments for a BOA constructor │ │ │ │ - (which is more efficient when keyword syntax isn't necessary.) │ │ │ │ - (:INCLUDE Supertype Slot-Spec*) │ │ │ │ - Make this type a subtype of the structure type Supertype. The optional │ │ │ │ - Slot-Specs override inherited slot options. │ │ │ │ - Slot options: │ │ │ │ - :TYPE Type-Spec │ │ │ │ - Asserts that the value of this slot is always of the specified type. │ │ │ │ - :READ-ONLY {T | NIL} │ │ │ │ - If true, no setter function is defined for this slot. │ │ │ │ -Evaluate FORM and return the Nth value (zero based) │ │ │ │ - without consing a temporary list of values. │ │ │ │ -N-RESULT │ │ │ │ -Output OBJECT to STREAM with "#<" prefix, ">" suffix, optionally │ │ │ │ - with object-type prefix and object-identity suffix, and executing the │ │ │ │ - code in BODY to provide possible further output. │ │ │ │ -CTYPECASE Keyform {(Type Form*)}* │ │ │ │ - Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ - is true. If no form is satisfied then a correctable error is signalled. │ │ │ │ -Define a global constant, saying that the value is constant and may be │ │ │ │ - compiled into code. If the variable already has a value, and this is not │ │ │ │ - EQL to the new value, the code is not portable (undefined behavior). The │ │ │ │ - third argument is an optional documentation string for the variable. │ │ │ │ -The first argument is some location holding a number. This number is │ │ │ │ - decremented by the second argument, DELTA, which defaults to 1. │ │ │ │ -The first argument is some location holding a number. This number is │ │ │ │ - incremented by the second argument, DELTA, which defaults to 1. │ │ │ │ -The first argument is a byte specifier. The second is any place form │ │ │ │ -acceptable to SETF. Replace the specified byte of the number in this │ │ │ │ -place with bits from the low-order end of the new value. │ │ │ │ -The form is evaluated with single stepping enabled. Function calls │ │ │ │ -outside the lexical scope of the form can be stepped into only if the │ │ │ │ -functions in question have been compiled with sufficient DEBUG policy │ │ │ │ -to be at least partially steppable. │ │ │ │ -Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ -tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ Return the 5th object in a list or NIL if there is no 5th object. │ │ │ │ COMMON-LISP │ │ │ │ Return SYMBOL's current bound value. │ │ │ │ AP`mlxh]x │ │ │ │ Substitute NEW for subtrees of TREE for which TEST is false. │ │ │ │ COMMON-LISP │ │ │ │ Return new integer with newbyte in specified position, newbyte is right justified. │ │ │ │ CHAR-BAG │ │ │ │ COMMON-LISP │ │ │ │ -MACROLET ({(name lambda-list form*)}*) body-form* │ │ │ │ -Evaluate the BODY-FORMS in an environment with the specified local macros │ │ │ │ -defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style │ │ │ │ -destructuring lambda list, and the FORMS evaluate to the expansion. │ │ │ │ -RETURN-FROM name value │ │ │ │ -Evaluate the VALUE, returning its values from the lexically enclosing │ │ │ │ -block NAME. This is constrained to be used only within the dynamic │ │ │ │ -extent of the block. │ │ │ │ -SYMBOL-MACROLET ({(name expansion)}*) decl* form* │ │ │ │ -Define the NAMES as symbol macros with the given EXPANSIONS. Within the │ │ │ │ -body, references to a NAME will effectively be replaced with the EXPANSION. │ │ │ │ -Transfer control to the named TAG in the lexically enclosing TAGBODY. This is │ │ │ │ -constrained to be used only within the dynamic extent of the TAGBODY. │ │ │ │ -PROGN form* │ │ │ │ -Evaluates each FORM in order, returning the values of the last form. With no │ │ │ │ -forms, returns NIL. │ │ │ │ -MULTIPLE-VALUE-PROG1 values-form form* │ │ │ │ -Evaluate VALUES-FORM and then the FORMS, but return all the values of │ │ │ │ -VALUES-FORM. │ │ │ │ -QUOTE value │ │ │ │ -Return VALUE without evaluating it. │ │ │ │ -THROW tag form │ │ │ │ -Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ │ │ │ │ -TAGBODY {tag | statement}* │ │ │ │ -Define tags for use with GO. The STATEMENTS are evaluated in order, skipping │ │ │ │ -TAGS, and NIL is returned. If a statement contains a GO to a defined TAG │ │ │ │ -within the lexical scope of the form, then control is transferred to the next │ │ │ │ -statement following that tag. A TAG must be an integer or a symbol. A │ │ │ │ -STATEMENT must be a list. Other objects are illegal within the body. │ │ │ │ -EVAL-WHEN (situation*) form* │ │ │ │ -Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, │ │ │ │ -:LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL). │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the car of the caadr of a list. │ │ │ │ Return a new sequence of all the argument sequences concatenated together │ │ │ │ which shares no structure with the original argument sequences of the │ │ │ │ specified RESULT-TYPE. │ │ │ │ ] ld01nV │ │ │ │ Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, │ │ │ │ @@ -31603,18 +31505,14 @@ │ │ │ │ Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ Coerce the Object to an object of type Output-Type-Spec. │ │ │ │ Exports SYMBOLS from PACKAGE, checking that no name conflicts result. │ │ │ │ Return the cons in ALIST whose car is equal (by a given test or EQL) to │ │ │ │ the ITEM. │ │ │ │ COMMON-LISP0 │ │ │ │ Return SYMBOL's current function definition. Settable with SETF. │ │ │ │ -Can STREAM perform input operations? │ │ │ │ -Return true if STREAM is not closed. A default method is provided │ │ │ │ - by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ - called on the stream. │ │ │ │ COMMON-LISP │ │ │ │ Return T if and only if calling ADJUST-ARRAY on ARRAY will return │ │ │ │ the identical object. │ │ │ │ Destructively return a list with elements which appear but once in LIST1 │ │ │ │ and LIST2. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -31709,14 +31607,140 @@ │ │ │ │ Calls the function associated with the given restart, prompting for any │ │ │ │ necessary arguments. If the argument restart is not a restart or a │ │ │ │ currently active non-NIL restart name, then a CONTROL-ERROR is signalled. │ │ │ │ Substitutes new for subtrees for which test is true. │ │ │ │ Return T if the arguments are in strictly non-decreasing alphabetic order. │ │ │ │ 2g7Gb<=t │ │ │ │ Make an instance of a condition object using the specified initargs. │ │ │ │ +CASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If a singleton key is T then the clause is a default clause. │ │ │ │ +FORM SB-KERNEL │ │ │ │ +qlC'XUV4I │ │ │ │ +Define a compiler-macro for NAME. │ │ │ │ +?)t@kV<" │ │ │ │ +DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)} │ │ │ │ + Define the structure type Name. Instances are created by MAKE-, │ │ │ │ + which takes &KEY arguments allowing initial slot values to the specified. │ │ │ │ + A SETF'able function - is defined for each slot to read and │ │ │ │ + write slot values. -p is a type predicate. │ │ │ │ + Popular DEFSTRUCT options (see manual for others): │ │ │ │ + (:CONSTRUCTOR Name) │ │ │ │ + (:PREDICATE Name) │ │ │ │ + Specify the name for the constructor or predicate. │ │ │ │ + (:CONSTRUCTOR Name Lambda-List) │ │ │ │ + Specify the name and arguments for a BOA constructor │ │ │ │ + (which is more efficient when keyword syntax isn't necessary.) │ │ │ │ + (:INCLUDE Supertype Slot-Spec*) │ │ │ │ + Make this type a subtype of the structure type Supertype. The optional │ │ │ │ + Slot-Specs override inherited slot options. │ │ │ │ + Slot options: │ │ │ │ + :TYPE Type-Spec │ │ │ │ + Asserts that the value of this slot is always of the specified type. │ │ │ │ + :READ-ONLY {T | NIL} │ │ │ │ + If true, no setter function is defined for this slot. │ │ │ │ +Evaluate FORM and return the Nth value (zero based) │ │ │ │ + without consing a temporary list of values. │ │ │ │ +N-RESULT │ │ │ │ +Output OBJECT to STREAM with "#<" prefix, ">" suffix, optionally │ │ │ │ + with object-type prefix and object-identity suffix, and executing the │ │ │ │ + code in BODY to provide possible further output. │ │ │ │ +CTYPECASE Keyform {(Type Form*)}* │ │ │ │ + Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ + is true. If no form is satisfied then a correctable error is signalled. │ │ │ │ +Define a global constant, saying that the value is constant and may be │ │ │ │ + compiled into code. If the variable already has a value, and this is not │ │ │ │ + EQL to the new value, the code is not portable (undefined behavior). The │ │ │ │ + third argument is an optional documentation string for the variable. │ │ │ │ +The first argument is some location holding a number. This number is │ │ │ │ + decremented by the second argument, DELTA, which defaults to 1. │ │ │ │ +The first argument is some location holding a number. This number is │ │ │ │ + incremented by the second argument, DELTA, which defaults to 1. │ │ │ │ +The first argument is a byte specifier. The second is any place form │ │ │ │ +acceptable to SETF. Replace the specified byte of the number in this │ │ │ │ +place with bits from the low-order end of the new value. │ │ │ │ +The form is evaluated with single stepping enabled. Function calls │ │ │ │ +outside the lexical scope of the form can be stepped into only if the │ │ │ │ +functions in question have been compiled with sufficient DEBUG policy │ │ │ │ +to be at least partially steppable. │ │ │ │ +Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ +tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ +Define a special variable at top level. Declare the variable │ │ │ │ + SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ + value, the old value is not clobbered. The third argument is an optional │ │ │ │ + documentation string for the variable. │ │ │ │ +Cause the iteration to terminate "normally", the same as implicit │ │ │ │ +termination by an iteration driving clause, or by use of WHILE or │ │ │ │ +UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ +collected result will be returned as the value of the LOOP. │ │ │ │ +CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If none of the keys matches then a correctable error is │ │ │ │ + signalled. │ │ │ │ +Bind the reader and printer control variables to values that enable READ │ │ │ │ + to reliably read the results of PRINT. These values are: │ │ │ │ + *PACKAGE* the COMMON-LISP-USER package │ │ │ │ + *PRINT-ARRAY* T │ │ │ │ + *PRINT-BASE* 10 │ │ │ │ + *PRINT-CASE* :UPCASE │ │ │ │ + *PRINT-CIRCLE* NIL │ │ │ │ + *PRINT-ESCAPE* T │ │ │ │ + *PRINT-GENSYM* T │ │ │ │ + *PRINT-LENGTH* NIL │ │ │ │ + *PRINT-LEVEL* NIL │ │ │ │ + *PRINT-LINES* NIL │ │ │ │ + *PRINT-MISER-WIDTH* NIL │ │ │ │ + *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ + *PRINT-PRETTY* NIL │ │ │ │ + *PRINT-RADIX* NIL │ │ │ │ + *PRINT-READABLY* T │ │ │ │ + *PRINT-RIGHT-MARGIN* NIL │ │ │ │ + *READ-BASE* 10 │ │ │ │ + *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ + *READ-EVAL* T │ │ │ │ + *READ-SUPPRESS* NIL │ │ │ │ + *READTABLE* the standard readtable │ │ │ │ + SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ + SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ +VECTOR-SYM │ │ │ │ +DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* │ │ │ │ + Executes the FORMs once for each external symbol in the given PACKAGE with │ │ │ │ + VAR bound to the current symbol. │ │ │ │ +(HANDLER-CASE form { (type ([var]) body) }* ) │ │ │ │ +Execute FORM in a context with handlers established for the condition types. A │ │ │ │ +peculiar property allows type to be :NO-ERROR. If such a clause occurs, and │ │ │ │ +form returns normally, all its values are passed to this clause as if by │ │ │ │ +MULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var │ │ │ │ +specification. │ │ │ │ +Signals an error if the value of TEST-FORM is NIL. Returns NIL. │ │ │ │ + Optional DATUM and ARGUMENTS can be used to change the signaled │ │ │ │ + error condition and are interpreted as in (APPLY #'ERROR DATUM │ │ │ │ + ARGUMENTS). │ │ │ │ + Continuing from the signaled error using the CONTINUE restart will │ │ │ │ + allow the user to alter the values of the SETFable locations │ │ │ │ + specified in PLACES and then start over with TEST-FORM. │ │ │ │ + If TEST-FORM is of the form │ │ │ │ + (FUNCTION ARG*) │ │ │ │ + where FUNCTION is a function (but not a special operator like │ │ │ │ + CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be │ │ │ │ + included in the error report if the assertion fails. │ │ │ │ +Define a new type, with syntax like DEFMACRO. │ │ │ │ +Execute FORMS handling ERROR conditions, returning the result of the last │ │ │ │ + form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled. │ │ │ │ +Evaluates the BODY in a dynamic environment where the restarts in the list │ │ │ │ + RESTARTS-FORM are associated with the condition returned by CONDITION-FORM. │ │ │ │ + This allows FIND-RESTART, etc., to recognize restarts that are not related │ │ │ │ + to the error currently being debugged. See also RESTART-CASE. │ │ │ │ +Takes an object and a location holding a list. If the object is │ │ │ │ + already in the list, does nothing; otherwise, conses the object onto │ │ │ │ + the list. Keyword arguments are accepted as per the ADJOIN function. │ │ │ │ +D`{^c/W$ │ │ │ │ +Associates a SETF update function or macro with the specified access │ │ │ │ + function or macro. The format is complex. See the manual for details. │ │ │ │ +Creates a new read-modify-write macro like PUSH or INCF. │ │ │ │ HOST SB-KERNEL0 │ │ │ │ Return the (logical) host object argument's list of translations. │ │ │ │ Return the first cons in ALIST whose CDR satisfies PREDICATE. If KEY │ │ │ │ is supplied, apply it to the CDR of each cons before testing. │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the cdr of the cdadr of a list. │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -31801,14 +31825,45 @@ │ │ │ │ to COMPILE otherwise, CLOSURE-P is non-NIL if the function's definition │ │ │ │ might have been enclosed in some non-null lexical environment, and │ │ │ │ NAME is some name (for debugging only) or NIL if there is no name. │ │ │ │ Return the 7th object in a list or NIL if there is no 7th object. │ │ │ │ COMMON-LISP │ │ │ │ Return a new list which is EQUAL to LIST. LIST may be improper. │ │ │ │ Return true if name has a global function definition. │ │ │ │ +PROGN form* │ │ │ │ +Evaluates each FORM in order, returning the values of the last form. With no │ │ │ │ +forms, returns NIL. │ │ │ │ +MULTIPLE-VALUE-PROG1 values-form form* │ │ │ │ +Evaluate VALUES-FORM and then the FORMS, but return all the values of │ │ │ │ +VALUES-FORM. │ │ │ │ +QUOTE value │ │ │ │ +Return VALUE without evaluating it. │ │ │ │ +THROW tag form │ │ │ │ +Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ │ │ │ │ +TAGBODY {tag | statement}* │ │ │ │ +Define tags for use with GO. The STATEMENTS are evaluated in order, skipping │ │ │ │ +TAGS, and NIL is returned. If a statement contains a GO to a defined TAG │ │ │ │ +within the lexical scope of the form, then control is transferred to the next │ │ │ │ +statement following that tag. A TAG must be an integer or a symbol. A │ │ │ │ +STATEMENT must be a list. Other objects are illegal within the body. │ │ │ │ +EVAL-WHEN (situation*) form* │ │ │ │ +Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, │ │ │ │ +:LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL). │ │ │ │ +LOCALLY declaration* form* │ │ │ │ +Sequentially evaluate the FORMS in a lexical environment where the │ │ │ │ +DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are │ │ │ │ +also processed as top level forms. │ │ │ │ +Can STREAM perform input operations? │ │ │ │ +Return true if STREAM is not closed. A default method is provided │ │ │ │ + by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ + called on the stream. │ │ │ │ +Close the given STREAM. No more I/O may be performed, but │ │ │ │ + inquiries may still be made. If :ABORT is true, an attempt is made │ │ │ │ + to clean up the side effects of having created the stream. │ │ │ │ +Can STREAM perform output operations? │ │ │ │ Same as CEILING, but returns first value as a float. │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the car of the caddr of a list. │ │ │ │ COMMON-LISP │ │ │ │ Extract the specified byte from integer, but do not right justify result. │ │ │ │ Change the CAR of CONS to X and return the CONS. │ │ │ │ Apply FUNCTION to successive tuples of elements of LIST and MORE-LISTS. │ │ │ │ @@ -31981,131 +32036,14 @@ │ │ │ │ See the manual for details. │ │ │ │ Attempt to set the element of ARRAY designated by its fill pointer │ │ │ │ to NEW-ELEMENT, and increment the fill pointer by one. If the fill pointer is │ │ │ │ too large, NIL is returned, otherwise the index of the pushed element is │ │ │ │ returned. │ │ │ │ Use the source pathname to translate the from-wildname's wild and │ │ │ │ unspecified elements into a completed to-pathname based on the to-wildname. │ │ │ │ -Define a special variable at top level. Declare the variable │ │ │ │ - SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ - value, the old value is not clobbered. The third argument is an optional │ │ │ │ - documentation string for the variable. │ │ │ │ -Cause the iteration to terminate "normally", the same as implicit │ │ │ │ -termination by an iteration driving clause, or by use of WHILE or │ │ │ │ -UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ -collected result will be returned as the value of the LOOP. │ │ │ │ -CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If none of the keys matches then a correctable error is │ │ │ │ - signalled. │ │ │ │ -Bind the reader and printer control variables to values that enable READ │ │ │ │ - to reliably read the results of PRINT. These values are: │ │ │ │ - *PACKAGE* the COMMON-LISP-USER package │ │ │ │ - *PRINT-ARRAY* T │ │ │ │ - *PRINT-BASE* 10 │ │ │ │ - *PRINT-CASE* :UPCASE │ │ │ │ - *PRINT-CIRCLE* NIL │ │ │ │ - *PRINT-ESCAPE* T │ │ │ │ - *PRINT-GENSYM* T │ │ │ │ - *PRINT-LENGTH* NIL │ │ │ │ - *PRINT-LEVEL* NIL │ │ │ │ - *PRINT-LINES* NIL │ │ │ │ - *PRINT-MISER-WIDTH* NIL │ │ │ │ - *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ - *PRINT-PRETTY* NIL │ │ │ │ - *PRINT-RADIX* NIL │ │ │ │ - *PRINT-READABLY* T │ │ │ │ - *PRINT-RIGHT-MARGIN* NIL │ │ │ │ - *READ-BASE* 10 │ │ │ │ - *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ - *READ-EVAL* T │ │ │ │ - *READ-SUPPRESS* NIL │ │ │ │ - *READTABLE* the standard readtable │ │ │ │ - SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ - SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ -VECTOR-SYM │ │ │ │ -DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* │ │ │ │ - Executes the FORMs once for each external symbol in the given PACKAGE with │ │ │ │ - VAR bound to the current symbol. │ │ │ │ -(HANDLER-CASE form { (type ([var]) body) }* ) │ │ │ │ -Execute FORM in a context with handlers established for the condition types. A │ │ │ │ -peculiar property allows type to be :NO-ERROR. If such a clause occurs, and │ │ │ │ -form returns normally, all its values are passed to this clause as if by │ │ │ │ -MULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var │ │ │ │ -specification. │ │ │ │ -Signals an error if the value of TEST-FORM is NIL. Returns NIL. │ │ │ │ - Optional DATUM and ARGUMENTS can be used to change the signaled │ │ │ │ - error condition and are interpreted as in (APPLY #'ERROR DATUM │ │ │ │ - ARGUMENTS). │ │ │ │ - Continuing from the signaled error using the CONTINUE restart will │ │ │ │ - allow the user to alter the values of the SETFable locations │ │ │ │ - specified in PLACES and then start over with TEST-FORM. │ │ │ │ - If TEST-FORM is of the form │ │ │ │ - (FUNCTION ARG*) │ │ │ │ - where FUNCTION is a function (but not a special operator like │ │ │ │ - CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be │ │ │ │ - included in the error report if the assertion fails. │ │ │ │ -Define a new type, with syntax like DEFMACRO. │ │ │ │ -Execute FORMS handling ERROR conditions, returning the result of the last │ │ │ │ - form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled. │ │ │ │ -Evaluates the BODY in a dynamic environment where the restarts in the list │ │ │ │ - RESTARTS-FORM are associated with the condition returned by CONDITION-FORM. │ │ │ │ - This allows FIND-RESTART, etc., to recognize restarts that are not related │ │ │ │ - to the error currently being debugged. See also RESTART-CASE. │ │ │ │ -Takes an object and a location holding a list. If the object is │ │ │ │ - already in the list, does nothing; otherwise, conses the object onto │ │ │ │ - the list. Keyword arguments are accepted as per the ADJOIN function. │ │ │ │ -D`{^c/W$ │ │ │ │ -Associates a SETF update function or macro with the specified access │ │ │ │ - function or macro. The format is complex. See the manual for details. │ │ │ │ -Creates a new read-modify-write macro like PUSH or INCF. │ │ │ │ -MORE-ARG │ │ │ │ -The first argument is a byte specifier. The second is any place form │ │ │ │ -acceptable to SETF. Replaces the specified byte of the number in this place │ │ │ │ -with bits from the corresponding position in the new value. │ │ │ │ -:INITIAL-ELEMENT ~S is not of type ~//. │ │ │ │ -Static arrays of type ~// not supported. │ │ │ │ -:INITIAL-CONTENTS contains elements not of type ~//. │ │ │ │ -The ~(~A~) ~// has been deprecated as of ~@[~A ~]version ~A.~@[ │ │ │ │ -DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ - Iteration construct. Each Var is initialized sequentially (like LET*) to the │ │ │ │ - value of the specified Init form. On subsequent iterations, the Vars are │ │ │ │ - sequentially assigned the value of the Step form (if any). The Test is │ │ │ │ - evaluated before each evaluation of the body Forms. When the Test is true, │ │ │ │ - the Exit-Forms are evaluated as a PROGN, with the result being the value │ │ │ │ - of the DO. A block named NIL is established around the entire expansion, │ │ │ │ - allowing RETURN to be used as an alternate exit mechanism. │ │ │ │ -DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ - Iteration construct. Each Var is initialized in parallel to the value of the │ │ │ │ - specified Init form. On subsequent iterations, the Vars are assigned the │ │ │ │ - value of the Step form (if any) in parallel. The Test is evaluated before │ │ │ │ - each evaluation of the body Forms. When the Test is true, the Exit-Forms │ │ │ │ - are evaluated as a PROGN, with the result being the value of the DO. A block │ │ │ │ - named NIL is established around the entire expansion, allowing RETURN to be │ │ │ │ - used as an alternate exit mechanism. │ │ │ │ -WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body) │ │ │ │ -Provides a method of manually looping over the elements of a hash-table. NAME │ │ │ │ -is bound to a generator-macro that, within the scope of the invocation, │ │ │ │ -returns one or three values. The first value tells whether any objects remain │ │ │ │ -in the hash table. When the first value is non-NIL, the second and third │ │ │ │ -values are the key and the value of the next object. │ │ │ │ -Consequences are undefined if HASH-TABLE is mutated during execution of BODY, │ │ │ │ -except for changing or removing elements corresponding to the current key. The │ │ │ │ -applies to all threads, not just the current one -- even for synchronized │ │ │ │ -hash-tables. If the table may be mutated by another thread during iteration, │ │ │ │ -use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR │ │ │ │ -Remove tracing from the specified functions. Untraces all │ │ │ │ -functions when called with no arguments. │ │ │ │ -Return the next element from LIST argument to the closest enclosing │ │ │ │ - use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH* │ │ │ │ - and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK. │ │ │ │ - If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing │ │ │ │ - is popped, but the *PRINT-LENGTH* testing still happens. │ │ │ │ -LAMBDA-LIST8 │ │ │ │ -QUALIFIERS │ │ │ │ Return a stream which takes its input from each of the streams in turn, │ │ │ │ going on to the next at EOF. │ │ │ │ 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). │ │ │ │ COMMON-LISP │ │ │ │ Return the number of dimensions of ARRAY. │ │ │ │ @@ -32122,75 +32060,14 @@ │ │ │ │ Rounds number (or number/divisor) to nearest integer. │ │ │ │ The second returned value is the remainder. │ │ │ │ Return T if all of the arguments are the same character. │ │ │ │ Case is ignored. │ │ │ │ Bitwise OR (LOGNOT INTEGER1) with INTEGER2. │ │ │ │ Return T if the arguments are in strictly decreasing alphabetic order. │ │ │ │ Case is ignored. │ │ │ │ -Backtrace for: ~S │ │ │ │ -Skip printing frame ~S │ │ │ │ -while printing frame ~S. The partial output is: ~S │ │ │ │ -non-FIXNUM non-NULL location in cell: ~S │ │ │ │ -updating obsolete instance │ │ │ │ -~S cannot handle the second argument ~S. │ │ │ │ -failed to resolve home directory for Unix uid=~S │ │ │ │ -select(2) │ │ │ │ -Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ -4E4i4<4`4 │ │ │ │ -*9@9d979[9. │ │ │ │ -Error calling tmpfile(): ~a │ │ │ │ -found no match for Unix uid=~S │ │ │ │ -~S~:[~;~:*~S~] │ │ │ │ -~S at ~S │ │ │ │ -~@[~S ~]~[free~;taken~;contested~:;err~] owner=~X │ │ │ │ -waiting on: │ │ │ │ -~@[tid=~D ~]~@[~S ~]~:[~{~I~A~^~2I~_ ~}~_~;~A~:[ no values~; values: ~:*~{~S~^, ~}~]~] │ │ │ │ -waiting on a mutex with a timeout │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -Cannot allocate an instance of ~S. │ │ │ │ -The object file ~A is~@ │ │ │ │ - older than the presumed source:~% ~A. │ │ │ │ -load object file │ │ │ │ -load source file │ │ │ │ -attempt to load an empty FASL file: │ │ │ │ - ^'!65 W │ │ │ │ ->5 Q/F │ │ │ │ -$@ 5 \!#6 5 n@ │ │ │ │ -$; 5 [ │ │ │ │ -Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ -or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ -LOCALLY declaration* form* │ │ │ │ -Sequentially evaluate the FORMS in a lexical environment where the │ │ │ │ -DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are │ │ │ │ -also processed as top level forms. │ │ │ │ -Specifies that the values returned by FORM conform to the │ │ │ │ -VALUE-TYPE, and causes the compiler to trust this information │ │ │ │ -unconditionally. │ │ │ │ -Consequences are undefined if any result is not of the declared type │ │ │ │ --- typical symptoms including memory corruptions. Use with great │ │ │ │ -SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ -Close the given STREAM. No more I/O may be performed, but │ │ │ │ - inquiries may still be made. If :ABORT is true, an attempt is made │ │ │ │ - to clean up the side effects of having created the stream. │ │ │ │ -Can STREAM perform output operations? │ │ │ │ -Return the stream line length or NIL. │ │ │ │ -This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ - optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ - The string argument is returned. The default method provided by │ │ │ │ - FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ - STREAM-WRITE-CHAR. │ │ │ │ -Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ - method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ -Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ - returns the integer as the result. │ │ │ │ -This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ - STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ - define their own method since it will usually be trivial and will │ │ │ │ - always be more efficient than the default method. │ │ │ │ Same as TRUNCATE, but returns first value as a float. │ │ │ │ Return the arc sine of NUMBER. │ │ │ │ If form is a macro (or symbol macro), expand it once. Return two values, │ │ │ │ the expanded form and a T-or-NIL flag indicating whether the form was, in │ │ │ │ fact, a macro. ENV is the lexical environment to expand in, which defaults │ │ │ │ to the null environment. │ │ │ │ COMMON-LISP │ │ │ │ @@ -32244,14 +32121,28 @@ │ │ │ │ The argument must be a character object. GRAPHIC-CHAR-P returns T if the │ │ │ │ argument is a printing character (space through ~ in ASCII), otherwise returns │ │ │ │ COMMON-LISP │ │ │ │ Return NUMBER + 1. │ │ │ │ Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS. │ │ │ │ Return NCONC of results. │ │ │ │ Return tail of LIST beginning with first element not satisfying TEST. │ │ │ │ +:INITIAL-ELEMENT ~S is not of type ~//. │ │ │ │ +Static arrays of type ~// not supported. │ │ │ │ +:INITIAL-CONTENTS contains elements not of type ~//. │ │ │ │ +The ~(~A~) ~// has been deprecated as of ~@[~A ~]version ~A.~@[ │ │ │ │ +~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ + ~// │ │ │ │ +illegal dotted lambda list: ~// │ │ │ │ +&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ +expected lambda list keyword at ~S in: ~// │ │ │ │ +~S and ~S are mutually exclusive: ~// │ │ │ │ +repeated ~S in lambda list: ~// │ │ │ │ +~A is not allowed in ~A: ~// │ │ │ │ +suspicious ~A ~S in lambda list: ~//. │ │ │ │ +expecting variable after ~A in: ~// │ │ │ │ Return PATHNAME's device. │ │ │ │ Return three values: │ │ │ │ 1) an integer representation of the significand. │ │ │ │ 2) the exponent for the power of 2 that the significand must be multiplied │ │ │ │ by to get the actual value. This differs from the DECODE-FLOAT exponent │ │ │ │ by FLOAT-DIGITS, since the significand has been scaled to have all its │ │ │ │ digits before the radix point. │ │ │ │ @@ -32260,21 +32151,245 @@ │ │ │ │ any non-negative real number. │ │ │ │ $9D.e5(8g │ │ │ │ Return the printed representation of OBJECT as a string with │ │ │ │ slashification off. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Return T iff OBJECT is an alien of type TYPE. │ │ │ │ +Return T iff the alien type TYPE1 is a subtype of TYPE2. Currently, the │ │ │ │ + only supported subtype relationships are is that any pointer type is a │ │ │ │ + subtype of (* t), and any array type first dimension will match │ │ │ │ + (array nil ...). Otherwise, the two types have to be │ │ │ │ + ALIEN-TYPE-=. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Cons up a piece of code which calls call-callback with INDEX and a │ │ │ │ pointer to the arguments. │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +MORE-ARG │ │ │ │ +The first argument is a byte specifier. The second is any place form │ │ │ │ +acceptable to SETF. Replaces the specified byte of the number in this place │ │ │ │ +with bits from the corresponding position in the new value. │ │ │ │ +DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ + Iteration construct. Each Var is initialized sequentially (like LET*) to the │ │ │ │ + value of the specified Init form. On subsequent iterations, the Vars are │ │ │ │ + sequentially assigned the value of the Step form (if any). The Test is │ │ │ │ + evaluated before each evaluation of the body Forms. When the Test is true, │ │ │ │ + the Exit-Forms are evaluated as a PROGN, with the result being the value │ │ │ │ + of the DO. A block named NIL is established around the entire expansion, │ │ │ │ + allowing RETURN to be used as an alternate exit mechanism. │ │ │ │ +DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ + Iteration construct. Each Var is initialized in parallel to the value of the │ │ │ │ + specified Init form. On subsequent iterations, the Vars are assigned the │ │ │ │ + value of the Step form (if any) in parallel. The Test is evaluated before │ │ │ │ + each evaluation of the body Forms. When the Test is true, the Exit-Forms │ │ │ │ + are evaluated as a PROGN, with the result being the value of the DO. A block │ │ │ │ + named NIL is established around the entire expansion, allowing RETURN to be │ │ │ │ + used as an alternate exit mechanism. │ │ │ │ +WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body) │ │ │ │ +Provides a method of manually looping over the elements of a hash-table. NAME │ │ │ │ +is bound to a generator-macro that, within the scope of the invocation, │ │ │ │ +returns one or three values. The first value tells whether any objects remain │ │ │ │ +in the hash table. When the first value is non-NIL, the second and third │ │ │ │ +values are the key and the value of the next object. │ │ │ │ +Consequences are undefined if HASH-TABLE is mutated during execution of BODY, │ │ │ │ +except for changing or removing elements corresponding to the current key. The │ │ │ │ +applies to all threads, not just the current one -- even for synchronized │ │ │ │ +hash-tables. If the table may be mutated by another thread during iteration, │ │ │ │ +use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR │ │ │ │ +Remove tracing from the specified functions. Untraces all │ │ │ │ +functions when called with no arguments. │ │ │ │ +Return the next element from LIST argument to the closest enclosing │ │ │ │ + use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH* │ │ │ │ + and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK. │ │ │ │ + If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing │ │ │ │ + is popped, but the *PRINT-LENGTH* testing still happens. │ │ │ │ +LAMBDA-LIST8 │ │ │ │ +QUALIFIERS │ │ │ │ +ETYPECASE Keyform {(Type Form*)}* │ │ │ │ + Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ + is true. If no form is satisfied then an error is signalled. │ │ │ │ +qlC'XUV4I │ │ │ │ +Execute FORM and print timing information on *TRACE-OUTPUT*. │ │ │ │ +On some hardware platforms estimated processor cycle counts are │ │ │ │ +included in this output; this number is slightly inflated, since it │ │ │ │ +includes the pipeline involved in reading the cycle counter -- │ │ │ │ +executing (TIME NIL) a few times will give you an idea of the │ │ │ │ +overhead, and its variance. The cycle counters are also per processor, │ │ │ │ +not per thread: if multiple threads are running on the same processor, │ │ │ │ +the reported counts will include cycles taken up by all threads │ │ │ │ +running on the processor where TIME was executed. Furthermore, if the │ │ │ │ +operating system migrates the thread to another processor between │ │ │ │ +reads of the cycle counter, the results will be completely bogus. │ │ │ │ +Finally, the counter is cycle counter, incremented by the hardware │ │ │ │ +even when the process is halted -- which is to say that cycles pass │ │ │ │ +normally during operations like SLEEP. │ │ │ │ +ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If none of the keys matches then an error is signalled. │ │ │ │ +(WITH-SIMPLE-RESTART (restart-name format-string format-arguments) │ │ │ │ + body) │ │ │ │ + If restart-name is not invoked, then all values returned by forms are │ │ │ │ + returned. If control is transferred to this restart, it immediately │ │ │ │ + returns the values NIL and T. │ │ │ │ +Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ +or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ +SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ +DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* │ │ │ │ + Define NAME as a condition type. This new type inherits slots and its │ │ │ │ + report function from the specified PARENT-TYPEs. A slot spec is a list of: │ │ │ │ + (slot-name :reader :initarg {Option Value}* │ │ │ │ + The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION │ │ │ │ + and :TYPE and the overall options :DEFAULT-INITARGS and │ │ │ │ + [type] :DOCUMENTATION are also allowed. │ │ │ │ + The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either │ │ │ │ + a string or a two-argument lambda or function name. If a function, the │ │ │ │ + function is called with the condition and stream to report the condition. │ │ │ │ + If a string, the string is printed. │ │ │ │ + Condition types are classes, but (as allowed by ANSI and not as described in │ │ │ │ + CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and │ │ │ │ + SLOT-VALUE may not be used on condition objects. │ │ │ │ +DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* │ │ │ │ + Executes the FORMs at least once for each symbol accessible in the given │ │ │ │ + PACKAGE with VAR bound to the current symbol. │ │ │ │ +(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*) │ │ │ │ + The form is evaluated in a dynamic context where the clauses have │ │ │ │ + special meanings as points to which control may be transferred (see │ │ │ │ + INVOKE-RESTART). When clauses contain the same case-name, │ │ │ │ + FIND-RESTART will find the first such clause. If form is a call to │ │ │ │ + SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the │ │ │ │ + signalled condition will be associated with the new restarts. │ │ │ │ +>)PW:`5w │ │ │ │ +Atomically decrements PLACE by DIFF, and returns the value of PLACE before │ │ │ │ +the decrement. │ │ │ │ +PLACE must access one of the following: │ │ │ │ + - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 32) │ │ │ │ + or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) │ │ │ │ + The type SB-EXT:WORD can be used for these purposes. │ │ │ │ + - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ + - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM. │ │ │ │ +Macroexpansion is performed on PLACE before expanding ATOMIC-DECF. │ │ │ │ +Decrementing is done using modular arithmetic, │ │ │ │ +which is well-defined over two different domains: │ │ │ │ + - For structures and arrays, the operation accepts and produces │ │ │ │ + an (UNSIGNED-BYTE 32), and DIFF must be of type (SIGNED-BYTE 32). │ │ │ │ + ATOMIC-DECF of #x0 by one results in #xFFFFFFFF being stored in PLACE. │ │ │ │ + - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ + ATOMIC-DECF of #x-20000000 by one results in #x1FFFFFFF │ │ │ │ + being stored in PLACE. │ │ │ │ +DIFF defaults to 1. │ │ │ │ +EXPERIMENTAL: Interface subject to change. │ │ │ │ +Ignores all runtime package lock violations during the execution of │ │ │ │ +body. Body can begin with declarations. │ │ │ │ +Limits concurrent accesses to HASH-TABLE for the duration of BODY. │ │ │ │ +If HASH-TABLE is synchronized, BODY will execute with exclusive │ │ │ │ +ownership of the table. If HASH-TABLE is not synchronized, BODY will │ │ │ │ +execute with other WITH-LOCKED-HASH-TABLE bodies excluded -- exclusion │ │ │ │ +of hash-table accesses not surrounded by WITH-LOCKED-HASH-TABLE is │ │ │ │ +unspecified. │ │ │ │ +Like POP, but atomic. PLACE may be read multiple times before │ │ │ │ +the operation completes -- the write does not occur until such time │ │ │ │ +that no other thread modified PLACE between the read and the write. │ │ │ │ +Works on all CASable places. │ │ │ │ +Atomically stores NEW in PLACE if OLD matches the current value of PLACE. │ │ │ │ +Two values are considered to match if they are EQ. Returns the previous value │ │ │ │ +of PLACE: if the returned value is EQ to OLD, the swap was carried out. │ │ │ │ +PLACE must be an CAS-able place. Built-in CAS-able places are accessor forms │ │ │ │ +whose CAR is one of the following: │ │ │ │ + CAR, CDR, FIRST, REST, SVREF, SYMBOL-PLIST, SYMBOL-VALUE, SLOT-VALUE │ │ │ │ + SB-MOP:STANDARD-INSTANCE-ACCESS, SB-MOP:FUNCALLABLE-STANDARD-INSTANCE-ACCESS, │ │ │ │ +or the name of a DEFSTRUCT created accessor for a slot whose storage type │ │ │ │ +is not raw. (Refer to the the "Efficiency" chapter of the manual │ │ │ │ +for the list of raw slot types. Future extensions to this macro may allow │ │ │ │ +it to work on some raw slot types.) │ │ │ │ +In case of SLOT-VALUE, if the slot is unbound, SLOT-UNBOUND is called unless │ │ │ │ +OLD is EQ to SB-PCL:+SLOT-UNBOUND+ in which case SB-PCL:+SLOT-UNBOUND+ is │ │ │ │ +returned and NEW is assigned to the slot. Additionally, the results are │ │ │ │ +unspecified if there is an applicable method on either │ │ │ │ +SB-MOP:SLOT-VALUE-USING-CLASS, (SETF SB-MOP:SLOT-VALUE-USING-CLASS), or │ │ │ │ +SB-MOP:SLOT-BOUNDP-USING-CLASS. │ │ │ │ +Additionally, the PLACE can be a anything for which a CAS-function has │ │ │ │ +been defined. (See SB-EXT:CAS for more information.) │ │ │ │ +Updates PLACE atomically to the value returned by calling function │ │ │ │ +designated by UPDATE-FN with ARGUMENTS and the previous value of PLACE. │ │ │ │ +PLACE may be read and UPDATE-FN evaluated and called multiple times before the │ │ │ │ +update succeeds: atomicity in this context means that the value of PLACE did │ │ │ │ +not change between the time it was read, and the time it was replaced with the │ │ │ │ +computed value. │ │ │ │ +PLACE can be any place supported by SB-EXT:COMPARE-AND-SWAP. │ │ │ │ +Examples: │ │ │ │ + ;;; Conses T to the head of FOO-LIST. │ │ │ │ + (defstruct foo list) │ │ │ │ + (defvar *foo* (make-foo)) │ │ │ │ + (atomic-update (foo-list *foo*) #'cons t) │ │ │ │ + (let ((x (cons :count 0))) │ │ │ │ + (mapc #'sb-thread:join-thread │ │ │ │ + (loop repeat 1000 │ │ │ │ + collect (sb-thread:make-thread │ │ │ │ + (lambda () │ │ │ │ + (loop repeat 1000 │ │ │ │ + do (atomic-update (cdr x) #'1+) │ │ │ │ + (sleep 0.00001)))))) │ │ │ │ + ;; Guaranteed to be (:COUNT . 1000000) -- if you replace │ │ │ │ + ;; atomic update with (INCF (CDR X)) above, the result becomes │ │ │ │ + ;; unpredictable. │ │ │ │ +Atomically increments PLACE by DIFF, and returns the value of PLACE before │ │ │ │ +the increment. │ │ │ │ +PLACE must access one of the following: │ │ │ │ + - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 32) │ │ │ │ + or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) │ │ │ │ + The type SB-EXT:WORD can be used for these purposes. │ │ │ │ + - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ + - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM. │ │ │ │ +Macroexpansion is performed on PLACE before expanding ATOMIC-INCF. │ │ │ │ +Incrementing is done using modular arithmetic, │ │ │ │ +which is well-defined over two different domains: │ │ │ │ + - For structures and arrays, the operation accepts and produces │ │ │ │ + an (UNSIGNED-BYTE 32), and DIFF must be of type (SIGNED-BYTE 32). │ │ │ │ + ATOMIC-INCF of #xFFFFFFFF by one results in #x0 being stored in PLACE. │ │ │ │ + - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ + ATOMIC-INCF of #x1FFFFFFF by one results in #x-20000000 │ │ │ │ + being stored in PLACE. │ │ │ │ +DIFF defaults to 1. │ │ │ │ +EXPERIMENTAL: Interface subject to change. │ │ │ │ +Return line# and column# of this macro invocation as multiple values. │ │ │ │ +Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ +and assigned to NAME both at compile- and load-time, but only if NAME is not │ │ │ │ +already bound. │ │ │ │ +Global variables share their values between all threads, and cannot be │ │ │ │ +locally bound, declared special, defined as constants, and neither bound │ │ │ │ +nor defined as symbol macros. │ │ │ │ +See also the declarations SB-EXT:GLOBAL and SB-EXT:ALWAYS-BOUND. │ │ │ │ +Wait until TEST-FORM evaluates to true, then return its primary value. │ │ │ │ +If TIMEOUT is provided, waits at most approximately TIMEOUT seconds before │ │ │ │ +returning NIL. │ │ │ │ +If WITH-DEADLINE has been used to provide a global deadline, signals a │ │ │ │ +DEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the │ │ │ │ +deadline. │ │ │ │ +Experimental: subject to change without prior notice. │ │ │ │ +Return character position of this macro invocation or NIL if unavailable. │ │ │ │ +Execute the body, asynchronously interrupting it and signalling a TIMEOUT │ │ │ │ +condition after at least EXPIRES seconds have passed. │ │ │ │ +Note that it is never safe to unwind from an asynchronous condition. Consider: │ │ │ │ + (defun call-with-foo (function) │ │ │ │ + (let (foo) │ │ │ │ + (unwind-protect │ │ │ │ + (progn │ │ │ │ + (setf foo (get-foo)) │ │ │ │ + (funcall function foo)) │ │ │ │ + (when foo │ │ │ │ + (release-foo foo))))) │ │ │ │ +If TIMEOUT occurs after GET-FOO has executed, but before the assignment, then │ │ │ │ +RELEASE-FOO will be missed. While individual sites like this can be made proof │ │ │ │ +against asynchronous unwinds, this doesn't solve the fundamental issue, as all │ │ │ │ +the frames potentially unwound through need to be proofed, which includes both │ │ │ │ +system and application code -- and in essence proofing everything will make │ │ │ │ +the system uninterruptible. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Return T iff TYPE1 and TYPE2 describe equivalent alien types. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ Analogous to GET-SETF-EXPANSION. Returns the following six values: │ │ │ │ @@ -32664,14 +32779,86 @@ │ │ │ │ Number of page faults. (Omitted if zero.) │ │ │ │ :BYTES-CONSED │ │ │ │ Approximate number of bytes consed. │ │ │ │ :ABORTED │ │ │ │ True if FUNCTION caused a non-local transfer of control. (Omitted if │ │ │ │ NIL.) │ │ │ │ EXPERIMENTAL: Interface subject to change. │ │ │ │ +Return the stream line length or NIL. │ │ │ │ +This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ + optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ + The string argument is returned. The default method provided by │ │ │ │ + FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ + STREAM-WRITE-CHAR. │ │ │ │ +Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ + method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ +Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ + returns the integer as the result. │ │ │ │ +This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ + STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ + define their own method since it will usually be trivial and will │ │ │ │ + always be more efficient than the default method. │ │ │ │ +This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. │ │ │ │ + It returns either a character or :EOF. The default method calls │ │ │ │ + STREAM-READ-CHAR and STREAM-UNREAD-CHAR. │ │ │ │ +This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ +Is STREAM known to be positioned at the beginning of a line? │ │ │ │ + It is permissible for an implementation to always return │ │ │ │ + NIL. This is used in the implementation of FRESH-LINE. Note that │ │ │ │ + while a value of 0 from STREAM-LINE-COLUMN also indicates the │ │ │ │ + beginning of a line, there are cases where STREAM-START-LINE-P can be │ │ │ │ + meaningfully implemented although STREAM-LINE-COLUMN can't be. For │ │ │ │ + example, for a window using variable-width characters, the column │ │ │ │ + number isn't very meaningful, but the beginning of the line does have │ │ │ │ + a clear meaning. The default method for STREAM-START-LINE-P on class │ │ │ │ + FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if │ │ │ │ + that is defined to return NIL, then a method should be provided for │ │ │ │ + either STREAM-START-LINE-P or STREAM-FRESH-LINE. │ │ │ │ +This is used by READ-LINE. A string is returned as the first value. The │ │ │ │ + second value is true if the string was terminated by end-of-file │ │ │ │ + instead of the end of a line. The default method uses repeated │ │ │ │ + calls to STREAM-READ-CHAR. │ │ │ │ +Return the column number where the next character │ │ │ │ + will be written, or NIL if that is not meaningful for this stream. │ │ │ │ + The first column on a line is numbered 0. This function is used in │ │ │ │ + the implementation of PPRINT and the FORMAT ~T directive. For every │ │ │ │ + character output stream class that is defined, a method must be │ │ │ │ + defined for this function, although it is permissible for it to │ │ │ │ + always return NIL. │ │ │ │ +This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given │ │ │ │ + output STREAM. The default method does nothing. │ │ │ │ +Write enough blank space so that the next character will be │ │ │ │ + written at the specified column. Returns true if the operation is │ │ │ │ + successful, or NIL if it is not supported for this stream. This is │ │ │ │ + intended for use by by PPRINT and FORMAT ~T. The default method uses │ │ │ │ + STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a │ │ │ │ + #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL. │ │ │ │ +This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. │ │ │ │ + The default method does nothing. │ │ │ │ +This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ +Read one character from the stream. Return either a │ │ │ │ + character object, or the symbol :EOF if the stream is at end-of-file. │ │ │ │ + Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a │ │ │ │ + method for this function. │ │ │ │ +This is used to implement READ-CHAR-NO-HANG. It returns either a │ │ │ │ + character, or NIL if no input is currently available, or :EOF if │ │ │ │ + end-of-file is reached. The default method provided by │ │ │ │ + FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this │ │ │ │ + is sufficient for file streams, but interactive streams should define │ │ │ │ + their own method. │ │ │ │ +Attempts to ensure that all output sent to the Stream has reached │ │ │ │ + its destination, and only then returns false. Implements │ │ │ │ + FINISH-OUTPUT. The default method does nothing. │ │ │ │ +Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ + if the stream is at end-of-file. │ │ │ │ +Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. │ │ │ │ + Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM │ │ │ │ + must define a method for this function. │ │ │ │ +Attempts to force any buffered output to be sent. Implements │ │ │ │ + FORCE-OUTPUT. The default method does nothing. │ │ │ │ Return a string obtained by decoding VECTOR according to EXTERNAL-FORMAT. │ │ │ │ If EXTERNAL-FORMAT is given, it must designate an external format. │ │ │ │ If given, START and END must be bounding index designators and │ │ │ │ designate a subsequence of VECTOR that should be decoded. │ │ │ │ If some of the octets of VECTOR (or the subsequence bounded by START │ │ │ │ and END) cannot be decoded by EXTERNAL-FORMAT an error of a subtype of │ │ │ │ SB-INT:CHARACTER-DECODING-ERROR is signaled. │ │ │ │ @@ -32694,14 +32881,20 @@ │ │ │ │ symbolic links are considered file entries. In both cases the pathname used │ │ │ │ for the symbolic link is not fully resolved, but names it as an immediate │ │ │ │ child of DIRECTORY. Defaults to T. │ │ │ │ :ERRORP │ │ │ │ If true, signal an error if DIRECTORY does not exist, cannot be read, etc. │ │ │ │ Defaults to T. │ │ │ │ Experimental: interface subject to change. │ │ │ │ +Specifies that the values returned by FORM conform to the │ │ │ │ +VALUE-TYPE, and causes the compiler to trust this information │ │ │ │ +unconditionally. │ │ │ │ +Consequences are undefined if any result is not of the declared type │ │ │ │ +-- typical symptoms including memory corruptions. Use with great │ │ │ │ +NEW-INFO │ │ │ │ Convert THING into a pathname, using the native conventions │ │ │ │ appropriate for the pathname host HOST, or if not specified the │ │ │ │ host of DEFAULTS. If THING is a string, the parse is bounded by │ │ │ │ START and END, and error behaviour is controlled by JUNK-ALLOWED, │ │ │ │ as with PARSE-NAMESTRING. For file systems whose native │ │ │ │ conventions allow directories to be indicated as files, if │ │ │ │ AS-DIRECTORY is true, return a pathname denoting THING as a │ │ │ │ @@ -32967,190 +33160,50 @@ │ │ │ │ Returns T if READTABLE normalizes symbols to NFKC, and NIL otherwise. │ │ │ │ The READTABLE-NORMALIZATION of the standard readtable is T. │ │ │ │ Cancel TIMER. Once this function returns it is guaranteed that │ │ │ │ TIMER shall not be triggered again and there are no unfinished │ │ │ │ triggers. │ │ │ │ UYPO&*1G │ │ │ │ q#E}=Lp~=f │ │ │ │ -ETYPECASE Keyform {(Type Form*)}* │ │ │ │ - Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ - is true. If no form is satisfied then an error is signalled. │ │ │ │ -qlC'XUV4I │ │ │ │ -Execute FORM and print timing information on *TRACE-OUTPUT*. │ │ │ │ -On some hardware platforms estimated processor cycle counts are │ │ │ │ -included in this output; this number is slightly inflated, since it │ │ │ │ -includes the pipeline involved in reading the cycle counter -- │ │ │ │ -executing (TIME NIL) a few times will give you an idea of the │ │ │ │ -overhead, and its variance. The cycle counters are also per processor, │ │ │ │ -not per thread: if multiple threads are running on the same processor, │ │ │ │ -the reported counts will include cycles taken up by all threads │ │ │ │ -running on the processor where TIME was executed. Furthermore, if the │ │ │ │ -operating system migrates the thread to another processor between │ │ │ │ -reads of the cycle counter, the results will be completely bogus. │ │ │ │ -Finally, the counter is cycle counter, incremented by the hardware │ │ │ │ -even when the process is halted -- which is to say that cycles pass │ │ │ │ -normally during operations like SLEEP. │ │ │ │ -ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If none of the keys matches then an error is signalled. │ │ │ │ -(WITH-SIMPLE-RESTART (restart-name format-string format-arguments) │ │ │ │ - body) │ │ │ │ - If restart-name is not invoked, then all values returned by forms are │ │ │ │ - returned. If control is transferred to this restart, it immediately │ │ │ │ - returns the values NIL and T. │ │ │ │ -DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* │ │ │ │ - Define NAME as a condition type. This new type inherits slots and its │ │ │ │ - report function from the specified PARENT-TYPEs. A slot spec is a list of: │ │ │ │ - (slot-name :reader :initarg {Option Value}* │ │ │ │ - The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION │ │ │ │ - and :TYPE and the overall options :DEFAULT-INITARGS and │ │ │ │ - [type] :DOCUMENTATION are also allowed. │ │ │ │ - The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either │ │ │ │ - a string or a two-argument lambda or function name. If a function, the │ │ │ │ - function is called with the condition and stream to report the condition. │ │ │ │ - If a string, the string is printed. │ │ │ │ - Condition types are classes, but (as allowed by ANSI and not as described in │ │ │ │ - CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and │ │ │ │ - SLOT-VALUE may not be used on condition objects. │ │ │ │ -DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* │ │ │ │ - Executes the FORMs at least once for each symbol accessible in the given │ │ │ │ - PACKAGE with VAR bound to the current symbol. │ │ │ │ -(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*) │ │ │ │ - The form is evaluated in a dynamic context where the clauses have │ │ │ │ - special meanings as points to which control may be transferred (see │ │ │ │ - INVOKE-RESTART). When clauses contain the same case-name, │ │ │ │ - FIND-RESTART will find the first such clause. If form is a call to │ │ │ │ - SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the │ │ │ │ - signalled condition will be associated with the new restarts. │ │ │ │ ->)PW:`5w │ │ │ │ -Atomically decrements PLACE by DIFF, and returns the value of PLACE before │ │ │ │ -the decrement. │ │ │ │ -PLACE must access one of the following: │ │ │ │ - - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 32) │ │ │ │ - or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) │ │ │ │ - The type SB-EXT:WORD can be used for these purposes. │ │ │ │ - - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ - - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM. │ │ │ │ -Macroexpansion is performed on PLACE before expanding ATOMIC-DECF. │ │ │ │ -Decrementing is done using modular arithmetic, │ │ │ │ -which is well-defined over two different domains: │ │ │ │ - - For structures and arrays, the operation accepts and produces │ │ │ │ - an (UNSIGNED-BYTE 32), and DIFF must be of type (SIGNED-BYTE 32). │ │ │ │ - ATOMIC-DECF of #x0 by one results in #xFFFFFFFF being stored in PLACE. │ │ │ │ - - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ - ATOMIC-DECF of #x-20000000 by one results in #x1FFFFFFF │ │ │ │ - being stored in PLACE. │ │ │ │ -DIFF defaults to 1. │ │ │ │ -EXPERIMENTAL: Interface subject to change. │ │ │ │ -Ignores all runtime package lock violations during the execution of │ │ │ │ -body. Body can begin with declarations. │ │ │ │ -Limits concurrent accesses to HASH-TABLE for the duration of BODY. │ │ │ │ -If HASH-TABLE is synchronized, BODY will execute with exclusive │ │ │ │ -ownership of the table. If HASH-TABLE is not synchronized, BODY will │ │ │ │ -execute with other WITH-LOCKED-HASH-TABLE bodies excluded -- exclusion │ │ │ │ -of hash-table accesses not surrounded by WITH-LOCKED-HASH-TABLE is │ │ │ │ -unspecified. │ │ │ │ -Like POP, but atomic. PLACE may be read multiple times before │ │ │ │ -the operation completes -- the write does not occur until such time │ │ │ │ -that no other thread modified PLACE between the read and the write. │ │ │ │ -Works on all CASable places. │ │ │ │ -Atomically stores NEW in PLACE if OLD matches the current value of PLACE. │ │ │ │ -Two values are considered to match if they are EQ. Returns the previous value │ │ │ │ -of PLACE: if the returned value is EQ to OLD, the swap was carried out. │ │ │ │ -PLACE must be an CAS-able place. Built-in CAS-able places are accessor forms │ │ │ │ -whose CAR is one of the following: │ │ │ │ - CAR, CDR, FIRST, REST, SVREF, SYMBOL-PLIST, SYMBOL-VALUE, SLOT-VALUE │ │ │ │ - SB-MOP:STANDARD-INSTANCE-ACCESS, SB-MOP:FUNCALLABLE-STANDARD-INSTANCE-ACCESS, │ │ │ │ -or the name of a DEFSTRUCT created accessor for a slot whose storage type │ │ │ │ -is not raw. (Refer to the the "Efficiency" chapter of the manual │ │ │ │ -for the list of raw slot types. Future extensions to this macro may allow │ │ │ │ -it to work on some raw slot types.) │ │ │ │ -In case of SLOT-VALUE, if the slot is unbound, SLOT-UNBOUND is called unless │ │ │ │ -OLD is EQ to SB-PCL:+SLOT-UNBOUND+ in which case SB-PCL:+SLOT-UNBOUND+ is │ │ │ │ -returned and NEW is assigned to the slot. Additionally, the results are │ │ │ │ -unspecified if there is an applicable method on either │ │ │ │ -SB-MOP:SLOT-VALUE-USING-CLASS, (SETF SB-MOP:SLOT-VALUE-USING-CLASS), or │ │ │ │ -SB-MOP:SLOT-BOUNDP-USING-CLASS. │ │ │ │ -Additionally, the PLACE can be a anything for which a CAS-function has │ │ │ │ -been defined. (See SB-EXT:CAS for more information.) │ │ │ │ -Updates PLACE atomically to the value returned by calling function │ │ │ │ -designated by UPDATE-FN with ARGUMENTS and the previous value of PLACE. │ │ │ │ -PLACE may be read and UPDATE-FN evaluated and called multiple times before the │ │ │ │ -update succeeds: atomicity in this context means that the value of PLACE did │ │ │ │ -not change between the time it was read, and the time it was replaced with the │ │ │ │ -computed value. │ │ │ │ -PLACE can be any place supported by SB-EXT:COMPARE-AND-SWAP. │ │ │ │ -Examples: │ │ │ │ - ;;; Conses T to the head of FOO-LIST. │ │ │ │ - (defstruct foo list) │ │ │ │ - (defvar *foo* (make-foo)) │ │ │ │ - (atomic-update (foo-list *foo*) #'cons t) │ │ │ │ - (let ((x (cons :count 0))) │ │ │ │ - (mapc #'sb-thread:join-thread │ │ │ │ - (loop repeat 1000 │ │ │ │ - collect (sb-thread:make-thread │ │ │ │ - (lambda () │ │ │ │ - (loop repeat 1000 │ │ │ │ - do (atomic-update (cdr x) #'1+) │ │ │ │ - (sleep 0.00001)))))) │ │ │ │ - ;; Guaranteed to be (:COUNT . 1000000) -- if you replace │ │ │ │ - ;; atomic update with (INCF (CDR X)) above, the result becomes │ │ │ │ - ;; unpredictable. │ │ │ │ -Atomically increments PLACE by DIFF, and returns the value of PLACE before │ │ │ │ -the increment. │ │ │ │ -PLACE must access one of the following: │ │ │ │ - - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 32) │ │ │ │ - or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) │ │ │ │ - The type SB-EXT:WORD can be used for these purposes. │ │ │ │ - - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ - - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM. │ │ │ │ -Macroexpansion is performed on PLACE before expanding ATOMIC-INCF. │ │ │ │ -Incrementing is done using modular arithmetic, │ │ │ │ -which is well-defined over two different domains: │ │ │ │ - - For structures and arrays, the operation accepts and produces │ │ │ │ - an (UNSIGNED-BYTE 32), and DIFF must be of type (SIGNED-BYTE 32). │ │ │ │ - ATOMIC-INCF of #xFFFFFFFF by one results in #x0 being stored in PLACE. │ │ │ │ - - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ - ATOMIC-INCF of #x1FFFFFFF by one results in #x-20000000 │ │ │ │ - being stored in PLACE. │ │ │ │ -DIFF defaults to 1. │ │ │ │ -EXPERIMENTAL: Interface subject to change. │ │ │ │ -Return line# and column# of this macro invocation as multiple values. │ │ │ │ -Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ -and assigned to NAME both at compile- and load-time, but only if NAME is not │ │ │ │ -already bound. │ │ │ │ -Global variables share their values between all threads, and cannot be │ │ │ │ -locally bound, declared special, defined as constants, and neither bound │ │ │ │ -nor defined as symbol macros. │ │ │ │ -See also the declarations SB-EXT:GLOBAL and SB-EXT:ALWAYS-BOUND. │ │ │ │ -Wait until TEST-FORM evaluates to true, then return its primary value. │ │ │ │ -If TIMEOUT is provided, waits at most approximately TIMEOUT seconds before │ │ │ │ -returning NIL. │ │ │ │ -If WITH-DEADLINE has been used to provide a global deadline, signals a │ │ │ │ -DEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the │ │ │ │ -deadline. │ │ │ │ -Experimental: subject to change without prior notice. │ │ │ │ -Return character position of this macro invocation or NIL if unavailable. │ │ │ │ -Execute the body, asynchronously interrupting it and signalling a TIMEOUT │ │ │ │ -condition after at least EXPIRES seconds have passed. │ │ │ │ -Note that it is never safe to unwind from an asynchronous condition. Consider: │ │ │ │ - (defun call-with-foo (function) │ │ │ │ - (let (foo) │ │ │ │ - (unwind-protect │ │ │ │ - (progn │ │ │ │ - (setf foo (get-foo)) │ │ │ │ - (funcall function foo)) │ │ │ │ - (when foo │ │ │ │ - (release-foo foo))))) │ │ │ │ -If TIMEOUT occurs after GET-FOO has executed, but before the assignment, then │ │ │ │ -RELEASE-FOO will be missed. While individual sites like this can be made proof │ │ │ │ -against asynchronous unwinds, this doesn't solve the fundamental issue, as all │ │ │ │ -the frames potentially unwound through need to be proofed, which includes both │ │ │ │ -system and application code -- and in essence proofing everything will make │ │ │ │ -the system uninterruptible. │ │ │ │ +3lG LN@tr │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +{DH(Rj~H │ │ │ │ +c8Pos03iG# │ │ │ │ +Allocate vector of LENGTH elements in static space. Only allocation │ │ │ │ +of specialized arrays is supported. │ │ │ │ +Returns the value of the constant FORM in ENVIRONMENT. Behaviour │ │ │ │ +is undefined unless CONSTANTP has been first used to determine the │ │ │ │ +constantness of the FORM in ENVIRONMENT. │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP0 │ │ │ │ +l|2f{<=id │ │ │ │ +7WIGzrg? │ │ │ │ +This function returns a list representing the state of the floating │ │ │ │ +point modes. The list is in the same format as the &KEY arguments to │ │ │ │ +SET-FLOATING-POINT-MODES, i.e. │ │ │ │ + (apply #'set-floating-point-modes (get-floating-point-modes)) │ │ │ │ +sets the floating point modes to their current values (and thus is a no-op). │ │ │ │ +"O3*`o:0 │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP │ │ │ │ +MORE-ARG │ │ │ │ +SB-INT09 │ │ │ │ +MORE-ARG │ │ │ │ +Delete all LIST entries EQ to ITEM (destructively modifying LIST), │ │ │ │ +and return the modified LIST. │ │ │ │ +Return a stream that sends all output to the stream TARGET, but modifies │ │ │ │ + the case of letters, depending on KIND, which should be one of: │ │ │ │ + :UPCASE - convert to upper case. │ │ │ │ + :DOWNCASE - convert to lower case. │ │ │ │ + :CAPITALIZE - convert the first letter of words to upper case and the │ │ │ │ + rest of the word to lower case. │ │ │ │ + :CAPITALIZE-FIRST - convert the first letter of the first word to upper │ │ │ │ + case and everything else to lower case. │ │ │ │ +GRANULARITY │ │ │ │ UNLOCKED-PACKAGES │ │ │ │ Unlocks PACKAGES for the dynamic scope of the body. Signals an │ │ │ │ error if any of PACKAGES is not a valid package designator. │ │ │ │ Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ and assigned to NAME at load-time, but only if NAME is not already bound. │ │ │ │ Attempts to read NAME at compile-time will signal an UNBOUND-VARIABLE error │ │ │ │ unless it has otherwise been assigned a value. │ │ │ │ @@ -33217,108 +33270,14 @@ │ │ │ │ (lBUY1$9 │ │ │ │ Define function names of the form of a list headed by SYMBOL to be │ │ │ │ a legal function name, subject to restrictions imposed by BODY. BODY │ │ │ │ is evaluated with VAR bound to the form required to check, and should │ │ │ │ return two values: the first value is a generalized boolean indicating │ │ │ │ legality, and the second a symbol for use as a BLOCK name or similar │ │ │ │ situations. │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -{DH(Rj~H │ │ │ │ -This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. │ │ │ │ - It returns either a character or :EOF. The default method calls │ │ │ │ - STREAM-READ-CHAR and STREAM-UNREAD-CHAR. │ │ │ │ -This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ -Is STREAM known to be positioned at the beginning of a line? │ │ │ │ - It is permissible for an implementation to always return │ │ │ │ - NIL. This is used in the implementation of FRESH-LINE. Note that │ │ │ │ - while a value of 0 from STREAM-LINE-COLUMN also indicates the │ │ │ │ - beginning of a line, there are cases where STREAM-START-LINE-P can be │ │ │ │ - meaningfully implemented although STREAM-LINE-COLUMN can't be. For │ │ │ │ - example, for a window using variable-width characters, the column │ │ │ │ - number isn't very meaningful, but the beginning of the line does have │ │ │ │ - a clear meaning. The default method for STREAM-START-LINE-P on class │ │ │ │ - FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if │ │ │ │ - that is defined to return NIL, then a method should be provided for │ │ │ │ - either STREAM-START-LINE-P or STREAM-FRESH-LINE. │ │ │ │ -This is used by READ-LINE. A string is returned as the first value. The │ │ │ │ - second value is true if the string was terminated by end-of-file │ │ │ │ - instead of the end of a line. The default method uses repeated │ │ │ │ - calls to STREAM-READ-CHAR. │ │ │ │ -Return the column number where the next character │ │ │ │ - will be written, or NIL if that is not meaningful for this stream. │ │ │ │ - The first column on a line is numbered 0. This function is used in │ │ │ │ - the implementation of PPRINT and the FORMAT ~T directive. For every │ │ │ │ - character output stream class that is defined, a method must be │ │ │ │ - defined for this function, although it is permissible for it to │ │ │ │ - always return NIL. │ │ │ │ -This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given │ │ │ │ - output STREAM. The default method does nothing. │ │ │ │ -Write enough blank space so that the next character will be │ │ │ │ - written at the specified column. Returns true if the operation is │ │ │ │ - successful, or NIL if it is not supported for this stream. This is │ │ │ │ - intended for use by by PPRINT and FORMAT ~T. The default method uses │ │ │ │ - STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a │ │ │ │ - #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL. │ │ │ │ -This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. │ │ │ │ - The default method does nothing. │ │ │ │ -This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ -Read one character from the stream. Return either a │ │ │ │ - character object, or the symbol :EOF if the stream is at end-of-file. │ │ │ │ - Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a │ │ │ │ - method for this function. │ │ │ │ -NEW-INFO │ │ │ │ -This is used to implement READ-CHAR-NO-HANG. It returns either a │ │ │ │ - character, or NIL if no input is currently available, or :EOF if │ │ │ │ - end-of-file is reached. The default method provided by │ │ │ │ - FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this │ │ │ │ - is sufficient for file streams, but interactive streams should define │ │ │ │ - their own method. │ │ │ │ -Attempts to ensure that all output sent to the Stream has reached │ │ │ │ - its destination, and only then returns false. Implements │ │ │ │ - FINISH-OUTPUT. The default method does nothing. │ │ │ │ -Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ - if the stream is at end-of-file. │ │ │ │ -Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. │ │ │ │ - Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM │ │ │ │ - must define a method for this function. │ │ │ │ -Attempts to force any buffered output to be sent. Implements │ │ │ │ - FORCE-OUTPUT. The default method does nothing. │ │ │ │ -c8Pos03iG# │ │ │ │ -Allocate vector of LENGTH elements in static space. Only allocation │ │ │ │ -of specialized arrays is supported. │ │ │ │ -Returns the value of the constant FORM in ENVIRONMENT. Behaviour │ │ │ │ -is undefined unless CONSTANTP has been first used to determine the │ │ │ │ -constantness of the FORM in ENVIRONMENT. │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP0 │ │ │ │ -l|2f{<=id │ │ │ │ -7WIGzrg? │ │ │ │ -This function returns a list representing the state of the floating │ │ │ │ -point modes. The list is in the same format as the &KEY arguments to │ │ │ │ -SET-FLOATING-POINT-MODES, i.e. │ │ │ │ - (apply #'set-floating-point-modes (get-floating-point-modes)) │ │ │ │ -sets the floating point modes to their current values (and thus is a no-op). │ │ │ │ -"O3*`o:0 │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -SB-INT09 │ │ │ │ -MORE-ARG │ │ │ │ -Delete all LIST entries EQ to ITEM (destructively modifying LIST), │ │ │ │ -and return the modified LIST. │ │ │ │ -Return a stream that sends all output to the stream TARGET, but modifies │ │ │ │ - the case of letters, depending on KIND, which should be one of: │ │ │ │ - :UPCASE - convert to upper case. │ │ │ │ - :DOWNCASE - convert to lower case. │ │ │ │ - :CAPITALIZE - convert the first letter of words to upper case and the │ │ │ │ - rest of the word to lower case. │ │ │ │ - :CAPITALIZE-FIRST - convert the first letter of the first word to upper │ │ │ │ - case and everything else to lower case. │ │ │ │ -GRANULARITY │ │ │ │ 8*Pu:pUU │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ Return the first pair of alist where item is EQ to the key of pair. │ │ │ │ FORMAT-DECODED-TIME formats a string containing decoded time │ │ │ │ expressed in a humanly-readable manner. The destination is any │ │ │ │ destination which can be accepted by the FORMAT function. The │ │ │ │ @@ -33360,24 +33319,14 @@ │ │ │ │ 8FF^FA^"3u │ │ │ │ COMMON-LISP │ │ │ │ POSSIBLY-LOGICAL-PATHNAME0% │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP03 │ │ │ │ -~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ - ~// │ │ │ │ -illegal dotted lambda list: ~// │ │ │ │ -&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ -expected lambda list keyword at ~S in: ~// │ │ │ │ -~S and ~S are mutually exclusive: ~// │ │ │ │ -repeated ~S in lambda list: ~// │ │ │ │ -~A is not allowed in ~A: ~// │ │ │ │ -suspicious ~A ~S in lambda list: ~//. │ │ │ │ -expecting variable after ~A in: ~// │ │ │ │ OPTIONAL-ARGS │ │ │ │ MORE-ARG │ │ │ │ PROMISE0 │ │ │ │ MAYBE-PACKAGE │ │ │ │ If CAR is eq to the car of OLD-CONS and CDR is eq to the CDR, return │ │ │ │ OLD-CONS, otherwise return (cons CAR CDR). │ │ │ │ a macro lambda list │ │ │ │ @@ -33417,53 +33366,14 @@ │ │ │ │ GET-FLOATING-POINT-MODES may be used to find the floating point modes │ │ │ │ currently in effect. SAVE-LISP-AND-DIE preserves the floating point modes │ │ │ │ in effect. │ │ │ │ define ~S as a constant │ │ │ │ compare-and-swap SYMBOL-VALUE of ~S │ │ │ │ set SYMBOL-VALUE of ~S │ │ │ │ make ~S unbound │ │ │ │ -Binds NAME as a local function for BODY. Each time #'NAME is called, it │ │ │ │ -returns SECONDS minus the time that has elapsed since BODY was entered, or │ │ │ │ -zero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME │ │ │ │ -returns NIL each time. │ │ │ │ -DEADLINE │ │ │ │ -OVERRIDE │ │ │ │ -SECONDS0 │ │ │ │ -Arranges for a TIMEOUT condition to be signalled if an operation │ │ │ │ -respecting deadlines occurs either after the deadline has passed, or │ │ │ │ -would take longer than the time left to complete. │ │ │ │ -Currently only SLEEP, blocking IO operations, GET-MUTEX, and │ │ │ │ -CONDITION-WAIT respect deadlines, but this includes their implicit │ │ │ │ -uses inside SBCL itself. │ │ │ │ -Unless OVERRIDE is true, existing deadlines can only be restricted, │ │ │ │ -not extended. Deadlines are per thread: children are unaffected by │ │ │ │ -their parent's deadlines. │ │ │ │ -Experimental. │ │ │ │ -Arrange with the garbage collector that OBJECTS will not be moved in memory │ │ │ │ -for the duration of BODY. Useful for e.g. foreign calls where another thread │ │ │ │ -may trigger garbage collection. │ │ │ │ -WITHOUT-GCING-BODY │ │ │ │ -Executes the forms in the body without doing a garbage collection. It │ │ │ │ -inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ -upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ -Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ -enabled in this thread. │ │ │ │ -Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ -SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ -Should be used with great care, and not at all in multithreaded application │ │ │ │ -code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ -held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ -stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ -system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ -locks, application code can never be certain that this invariant is │ │ │ │ -maintained. │ │ │ │ -Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ -Establish a handler with SB-SYS:ADD-FD-HANDLER for the duration of BODY. │ │ │ │ - DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to │ │ │ │ - use, and FUNCTION is the function to call whenever FD is usable. │ │ │ │ COMMON-LISP │ │ │ │ Return the position of the first element EQ to ITEM. │ │ │ │ COMMON-LISP │ │ │ │ EXTERNAL-FORMAT │ │ │ │ Returns the address of the foreign symbol NAME, or NIL. Does not enter the │ │ │ │ symbol in the linkage table, and never returns an address in the linkage-table. │ │ │ │ SB-ALIEN │ │ │ │ @@ -33495,15 +33405,53 @@ │ │ │ │ Find the DEFER-DEADLINE restart associated with CONDITION, and │ │ │ │ invoke it with SECONDS as argument (deferring the deadline by that many │ │ │ │ seconds.) Otherwise return NIL if the restart is not found. │ │ │ │ Remove any handlers referring to FD. This should only be used when attempting │ │ │ │ to recover from a detected inconsistency. │ │ │ │ HANDLER0 │ │ │ │ COMMON-LISP │ │ │ │ - SLOT-NAME │ │ │ │ +Binds NAME as a local function for BODY. Each time #'NAME is called, it │ │ │ │ +returns SECONDS minus the time that has elapsed since BODY was entered, or │ │ │ │ +zero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME │ │ │ │ +returns NIL each time. │ │ │ │ +DEADLINE │ │ │ │ +OVERRIDE │ │ │ │ +SECONDS0 │ │ │ │ +Arranges for a TIMEOUT condition to be signalled if an operation │ │ │ │ +respecting deadlines occurs either after the deadline has passed, or │ │ │ │ +would take longer than the time left to complete. │ │ │ │ +Currently only SLEEP, blocking IO operations, GET-MUTEX, and │ │ │ │ +CONDITION-WAIT respect deadlines, but this includes their implicit │ │ │ │ +uses inside SBCL itself. │ │ │ │ +Unless OVERRIDE is true, existing deadlines can only be restricted, │ │ │ │ +not extended. Deadlines are per thread: children are unaffected by │ │ │ │ +their parent's deadlines. │ │ │ │ +Experimental. │ │ │ │ +Arrange with the garbage collector that OBJECTS will not be moved in memory │ │ │ │ +for the duration of BODY. Useful for e.g. foreign calls where another thread │ │ │ │ +may trigger garbage collection. │ │ │ │ +WITHOUT-GCING-BODY │ │ │ │ +Executes the forms in the body without doing a garbage collection. It │ │ │ │ +inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ +upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ +Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ +enabled in this thread. │ │ │ │ +Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ +SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ +Should be used with great care, and not at all in multithreaded application │ │ │ │ +code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ +held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ +stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ +system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ +locks, application code can never be certain that this invariant is │ │ │ │ +maintained. │ │ │ │ +Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ +Establish a handler with SB-SYS:ADD-FD-HANDLER for the duration of BODY. │ │ │ │ + DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to │ │ │ │ + use, and FUNCTION is the function to call whenever FD is usable. │ │ │ │ Executes BODY with deferrable interrupts conditionally enabled. If there │ │ │ │ are pending interrupts they take effect prior to executing BODY. │ │ │ │ As interrupts are normally allowed WITH-INTERRUPTS only makes sense if there │ │ │ │ is an outer WITHOUT-INTERRUPTS with a corresponding ALLOW-WITH-INTERRUPTS: │ │ │ │ interrupts are not enabled if any outer WITHOUT-INTERRUPTS is not accompanied │ │ │ │ by ALLOW-WITH-INTERRUPTS. │ │ │ │ OUTER-ALLOW-WITH-INRUPTS │ │ │ │ @@ -33530,40 +33478,113 @@ │ │ │ │ ;; The body of the lambda would be executed with WITH-INTERRUPTS allowed │ │ │ │ ;; regardless of the interrupt policy in effect when it is called. │ │ │ │ (lambda () (allow-with-interrupts ...))) │ │ │ │ (without-interrupts │ │ │ │ ;; The body of the lambda would be executed with interrupts enabled │ │ │ │ ;; regardless of the interrupt policy in effect when it is called. │ │ │ │ (lambda () (with-local-interrupts ...))) │ │ │ │ +encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ +4E4i4<4`4 │ │ │ │ +*9@9d979[9. │ │ │ │ +Syscall poll(2) failed: ~A │ │ │ │ +failed to resolve home directory for Unix uid=~S │ │ │ │ +select(2) │ │ │ │ +Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ +4E4i4<4`4 │ │ │ │ +*9@9d979[9. │ │ │ │ +Error calling tmpfile(): ~a │ │ │ │ +~S is not an early-method. │ │ │ │ +No slot called ~S in ~S. │ │ │ │ +Cannot look up slot-definition for ~S in ~S (too early to finalize.) │ │ │ │ +~@ │ │ │ │ +JMi ? 7 -$ │ │ │ │ +Backtrace for: ~S │ │ │ │ +Skip printing frame ~S │ │ │ │ +while printing frame ~S. The partial output is: ~S │ │ │ │ +non-FIXNUM non-NULL location in cell: ~S │ │ │ │ +updating obsolete instance │ │ │ │ +~S cannot handle the second argument ~S. │ │ │ │ +found no match for Unix uid=~S │ │ │ │ +~S~:[~;~:*~S~] │ │ │ │ +~S at ~S │ │ │ │ +~@[~S ~]~[free~;taken~;contested~:;err~] owner=~X │ │ │ │ +waiting on: │ │ │ │ +~@[tid=~D ~]~@[~S ~]~:[~{~I~A~^~2I~_ ~}~_~;~A~:[ no values~; values: ~:*~{~S~^, ~}~]~] │ │ │ │ +waiting on a mutex with a timeout │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +Cannot allocate an instance of ~S. │ │ │ │ +WRAPPER3 │ │ │ │ +SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ +1.0.56.55 │ │ │ │ + SLOT-NAME │ │ │ │ COMMON-LISP0 │ │ │ │ 8(PW:0uUc │ │ │ │ optimize away possible call to FDEFINITION at runtime │ │ │ │ COMMON-LISP │ │ │ │ METHOD-CELL │ │ │ │ MORE-ARG │ │ │ │ f&j"$l$SJ2; │ │ │ │ -COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ SLOT-NAME │ │ │ │ SLOT-NAME │ │ │ │ SLOT-NAME │ │ │ │ +COMMON-LISP │ │ │ │ +@,$Gq[rNPSg │ │ │ │ +.ANONYMOUS. │ │ │ │ +COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -@,$Gq[rNPSg │ │ │ │ -.ANONYMOUS. │ │ │ │ -SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ +Tests if STRING is normalized to FORM │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ + NODE-HASH │ │ │ │ + NODE-HASH │ │ │ │ + NODE-HASH │ │ │ │ +SO-DATA0 │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +0)pO:VUU │ │ │ │ +NUMBER-MATCHABLE-P8 │ │ │ │ +ONLY-INITIAL-ENTRIES0 │ │ │ │ +COMMON-LISP │ │ │ │ +MNEMONIC0 │ │ │ │ +OPERANDS │ │ │ │ +(p"dD<07 │ │ │ │ +kyHSeSKj │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ + NODE-DATA8 │ │ │ │ +NODE-KEY │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +MACRO-ENVIRONMENT8 │ │ │ │ +SOURCE-CODE │ │ │ │ +UNIVERSE0 │ │ │ │ + GENERATOR8 │ │ │ │ +GENERATOR-LAMBDA0 │ │ │ │ +ACCESSOR-TYPE │ │ │ │ +ACCESSOR-TYPE │ │ │ │ +WRAPPER00 │ │ │ │ +ACCESSOR-TYPE │ │ │ │ +WRAPPER00 │ │ │ │ +WRAPPER1 │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ +Convert a LIST into hash-table that has the same elements when viewed as a set, │ │ │ │ +up to the given equality TEST │ │ │ │ +REST-ARG │ │ │ │ +pathname TYPE for lisp FASt Loading files │ │ │ │ 5y5C9b:8;?< │ │ │ │ AJBDC8DnE{FXG │ │ │ │ SYS:SRC;PCL;WRAPPER.LISP │ │ │ │ SYS:SRC;PCL;DLISP3.LISP │ │ │ │ SYS:SRC;CODE;SETF.LISP │ │ │ │ -WRAPPER3 │ │ │ │ NpPRQ/X Y%Z │ │ │ │ -1.0.56.55 │ │ │ │ SYS:SRC;PCL;ENV.LISP │ │ │ │ Return a type specifier for SPECIALIZER, a non-parsed specializer │ │ │ │ form or a SPECIALIZER instance. │ │ │ │ More specifically, SPECIALIZER can be │ │ │ │ * a non-parsed specializer form such as │ │ │ │ * a symbol naming a class │ │ │ │ * a list of the form (eql OBJECT) │ │ │ │ @@ -33594,89 +33615,38 @@ │ │ │ │ Replaces the element at position INDEX of SEQUENCE with NEW-VALUE │ │ │ │ and returns NEW-VALUE or signals a PROTOCOL-UNIMPLEMENTED error if │ │ │ │ the sequence protocol is not implemented for the class of │ │ │ │ SEQUENCE. │ │ │ │ 3:@@0E&}X3 │ │ │ │ 3:@@0V"&}X3 │ │ │ │ 3:@@0E&}["& │ │ │ │ + ^'!65 W │ │ │ │ +>5 Q/F │ │ │ │ +$@ 5 \!#6 5 n@ │ │ │ │ +$; 5 [ │ │ │ │ +The object file ~A is~@ │ │ │ │ + older than the presumed source:~% ~A. │ │ │ │ +load object file │ │ │ │ +load source file │ │ │ │ +attempt to load an empty FASL file: │ │ │ │ UbQgg`mZ │ │ │ │ result type unsuitable │ │ │ │ RESULT-TYPE argument not constant │ │ │ │ can't analyze sequence type relationship │ │ │ │ / X(&/&a6 │ │ │ │ Returns a freshly allocated sequence of length LENGTH and of the │ │ │ │ same class as SEQUENCE. Elements of the new sequence are │ │ │ │ initialized to INITIAL-ELEMENT, if supplied, initialized to │ │ │ │ INITIAL-CONTENTS if supplied, or undefined if neither is supplied. │ │ │ │ Signals a PROTOCOL-UNIMPLEMENTED error if the sequence protocol is │ │ │ │ not implemented for the class of SEQUENCE. │ │ │ │ -COMMON-LISP │ │ │ │ -Tests if STRING is normalized to FORM │ │ │ │ - NODE-HASH │ │ │ │ - NODE-HASH │ │ │ │ - NODE-HASH │ │ │ │ -SO-DATA0 │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ .++...."G │ │ │ │ +(((+++" │ │ │ │ gc_card_mark │ │ │ │ , 5s(&T"# │ │ │ │ -0)pO:VUU │ │ │ │ -SIGNED-IMM-BYTE.PREFILTER │ │ │ │ -SIGNED-IMM-DATA.PREFILTER │ │ │ │ -ACCUM.PRINTER │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -NUMBER-MATCHABLE-P8 │ │ │ │ -ONLY-INITIAL-ENTRIES0 │ │ │ │ -COMMON-LISP │ │ │ │ -MNEMONIC0 │ │ │ │ -OPERANDS │ │ │ │ -(p"dD<07 │ │ │ │ -kyHSeSKj │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -"{BD/7\, │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ - NODE-DATA8 │ │ │ │ -NODE-KEY │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -Convert a LIST into hash-table that has the same elements when viewed as a set, │ │ │ │ -up to the given equality TEST │ │ │ │ -REST-ARG │ │ │ │ -pathname TYPE for lisp FASt Loading files │ │ │ │ -MACRO-ENVIRONMENT8 │ │ │ │ -SOURCE-CODE │ │ │ │ -UNIVERSE0 │ │ │ │ - GENERATOR8 │ │ │ │ -GENERATOR-LAMBDA0 │ │ │ │ -ACCESSOR-TYPE │ │ │ │ -ACCESSOR-TYPE │ │ │ │ -WRAPPER00 │ │ │ │ -ACCESSOR-TYPE │ │ │ │ -WRAPPER00 │ │ │ │ -WRAPPER1 │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -Return the current position for LABEL. Chooser maybe-shrink functions │ │ │ │ - should supply IF-AFTER and DELTA in order to ensure correct results. │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Emit an alignment restriction to the current segment. │ │ │ │ -COMMON-LISP │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ -Do any final processing of SEGMENT and return the total number of bytes │ │ │ │ - covered by this segment. │ │ │ │ WR^Wgh|\ │ │ │ │ non-trivial :KEY or :TEST │ │ │ │ 5%,.($(> │ │ │ │ 1`%&T"# │ │ │ │ 5[%&U"# │ │ │ │ +(((+++" │ │ │ │ 0 c++++" │ │ │ │ @@ -33702,26 +33672,73 @@ │ │ │ │ ~A:~A ~W │ │ │ │ &7 e8B 4 │ │ │ │ Store and return a value as the slot-value. │ │ │ │ Return a value as the slot-value. │ │ │ │ &7 e8B 8 │ │ │ │ hash-table │ │ │ │ !T#O-K$D;N#G(? │ │ │ │ -+4+G("%7 │ │ │ │ -displaced │ │ │ │ -(VECTOR │ │ │ │ -) of length │ │ │ │ -length mismatch in ~S │ │ │ │ -supplied both ~S and ~S to ~S │ │ │ │ -~@[(ID=~d) ~]for ~S~@[, INVALID=~S~] │ │ │ │ +ARGS-MINIMAL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +Return the current position for LABEL. Chooser maybe-shrink functions │ │ │ │ + should supply IF-AFTER and DELTA in order to ensure correct results. │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Emit an alignment restriction to the current segment. │ │ │ │ +COMMON-LISP │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ +Do any final processing of SEGMENT and return the total number of bytes │ │ │ │ + covered by this segment. │ │ │ │ +SIGNED-IMM-BYTE.PREFILTER │ │ │ │ +SIGNED-IMM-DATA.PREFILTER │ │ │ │ +ACCUM.PRINTER │ │ │ │ +COMMON-LISP │ │ │ │ +"{BD/7\, │ │ │ │ +Execute BODY (as a progn) with DEST as the current section or segment. │ │ │ │ +COMMON-LISP │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP0 │ │ │ │ +CODE-OBJ │ │ │ │ + DEBUG-FUN │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +BREAKPOINT8 │ │ │ │ + SEMAPHORE82 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +Execute BODY (as a PROGN) without scheduling any of the instructions │ │ │ │ + generated inside it. This is not protected by UNWIND-PROTECT, so │ │ │ │ + DO NOT use THROW or RETURN-FROM to escape from it. │ │ │ │ +Emit the specified instruction to the current segment. │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ +1)Fpl]ai │ │ │ │ + NEW-VALUE0 │ │ │ │ +Takes an object and a location holding a list. Conses the object onto │ │ │ │ + the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ +The argument is a location holding a list. Pops one item off the front │ │ │ │ + of the list and returns it. │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +COMMON-LISP8 │ │ │ │ SYS:SRC;COMPILER;X86;MOVE.LISP │ │ │ │ SYS:SRC;COMPILER;X86;TYPE-VOPS.LISP │ │ │ │ SYS:SRC;COMPILER;VMDEF.LISP │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/dumper-PTGsyz2X.lisp │ │ │ │ -ARGS-MINIMAL │ │ │ │ SYS:SRC;CODE;SOLIST.LISP │ │ │ │ The debug prompt is square brackets, with number(s) indicating the current │ │ │ │ control stack level and, if you've entered the debugger recursively, how │ │ │ │ deeply recursed you are. │ │ │ │ Any command -- including the name of a restart -- may be uniquely abbreviated. │ │ │ │ The debugger rebinds various special variables for controlling i/o, sometimes │ │ │ │ to defaults (much like WITH-STANDARD-IO-SYNTAX does) and sometimes to │ │ │ │ @@ -33782,83 +33799,28 @@ │ │ │ │ Restart execution of the current frame, if this frame is for a │ │ │ │ global function which was compiled with a sufficiently high │ │ │ │ DEBUG optimization quality. │ │ │ │ Discard all pending input on *STANDARD-INPUT*. (This can be │ │ │ │ useful when the debugger was invoked to handle an error in │ │ │ │ deeply nested input syntax, and now the reader is confused.) │ │ │ │ SYS:SRC;PCL;FSC.LISP │ │ │ │ -COMMON-LISP │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP0 │ │ │ │ -CODE-OBJ │ │ │ │ - DEBUG-FUN │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -BREAKPOINT8 │ │ │ │ - SEMAPHORE82 │ │ │ │ -Execute BODY (as a progn) with DEST as the current section or segment. │ │ │ │ -Execute BODY (as a PROGN) without scheduling any of the instructions │ │ │ │ - generated inside it. This is not protected by UNWIND-PROTECT, so │ │ │ │ - DO NOT use THROW or RETURN-FROM to escape from it. │ │ │ │ -Emit the specified instruction to the current segment. │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -1)Fpl]ai │ │ │ │ - NEW-VALUE0 │ │ │ │ -Takes an object and a location holding a list. Conses the object onto │ │ │ │ - the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ -The argument is a location holding a list. Pops one item off the front │ │ │ │ - of the list and returns it. │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -COMMON-LISP8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP8 │ │ │ │ - NEW-VALUE │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -VALUE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-ALIST │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -d%d@==w,DE6) │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ -SYS:SRC;CODE;C-CALL.LISP │ │ │ │ -SYS:SRC;CODE;BARRIER.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ -3J6+8k8}A │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-MAC.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UTF.LISP │ │ │ │ -4M4P:S@w@ │ │ │ │ -XXX/cfc~e │ │ │ │ -SYS:SRC;CODE;FILESYS.LISP │ │ │ │ +bitmap describing the status of the action. │ │ │ │ +STAMP associated with the ACTION if it has been completed already in some │ │ │ │ +previous session or image, T if it was done and builtin the image, or NIL if it needs to be done. │ │ │ │ +the highest (operate-level) at which the action was needed │ │ │ │ +INDEX associated with the ACTION in the current session, │ │ │ │ +or NIL if no the status is considered outside of a specific plan. │ │ │ │ +the current number of recursive LOADs │ │ │ │ ++4+G("%7 │ │ │ │ +displaced │ │ │ │ +(VECTOR │ │ │ │ +) of length │ │ │ │ +length mismatch in ~S │ │ │ │ +supplied both ~S and ~S to ~S │ │ │ │ +~@[(ID=~d) ~]for ~S~@[, INVALID=~S~] │ │ │ │ Component │ │ │ │ :STREAMS ~S │ │ │ │ discarding unsupported DOCUMENTATION: doc-type ~S for object of type ~S │ │ │ │ _+,K%$>5Mf4"n : │ │ │ │ ~S~:[~;, interrupted~] │ │ │ │ :INPUT-STREAM ~S :OUTPUT-STREAM ~S │ │ │ │ ~@ │ │ │ │ @@ -34052,118 +34014,198 @@ │ │ │ │ ~@[next=~S~] │ │ │ │ q56*"!*< │ │ │ │ ~A on ~:[~;BOGUS ~]~:[inactive~;active~] descriptor ~W: ~S │ │ │ │ +~W~@[ in ~S~] │ │ │ │ :SYMBOL ~S │ │ │ │ *7 e8B │ │ │ │ + ! ! % (Y │ │ │ │ +because │ │ │ │ Starting a ~A without a timeout while interrupts are disabled. │ │ │ │ ~&=== Starting a ~A without a timeout while interrupts are disabled. === │ │ │ │ a method lambda list │ │ │ │ -because │ │ │ │ ~S is a set, not a map │ │ │ │ _jga[a\SPh^X[hvshXIQ │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/dumper-PTGsyz2X.lisp │ │ │ │ +SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ +SYS:SRC;CODE;C-CALL.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ +3J6+8k8}A │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-MAC.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UTF.LISP │ │ │ │ +4M4P:S@w@ │ │ │ │ +XXX/cfc~e │ │ │ │ +SYS:SRC;CODE;BARRIER.LISP │ │ │ │ +SYS:SRC;CODE;FILESYS.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-EBCDIC.LISP │ │ │ │ KV-VECTOR-REHASHING │ │ │ │ REHASHING-STAMP │ │ │ │ OLD-KV-VECTOR │ │ │ │ NEW-KV-VECTOR │ │ │ │ HASH-TABLE-PAIRS-CAPACITY │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-EBCDIC.LISP │ │ │ │ SYS:SRC;CODE;QUERY.LISP │ │ │ │ SYS:SRC;CODE;FORMAT-TIME.LISP │ │ │ │ SYS:SRC;CODE;TARGET-STREAM.LISP │ │ │ │ +CLEANUP-FUN-1 │ │ │ │ NEW-CELLS │ │ │ │ HAS-TRUNCATED-FLAG │ │ │ │ -CLEANUP-FUN-1 │ │ │ │ -lisp_init_function │ │ │ │ -tot_gc_nsec │ │ │ │ -gc_coalesce_string_literals │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ -SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ -lisp_package_vector │ │ │ │ address ~X not in the code component ~S │ │ │ │ ; Jump table (~d entries) @ ~X │ │ │ │ ; ~vt~v,'02x = ~a │ │ │ │ +_oXONwax │ │ │ │ +gUvrgUlETE │ │ │ │ +WRRNgqCcT │ │ │ │ +encountered the non-standard lambda list keyword ~S │ │ │ │ +{FN[e]d\hc │ │ │ │ +31#[d[Xds\ │ │ │ │ +[d[Xdsbdd │ │ │ │ ~S is wired to location ~D in SC ~A of kind ~S that it conflicts with. │ │ │ │ ~S is wired to a location that is out of bounds. │ │ │ │ failed to pack after growing SC? │ │ │ │ $Bf^(!5u │ │ │ │ - Z%&l(# │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP8 │ │ │ │ + NEW-VALUE │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +VALUE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ + NEW-ALIST │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +d%d@==w,DE6) │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +K%'#)V%= │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +qVN' 2I)S │ │ │ │ +L%g#-V%= │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +COMMON-LISP8 │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP8 │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ +MORE-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +COMMON-LISP8 │ │ │ │ +Set the translations list for the logical host argument. │ │ │ │ + NEW-VALUE0 │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP8 │ │ │ │ +SEQUENCE │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP8 │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP8 │ │ │ │ +Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE. │ │ │ │ +SB-ALIEN │ │ │ │ +SB-ALIEN │ │ │ │ +SB-ALIEN │ │ │ │ + NEW-VALUE │ │ │ │ + READTABLE │ │ │ │ +COMMON-LISP0 │ │ │ │ +Sets the READTABLE-NORMALIZATION of the given READTABLE to NEW-VALUE. │ │ │ │ +Pass T to make READTABLE normalize symbols to NFKC (the default behavior), │ │ │ │ +and NIL to suppress normalization. │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ +SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ +lisp_package_vector │ │ │ │ +SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ +SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;LATE-NLX.LISP │ │ │ │ $&%B%X%m& │ │ │ │ E/ETEyE,G │ │ │ │ SYS:SRC;ASSEMBLY;X86;SUPPORT.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ -SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ SYS:SRC;COMPILER;X86;NLX.LISP │ │ │ │ SYS:SRC;COMPILER;ENVANAL.LISP │ │ │ │ SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ SYS:SRC;COMPILER;DFO.LISP │ │ │ │ +SYS:SRC;COMPILER;STACK.LISP │ │ │ │ +SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ ORIGINAL-KIND │ │ │ │ LAST-POP │ │ │ │ BLOCK-DELETE-P │ │ │ │ USE-HOME │ │ │ │ -SYS:SRC;COMPILER;STACK.LISP │ │ │ │ -SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ +LAST-LOSE │ │ │ │ +COALESCED │ │ │ │ + Z%&l(# │ │ │ │ ) '& ',R │ │ │ │ &5`%&/&8&]"# │ │ │ │ &5`%&/&I"&a0 │ │ │ │ , 5c(&T"# │ │ │ │ (333_$+." │ │ │ │ j(&/&]"# │ │ │ │ " x(&b"# │ │ │ │ " W0&]"# │ │ │ │ 7$ (?$ (- │ │ │ │ 3j%&/&A │ │ │ │ + 9 *&]"# │ │ │ │ SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ SYS:SRC;COMPILER;GTN.LISP │ │ │ │ SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ +SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ &@"&I"&I"&a0 │ │ │ │ &@"&I"&I"&I"&a0 │ │ │ │ ** tail-call old-fp in reg not S0 │ │ │ │ ** tail-call old-fp not S0 │ │ │ │ $ {%&T%# │ │ │ │ nvalues is 1 │ │ │ │ 1X(&X0 │ │ │ │ 1++...."F │ │ │ │ +(((+++$ │ │ │ │ .(((+++$ │ │ │ │ 4++...."F │ │ │ │ .(((+++$ │ │ │ │ +(((+++$ │ │ │ │ -_oXONwax │ │ │ │ -gUvrgUlETE │ │ │ │ -WRRNgqCcT │ │ │ │ -encountered the non-standard lambda list keyword ~S │ │ │ │ -{FN[e]d\hc │ │ │ │ -31#[d[Xds\ │ │ │ │ -[d[Xdsbdd │ │ │ │ jit-code.txt │ │ │ │ ~&; Logging code allocation to ~S │ │ │ │ ~&New code(~Db,~A): ~A │ │ │ │ -Replace the function binding │ │ │ │ a generic function lambda list │ │ │ │ Multiple ~S options in DEFCLASS ~S. │ │ │ │ ~S is not a legal :documentation value │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~S is not a legal defclass option. │ │ │ │ t]R]oN{XbxQ │ │ │ │ ~S structure class │ │ │ │ ~Aconstructor │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -LAST-LOSE │ │ │ │ -COALESCED │ │ │ │ -Argument and/or result bit arrays are not the same length:~ │ │ │ │ - ~% ~S~% ~S ~% ~S │ │ │ │ -SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ +tKS[^\tKR[[oQd │ │ │ │ +unknown TRACE option: ~S │ │ │ │ +Replace the function binding │ │ │ │ X|!bMXg) │ │ │ │ }T*4p]1>< │ │ │ │ n>S7Auh7 │ │ │ │ T*4p]1>< │ │ │ │ }T*4p*W │ │ │ │ 4"YsOpG6 │ │ │ │ Rrvcgvg w │ │ │ │ @@ -34759,132 +34801,45 @@ │ │ │ │ qRr,'KHY │ │ │ │ tr`^m"R6 │ │ │ │ r|t."@rSU │ │ │ │ ^,=(Q,gD │ │ │ │ h]m2_]rxc] │ │ │ │ |8wfyQS8 │ │ │ │ H>p|[by6 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -K%'#)V%= │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -qVN' 2I)S │ │ │ │ -L%g#-V%= │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ -MORE-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -COMMON-LISP8 │ │ │ │ -Set the translations list for the logical host argument. │ │ │ │ - NEW-VALUE0 │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP8 │ │ │ │ -SEQUENCE │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP8 │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP8 │ │ │ │ -Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE. │ │ │ │ -SB-ALIEN │ │ │ │ -SB-ALIEN │ │ │ │ -SB-ALIEN │ │ │ │ - NEW-VALUE │ │ │ │ - READTABLE │ │ │ │ -COMMON-LISP0 │ │ │ │ -Sets the READTABLE-NORMALIZATION of the given READTABLE to NEW-VALUE. │ │ │ │ -Pass T to make READTABLE normalize symbols to NFKC (the default behavior), │ │ │ │ -and NIL to suppress normalization. │ │ │ │ -COMMON-LISP8 │ │ │ │ -UNIX-SETITIMER sets the INTERVAL and VALUE slots of one of three system │ │ │ │ - timers (:real :virtual or :profile). A SIGALRM, SIGVTALRM, or SIGPROF │ │ │ │ - respectively will be delivered in VALUE from now. │ │ │ │ - INTERVAL, when non-zero, is reloaded into the timer on each expiration. │ │ │ │ - Setting VALUE to zero disables the timer. See the Unix man page for more │ │ │ │ - details. On success, unix-setitimer returns the │ │ │ │ - old contents of the INTERVAL and VALUE slots as in unix-getitimer. │ │ │ │ -UNIX-GETITIMER returns the INTERVAL and VALUE slots of one of │ │ │ │ - three system timers (:real :virtual or :profile). On success, │ │ │ │ - unix-getitimer returns 5 values, │ │ │ │ - T, it-interval-secs, it-interval-usec, it-value-secs, it-value-usec. │ │ │ │ -SB-ALIEN │ │ │ │ -COMMON-LISP │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ -load TN allocated, but no move function?~@ │ │ │ │ - VM definition is inconsistent, recompile and try again. │ │ │ │ -SYS:SRC;COMPILER;PACK.LISP │ │ │ │ -SYS:SRC;CODE;ICF.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;ALLOC.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;ARRAY.LISP │ │ │ │ -SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;SAP.LISP │ │ │ │ -tKS[^\tKR[[oQd │ │ │ │ -unknown TRACE option: ~S │ │ │ │ U`m< │ │ │ │ WS7Auh7v │ │ │ │ }U~A+%vg) │ │ │ │ -'((.4O │ │ │ │ loading ~S │ │ │ │ loading stuff from ~S │ │ │ │ ;;;;;;;;;;;;;;;; │ │ │ │ -can't understand something in the arglist ~S │ │ │ │ -dummy macro │ │ │ │ -Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ -Got to T branch in ~S │ │ │ │ -cannot use optimized accessor in safe code │ │ │ │ -Cannot make slot ~S in ~S unbound. │ │ │ │ -slot name is not an interned symbol │ │ │ │ -Output-partial-line called when nothing can be output. │ │ │ │ -~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ -attempt to emit ~S a second time │ │ │ │ -Alignment ~S needs more space now? It was ~W, and is ~W now. │ │ │ │ -~S shrunk by ~W bytes, but claimed that it preserves ~W bits of alignment. │ │ │ │ -~S emitted ~W bytes, but claimed its max was ~W. │ │ │ │ -Chooser ~S passed, but not before emitting ~W bytes. │ │ │ │ -~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -:GENERIC-FUNCTION-CLASS argument │ │ │ │ -:METHOD-CLASS argument │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ +Argument and/or result bit arrays are not the same length:~ │ │ │ │ + ~% ~S~% ~S ~% ~S │ │ │ │ +SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ +SYS:SRC;COMPILER;PACK.LISP │ │ │ │ +load TN allocated, but no move function?~@ │ │ │ │ + VM definition is inconsistent, recompile and try again. │ │ │ │ +SYS:SRC;CODE;ICF.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;ALLOC.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;ARRAY.LISP │ │ │ │ JUMPTABLE-WORD │ │ │ │ Dynamic space │ │ │ │ Text space │ │ │ │ Read-only space │ │ │ │ Static space │ │ │ │ Control stack │ │ │ │ Binding stack │ │ │ │ -WRAPPER4 │ │ │ │ +SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;SAP.LISP │ │ │ │ SYS:SRC;CODE;MISC.LISP │ │ │ │ SYS:SRC;CODE;LINUX-OS.LISP │ │ │ │ +WRAPPER4 │ │ │ │ SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ -SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ ~S outside of a effective method form │ │ │ │ +SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ Character-Tabulation-With-Justification │ │ │ │ Start-Selected-Area │ │ │ │ Start-Guarded-Area │ │ │ │ Line-Tabulation-Set │ │ │ │ Message-Waiting │ │ │ │ Single-Shift-Three │ │ │ │ Single-Character-Introducer │ │ │ │ @@ -34908,14 +34863,74 @@ │ │ │ │ Next-Line │ │ │ │ Partial-Line-Forward │ │ │ │ Reverse-Linefeed │ │ │ │ Set-Transmit-State │ │ │ │ Partial-Line-Backward │ │ │ │ String-Terminator │ │ │ │ KV-VECTOR-SUPPLEMENT │ │ │ │ +can't understand something in the arglist ~S │ │ │ │ +'((.4O │ │ │ │ +Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ +dummy macro │ │ │ │ +Got to T branch in ~S │ │ │ │ +Output-partial-line called when nothing can be output. │ │ │ │ +~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ +cannot use optimized accessor in safe code │ │ │ │ +Cannot make slot ~S in ~S unbound. │ │ │ │ +slot name is not an interned symbol │ │ │ │ +attempt to emit ~S a second time │ │ │ │ +Alignment ~S needs more space now? It was ~W, and is ~W now. │ │ │ │ +~S shrunk by ~W bytes, but claimed that it preserves ~W bits of alignment. │ │ │ │ +~S emitted ~W bytes, but claimed its max was ~W. │ │ │ │ +Chooser ~S passed, but not before emitting ~W bytes. │ │ │ │ +~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ +IN-WITHOUT-SCHEDULING │ │ │ │ +No encoder for ~S │ │ │ │ +FUNCTION doc-type is not supported. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +:GENERIC-FUNCTION-CLASS argument │ │ │ │ +:METHOD-CLASS argument │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +dynamic_space_size │ │ │ │ +SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ +SYS:SRC;CODE;WEAK.LISP │ │ │ │ +SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ +SYS:SRC;CODE;UNCROSS.LISP │ │ │ │ +Superclass of all Gray output streams whose element-type │ │ │ │ +is a subtype of character. │ │ │ │ +Superclass of all Gray output streams whose element-type │ │ │ │ +is a subtype of unsigned-byte or signed-byte. │ │ │ │ +SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ +SYS:SRC;PCL;WALK.LISP │ │ │ │ +SYS:SRC;CODE;SHOW.LISP │ │ │ │ +COMMON-LISP8 │ │ │ │ +UNIX-SETITIMER sets the INTERVAL and VALUE slots of one of three system │ │ │ │ + timers (:real :virtual or :profile). A SIGALRM, SIGVTALRM, or SIGPROF │ │ │ │ + respectively will be delivered in VALUE from now. │ │ │ │ + INTERVAL, when non-zero, is reloaded into the timer on each expiration. │ │ │ │ + Setting VALUE to zero disables the timer. See the Unix man page for more │ │ │ │ + details. On success, unix-setitimer returns the │ │ │ │ + old contents of the INTERVAL and VALUE slots as in unix-getitimer. │ │ │ │ +UNIX-GETITIMER returns the INTERVAL and VALUE slots of one of │ │ │ │ + three system timers (:real :virtual or :profile). On success, │ │ │ │ + unix-getitimer returns 5 values, │ │ │ │ + T, it-interval-secs, it-interval-usec, it-value-secs, it-value-usec. │ │ │ │ +SB-ALIEN │ │ │ │ +Unix-lseek accepts a file descriptor and moves the file pointer by │ │ │ │ + OFFSET octets. Whence can be any of the following: │ │ │ │ + L_SET Set the file pointer. │ │ │ │ + L_INCR Increment the file pointer. │ │ │ │ + L_XTND Extend the file size. │ │ │ │ +SB-ALIEN │ │ │ │ +COMMON-LISP │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ Print a listing of the call stack to STREAM, defaulting to *DEBUG-IO*. │ │ │ │ COUNT is the number of frames to backtrace, defaulting to │ │ │ │ *BACKTRACE-FRAME-COUNT*. │ │ │ │ START is the number of the frame the backtrace should start from. │ │ │ │ FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ values are an explicit SB-DI:FRAME object, and the │ │ │ │ keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ @@ -34945,98 +34960,46 @@ │ │ │ │ OPERANDS │ │ │ │ MNEMONIC │ │ │ │ OPERANDS │ │ │ │ COMMON-LISP │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ -Unix-lseek accepts a file descriptor and moves the file pointer by │ │ │ │ - OFFSET octets. Whence can be any of the following: │ │ │ │ - L_SET Set the file pointer. │ │ │ │ - L_INCR Increment the file pointer. │ │ │ │ - L_XTND Extend the file size. │ │ │ │ -SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ L,(`o:0(` │ │ │ │ SB-ALIEN │ │ │ │ OPTIONAL-ARGS │ │ │ │ AC 4@A#C │ │ │ │ -dynamic_space_size │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ SPECIALIZER │ │ │ │ SB-MOP0 │ │ │ │ ! U$'19z │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ -OPERATION-CLASS │ │ │ │ -This function creates and memoizes an instance of OPERATION-CLASS. │ │ │ │ -All operation instances MUST be created through this function. │ │ │ │ -Use of INITARGS is not supported at this time. │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -i=6xm+O!Y │ │ │ │ -SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ -SYS:SRC;CODE;WEAK.LISP │ │ │ │ -SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ -Superclass of all Gray output streams whose element-type │ │ │ │ -is a subtype of character. │ │ │ │ -Superclass of all Gray output streams whose element-type │ │ │ │ -is a subtype of unsigned-byte or signed-byte. │ │ │ │ -SYS:SRC;CODE;UNCROSS.LISP │ │ │ │ -SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ -SYS:SRC;PCL;WALK.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ SYS:SRC;PCL;SLOT-NAME.LISP │ │ │ │ -the current number of recursive LOADs │ │ │ │ +SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ Specializer lock │ │ │ │ pv table index lock │ │ │ │ -~S ~S #X~8,'0X ~S ~// │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ SBCL specific extensions to MOP: if this value is read from an │ │ │ │ instance using STANDARD-INSTANCE-ACCESS, the slot is unbound. │ │ │ │ Similarly, an :INSTANCE allocated slot can be made unbound by │ │ │ │ assigning this to it using (SETF STANDARD-INSTANCE-ACCESS). │ │ │ │ Value of +SLOT-UNBOUND+ is unspecified, and should not be relied to be │ │ │ │ of any particular type, but it is guaranteed to be suitable for EQ │ │ │ │ comparison. │ │ │ │ -SYS:SRC;CODE;SHOW.LISP │ │ │ │ -uv`}n*?n │ │ │ │ -8&PW:*ff │ │ │ │ -FHp~gA|l │ │ │ │ -inline non-SIMPLE-vector-handling logic │ │ │ │ -open code │ │ │ │ - DIMENSION │ │ │ │ -SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ -strength reduce large variable right shift │ │ │ │ -Convert %ASH/RIGHT by constant back to ASH │ │ │ │ -COMMON-LISP0 │ │ │ │ -SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ -SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ -/build/reproducible-path/sbcl-2.5.10/contrib/asdf/asdf.lisp │ │ │ │ -&!#4/.yRKO │ │ │ │ -expand inline │ │ │ │ -convert to inline logical operations │ │ │ │ -rmTM)_F, │ │ │ │ -Bl&MICN: │ │ │ │ -]a;X|TTi │ │ │ │ --ZZZZ#2k{') │ │ │ │ -]a;X|TTi │ │ │ │ +~S ~S #X~8,'0X ~S ~// │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ Compute a method lambda form based on METHOD-LAMBDA, possibly │ │ │ │ taking into account PROTO-GENERIC-FUNCTION, PROTO-METHOD, QUALIFIERS, │ │ │ │ SPECIALIZERS and ENVIRONMENT. │ │ │ │ Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ uninitialized. However, their classes and prototypes can be inspected. │ │ │ │ SPECIALIZERS is a list of specializer objects (i.e. parsed). │ │ │ │ Return three values: │ │ │ │ @@ -35050,18 +35013,47 @@ │ │ │ │ described by ENVIRONMENT, parses the specializer SPECIALIZER-NAME and │ │ │ │ yields the appropriate specializer object. │ │ │ │ Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ uninitialized. However their classes and prototypes can be │ │ │ │ inspected. │ │ │ │ NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ protocol. Interface subject to change. │ │ │ │ -7)`W:0 │ │ │ │ -~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ Moves ITERATOR one position forward or backward in SEQUENCE │ │ │ │ depending on the iteration direction encoded in FROM-END. │ │ │ │ Returns non-NIL when ITERATOR has reached LIMIT (which may │ │ │ │ correspond to the end of SEQUENCE) with respect to the iteration │ │ │ │ direction encoded in FROM-END. │ │ │ │ Returns the element of SEQUENCE associated to the position of │ │ │ │ ITERATOR. │ │ │ │ @@ -35127,15 +35112,51 @@ │ │ │ │ but receives a prototype instance of an extended sequence class │ │ │ │ instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ methods on this generic function specify how extended sequence │ │ │ │ classes act when they are specified as the result type in a │ │ │ │ CL:CONCATENATE call. RESULT-PROTOTYPE may not be fully initialized │ │ │ │ and thus should only be used for dispatch and to determine its │ │ │ │ class. │ │ │ │ +/build/reproducible-path/sbcl-2.5.10/contrib/asdf/asdf.lisp │ │ │ │ +SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ +SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ The width of instruction bytes. │ │ │ │ +~&Your command, ~S, is ambiguous: │ │ │ │ +~&error flushed (because ~S is set) │ │ │ │ +~@ │ │ │ │ +~2&Assembler input: │ │ │ │ + ~:@(~A~) ~{~A~^, ~}~A │ │ │ │ +# Unused labels: │ │ │ │ +# end of input │ │ │ │ +# postit ~S~A │ │ │ │ + # ~{~@[~A~^, ~]~} │ │ │ │ + (notused) │ │ │ │ +~A~{~A: ~}~A │ │ │ │ +ZM0%#tXK! │ │ │ │ +1.0.11.18 │ │ │ │ +Load the fasl file anyway │ │ │ │ +FOP stack underflow │ │ │ │ +No applicable method found for ~S │ │ │ │ +No primary method found for ~S among applicable methods: ~S │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +2K#"&%6- │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ +~&; While loading ~S: │ │ │ │ +xRUUtRTT │ │ │ │ +~&~6x : [~D,~D] ~2,'0x~v@{ ~x~} │ │ │ │ + ~35t~(~a~) │ │ │ │ +corrupt fasl file: FOP code #x~x │ │ │ │ +cannot load assembler code except at cold load │ │ │ │ +fasl stack not empty when it should be │ │ │ │ +fasl table of improper size │ │ │ │ +~S loaded │ │ │ │ +tNQQnNNN │ │ │ │ The column in which end-of-line comments for notes are started. │ │ │ │ Unpacked a TN to satisfy operand SC restriction. │ │ │ │ Repacked a block due to TN unpacking. │ │ │ │ Unpacked some operand TN. │ │ │ │ When set (the default), evaluations in the debugger's command loop occur │ │ │ │ relative to the current frame's environment without the need of debugger │ │ │ │ forms that explicitly control this kind of evaluation. │ │ │ │ @@ -35162,49 +35183,35 @@ │ │ │ │ ((sb-pcl:slow-method [*] (*)) ...args...) │ │ │ │ In the this case arguments may include values internal to SBCL's method │ │ │ │ dispatch machinery. │ │ │ │ If the trace indentation exceeds this value, then indentation restarts at │ │ │ │ the increase in trace indentation at each call level │ │ │ │ Default number of frames to backtrace. Defaults to 1000. │ │ │ │ This is T while in the debugger. │ │ │ │ -~&Your command, ~S, is ambiguous: │ │ │ │ -~&error flushed (because ~S is set) │ │ │ │ -~@ │ │ │ │ -IN-WITHOUT-SCHEDULING │ │ │ │ -No encoder for ~S │ │ │ │ -FUNCTION doc-type is not supported. │ │ │ │ -No applicable method found for ~S │ │ │ │ -No primary method found for ~S among applicable methods: ~S │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -2K#"&%6- │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ -V\^jbebp │ │ │ │ -wrong number of arguments; expected ~W, got ~W │ │ │ │ -can't tell function type at compile time │ │ │ │ -Non-list or improper list spliced in ~ │ │ │ │ - the middle of a backquoted list. │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ +~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ Parse SPECIALIZER-NAME into a specializer object suitable for GENERIC-FUNCTION. │ │ │ │ If SPECIALIZER-NAME is not well-formed with respect to the specializer │ │ │ │ syntax of GENERIC-FUNCTION, an error of type │ │ │ │ SB-PCL:SPECIALIZER-NAME-SYNTAX-ERROR is signaled. │ │ │ │ If GENERIC-FUNCTION is a STANDARD-GENERIC-FUNCTION and │ │ │ │ SPECIALIZER-NAME is a symbol that does not name an existing class, an │ │ │ │ error of type SB-PCL:CLASS-NOT-FOUND-ERROR is signaled. │ │ │ │ Other errors may be signaled for generic function classes other than │ │ │ │ STANDARD-GENERIC-FUNCTION. │ │ │ │ If GENERIC-FUNCTION is a STANDARD-GENERIC-FUNCTION and │ │ │ │ SPECIALIZER-NAME is of the form (eql OBJECT), OBJECT is not │ │ │ │ evaluated (in contrast to DEFMETHOD's behavior). │ │ │ │ NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ protocol. Interface subject to change. │ │ │ │ -It has a slot ~//, while ~// is requested. │ │ │ │ -~//, slot:~S, ~:S │ │ │ │ +COMMON-LISP │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +COMMON-LISP │ │ │ │ +NEW-STATUS │ │ │ │ +COMMON-LISP0 │ │ │ │ fmt$34QLWU │ │ │ │ OPTIONAL-ARGS │ │ │ │ DOC-TYPE │ │ │ │ NEW-VALUE │ │ │ │ fmt$183UB1 │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ @@ -35240,14 +35247,18 @@ │ │ │ │ ITERATOR │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-CLASS │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ uGsn/Io+ │ │ │ │ +It has a slot ~//, while ~// is requested. │ │ │ │ +~//, slot:~S, ~:S │ │ │ │ +~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ +Element-type: ~// │ │ │ │ !r\TBN!P │ │ │ │ INITARGS │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-CLASS │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SEQUENCE │ │ │ │ @@ -35345,16 +35356,14 @@ │ │ │ │ REST-ARG │ │ │ │ ``$8$0$ │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ fmt$T0FG9 │ │ │ │ OPTIONAL-ARGS │ │ │ │ -~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ -Element-type: ~// │ │ │ │ /}8u.8?oh │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ wBc;pLVce │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ fmt$3G9W75 │ │ │ │ @@ -35453,77 +35462,71 @@ │ │ │ │ NEW-VALUE │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ +~@ │ │ │ │ +~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ +V\^jbebp │ │ │ │ +wrong number of arguments; expected ~W, got ~W │ │ │ │ +can't tell function type at compile time │ │ │ │ +Non-list or improper list spliced in ~ │ │ │ │ + the middle of a backquoted list. │ │ │ │ +ELEMENT-TYPE is not constant. │ │ │ │ +can't compile TYPEP of anonymous or undefined class: │ │ │ │ +~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ +REHASH-STAMP-ELT │ │ │ │ +NEW-STAMP │ │ │ │ +PKGNICK-INDEX-BITS │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ -~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ -REHASH-STAMP-ELT │ │ │ │ -NEW-STAMP │ │ │ │ -PKGNICK-INDEX-BITS │ │ │ │ Normalize STRING to the Unicode normalization form FORM. │ │ │ │ Acceptable values for form are :NFD, :NFC, :NFKD, and :NFKC. │ │ │ │ If FILTER is a function it is called on each decomposed character and │ │ │ │ only characters for which it returns T are collected. │ │ │ │ +hjtt\yDskl │ │ │ │ +TEMP-VAR │ │ │ │ +BL)%`Os0 │ │ │ │ +SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ MISS-FN- │ │ │ │ -ELEMENT-TYPE is not constant. │ │ │ │ -Could not insert ~S:~S to supposedly empty ~S. │ │ │ │ -~@ │ │ │ │ -~S with non-constant EMF ~S │ │ │ │ -Function is not TRACEd: ~S │ │ │ │ -Invalid designator for initial backtrace frame: ~S │ │ │ │ - [~{~(~A~)~^,~}] │ │ │ │ - source: ~S │ │ │ │ -~& no source available for frame │ │ │ │ -~& error printing frame source: ~A │ │ │ │ -~& error finding frame source: ~A │ │ │ │ -~S is neither a type nor a specializer. │ │ │ │ -~S is not a legal specializer type. │ │ │ │ -~S cannot handle the second argument ~S │ │ │ │ -bad argument to TYPE-CLASS │ │ │ │ -can't compile TYPEP of anonymous or undefined class: │ │ │ │ CLEANUP-FUN-19 │ │ │ │ WITHOUT-INTERRUPTS-BODY-1 │ │ │ │ CLEANUP-FUN-10 │ │ │ │ CLEANUP-FUN-2 │ │ │ │ -BL)%`Os0 │ │ │ │ +START-LVAR │ │ │ │ fP:*PW:P │ │ │ │ d3M:'T,D │ │ │ │ d3M:'T,D │ │ │ │ -~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ 2=Ya1q)! │ │ │ │ 2=Ya1q)! │ │ │ │ 2=Ya1q)! │ │ │ │ h^T`Rz~,,. │ │ │ │ WSO&&#k'+c] │ │ │ │ /(`o:00$ │ │ │ │ %doI$eJ) │ │ │ │ \f\lKI|@ │ │ │ │ -RMYANCB_V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ O3%PW:.ff │ │ │ │ 4CoAbA_z │ │ │ │ 4CoAbA_z │ │ │ │ 2(`o:0LYk │ │ │ │ E' >U_O[ │ │ │ │ cquUU}UWu_ │ │ │ │ :::VWUUx\U │ │ │ │ +RMYANCB_V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ +0Zz*X%kyI │ │ │ │ 8%PW:*ff │ │ │ │ a3;!S h` │ │ │ │ N2+pm:VU │ │ │ │ >_/+JtkJV │ │ │ │ uT4a.]V& │ │ │ │ ]M}i!(p$0x │ │ │ │ @@ -35533,85 +35536,45 @@ │ │ │ │ h0Mmc/]KK │ │ │ │ :)Pu:03sffuR │ │ │ │ NfZ$oGIT │ │ │ │ V"TWq,6{ │ │ │ │ >*PW:03uY │ │ │ │ 0o,qfL%}0?bQ │ │ │ │ START-LAB │ │ │ │ -hjtt\yDskl │ │ │ │ -TEMP-VAR │ │ │ │ CONSTANT SB-KERNEL0& │ │ │ │ +bf6nkkkk │ │ │ │ Backspace │ │ │ │ COMMON-LISP │ │ │ │ FUN-NAME │ │ │ │ -bf6nkkkk │ │ │ │ -SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ -SYS:SRC;PCL;ECD.LISP │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP │ │ │ │ OPERATION │ │ │ │ PPRINT-DISPATCH │ │ │ │ COMMON-LISP │ │ │ │ .+pO:t-T\ │ │ │ │ _3P=PJ?p │ │ │ │ -START-LVAR │ │ │ │ -WRAPPER6 │ │ │ │ +STREAM-WE-ARE-LOADING-FROM │ │ │ │ +COMMON-LISP │ │ │ │ NODE-BLOCK │ │ │ │ +Function is not TRACEd: ~S │ │ │ │ +Could not insert ~S:~S to supposedly empty ~S. │ │ │ │ +~@ │ │ │ │ +~S with non-constant EMF ~S │ │ │ │ +Invalid designator for initial backtrace frame: ~S │ │ │ │ U3/adXXad │ │ │ │ Unexpectedly small N-RANDOM-CHUNK-BITS │ │ │ │ ~S doesn't have a precise float representation. │ │ │ │ The RATIONAL value isn't known at compile time. │ │ │ │ e#(+-** ) 8j │ │ │ │ W[dt5]Y\XeXXs@YXX │ │ │ │ ZZZZwdi`\ │ │ │ │ UB~D-BASH-COPY │ │ │ │ CLEANUP-FUN-11 │ │ │ │ WITHOUT-GCING-BODY-10 │ │ │ │ WITHOUT-GCING-BODY-0 │ │ │ │ - METATYPES │ │ │ │ - METATYPES │ │ │ │ - METATYPES │ │ │ │ -STREAM-WE-ARE-LOADING-FROM │ │ │ │ -COMMON-LISP │ │ │ │ -mZt9q@v= │ │ │ │ -Oa_s"(PH0 │ │ │ │ -REST-ARG │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -LOCATION0 │ │ │ │ -METHOD-ARGS │ │ │ │ -PV-TABLE0 │ │ │ │ -al.v}#|~= │ │ │ │ -L&P PP$( │ │ │ │ -SPECIALIZER │ │ │ │ -SB-MOP0 │ │ │ │ -COMMON-LISP1 │ │ │ │ -ENVIRONMENT │ │ │ │ -KEYWORDS-AND-FORMS │ │ │ │ -UNIVERSE │ │ │ │ -nqf4m{mw │ │ │ │ -METHOD-LAMBDA │ │ │ │ -PROTO-GF │ │ │ │ -PROTO-METHOD │ │ │ │ -PROTO-GENERIC-FUNCTION │ │ │ │ -SPECIALIZER-NAME0 │ │ │ │ -SPECIALIZER-NAME0 │ │ │ │ -SPECIALIZER │ │ │ │ -u: Uu@ Y │ │ │ │ -PROTO-GENERIC-FUNCTION │ │ │ │ -PROTO-METHOD │ │ │ │ -SPECIALIZER │ │ │ │ -SPECIALIZER │ │ │ │ -INITARGS │ │ │ │ -METHOD-LAMBDA │ │ │ │ - NEW-VALUE │ │ │ │ - NEW-VALUE │ │ │ │ - NEW-VALUE │ │ │ │ -DOC-TYPE0 │ │ │ │ - DOC-TYPE9 │ │ │ │ - NEW-VALUE │ │ │ │ ^R33dddap\iddRd │ │ │ │ wjTWh]gsv\z │ │ │ │ ~S is an illegal control arg to BOOLE. │ │ │ │ BOOLE code is not a constant. │ │ │ │ array bounds unknown │ │ │ │ ~@ │ │ │ │ @@ -35635,63 +35598,98 @@ │ │ │ │ N%,~ l | │ │ │ │ l_ nbkbb nU │ │ │ │ ohnbkbkn^bh_dd`Xuagt │ │ │ │ ~@ │ │ │ │ rZsOmmsj\ │ │ │ │ :FROM-END is not constant. │ │ │ │ U[tr`n`p\ │ │ │ │ -SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ IJJn\eedgZ │ │ │ │ Uknown upgraded array element type of the result │ │ │ │ The function doesn't have a fixed argument count. │ │ │ │ -bogus arguments to MOV: ~S ~S │ │ │ │ -bogus args to XCHG: ~S ~S │ │ │ │ -bogus operands for TEST: ~S and ~S │ │ │ │ -can't scan bytes: ~S │ │ │ │ -don't know what to do with ~A │ │ │ │ -can't bounds-test bytes: ~S │ │ │ │ -["2N++ *H │ │ │ │ -~&~6x : [~D,~D] ~2,'0x~v@{ ~x~} │ │ │ │ - ~35t~(~a~) │ │ │ │ -corrupt fasl file: FOP code #x~x │ │ │ │ -CLEANUP-FUN-43 │ │ │ │ -CLEANUP-FUN-31 │ │ │ │ -CLEANUP-FUN-16 │ │ │ │ -auxiliary │ │ │ │ -SYS:SRC;PCL;DLISP.LISP │ │ │ │ ~S is an unknown vector type │ │ │ │ ~S ~S is not a ~S │ │ │ │ This shouldn't happen. │ │ │ │ The type is not constant at compile time; can't open code. │ │ │ │ +auxiliary │ │ │ │ +mZt9q@v= │ │ │ │ +Oa_s"(PH0 │ │ │ │ +REST-ARG │ │ │ │ + METATYPES │ │ │ │ + METATYPES │ │ │ │ + METATYPES │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +LOCATION0 │ │ │ │ +METHOD-ARGS │ │ │ │ +PV-TABLE0 │ │ │ │ +L&P PP$( │ │ │ │ +ENVIRONMENT │ │ │ │ +KEYWORDS-AND-FORMS │ │ │ │ +UNIVERSE │ │ │ │ +al.v}#|~= │ │ │ │ +nqf4m{mw │ │ │ │ +COMMON-LISP1 │ │ │ │ +RES^ac(P(6 │ │ │ │ +COMMON-LISP │ │ │ │ +INITARGS │ │ │ │ +COMMON-LISP │ │ │ │ +sG@,/KCk │ │ │ │ +SPECIALIZER │ │ │ │ +SB-MOP0 │ │ │ │ +METHOD-LAMBDA │ │ │ │ +PROTO-GF │ │ │ │ +PROTO-METHOD │ │ │ │ +PROTO-GENERIC-FUNCTION │ │ │ │ +SPECIALIZER-NAME0 │ │ │ │ +SPECIALIZER-NAME0 │ │ │ │ +SPECIALIZER │ │ │ │ +u: Uu@ Y │ │ │ │ +PROTO-GENERIC-FUNCTION │ │ │ │ +PROTO-METHOD │ │ │ │ +SPECIALIZER │ │ │ │ +~@ │ │ │ │ +SPECIALIZER │ │ │ │ +INITARGS │ │ │ │ +METHOD-LAMBDA │ │ │ │ + NEW-VALUE │ │ │ │ + NEW-VALUE │ │ │ │ + NEW-VALUE │ │ │ │ +DOC-TYPE0 │ │ │ │ + DOC-TYPE9 │ │ │ │ + NEW-VALUE │ │ │ │ + NEW-VALUE0 │ │ │ │ +CLEANUP-FUN-43 │ │ │ │ +CLEANUP-FUN-31 │ │ │ │ +CLEANUP-FUN-16 │ │ │ │ Aliens of type ~S cannot be represented immediately. │ │ │ │ The alien type is not constant, so access cannot be open coded. │ │ │ │ [X^TX[XXXR^ │ │ │ │ [X^TX[XXXR^ │ │ │ │ -~2&Assembler input: │ │ │ │ - ~:@(~A~) ~{~A~^, ~}~A │ │ │ │ -# Unused labels: │ │ │ │ -# end of input │ │ │ │ -# postit ~S~A │ │ │ │ - # ~{~@[~A~^, ~]~} │ │ │ │ - (notused) │ │ │ │ -~A~{~A: ~}~A │ │ │ │ -ZM0%#tXK! │ │ │ │ -1.0.11.18 │ │ │ │ -Load the fasl file anyway │ │ │ │ -FOP stack underflow │ │ │ │ -~&; While loading ~S: │ │ │ │ -xRUUtRTT │ │ │ │ -cannot load assembler code except at cold load │ │ │ │ -fasl stack not empty when it should be │ │ │ │ -fasl table of improper size │ │ │ │ -~S loaded │ │ │ │ -tNQQnNNN │ │ │ │ + [~{~(~A~)~^,~}] │ │ │ │ + source: ~S │ │ │ │ +~& no source available for frame │ │ │ │ +~& error printing frame source: ~A │ │ │ │ +~& error finding frame source: ~A │ │ │ │ +~S is neither a type nor a specializer. │ │ │ │ +~S is not a legal specializer type. │ │ │ │ +~S cannot handle the second argument ~S │ │ │ │ +bad argument to TYPE-CLASS │ │ │ │ +bogus arguments to MOV: ~S ~S │ │ │ │ +bogus args to XCHG: ~S ~S │ │ │ │ +bogus operands for TEST: ~S and ~S │ │ │ │ +can't scan bytes: ~S │ │ │ │ +don't know what to do with ~A │ │ │ │ +can't bounds-test bytes: ~S │ │ │ │ +SYS:SRC;PCL;ECD.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ +SYS:SRC;PCL;DLISP.LISP │ │ │ │ +WRAPPER6 │ │ │ │ Not a property list: ~S │ │ │ │ WRAPPER- │ │ │ │ Every metatype is T. │ │ │ │ +kqbkwhuXRae^[X][U │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ )&0*#&# cj │ │ │ │ methods matching one of the patterns: │ │ │ │ methods matching the pattern: │ │ │ │ Multiple slots named ~S in DEFCLASS ~S. │ │ │ │ ~@ │ │ │ │ @@ -35725,15 +35723,14 @@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ Cannot make structure slots unbound │ │ │ │ ~@<~S, in ~S ~S, is not a non-~S atom.~@:> │ │ │ │ i^YPP`Ri^YPP`NdP │ │ │ │ oUVQO^Zm │ │ │ │ UVQik^Z[^ │ │ │ │ -kqbkwhuXRae^[X][U │ │ │ │ The key for the last case arg to mcase was not T │ │ │ │ ~@<~S of ~S is neither ~S nor a ~S.~@:> │ │ │ │ Something strange where symbol or class expected. │ │ │ │ e(P" " │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ @@ -35775,14 +35772,21 @@ │ │ │ │ the method has ~A required arguments than the generic function. │ │ │ │ the method and generic function differ in whether they accept~_~ │ │ │ │ &REST or &KEY arguments. │ │ │ │ the method has ~A optional arguments than the generic function. │ │ │ │ the method does not accept each of the &KEY arguments~2I~_~ │ │ │ │ ~S. │ │ │ │ ~@ │ │ │ │ +^b^UhgPY[PnWd[ps │ │ │ │ +illegal kind argument to ~S: ~S │ │ │ │ +[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ +^b^UhgXXPY[XXPLShWj │ │ │ │ +The RESTP argument is not constant. │ │ │ │ +nY\[Y[YSknX │ │ │ │ +^b^UhnW\YbW\LShWj │ │ │ │ While computing the class precedence list of the class ~A. │ │ │ │ ]YikNXp^ggd^ │ │ │ │ ~@ │ │ │ │ The class │ │ │ │ follows the class │ │ │ │ @@ -35793,55 +35797,118 @@ │ │ │ │ PATHNAME-INITARG- │ │ │ │ BIT-VECTOR-INITARG- │ │ │ │ STRING-INITARG- │ │ │ │ Tuple ~S not found │ │ │ │ ~@ │ │ │ │ No SLOT-INFO for ~S in ~S │ │ │ │ ~@ │ │ │ │ -^b^UhgPY[PnWd[ps │ │ │ │ -illegal kind argument to ~S: ~S │ │ │ │ -[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ -^b^UhgXXPY[XXPLShWj │ │ │ │ -The RESTP argument is not constant. │ │ │ │ -nY\[Y[YSknX │ │ │ │ -^b^UhnW\YbW\LShWj │ │ │ │ -Invalid eq-p argument: ~S │ │ │ │ __d\ t X t │ │ │ │ early method with no method-function │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ # │ │ │ │ XYedR_tcdPll\U_k^ddP │ │ │ │ ^aaf[d^] │ │ │ │ No ~S methods. │ │ │ │ ANY-KEYP │ │ │ │ :8++p.M;b │ │ │ │ Remove all methods. │ │ │ │ ~S is not a STANDARD-CLASS. │ │ │ │ EFFECTIVE-METHOD-GENSYM- │ │ │ │ +Invalid eq-p argument: ~S │ │ │ │ +a_dgRVaX │ │ │ │ +WaWR\fmj │ │ │ │ d?J;z\D │ │ │ │ f?E !CB != │ │ │ │ +["2N++ *H │ │ │ │ ~:<~W~^ ~3I~:_~W~^~1I~@{~:@_~:<~^~W~^ ~:I~@_~@{~W~^ ~_~}~:>~}~:> │ │ │ │ -a_dgRVaX │ │ │ │ -WaWR\fmj │ │ │ │ -C,'6(&&ffu8((,2"6 │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ 1AO]j"&p( │ │ │ │ :TYPE must be one of ~S │ │ │ │ Must not specify :SORT or :TEST with :KEY-TYPE │ │ │ │ Must specify both :SORT and :TEST │ │ │ │ .~A ~S~:[~:A~;~] │ │ │ │ bF:'eH*E │ │ │ │ -\E\YXkaSRPXXjkZyd │ │ │ │ multiple specializing masters: ~S │ │ │ │ ~@ │ │ │ │ +\E\YXkaSRPXXjkZyd │ │ │ │ +RVN\jNZ[m │ │ │ │ +SU\mXxV\HhmX │ │ │ │ ;;; [~W] │ │ │ │ .SKIP ~D │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ #X~2,'0x │ │ │ │ +)^I~bFGe │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +COMMON-LISP │ │ │ │ +5=q]T9T" │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +SPECIALIZER-COUNT │ │ │ │ +.FASL-INPUT. │ │ │ │ +TABLE-INDEX │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +Etq'XX9< │ │ │ │ +APPLICABLE-METHODS0 │ │ │ │ +TLA9Q!+\% │ │ │ │ + NEW-VALUE │ │ │ │ +FASL-INPUT │ │ │ │ + NEW-VALUE │ │ │ │ +.FASL-INPUT. │ │ │ │ +COMMON-LISP │ │ │ │ +PACKAGE-NAME │ │ │ │ +COMMON-LISP0 │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ +.FASL-INPUT. │ │ │ │ +'V(U)*+T │ │ │ │ +,S-./R0Q123P4O567N8M9:;L?J@IABCHDEG │ │ │ │ +:96521.-*) │ │ │ │ +J_ Nc ] │ │ │ │ + CHAR-CODE │ │ │ │ +COMMON-LISP8 │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ +.FASL-INPUT. │ │ │ │ +N-BYTES0 │ │ │ │ +.FASL-INPUT.0 │ │ │ │ +.FASL-INPUT.0 │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ +.FASL-INPUT. │ │ │ │ +TABLE-SIZE │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ + FUN-INDEX │ │ │ │ +.FASL-INPUT. │ │ │ │ +DEPTHOID │ │ │ │ +COMMON-LISP │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +COMMON-LISP │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +{R]O) Rw │ │ │ │ +~= oDwe_CN │ │ │ │ +juZ=2[U-e7 │ │ │ │ +COMMON-LISP │ │ │ │ #x~8,'0x: ~a~@[ +~d~] │ │ │ │ ~&; Size: ~a bytes. Origin: #x~x~@[ (segment 1 of ~D)~] │ │ │ │ ~&; Origin #x~x (segment ~D of ~D) │ │ │ │ (&MORE ~s) │ │ │ │ (&OPTIONAL ~s) │ │ │ │ (XEP ~s) │ │ │ │ bogus operands to ~A │ │ │ │ @@ -35977,16 +36044,14 @@ │ │ │ │ error printing ~a {~x} │ │ │ │ error printing object │ │ │ │ Index ~a out of bounds for ~a supplied argument~:p. │ │ │ │ more unavailable arguments │ │ │ │ ~&~S: FUN-END in ~S │ │ │ │ ~&~S: FUN-START in ~S │ │ │ │ ~&~S: ~S in ~S │ │ │ │ -RVN\jNZ[m │ │ │ │ -SU\mXxV\HhmX │ │ │ │ invalid argument value │ │ │ │ Unused arguments have no values. │ │ │ │ No argument values are available. │ │ │ │ Specify variable ID to disambiguate ~S. Use one of ~S. │ │ │ │ invalid variable ID, ~W: should have been one of ~S │ │ │ │ specification ambiguous: │ │ │ │ No known valid variables match ~S. │ │ │ │ @@ -36025,43 +36090,14 @@ │ │ │ │ maybe invalid prepositions were specified in iteration path descriptor? │ │ │ │ Arithmetic index must be an atom. │ │ │ │ The variable substitution for ~S occurs twice in a USING phrase,~@ │ │ │ │ with ~S and ~S. │ │ │ │ Preposition ~S was used when some other preposition has subsumed it. │ │ │ │ A ~S prepositional phrase occurs multiply for some LOOP clause. │ │ │ │ A compound form was expected, but ~S found. │ │ │ │ -RESTART-FRAME │ │ │ │ -LIST-BREAKPOINTS │ │ │ │ -LIST-LOCATIONS │ │ │ │ -LIST-LOCALS │ │ │ │ -SPECIALIZER-COUNT │ │ │ │ - NEW-VALUE0 │ │ │ │ -RES^ac(P(6 │ │ │ │ -COMMON-LISP │ │ │ │ -INITARGS │ │ │ │ -COMMON-LISP │ │ │ │ -sG@,/KCk │ │ │ │ -Etq'XX9< │ │ │ │ -APPLICABLE-METHODS0 │ │ │ │ -TLA9Q!+\% │ │ │ │ - NEW-VALUE │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -{R]O) Rw │ │ │ │ -~= oDwe_CN │ │ │ │ -juZ=2[U-e7 │ │ │ │ -COMMON-LISP │ │ │ │ -SB-DISASSEM0 │ │ │ │ -SB-DISASSEM │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -LAMBDA-LIST │ │ │ │ -LAMBDA-LIST0 │ │ │ │ -^t#sFZuj= │ │ │ │ -H(`$(Cc| │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ 3'{xU_pUU^mv │ │ │ │ 4 .$ d_%Xa │ │ │ │ This LOOP clause is not permitted with anonymous collectors. │ │ │ │ current LOOP context:~{ ~S~}. │ │ │ │ MINMAXTMP │ │ │ │ secondary clause misplaced at top level in LOOP macro: ~S ~S ~S ... │ │ │ │ unknown LOOP keyword: ~S │ │ │ │ @@ -36076,14 +36112,18 @@ │ │ │ │ Unused USING vars: ~S. │ │ │ │ "Inclusive" iteration is not possible with the ~S LOOP iteration path. │ │ │ │ ~S is not the name of a LOOP iteration path. │ │ │ │ ~S was found where a LOOP iteration path name was expected. │ │ │ │ ~S was found where ITS or EACH expected in LOOP iteration path syntax. │ │ │ │ unrecognizable LOOP iteration path syntax: missing EACH or THE? │ │ │ │ Too many prepositions │ │ │ │ +RESTART-FRAME │ │ │ │ +LIST-BREAKPOINTS │ │ │ │ +LIST-LOCATIONS │ │ │ │ +LIST-LOCALS │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ The tag :A appears more than once in a tagbody. │ │ │ │ ~@ │ │ │ │ @@ -36096,99 +36136,92 @@ │ │ │ │ 4O0A"%5i │ │ │ │ ~@ │ │ │ │ ignoring unknown optimization quality ~S in ~S │ │ │ │ ~@ │ │ │ │ Tried to set a symbol-macrolet! │ │ │ │ VU\Y\eem │ │ │ │ [PM^hN[P │ │ │ │ +C,'6(&&ffu8((,2"6 │ │ │ │ operation. │ │ │ │ operation │ │ │ │ resetting │ │ │ │ configuration. │ │ │ │ _.=6__X2$8 │ │ │ │ .A%" 0#> │ │ │ │ +autom4te.cache │ │ │ │ +cover_db │ │ │ │ ;%G%Zi03 (#),* │ │ │ │ ,#3;((P"_ │ │ │ │ unexpected special form ~S │ │ │ │ Invalid Huffman-code: ~S │ │ │ │ Not a variable declaration the walker cares about: ~S │ │ │ │ Ignoring doc-type ~a for ~a. │ │ │ │ -autom4te.cache │ │ │ │ -cover_db │ │ │ │ +R7z+1F@*b │ │ │ │ +:555?<<1F7F │ │ │ │ +XV │ │ │ │ +YVl\VVVVi_YYoX │ │ │ │ ,h2E │ │ │ │ -~@ │ │ │ │ -named ~// │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~//~:[~:; ~:S~] │ │ │ │ -New lambda-list ~// is incompatible with existing methods of ~S. │ │ │ │ -Old lambda-list ~// │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -HASH-KEYS │ │ │ │ -HASH-VALUES │ │ │ │ -EXTERNAL-SYMBOL │ │ │ │ -PRESENT-SYMBOL │ │ │ │ -PRESENT-SYMBOLS │ │ │ │ +SB-DISASSEM0 │ │ │ │ +SB-DISASSEM │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +LAMBDA-LIST │ │ │ │ +LAMBDA-LIST0 │ │ │ │ +^t#sFZuj= │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +H(`$(Cc| │ │ │ │ +&}/]4AD#o │ │ │ │ ARG-NAMES │ │ │ │ +MORE-ARG │ │ │ │ +Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ +fold identity operation │ │ │ │ +SYS:SRC;COMPILER;X86;MEMORY.LISP │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ASSEM-RTNS.LISP │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ARITH.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;VALUES.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;SUBPRIM.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;SHOW.LISP │ │ │ │ +SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ +UUuUU]WW │ │ │ │ 21e_Z3g'6 │ │ │ │ LINE-SIZE │ │ │ │ VECTOR-LENGTH │ │ │ │ ,$v:"e 9 │ │ │ │ ARG-INFO │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ V#@Nu:`kj │ │ │ │ COMMON-LISP │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ -&}/]4AD#o │ │ │ │ -UUuUU]WW │ │ │ │ -Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ -Returns the last value returned by FUNCTION. │ │ │ │ -COUNT is the number of frames to backtrace, defaulting to │ │ │ │ -*BACKTRACE-FRAME-COUNT*. │ │ │ │ -START is the number of the frame the backtrace should start from. │ │ │ │ -FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ -values are an explicit SB-DI:FRAME object, and the │ │ │ │ -keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ -is :DEBUGGER-FRAME. │ │ │ │ - :CURRENT-FRAME │ │ │ │ - specifies the caller of MAP-BACKTRACE. │ │ │ │ - :INTERRUPTED-FRAME │ │ │ │ - specifies the first interrupted frame on the stack (typically the frame │ │ │ │ - where the error occurred, as opposed to error handling frames) if any, │ │ │ │ - otherwise behaving as :CURRENT-FRAME. │ │ │ │ - :DEBUGGER-FRAME │ │ │ │ - specifies the currently debugged frame when inside the debugger, and │ │ │ │ - behaves as :INTERRUPTED-FRAME outside the debugger. │ │ │ │ -8ymdXBjP │ │ │ │ -Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ -fold identity operation │ │ │ │ -SYS:SRC;COMPILER;X86;MEMORY.LISP │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ASSEM-RTNS.LISP │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ARITH.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;VALUES.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;SUBPRIM.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;SHOW.LISP │ │ │ │ -SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ +HASH-KEYS │ │ │ │ +HASH-VALUES │ │ │ │ +EXTERNAL-SYMBOL │ │ │ │ +PRESENT-SYMBOL │ │ │ │ +PRESENT-SYMBOLS │ │ │ │ +~@ │ │ │ │ +named ~// │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~//~:[~:; ~:S~] │ │ │ │ +New lambda-list ~// is incompatible with existing methods of ~S. │ │ │ │ +Old lambda-list ~// │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +RMYANCB_ │ │ │ │ +V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ recode as leas, shifts and adds │ │ │ │ -MORE-ARG │ │ │ │ -DISPLACEMENT.USE-LABEL │ │ │ │ -DISPLACEMENT.PRINTER │ │ │ │ -COMMON-LISP │ │ │ │ optimize to inlined RANDOM-CHUNK operations │ │ │ │ Use inline float operations. │ │ │ │ open-code INTEGER to RATIO comparison │ │ │ │ open-code RATIONAL to FLOAT comparison │ │ │ │ invert or open code │ │ │ │ open-code FLOAT to RATIONAL comparison │ │ │ │ convert to simpler equality predicate │ │ │ │ -RMYANCB_ │ │ │ │ -V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ associate LOGIOR/(LOGIOR) of constants │ │ │ │ FORM SB-KERNEL │ │ │ │ associate +/(+ -) of constants │ │ │ │ check for iteration variable reoptimization │ │ │ │ convert (- 0 x) to negate │ │ │ │ associate -/(+ -) of constants │ │ │ │ associate LOGTEST/(LOGAND) of constants │ │ │ │ @@ -36200,20 +36233,56 @@ │ │ │ │ associate LOGXOR/(LOGXOR) of constants │ │ │ │ SB-ALIEN0 │ │ │ │ SB-ALIEN0 │ │ │ │ constant-fold INTEGER to RATIO comparison │ │ │ │ RM/,pm:F@U │ │ │ │ convert NTHCDR to CAxxR │ │ │ │ SEQS-NAMES │ │ │ │ -SUB-ACCESSOR2 │ │ │ │ -SRC-SIZE │ │ │ │ convert to EQ test │ │ │ │ ARRAY-TYPE SB-KERNEL0 │ │ │ │ recode as an ODDP check │ │ │ │ +SUB-ACCESSOR2 │ │ │ │ recode as multiplication or sqrt │ │ │ │ +associate LOGAND/(LOGAND) of constants │ │ │ │ +DISPLACEMENT.USE-LABEL │ │ │ │ +DISPLACEMENT.PRINTER │ │ │ │ +COMMON-LISP │ │ │ │ + SLOT-TYPE │ │ │ │ +COMMON-LISP85 │ │ │ │ +This should be eliminated as dead code. │ │ │ │ +DATA-START │ │ │ │ +SRC-SIZE │ │ │ │ +T/qt2eF")3 │ │ │ │ +ELEMENT-TYPE │ │ │ │ +precompute external-format lookup │ │ │ │ +Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ +Returns the last value returned by FUNCTION. │ │ │ │ +COUNT is the number of frames to backtrace, defaulting to │ │ │ │ +*BACKTRACE-FRAME-COUNT*. │ │ │ │ +START is the number of the frame the backtrace should start from. │ │ │ │ +FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ +values are an explicit SB-DI:FRAME object, and the │ │ │ │ +keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ +is :DEBUGGER-FRAME. │ │ │ │ + :CURRENT-FRAME │ │ │ │ + specifies the caller of MAP-BACKTRACE. │ │ │ │ + :INTERRUPTED-FRAME │ │ │ │ + specifies the first interrupted frame on the stack (typically the frame │ │ │ │ + where the error occurred, as opposed to error handling frames) if any, │ │ │ │ + otherwise behaving as :CURRENT-FRAME. │ │ │ │ + :DEBUGGER-FRAME │ │ │ │ + specifies the currently debugged frame when inside the debugger, and │ │ │ │ + behaves as :INTERRUPTED-FRAME outside the debugger. │ │ │ │ +8ymdXBjP │ │ │ │ +METHODS8 │ │ │ │ +SORTED-P │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +CONSTANT SB-KERNEL0 │ │ │ │ +METHOD-ALIST │ │ │ │ +WRAPPERS │ │ │ │ 7jUDIQ&| │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ @@ -36300,119 +36369,23 @@ │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ OPTIONAL-ARGS │ │ │ │ SEGMENT0 │ │ │ │ SEGMENT0 │ │ │ │ .ANONYMOUS. │ │ │ │ MARK-INDEX │ │ │ │ -METHODS8 │ │ │ │ -SORTED-P │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -CONSTANT SB-KERNEL0 │ │ │ │ -METHOD-ALIST │ │ │ │ -WRAPPERS │ │ │ │ -Coerce CLASS to a class that is subclass of SUPER if specified, │ │ │ │ -or invoke ERROR handler as per CALL-FUNCTION. │ │ │ │ -A keyword designates the name a symbol, which when found in either PACKAGE, designates a class. │ │ │ │ --- for backward compatibility, *PACKAGE* is also accepted for now, but this may go in the future. │ │ │ │ -A string is read as a symbol while in PACKAGE, the symbol designates a class. │ │ │ │ -A class object designates itself. │ │ │ │ -NIL designates itself (no class). │ │ │ │ -A symbol otherwise designates a class by name. │ │ │ │ -Lookup the TABLE for a KEY as by GETHASH, but if not present, │ │ │ │ -call the (possibly constant) function designated by DEFAULT as per CALL-FUNCTION, │ │ │ │ -set the corresponding entry to the result in the table. │ │ │ │ -Return two values: the entry after its optional computation, and whether it was found │ │ │ │ -associate LOGAND/(LOGAND) of constants │ │ │ │ -DATA-START │ │ │ │ -This should be eliminated as dead code. │ │ │ │ - SLOT-TYPE │ │ │ │ -COMMON-LISP85 │ │ │ │ -T/qt2eF")3 │ │ │ │ -ELEMENT-TYPE │ │ │ │ -precompute external-format lookup │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -CLASS-SLOT-P │ │ │ │ -)^I~bFGe │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -COMMON-LISP │ │ │ │ -5=q]T9T" │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -TABLE-INDEX │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -FASL-INPUT │ │ │ │ - NEW-VALUE │ │ │ │ -.FASL-INPUT. │ │ │ │ -COMMON-LISP │ │ │ │ -PACKAGE-NAME │ │ │ │ -COMMON-LISP0 │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ -.FASL-INPUT. │ │ │ │ -'V(U)*+T │ │ │ │ -,S-./R0Q123P4O567N8M9:;L?J@IABCHDEG │ │ │ │ -:96521.-*) │ │ │ │ -J_ Nc ] │ │ │ │ - CHAR-CODE │ │ │ │ -COMMON-LISP8 │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ -.FASL-INPUT. │ │ │ │ -N-BYTES0 │ │ │ │ -.FASL-INPUT.0 │ │ │ │ -.FASL-INPUT.0 │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ -.FASL-INPUT. │ │ │ │ -TABLE-SIZE │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ - FUN-INDEX │ │ │ │ -.FASL-INPUT. │ │ │ │ -DEPTHOID │ │ │ │ -COMMON-LISP │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -COMMON-LISP │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ CLASSES-LIST │ │ │ │ OPTIONAL-ARGS │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ NEW-VALUE │ │ │ │ SLOT-NAME │ │ │ │ +CLASS-SLOT-P │ │ │ │ A08F_f8Y │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ SLOT-NAME0 │ │ │ │ VKUSial$ │ │ │ │ .ANONYMOUS. │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -36421,22 +36394,26 @@ │ │ │ │ fmt$VU8JH │ │ │ │ *SRgai9" │ │ │ │ COMMON-LISP │ │ │ │ .DOLIST-CAREFULLY. │ │ │ │ COMMON-LISP │ │ │ │ SPECIALIZERS │ │ │ │ FORM SB-KERNEL0 │ │ │ │ +CLASS-SLOT-P │ │ │ │ COMMON-LISP │ │ │ │ +CLASS-SLOT-P │ │ │ │ +CLASS-SLOT-P │ │ │ │ i-qld*#) │ │ │ │ TYPE-NAME8 │ │ │ │ CACHED-EMF-P │ │ │ │ METATYPES │ │ │ │ RETURN-VALUE-P │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +CLASS-SLOT-P │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ COMMON-LISP │ │ │ │ CLASS-PROTO │ │ │ │ INITARGS │ │ │ │ INVALID8 │ │ │ │ COMMON-LISP │ │ │ │ @@ -36452,25 +36429,29 @@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ CLOSURE-VARIABLES │ │ │ │ COMMON-LISP0I │ │ │ │ 4(@DPX`> │ │ │ │ X SB-KERNEL │ │ │ │ w0a\;!;+ │ │ │ │ +CLASS-SLOT-P │ │ │ │ ARG-NUMBER │ │ │ │ SPECIALIZER-CACHE0 │ │ │ │ NEW-VALUE │ │ │ │ SLOT-NAME │ │ │ │ ARG-INFO │ │ │ │ FORM SB-KERNEL │ │ │ │ +&P:,`W:00 │ │ │ │ +METHOD-CALL │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME0 │ │ │ │ METHOD-LAMBDA │ │ │ │ METHOD-NAME │ │ │ │ +CLASS-SLOT-P │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ FORM SB-KERNEL │ │ │ │ REQUIRED-PARAMETERS │ │ │ │ SLOT-NAME │ │ │ │ SPARAMETER0< │ │ │ │ 7YOl6R![" │ │ │ │ SLOT-NAME0 │ │ │ │ @@ -36487,27 +36468,30 @@ │ │ │ │ COMMON-LISP │ │ │ │ PV-PARAMETERS0 │ │ │ │ PV-TABLE │ │ │ │ REST-ARG │ │ │ │ CLASS-OR-NAME0 │ │ │ │ SPECIALIZERS │ │ │ │ CLASS-SLOT-P │ │ │ │ +CLASS-SLOT-P │ │ │ │ +CLASS-SLOT-P │ │ │ │ METATYPES │ │ │ │ QUALIFIER8 │ │ │ │ TYPE-NAME │ │ │ │ COMMON-LISP │ │ │ │ -&P:,`W:00 │ │ │ │ -METHOD-CALL │ │ │ │ -ARG-NUMBER │ │ │ │ +CLASS-SLOT-P │ │ │ │ ~@ │ │ │ │ SI-AROUND │ │ │ │ DUMMY-NODE-P │ │ │ │ +ARG-NUMBER │ │ │ │ LAMBDA-LIST │ │ │ │ +CLASS-SLOT-P │ │ │ │ fmt$2J775S │ │ │ │ +CLASS-SLOT-P │ │ │ │ TUuUuU}UW_]uu │ │ │ │ KEYWORDS │ │ │ │ LAMBDA-LIST │ │ │ │ MORE-ARG │ │ │ │ y['8MSZ3J6 │ │ │ │ SLOT-NAME │ │ │ │ MORE-ARG │ │ │ │ @@ -36518,20 +36502,26 @@ │ │ │ │ REST-ARG │ │ │ │ D(]VYU^- │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NODE-HASH │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ +Coerce CLASS to a class that is subclass of SUPER if specified, │ │ │ │ +or invoke ERROR handler as per CALL-FUNCTION. │ │ │ │ +A keyword designates the name a symbol, which when found in either PACKAGE, designates a class. │ │ │ │ +-- for backward compatibility, *PACKAGE* is also accepted for now, but this may go in the future. │ │ │ │ +A string is read as a symbol while in PACKAGE, the symbol designates a class. │ │ │ │ +A class object designates itself. │ │ │ │ +NIL designates itself (no class). │ │ │ │ +A symbol otherwise designates a class by name. │ │ │ │ +Lookup the TABLE for a KEY as by GETHASH, but if not present, │ │ │ │ +call the (possibly constant) function designated by DEFAULT as per CALL-FUNCTION, │ │ │ │ +set the corresponding entry to the result in the table. │ │ │ │ +Return two values: the entry after its optional computation, and whether it was found │ │ │ │ SB-DISASSEM │ │ │ │ SB-DISASSEM │ │ │ │ COMPONENT │ │ │ │ OPERATION0 │ │ │ │ ASDF/COMPONENT0 │ │ │ │ Given a designator for a component NAME, return the name as a string. │ │ │ │ The designator can be a COMPONENT (designing its name; note that a SYSTEM is a component), │ │ │ │ @@ -36561,86 +36551,92 @@ │ │ │ │ if the SPECIFIED pathname does have an absolute directory, │ │ │ │ then the HOST and DEVICE both come from the SPECIFIED pathname. │ │ │ │ This is what users want on a modern Unix or Windows operating system, │ │ │ │ unlike the MERGE-PATHNAMES behavior. │ │ │ │ Also, if either argument is NIL, then the other argument is returned unmodified; │ │ │ │ this is unlike MERGE-PATHNAMES which always merges with a pathname, │ │ │ │ by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL. │ │ │ │ -4Ic`QY)8b$LP │ │ │ │ PATHSPEC8 │ │ │ │ If PATHSPEC is a pathname or namestring object that parses as a pathname │ │ │ │ possessing an :ABSOLUTE directory component, return the (parsed) pathname. │ │ │ │ Otherwise return NIL │ │ │ │ -Detect circular dependencies │ │ │ │ -Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ - ARGUMENTS │ │ │ │ +Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ +Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ +4Ic`QY)8b$LP │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ +MORE-ARG │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ SO-KEY8% │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ 0337#23BA │ │ │ │ COMMON-LISP0 │ │ │ │ SEGMENT0 │ │ │ │ +FORM SB-KERNEL │ │ │ │ +STEP implements a debugging paradigm wherein the programmer is allowed │ │ │ │ + to step through the evaluation of a form. We use the debugger's stepping │ │ │ │ + facility to step through an anonymous function containing only form. │ │ │ │ + Currently the stepping facility only supports stepping compiled code, │ │ │ │ + so step will try to compile the resultant anonymous function. If this │ │ │ │ + fails, e.g. because it closes over a non-null lexical environment, an │ │ │ │ + error is signalled. │ │ │ │ +o9MS Liy[9 │ │ │ │ +)Cetj+$%A │ │ │ │ ERRNUM0+ │ │ │ │ COMMON-LISP │ │ │ │ BYTE-OFFSET2 │ │ │ │ -Overwriting already existing readtable ~S. │ │ │ │ -&OPTIONAL and &KEY found in the same lambda list: ~S │ │ │ │ -No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function. │ │ │ │ -Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ -Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ -~// is undefined, not tracing. │ │ │ │ -asdf-output-translations │ │ │ │ -source-registry │ │ │ │ SC+OFFSET │ │ │ │ SEGMENT0 │ │ │ │ DSTATE0% │ │ │ │ FQ<*Pu:0 │ │ │ │ COMMON-LISP │ │ │ │ ob^Mk";5 │ │ │ │ COMMON-LISP │ │ │ │ :#%$&w^e │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP │ │ │ │ +OTHER-SPECIALIZERS │ │ │ │ +Overwriting already existing readtable ~S. │ │ │ │ +&OPTIONAL and &KEY found in the same lambda list: ~S │ │ │ │ +No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function. │ │ │ │ +~// is undefined, not tracing. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +asdf-output-translations │ │ │ │ +source-registry │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP │ │ │ │ -6mvpEnE │ │ │ │ -R7z+1F@*b │ │ │ │ -:555?<<1F7F │ │ │ │ -XV │ │ │ │ -YVl\VVVVi_YYoX │ │ │ │ -C'#K54i(W8@ │ │ │ │ -Continue using :external-format :default │ │ │ │ -~@ │ │ │ │ -These functions were not called: │ │ │ │ COMMON-LISP │ │ │ │ +common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ SB-ALIEN │ │ │ │ INTEGER1 │ │ │ │ COMMON-LISP0 │ │ │ │ NEIGHBOR │ │ │ │ FFvVtYXh|@ │ │ │ │ 9H%*BJEFL@T │ │ │ │ b*]hhFh$I │ │ │ │ |&N28_J'7 │ │ │ │ N2*`o:02e │ │ │ │ p;ZFc;T?# │ │ │ │ DzGNY/]O │ │ │ │ COMMON-LISP │ │ │ │ -common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ -OTHER-SPECIALIZERS │ │ │ │ DEFAULT0 │ │ │ │ VQ<+`o:0 │ │ │ │ COMMON-LISP │ │ │ │ .tyiETt+ │ │ │ │ LOCATION │ │ │ │ ,'/z<(@F0 │ │ │ │ Returns as multiple values a descriptive name for the function responsible │ │ │ │ @@ -36660,26 +36656,14 @@ │ │ │ │ ARG-COUNT │ │ │ │ ESCAPED0 │ │ │ │ DEBUG-FUN0 │ │ │ │ DEFINITION │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP0 │ │ │ │ OPTIONAL-ARGS │ │ │ │ -FORM SB-KERNEL │ │ │ │ -STEP implements a debugging paradigm wherein the programmer is allowed │ │ │ │ - to step through the evaluation of a form. We use the debugger's stepping │ │ │ │ - facility to step through an anonymous function containing only form. │ │ │ │ - Currently the stepping facility only supports stepping compiled code, │ │ │ │ - so step will try to compile the resultant anonymous function. If this │ │ │ │ - fails, e.g. because it closes over a non-null lexical environment, an │ │ │ │ - error is signalled. │ │ │ │ -o9MS Liy[9 │ │ │ │ -)Cetj+$%A │ │ │ │ -LABEL.PREFILTER │ │ │ │ -IMM-WORD.PREFILTER │ │ │ │ Return the N'th argument's value if possible. Argument zero is the first │ │ │ │ argument in a frame's default printed representation. Count keyword/value │ │ │ │ pairs as separate arguments. │ │ │ │ Returns a list describing the call stack. Each frame is represented │ │ │ │ by a sublist: │ │ │ │ ( ...args...) │ │ │ │ where the name describes the function responsible for the frame. The name │ │ │ │ @@ -36722,26 +36706,29 @@ │ │ │ │ The result of this function is limited to the availability of variable │ │ │ │ information. This is SETF'able. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ LOOP-TOKEN │ │ │ │ FORM SB-KERNEL0 │ │ │ │ FORM SB-KERNEL8" │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ FORMAT-ARGS │ │ │ │ FORMAT-STRING │ │ │ │ REST-ARG │ │ │ │ OPTIONAL-ARGS │ │ │ │ NEGATE SB-KERNEL │ │ │ │ DATA-TYPE │ │ │ │ FORM SB-KERNEL │ │ │ │ RESTRICTIVE │ │ │ │ SPECIFICALLY │ │ │ │ +C'#K54i(W8@ │ │ │ │ +Continue using :external-format :default │ │ │ │ +~@ │ │ │ │ +These functions were not called: │ │ │ │ + uD 3BV,# $! │ │ │ │ +STANDARD method combination accepts no options. │ │ │ │ NEGATE SB-KERNEL │ │ │ │ RESTRICTIVE │ │ │ │ VAR-VAL-PAIRS0 │ │ │ │ D_UkEoQ[IW │ │ │ │ COMMON-LISP │ │ │ │ DATA-TYPE │ │ │ │ FUNCTION-DEF │ │ │ │ @@ -36874,16 +36861,19 @@ │ │ │ │ a list for each collection, in order. │ │ │ │ E.g., │ │ │ │ (while-collecting (foo bar) │ │ │ │ (dolist (x '((a 1) (b 2) (c 3))) │ │ │ │ (foo (first x)) │ │ │ │ (bar (second x)))) │ │ │ │ Returns two values: (A B C) and (1 2 3). │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-VALUE │ │ │ │ +Detect circular dependencies │ │ │ │ +Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ + ARGUMENTS │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ ASDF/COMPONENT │ │ │ │ Coerce a system designator NAME into a string suitable as a filename component. │ │ │ │ The (current) transformation is to replace characters /:\ each by --, │ │ │ │ the former being forbidden in a filename component. │ │ │ │ NB: The onus is unhappily on the user to avoid clashes. │ │ │ │ fmt$TDSP4 │ │ │ │ fmt$26JOW8 │ │ │ │ @@ -37003,21 +36993,22 @@ │ │ │ │ PSEUDOSYMBOL │ │ │ │ Does PATHNAME represent a directory? │ │ │ │ A directory-pathname is a pathname _without_ a filename. The three │ │ │ │ ways that the filename components can be missing are for it to be NIL, │ │ │ │ :UNSPECIFIC or the empty string. │ │ │ │ Note that this does _not_ check to see that PATHNAME points to an │ │ │ │ actually-existing directory. │ │ │ │ +CLEANUP-FUN-42 │ │ │ │ +CLEANUP-FUN-141 │ │ │ │ when given a pathname P (designated by a string as per PARSE-NAMESTRING), │ │ │ │ probes the filesystem for a file or directory with given pathname. │ │ │ │ If it exists, return its truename if TRUENAME is true, │ │ │ │ or the original (parsed) pathname if it is false (the default). │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ -uUr]H0mJ │ │ │ │ The type of Lisp implementation used, as a short UIOP-standardized keyword │ │ │ │ Calls FUN with a staging pathname, and atomically │ │ │ │ renames the staging pathname to the PATHNAME in the end. │ │ │ │ NB: this protects only against failure of the program, not against concurrent attempts. │ │ │ │ For the latter case, we ought pick a random suffix and atomically open it. │ │ │ │ OUTPUT0 │ │ │ │ Combine a list of FASLs INPUTS into a single FASL OUTPUT │ │ │ │ @@ -37039,16 +37030,14 @@ │ │ │ │ by letting you supply a symbol or keyword for the name; │ │ │ │ also works well when the package is not present. │ │ │ │ If optional ERROR argument is NIL, return NIL instead of an error │ │ │ │ when the symbol is not found. │ │ │ │ Compute the transitive sub-components of given COMPONENT that are of given TYPE │ │ │ │ Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE? │ │ │ │ If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead. │ │ │ │ -CLEANUP-FUN-42 │ │ │ │ -CLEANUP-FUN-141 │ │ │ │ DEPRECATED: all subclasses of OPERATION used in ASDF should inherit from one of │ │ │ │ DOWNWARD-OPERATION UPWARD-OPERATION SIDEWAY-OPERATION SELFWARD-OPERATION NON-PROPAGATING-OPERATION. │ │ │ │ The function BACKWARD-COMPATIBLE-DEPENDS-ON temporarily provides ASDF2 behaviour for those that │ │ │ │ don't. In the future this functionality will be removed, and the default will be no propagation. │ │ │ │ Convert a list of directives to a list of pathnames. No two │ │ │ │ pathnames in th eresult have the same pathname-name. A directive │ │ │ │ should be a list of a symbol and a pathname. The directive can be │ │ │ │ @@ -37057,54 +37046,45 @@ │ │ │ │ A new empty file with said temporary pathname is created, to ensure there is no │ │ │ │ clash with any concurrent process attempting the same thing. │ │ │ │ create a new OUTPUT file the contents of which a the concatenate of the INPUTS files. │ │ │ │ Rename a file, overwriting any previous file with the TARGET name, │ │ │ │ in an atomic way if the implementation allows. │ │ │ │ Enforce that OPERATION instances must be created with MAKE-OPERATION. │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ + NEW-VALUE │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ LOCATION0 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ NEW-VALUE │ │ │ │ REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +DECLARATION │ │ │ │ +COMMON-LISP │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP0 │ │ │ │ Returns the canonical combining class (CCC) of CHARACTER │ │ │ │ +uUr]H0mJ │ │ │ │ +LABEL.PREFILTER │ │ │ │ +IMM-WORD.PREFILTER │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ +SB-DISASSEM │ │ │ │ COMMON-LISP0 │ │ │ │ -DECLARATION │ │ │ │ -COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ NEW-VALUE │ │ │ │ -SB-DISASSEM │ │ │ │ -COMMON-LISP0 │ │ │ │ FP-REG.PRINTER │ │ │ │ COMMON-LISP │ │ │ │ +TZ+yuOZ3 │ │ │ │ DOC-TYPE │ │ │ │ NEW-VALUE │ │ │ │ ^L:MW-Z9 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ ^P:MW-Z9 │ │ │ │ IMM-ADDR.PREFILTER │ │ │ │ IMM-BYTE.PREFILTER │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -TZ+yuOZ3 │ │ │ │ -sbcl-source │ │ │ │ -CLEANUP-FUN-5 │ │ │ │ -surplus arguments: ~S │ │ │ │ -V-8QXZ()7695JUITGPFK │ │ │ │ -OHED21430WSL │ │ │ │ -STANDARD method combination accepts no options. │ │ │ │ - uD 3BV,# $! │ │ │ │ -The :DISPLACED-TO array is too small │ │ │ │ -The number of dimensions is not equal to the rank of the array │ │ │ │ -Can't displace an array of type ~S to another of type ~S │ │ │ │ -SYS:SRC;PCL;DLISP2.LISP │ │ │ │ -WRAPPER10 │ │ │ │ -/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ -SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST │ │ │ │ n!gO[Z2% │ │ │ │ CvuPk.CDz[ │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ COMMON-LISP │ │ │ │ Call a function associated with symbol of given name in given package, │ │ │ │ with given ARGS. Useful when the call is read before the package is loaded, │ │ │ │ @@ -37114,31 +37094,63 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ 4,PW:033S │ │ │ │ 2T~^x3#F │ │ │ │ EicOII>$ │ │ │ │ COMMON-LISP0 │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ +sbcl-source │ │ │ │ +CLEANUP-FUN-5 │ │ │ │ +surplus arguments: ~S │ │ │ │ +V-8QXZ()7695JUITGPFK │ │ │ │ +OHED21430WSL │ │ │ │ +The :DISPLACED-TO array is too small │ │ │ │ +The number of dimensions is not equal to the rank of the array │ │ │ │ +Can't displace an array of type ~S to another of type ~S │ │ │ │ +SYS:SRC;PCL;DLISP2.LISP │ │ │ │ +WRAPPER10 │ │ │ │ +SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST │ │ │ │ +/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ +sb-aclrepl │ │ │ │ +sb-bsd-sockets │ │ │ │ +sb-capstone │ │ │ │ +sb-cltl2 │ │ │ │ +sb-concurrency │ │ │ │ +sb-cover │ │ │ │ +sb-executable │ │ │ │ +sb-grovel │ │ │ │ +sb-introspect │ │ │ │ +sb-posix │ │ │ │ +sb-queue │ │ │ │ +sb-rotate-byte │ │ │ │ +sb-simple-streams │ │ │ │ +sb-sprof │ │ │ │ +fiveam-asdf │ │ │ │ +asdf-tools │ │ │ │ +asdf-driver │ │ │ │ +CLEANUP-FUN-14 │ │ │ │ +contrib/debug.lisp │ │ │ │ *ASDF-VERSION* │ │ │ │ *ASDF-REVISION* │ │ │ │ #: :U j( │ │ │ │ /7&!"@#"@ │ │ │ │ ;; loading file │ │ │ │ ;; loading system │ │ │ │ /%/(%+" │ │ │ │ NvNii3$( │ │ │ │ <*9Q 7 & │ │ │ │ -UY]RYck`` │ │ │ │ +z 4z 4z 4+ │ │ │ │ &(1,g o │ │ │ │ +UY]RYck`` │ │ │ │ ") )g │ │ │ │ Illegal function call in method body: │ │ │ │ +w(,,(%$"l V │ │ │ │ COMMON-LISP │ │ │ │ Changes the home package of a symbol, also leaving it present in its old home if any │ │ │ │ -SYSTEM0 │ │ │ │ +L-)Pu:03 │ │ │ │ COMMON-LISP │ │ │ │ DEFINE-PACKAGE takes a PACKAGE and a number of CLAUSES, of the form │ │ │ │ (KEYWORD . ARGS). │ │ │ │ DEFINE-PACKAGE supports the following keywords: │ │ │ │ SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN, NICKNAMES, │ │ │ │ DOCUMENTATION -- as per CL:DEFPACKAGE. │ │ │ │ USE -- as per CL:DEFPACKAGE, but if neither USE, USE-REEXPORT, MIX, │ │ │ │ @@ -37167,39 +37179,37 @@ │ │ │ │ upgrading ASDF). Most programmers will have no use for this option. │ │ │ │ LOCAL-NICKNAMES -- If the host implementation supports package local nicknames │ │ │ │ (check for the :PACKAGE-LOCAL-NICKNAMES feature), then this should be a list of │ │ │ │ nickname and package name pairs. Using this option will cause an error if the │ │ │ │ host CL implementation does not support it. │ │ │ │ USE-REEXPORT, MIX-REEXPORT -- Use or mix the specified packages as per the USE or │ │ │ │ MIX directives, and reexport their contents as per the REEXPORT directive. │ │ │ │ -L-)Pu:03 │ │ │ │ ffffff6nkkk │ │ │ │ @y$2QARR7 │ │ │ │ The function to call if there are errors in the command-line │ │ │ │ buildapp application. │ │ │ │ +SYSTEM0 │ │ │ │ ENCODING │ │ │ │ Default, ignorant, function to transform a character ENCODING as a │ │ │ │ portable keyword to an implementation-dependent EXTERNAL-FORMAT specification. │ │ │ │ Load system ASDF-ENCODINGS to hook in a better one. │ │ │ │ Trivial function to use as *encoding-detection-hook*, │ │ │ │ always 'detects' the *default-encoding* │ │ │ │ +convert (* x 0) to 0 │ │ │ │ +associate */(* /) of constants │ │ │ │ +convert x*2^k to shift │ │ │ │ +optimize multiplication by one │ │ │ │ DISPATCH-ENTRY │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ Convert the DIRECTORY component from a format usable by the underlying │ │ │ │ implementation's MAKE-PATHNAME and other primitives to a CLHS-standard format │ │ │ │ that is a list and not a string. │ │ │ │ Helper for MERGE-PATHNAMES* that handles directory components │ │ │ │ Make a pathname component suitable for use in a logical-pathname │ │ │ │ -Given a SYSTEM on which operate is called and the specified FORCE argument, │ │ │ │ -extract a hash-set of systems that are forced, or a predicate on system names, │ │ │ │ -or NIL if none are forced, or :ALL if all are. │ │ │ │ -Given a SYSTEM on which operate is called, the specified FORCE-NOT argument, │ │ │ │ -and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not, │ │ │ │ -or predicate on system names, or NIL if none are forced, or :ALL if all are. │ │ │ │ Report results from profiling. The results are approximately │ │ │ │ adjusted for profiling overhead. The compensation may be rather │ │ │ │ inaccurate when bignums are involved in runtime calculation, as in a │ │ │ │ very-long-running Lisp process. │ │ │ │ If LIMIT is set to an integer, only the top LIMIT results are │ │ │ │ reported. If PRINT-NO-CALL-LIST is T (the default) then a list of │ │ │ │ uncalled profiled functions are listed. │ │ │ │ @@ -37207,23 +37217,63 @@ │ │ │ │ If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK │ │ │ │ and save those warnings to the given file for latter use, │ │ │ │ possibly in a different process. Otherwise just call THUNK. │ │ │ │ SETTINGS81 │ │ │ │ Proclaim the optimization settings in *OPTIMIZATION-SETTINGS* │ │ │ │ Detect SB-GROVEL unknown-constant conditions on older versions of SBCL │ │ │ │ Get current compiler optimization settings, ready to PROCLAIM again │ │ │ │ -contrib/debug.lisp │ │ │ │ -CLEANUP-FUN-14 │ │ │ │ +return a portable S-expression, portably readable and writeable in any Common Lisp implementation │ │ │ │ +using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by │ │ │ │ +WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF. │ │ │ │ +This function provides a portable wrapper around COMPILE-FILE. │ │ │ │ +It ensures that the OUTPUT-FILE value is only returned and │ │ │ │ +the file only actually created if the compilation was successful, │ │ │ │ +even though your implementation may not do that. It also checks an optional │ │ │ │ +user-provided consistency function COMPILE-CHECK to determine success; │ │ │ │ +it will call this function if not NIL at the end of the compilation │ │ │ │ +with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE │ │ │ │ +where TMP-FILE is the name of a temporary output-file. │ │ │ │ +It also checks two flags (with legacy british spelling from ASDF1), │ │ │ │ +*COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR* │ │ │ │ +with appropriate implementation-dependent defaults, │ │ │ │ +and if a failure (respectively warnings) are reported by COMPILE-FILE, │ │ │ │ +it will consider that an error unless the respective behaviour flag │ │ │ │ +is one of :SUCCESS :WARN :IGNORE. │ │ │ │ +If WARNINGS-FILE is defined, deferred warnings are saved to that file. │ │ │ │ +On ECL or MKCL, it creates both the linkable object and loadable fasl files. │ │ │ │ +On implementations that erroneously do not recognize standard keyword arguments, │ │ │ │ +it will filter them appropriately. │ │ │ │ +Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled │ │ │ │ +Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents │ │ │ │ +Given the results of COMPILE-FILE, raise an error or warning as appropriate │ │ │ │ +L2mX^UY)mS │ │ │ │ +Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT. │ │ │ │ +One of three functions required for deferred-warnings support in ASDF. │ │ │ │ +INPUT-FILE │ │ │ │ +From a INPUT-FILE pathname, return a corresponding .lisp source pathname │ │ │ │ +COMMON-LISP │ │ │ │ +Portably read and evaluate forms from a STRING. │ │ │ │ +Call given THUNK in a context where uninteresting conditions and loader conditions are muffled │ │ │ │ +Portably return the LOAD-PATHNAME of the current source file or fasl. │ │ │ │ + May return a relative pathname. │ │ │ │ +wwwwwwwwwww │ │ │ │ +OPTIONS0 │ │ │ │ for each substring in SUBSTRINGS, find occurrences of it within STRING │ │ │ │ that don't use parts of matched occurrences of previous strings, and │ │ │ │ FROB them, that is to say, remove them if FROB is NIL, │ │ │ │ replace by FROB if FROB is a STRING, or if FROB is a FUNCTION, │ │ │ │ call FROB with the match and a function that emits a string in the output. │ │ │ │ Return a string made of the parts not omitted or emitted by FROB. │ │ │ │ -w(,,(%$"l V │ │ │ │ +CLEANUP-FUN-115 │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ +SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ +CLEANUP-FUN-240 │ │ │ │ +V-8QXZ()7695JUI │ │ │ │ +D21430WSL │ │ │ │ measuring PROFILE overhead.. │ │ │ │ ignoring undefined function ~S │ │ │ │ ~S is already profiled, so unprofiling it first. │ │ │ │ QNNNV"""" │ │ │ │ :'*''*$'*%g │ │ │ │ :KHKHKHKEKKxf │ │ │ │ ~@ │ │ │ │ @@ -37234,39 +37284,23 @@ │ │ │ │ estimated total profiling overhead: │ │ │ │ seconds │ │ │ │ overhead estimation parameters: │ │ │ │ s/call, │ │ │ │ s total profiling, │ │ │ │ s internal profiling │ │ │ │ ~&~@{ ~v:@<~A~>~^|~} │ │ │ │ -FROM-END- │ │ │ │ -Hn[RJfQ\mUPFkWp| │ │ │ │ -CLEANUP-FUN-115 │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ -CLEANUP-FUN-240 │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ -SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ -wwwwwwwwwww │ │ │ │ -convert (* x 0) to 0 │ │ │ │ -associate */(* /) of constants │ │ │ │ -convert x*2^k to shift │ │ │ │ -optimize multiplication by one │ │ │ │ while handling code walker REPEAT: │ │ │ │ │ │ │ │ ran into STOP while still in REPEAT template │ │ │ │ NTR(* ! │ │ │ │ -n+y\LC* │ │ │ │ +FROM-END- │ │ │ │ +Hn[RJfQ\mUPFkWp| │ │ │ │ SzKzffioo │ │ │ │ -V-8QXZ()7695JUI │ │ │ │ -D21430WSL │ │ │ │ -Argument and result bit arrays are not the same length:~ │ │ │ │ - ~% ~S~% ~S │ │ │ │ #(p$Hh; Wk │ │ │ │ lVCOSg'/ │ │ │ │ -OPTIONS0 │ │ │ │ Unwrap any profiling code around the named functions, or if no names │ │ │ │ are given, unprofile all profiled functions. A symbol names │ │ │ │ a function. A string names all the functions named by symbols in the │ │ │ │ named package. NAMES defaults to the list of names of all currently │ │ │ │ profiled functions. │ │ │ │ PROFILE Name* │ │ │ │ If no names are supplied, return the list of profiled functions. │ │ │ │ @@ -37278,61 +37312,21 @@ │ │ │ │ undefined, then we give a warning and ignore it. See also │ │ │ │ UNPROFILE, REPORT and RESET. │ │ │ │ Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS │ │ │ │ Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS │ │ │ │ OMd@ t@% │ │ │ │ L/-`o:01 │ │ │ │ -A wrapper macro for code that should only be run when upgrading a │ │ │ │ -previously-loaded version of ASDF. │ │ │ │ -return a portable S-expression, portably readable and writeable in any Common Lisp implementation │ │ │ │ -using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by │ │ │ │ -WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF. │ │ │ │ -This function provides a portable wrapper around COMPILE-FILE. │ │ │ │ -It ensures that the OUTPUT-FILE value is only returned and │ │ │ │ -the file only actually created if the compilation was successful, │ │ │ │ -even though your implementation may not do that. It also checks an optional │ │ │ │ -user-provided consistency function COMPILE-CHECK to determine success; │ │ │ │ -it will call this function if not NIL at the end of the compilation │ │ │ │ -with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE │ │ │ │ -where TMP-FILE is the name of a temporary output-file. │ │ │ │ -It also checks two flags (with legacy british spelling from ASDF1), │ │ │ │ -*COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR* │ │ │ │ -with appropriate implementation-dependent defaults, │ │ │ │ -and if a failure (respectively warnings) are reported by COMPILE-FILE, │ │ │ │ -it will consider that an error unless the respective behaviour flag │ │ │ │ -is one of :SUCCESS :WARN :IGNORE. │ │ │ │ -If WARNINGS-FILE is defined, deferred warnings are saved to that file. │ │ │ │ -On ECL or MKCL, it creates both the linkable object and loadable fasl files. │ │ │ │ -On implementations that erroneously do not recognize standard keyword arguments, │ │ │ │ -it will filter them appropriately. │ │ │ │ -Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled │ │ │ │ -Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents │ │ │ │ -Given the results of COMPILE-FILE, raise an error or warning as appropriate │ │ │ │ -CLEANUP-FUN-3 │ │ │ │ -CLEANUP-FUN-0 │ │ │ │ -CLEANUP-FUN-47 │ │ │ │ -VERTEX-SC │ │ │ │ -common-lisp │ │ │ │ -sbcl-2.5.10.debian-linux-x86-s │ │ │ │ -asdf-output-translations.conf.d │ │ │ │ -source-registry.conf.d │ │ │ │ -L2mX^UY)mS │ │ │ │ -Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT. │ │ │ │ -One of three functions required for deferred-warnings support in ASDF. │ │ │ │ -INPUT-FILE │ │ │ │ -From a INPUT-FILE pathname, return a corresponding .lisp source pathname │ │ │ │ -COMMON-LISP │ │ │ │ -Portably read and evaluate forms from a STRING. │ │ │ │ -Call given THUNK in a context where uninteresting conditions and loader conditions are muffled │ │ │ │ -Portably return the LOAD-PATHNAME of the current source file or fasl. │ │ │ │ - May return a relative pathname. │ │ │ │ Given the warnings or failures as resulted from COMPILE-FILE or checking deferred warnings, │ │ │ │ raise an error or warning as appropriate │ │ │ │ Portably return the PATHNAME of the current Lisp source file being compiled or loaded │ │ │ │ +Argument and result bit arrays are not the same length:~ │ │ │ │ + ~% ~S~% ~S │ │ │ │ +CLEANUP-FUN-3 │ │ │ │ +CLEANUP-FUN-0 │ │ │ │ Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS, │ │ │ │ re-intern and raise any warnings that are still meaningful. │ │ │ │ Given a simple SEXP, return a representation of it as a portable SEXP. │ │ │ │ Simple means made of symbols, numbers, characters, simple-strings, pathnames, cons cells. │ │ │ │ Save forward reference conditions so they may be issued at a latter time, │ │ │ │ possibly in a different process. │ │ │ │ given a S-expression created by REIFY-DEFERRED-WARNINGS, reinstantiate the corresponding │ │ │ │ @@ -37494,14 +37488,42 @@ │ │ │ │ also "Configuration DSL") in the ASDF manual. │ │ │ │ Return the file named X in the user configuration directory for common-lisp. │ │ │ │ DEPRECATED. │ │ │ │ Is X a configuration inheritance directive? │ │ │ │ Return the pathname for the file named X under the system configuration directory │ │ │ │ for common-lisp. DEPRECATED. │ │ │ │ Register a function to be called when clearing configuration │ │ │ │ +/usr/lib/sbcl/contrib/sb-aclrepl.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-bsd-sockets.asd │ │ │ │ +common-lisp │ │ │ │ +sbcl-2.5.10.debian-linux-x86-s │ │ │ │ +asdf-output-translations.conf.d │ │ │ │ +source-registry.conf.d │ │ │ │ +VERTEX-SC │ │ │ │ +/usr/lib/sbcl/contrib/sb-capstone.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-cltl2.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-concurrency.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-cover.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-executable.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-gmp.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-grovel.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-introspect.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-md5.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-mpfr.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-perf.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-posix.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-queue.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-rotate-byte.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-rt.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-simple-streams.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-sprof.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/contrib/fiveam-asdf/fiveam-asdf.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/tools/asdf-tools.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/uiop/asdf-driver.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/uiop/uiop.asd │ │ │ │ The preference-ordered set of additional base paths to search for configuration files. │ │ │ │ Returns a list of absolute directory pathnames. │ │ │ │ MORE may contain specifications for a subpath relative to these directories: │ │ │ │ subpathname specification and keyword arguments as per RESOLVE-LOCATION (see │ │ │ │ also "Configuration DSL") in the ASDF manual. │ │ │ │ Is X the specification of a location function? │ │ │ │ Is X a designator for a location? │ │ │ │ @@ -37613,14 +37635,20 @@ │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP0 │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ ASDF/SYSTEM │ │ │ │ +Given a SYSTEM on which operate is called and the specified FORCE argument, │ │ │ │ +extract a hash-set of systems that are forced, or a predicate on system names, │ │ │ │ +or NIL if none are forced, or :ALL if all are. │ │ │ │ +Given a SYSTEM on which operate is called, the specified FORCE-NOT argument, │ │ │ │ +and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not, │ │ │ │ +or predicate on system names, or NIL if none are forced, or :ALL if all are. │ │ │ │ Coerces its argument into a PATHNAME, │ │ │ │ optionally doing some transformations and checking specified constraints. │ │ │ │ If the argument is NIL, then NIL is returned unless the WANT-PATHNAME constraint is specified. │ │ │ │ If the argument is a STRING, it is first converted to a pathname via │ │ │ │ PARSE-UNIX-NAMESTRING, PARSE-NAMESTRING or PARSE-NATIVE-NAMESTRING respectively │ │ │ │ depending on the NAMESTRING argument being :UNIX, :LISP or :NATIVE respectively, │ │ │ │ or else by using CALL-FUNCTION on the NAMESTRING argument; │ │ │ │ @@ -37667,14 +37695,16 @@ │ │ │ │ ENSURE-DIRECTORIES-EXIST creates any parent directory with ENSURE-DIRECTORIES-EXIST. │ │ │ │ TRUENAME replaces the pathname by its truename, or errors if not possible. │ │ │ │ RESOLVE-SYMLINKS replaces the pathname by a variant with symlinks resolved by RESOLVE-SYMLINKS. │ │ │ │ TRUENAMIZE uses TRUENAMIZE to resolve as many symlinks as possible. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ RESOLVED │ │ │ │ +A wrapper macro for code that should only be run when upgrading a │ │ │ │ +previously-loaded version of ASDF. │ │ │ │ NORMALIZED-NAMESTRING │ │ │ │ is X a logical-pathname? │ │ │ │ ASDF/COMPONENT │ │ │ │ ASDF/SYSTEM │ │ │ │ Clear the entry for a SYSTEM in the database of systems previously defined. │ │ │ │ However if the system was registered as PRELOADED (which it is if it is IMMUTABLE), │ │ │ │ then a new system with the same name will be defined and registered in its place │ │ │ │ @@ -37705,19 +37735,14 @@ │ │ │ │ We assume filename has no directory component. │ │ │ │ The last . if any separates name and type from from type, │ │ │ │ except that if there is only one . and it is in first position, │ │ │ │ the whole filename is the NAME with an empty type. │ │ │ │ NAME is always a string. │ │ │ │ For an empty type, *UNSPECIFIC-PATHNAME-TYPE* is returned. │ │ │ │ What character does the current OS conventionally uses to separate directories? │ │ │ │ -MORE-ARG │ │ │ │ -The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO). │ │ │ │ -It will build system FOO using the operation BUILD-OP, │ │ │ │ -the meaning of which is configurable by the system, and │ │ │ │ -defaults to LOAD-OP, to load it in current image. │ │ │ │ Is this action valid to include amongst dependencies? │ │ │ │ A partial test of the values of a component. │ │ │ │ COMPONENT │ │ │ │ ASDF/COMPONENT0 │ │ │ │ COMMON-LISP │ │ │ │ Is the PATHNAME under the current installation of the CL implementation? │ │ │ │ Parse the dependency defs in DD-LIST into canonical form by translating all │ │ │ │ @@ -37758,15 +37783,14 @@ │ │ │ │ your reader will not have magically used the KEYWORD package, so you need specify │ │ │ │ keywords explicitly. │ │ │ │ Given a VERSION string, and the starting versions for notifying the programmer of │ │ │ │ various levels of deprecation, return the current level of deprecation as per WITH-DEPRECATION │ │ │ │ that is the highest level that has a declared version older than the specified version. │ │ │ │ Each start version for a level of deprecation can be specified by a keyword argument, or │ │ │ │ if left unspecified, will be the NEXT-VERSION of the immediate lower level of deprecation. │ │ │ │ -SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ Read the contents of the INPUT stream as a list of forms, │ │ │ │ then return the ACCESS-AT of these forms following the AT. │ │ │ │ AT defaults to 0, i.e. return the first form. │ │ │ │ AT is typically a list of integers. │ │ │ │ If AT is NIL, it will return all the forms in the file. │ │ │ │ The stream will not be read beyond the Nth form, │ │ │ │ where N is the index specified by path, │ │ │ │ @@ -37786,17 +37810,23 @@ │ │ │ │ where N is the index specified by path │ │ │ │ if path is either an integer or a list that starts with an integer. │ │ │ │ Read the contents of the INPUT stream as a list of lines, return those lines. │ │ │ │ Note: relies on the Lisp's READ-LINE, but additionally removes any remaining CR │ │ │ │ from the line-ending if the file or stream had CR+LF but Lisp only removed LF. │ │ │ │ Read no more than COUNT lines. │ │ │ │ Read the contents of the INPUT stream as a string │ │ │ │ -CLEANUP-FUN-4 │ │ │ │ -CLEANUP-FUN-226 │ │ │ │ Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ +Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ +where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ +on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ +MORE-ARG │ │ │ │ +The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO). │ │ │ │ +It will build system FOO using the operation BUILD-OP, │ │ │ │ +the meaning of which is configurable by the system, and │ │ │ │ +defaults to LOAD-OP, to load it in current image. │ │ │ │ return the hostname of the current host │ │ │ │ 70G';|.; │ │ │ │ Shorthand for `(asdf:operate 'asdf:test-op system)`. See OPERATE for details. │ │ │ │ Apply FN to each defined system. │ │ │ │ FN should be a function of one argument. It will be │ │ │ │ called with an object of type asdf:system. │ │ │ │ SYSTEM-NAME │ │ │ │ @@ -37914,53 +37944,38 @@ │ │ │ │ A wrapper around TRANSLATE-PATHNAME to be used by the ASDF output-translations facility. │ │ │ │ PATH is the pathname to be translated. │ │ │ │ ABSOLUTE-SOURCE is an absolute pathname to use as source for translate-pathname, │ │ │ │ DESTINATION is either a function, to be called with PATH and ABSOLUTE-SOURCE, │ │ │ │ or a relative pathname, to be merged with ROOT and used as destination for translate-pathname │ │ │ │ or an absolute pathname, to be used as destination for translate-pathname. │ │ │ │ In that last case, if ROOT is non-NIL, PATH is first transformated by DIRECTORIZE-PATHNAME-HOST-DEVICE. │ │ │ │ +CLEANUP-FUN-4 │ │ │ │ +CLEANUP-FUN-47 │ │ │ │ +CLEANUP-FUN-226 │ │ │ │ +SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ +CLEANUP-FUN-53 │ │ │ │ COUNTER0 │ │ │ │ &ZE h%vo │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ A readable data structure that identifies the action. │ │ │ │ Reconstitute an action from its action-path │ │ │ │ FORMAT helper to display an action's action-description. │ │ │ │ Use it in FORMAT control strings as ~/asdf-action:format-action/ │ │ │ │ -CLEANUP-FUN-53 │ │ │ │ -Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ -where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ -on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ -?haeSzv] │ │ │ │ -VT*P2 D# │ │ │ │ -Executes BODY with the elements of VARS bound to the iteration │ │ │ │ - state returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ - ARGS. Elements of VARS may be NIL in which case the corresponding │ │ │ │ - value returned by MAKE-SEQUENCE-ITERATOR is ignored. │ │ │ │ -Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ -bound to local functions which execute the iteration state query and │ │ │ │ -mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ -ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ -name, no local functions are established for those names. The │ │ │ │ -functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ -dynamic extent. │ │ │ │ -Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ - SEQUENCE, then returns RETURN. │ │ │ │ -Evaluate BODY in a context when VAR is bound to an input stream that always returns end of file. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ -Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ P]D!`_eW │ │ │ │ ASDF/COMPONENT │ │ │ │ COMMON-LISP │ │ │ │ Is the provided version a compatible substitution for the required-version? │ │ │ │ If major versions differ, it's not compatible. │ │ │ │ If they are equal, then any later version is compatible, │ │ │ │ with later being determined by a lexicographical comparison of minor numbers. │ │ │ │ DEPRECATED. │ │ │ │ DEPRECATED. Please use UIOP:PARSE-UNIX-NAMESTRING instead. │ │ │ │ +V-8QXZ()7695JU │ │ │ │ +D21430WS │ │ │ │ Return a list of the files in a directory according to the PATTERN. │ │ │ │ Subdirectories should NOT be returned. │ │ │ │ PATTERN defaults to a pattern carefully chosen based on the implementation; │ │ │ │ override the default at your own risk. │ │ │ │ DIRECTORY-FILES tries NOT to resolve symlinks if the implementation permits this, │ │ │ │ but the behavior in presence of symlinks is not portable. Use IOlib to handle such situations. │ │ │ │ Extract a list of pathname from a user-configured environment variable, as per native OS, │ │ │ │ @@ -37998,14 +38013,49 @@ │ │ │ │ a physical non-wildcard directory pathname (not namestring). │ │ │ │ If the directory does not exist, the IF-DOES-NOT-EXIST argument specifies what happens: │ │ │ │ if it is :ERROR (the default), an error is signaled, whereas if it is :IGNORE, nothing is done. │ │ │ │ Furthermore, before any deletion is attempted, the DIRECTORY-PATHNAME must pass │ │ │ │ the validation function designated (as per ENSURE-FUNCTION) by the VALIDATE keyword argument │ │ │ │ which in practice is thus compulsory, and validates by returning a non-NIL result. │ │ │ │ If you're suicidal or extremely confident, just use :VALIDATE T. │ │ │ │ +?haeSzv] │ │ │ │ +VT*P2 D# │ │ │ │ +Executes BODY with the elements of VARS bound to the iteration │ │ │ │ + state returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ + ARGS. Elements of VARS may be NIL in which case the corresponding │ │ │ │ + value returned by MAKE-SEQUENCE-ITERATOR is ignored. │ │ │ │ +Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ +bound to local functions which execute the iteration state query and │ │ │ │ +mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ +ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ +name, no local functions are established for those names. The │ │ │ │ +functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ +dynamic extent. │ │ │ │ +Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ + SEQUENCE, then returns RETURN. │ │ │ │ +Evaluate BODY in a context when VAR is bound to an input stream that always returns end of file. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ +Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ +R1SU&f?% │ │ │ │ +Evaluate BODY where the symbols specified by keyword arguments │ │ │ │ +STREAM and PATHNAME (if respectively specified) are bound corresponding │ │ │ │ +to a newly created temporary file ready for I/O, as per CALL-WITH-TEMPORARY-FILE. │ │ │ │ +At least one of STREAM or PATHNAME must be specified. │ │ │ │ +If the STREAM is not specified, it will be closed before the BODY is evaluated. │ │ │ │ +If STREAM is specified, then the :CLOSE-STREAM label if it appears in the BODY, │ │ │ │ +separates forms run before and after the stream is closed. │ │ │ │ +The values of the last form of the BODY (not counting the separating :CLOSE-STREAM) are returned. │ │ │ │ +Upon success, the KEEP form is evaluated and the file is is deleted unless it evaluates to TRUE. │ │ │ │ +Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ +Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ +of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ +the scope of this binding. │ │ │ │ +Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR) │ │ │ │ +as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding. │ │ │ │ +Establish safe CL reader options around the evaluation of BODY │ │ │ │ VERSION-LIST │ │ │ │ When VERSION is not nil, it is a string, then parse it as a version, compute the next version │ │ │ │ and return it as a string. │ │ │ │ Copy contents of the INPUT file to the OUTPUT file │ │ │ │ Call a THUNK with stream and/or pathname arguments identifying a temporary file. │ │ │ │ The temporary file's pathname will be based on concatenating │ │ │ │ PREFIX (or "tmp" if it's NIL), a random alphanumeric string, │ │ │ │ @@ -38049,245 +38099,38 @@ │ │ │ │ This function will thus let you traverse a filesystem hierarchy, │ │ │ │ superseding the functionality of CL-FAD:WALK-DIRECTORY. │ │ │ │ The behavior in presence of symlinks is not portable. Use IOlib to handle such situations. │ │ │ │ OPTIONAL-ARGS │ │ │ │ Escape a token for the current operating system shell │ │ │ │ DIRECTORY-PATHNAME0 │ │ │ │ Delete an empty directory │ │ │ │ -Is X the name of a file that exists on the filesystem? │ │ │ │ -Launch program specified by COMMAND, │ │ │ │ -either a list of strings specifying a program and list of arguments, │ │ │ │ -or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on │ │ │ │ -Windows) _asynchronously_. │ │ │ │ -If OUTPUT is a pathname, a string designating a pathname, or NIL (the │ │ │ │ -default) designating the null device, the file at that path is used as │ │ │ │ -If it's :INTERACTIVE, output is inherited from the current process; │ │ │ │ -beware that this may be different from your *STANDARD-OUTPUT*, and │ │ │ │ -under SLIME will be on your *inferior-lisp* buffer. If it's T, output │ │ │ │ -goes to your current *STANDARD-OUTPUT* stream. If it's :STREAM, a new │ │ │ │ -stream will be made available that can be accessed via │ │ │ │ -PROCESS-INFO-OUTPUT and read from. Otherwise, OUTPUT should be a value │ │ │ │ -that the underlying lisp implementation knows how to handle. │ │ │ │ -IF-OUTPUT-EXISTS, which is only meaningful if OUTPUT is a string or a │ │ │ │ -pathname, can take the values :ERROR, :APPEND, and :SUPERSEDE (the │ │ │ │ -default). The meaning of these values and their effect on the case │ │ │ │ -where OUTPUT does not exist, is analogous to the IF-EXISTS parameter │ │ │ │ -to OPEN with :DIRECTION :OUTPUT. │ │ │ │ -ERROR-OUTPUT is similar to OUTPUT. T designates the *ERROR-OUTPUT*, │ │ │ │ -:OUTPUT means redirecting the error output to the output stream, │ │ │ │ -and :STREAM causes a stream to be made available via │ │ │ │ -PROCESS-INFO-ERROR-OUTPUT. │ │ │ │ -IF-ERROR-OUTPUT-EXISTS is similar to IF-OUTPUT-EXIST, except that it │ │ │ │ -affects ERROR-OUTPUT rather than OUTPUT. │ │ │ │ -INPUT is similar to OUTPUT, except that T designates the │ │ │ │ -*STANDARD-INPUT* and a stream requested through the :STREAM keyword │ │ │ │ -would be available through PROCESS-INFO-INPUT. │ │ │ │ -IF-INPUT-DOES-NOT-EXIST, which is only meaningful if INPUT is a string │ │ │ │ -or a pathname, can take the values :CREATE and :ERROR (the │ │ │ │ -default). The meaning of these values is analogous to the │ │ │ │ -IF-DOES-NOT-EXIST parameter to OPEN with :DIRECTION :INPUT. │ │ │ │ -ELEMENT-TYPE and EXTERNAL-FORMAT are passed on to your Lisp │ │ │ │ -implementation, when applicable, for creation of the output stream. │ │ │ │ -LAUNCH-PROGRAM returns a PROCESS-INFO object. │ │ │ │ -LAUNCH-PROGRAM currently does not smooth over all the differences between │ │ │ │ -implementations. Of particular note is when streams are provided for OUTPUT or │ │ │ │ -ERROR-OUTPUT. Some implementations don't support this at all, some support only │ │ │ │ -certain subclasses of streams, and some support any arbitrary │ │ │ │ -stream. Additionally, the implementations that support streams may have │ │ │ │ -differing behavior on how those streams are filled with data. If data is not │ │ │ │ -periodically read from the child process and sent to the stream, the child │ │ │ │ -could block because its output buffers are full. │ │ │ │ -Call the ESCAPER function on TOKEN string if it needs escaping as per │ │ │ │ -REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN, │ │ │ │ -using STREAM as output (or returning result as a string if NIL) │ │ │ │ -Given a COMMAND as a list of tokens, return a string of the │ │ │ │ -spaced, escaped tokens, using ESCAPER to escape. │ │ │ │ -On supported implementations (most that matter), or when invoked by a proper wrapper script, │ │ │ │ -return a string that for the name with which the program was invoked, i.e. argv[0] in C. │ │ │ │ -Otherwise, return NIL. │ │ │ │ -Die in error with some error message │ │ │ │ -Resolve as much of a pathname as possible │ │ │ │ -Return a default directory to use for temporary files │ │ │ │ - uyG3tBNr │ │ │ │ -Call FUN with an output stream that discards all output. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP │ │ │ │ -Handle a fatal CONDITION: │ │ │ │ -depending on whether *LISP-INTERACTION* is set, enter debugger or die │ │ │ │ -Where are the system files of the current installation of the CL implementation? │ │ │ │ -Bt#"LS%>K │ │ │ │ -Safe variant of FILE-WRITE-DATE that may return NIL rather than raise an error. │ │ │ │ -DEFAULTS0 │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Find the actual DEFAULTS to use for pathnames, including │ │ │ │ -resolving them with respect to GETCWD if the DEFAULTS were relative │ │ │ │ -Return a directory to use for temporary files │ │ │ │ -Pathname to a bit bucket device that discards any information written to it │ │ │ │ -and always returns EOF when read from │ │ │ │ -Print a backtrace, directly accessing the implementation │ │ │ │ -Variant of WRITE that also calls TERPRI afterwards │ │ │ │ -Evaluate a THUNK of code: │ │ │ │ -If a function, FUNCALL it without arguments. │ │ │ │ -If a constant literal and not a sequence, return it. │ │ │ │ -If a cons or a symbol, EVAL it. │ │ │ │ -If a string, repeatedly read and evaluate from it, returning the last values. │ │ │ │ -COMMON-LISP0 │ │ │ │ -MORE-ARG │ │ │ │ -Open FILE with option KEYS, read its contents as a string │ │ │ │ -Close any stream that the process might own. Needs to be run │ │ │ │ -whenever streams were requested by passing :stream to :input, :output, │ │ │ │ -or :error-output. │ │ │ │ -Open input FILE with option KEYS (except COUNT), │ │ │ │ -and read its contents as per SLURP-STREAM-FORMS with given COUNT. │ │ │ │ -If COUNT is null, read to the end of the stream; │ │ │ │ -if COUNT is an integer, stop after COUNT forms were read. │ │ │ │ -BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ -Extract a list of absolute directories from a user-configured environment variable, │ │ │ │ -as per native OS. Any empty entries in the environment variable X will be returned as │ │ │ │ -Given a string of pathnames specified in native OS syntax, separate them in a list, │ │ │ │ -check constraints and normalize each one as per ENSURE-PATHNAME, │ │ │ │ -where an empty string denotes NIL. │ │ │ │ -REST-ARG │ │ │ │ -Return a list of the entries in a directory by calling DIRECTORY. │ │ │ │ -Try to override the defaults to not resolving symlinks, if implementation allows. │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Escape a list of command-line arguments into a string suitable for parsing │ │ │ │ -by /bin/sh in POSIX │ │ │ │ -Cause the process to exit. To that end, the process may or may │ │ │ │ -not be sent a signal, which it will find harder (or even impossible) │ │ │ │ -to ignore if URGENT is T. On some platforms, it may also be subject to │ │ │ │ -race conditions. │ │ │ │ -CALL-NOW-P │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Regiter a hook function to be run when restoring a dumped image │ │ │ │ -Escape a command for the current operating system's shell │ │ │ │ -Call THUNK in a context where fatal conditions are appropriately handled │ │ │ │ -Finish output on the main output streams as well as any specified one. │ │ │ │ -Useful for portably flushing I/O before user input or program exit. │ │ │ │ -Is the CONDITION fatal? │ │ │ │ -Portably read and evaluate forms from INPUT, return the last values. │ │ │ │ -Escape a string TOKEN within double-quotes if needed │ │ │ │ -for use within a POSIX Bourne shell, outputing to S. │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -Just like format, but call finish-outputs before and after the output. │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Escape a string TOKEN within double-quotes if needed │ │ │ │ -for use within a MS Windows command-line, outputing to S. │ │ │ │ -CALL-NOW-P │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Register a the hook function to be run before to dump an image │ │ │ │ -Print a backtrace │ │ │ │ -Is X an "easy" character that does not require quoting by the shell? │ │ │ │ -If DIRECTORY isn't a logical pathname, return ENTRIES. If it is, │ │ │ │ -given ENTRIES in the DIRECTORY, remove the entries which are physical yet │ │ │ │ -when transformed by MERGER have a different TRUENAME. │ │ │ │ -Also remove duplicates as may appear with some translation rules. │ │ │ │ -This function is used as a helper to DIRECTORY-FILES to avoid invalid entries │ │ │ │ -when using logical-pathnames. │ │ │ │ -Extract an absolute directory pathname from a user-configured environment variable, │ │ │ │ -as per native OS │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -Add a SUFFIX to the name of a PATHNAME, return a new pathname. │ │ │ │ -Further KEYS can be passed to MAKE-PATHNAME. │ │ │ │ ->,`W:0LmQ │ │ │ │ -Reads the specified line from the top of a file using a safe standardized syntax. │ │ │ │ -Extracts the line using READ-FILE-LINE, │ │ │ │ -within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ -From a native namestring suitable for use by the operating system, return │ │ │ │ -a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME │ │ │ │ ->,`W:0LmQ │ │ │ │ -Reads the specified form from the top of a file using a safe standardized syntax. │ │ │ │ -Extracts the form using READ-FILE-FORM, │ │ │ │ -within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ -Extract a pathname from a user-configured environment variable, as per native OS, │ │ │ │ -check constraints and normalize as per ENSURE-PATHNAME. │ │ │ │ -Find what the actual command line for this process was. │ │ │ │ -Open input FILE with option KEYS (except AT), │ │ │ │ -and read its contents as per SLURP-STREAM-LINE with given AT specifier. │ │ │ │ -BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ -Call FUN with an input stream that always returns end of file. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ -If the desired INPUT is a string, return that string; otherwise slurp the INPUT into a string │ │ │ │ -and return that │ │ │ │ -From a non-wildcard CL pathname, a return namestring suitable for passing to the operating system │ │ │ │ -Parse a VERSION-STRING as a series of natural numbers separated by dots. │ │ │ │ -Return a (non-null) list of integers if the string is valid; │ │ │ │ -otherwise return NIL. │ │ │ │ -When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL, │ │ │ │ -with format arguments explaining why the version is invalid. │ │ │ │ -ON-ERROR is also called if the version is not canonical │ │ │ │ -in that it doesn't print back to itself, but the list is returned anyway. │ │ │ │ -R1SU&f?% │ │ │ │ -Evaluate BODY where the symbols specified by keyword arguments │ │ │ │ -STREAM and PATHNAME (if respectively specified) are bound corresponding │ │ │ │ -to a newly created temporary file ready for I/O, as per CALL-WITH-TEMPORARY-FILE. │ │ │ │ -At least one of STREAM or PATHNAME must be specified. │ │ │ │ -If the STREAM is not specified, it will be closed before the BODY is evaluated. │ │ │ │ -If STREAM is specified, then the :CLOSE-STREAM label if it appears in the BODY, │ │ │ │ -separates forms run before and after the stream is closed. │ │ │ │ -The values of the last form of the BODY (not counting the separating :CLOSE-STREAM) are returned. │ │ │ │ -Upon success, the KEEP form is evaluated and the file is is deleted unless it evaluates to TRUE. │ │ │ │ -Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ -Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ -of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ -the scope of this binding. │ │ │ │ -Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR) │ │ │ │ -as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding. │ │ │ │ -Establish safe CL reader options around the evaluation of BODY │ │ │ │ -Call BODY while the POSIX current working directory is set to DIR │ │ │ │ -Evaluate BODY in a context when VAR is bound to an output stream that discards all output. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ -Given a deprecation LEVEL (a form to be EVAL'ed at macro-expansion time), instrument the │ │ │ │ -DEFUN and DEFMETHOD forms in DEFINITIONS to notify the programmer of the deprecation of the function │ │ │ │ -when it is compiled or called. │ │ │ │ -Increasing levels (as result from evaluating LEVEL) are: NIL (not deprecated yet), │ │ │ │ -:STYLE-WARNING (a style warning is issued when used), :WARNING (a full warning is issued when used), │ │ │ │ -:ERROR (a continuable error instead), and :DELETE (it's an error if the code is still there while │ │ │ │ -at that level). │ │ │ │ -Forms other than DEFUN and DEFMETHOD are not instrumented, and you can protect a DEFUN or DEFMETHOD │ │ │ │ -from instrumentation by enclosing it in a PROGN. │ │ │ │ -SB-DISASSEM │ │ │ │ -COMMON-LISP │ │ │ │ -V-8QXZ()7695JU │ │ │ │ -D21430WS │ │ │ │ -reproducible-path │ │ │ │ -buildapp-1.5.6 │ │ │ │ CLEANUP-FUN-34 │ │ │ │ CLEANUP-FUN-20 │ │ │ │ BEFORE77 │ │ │ │ +reproducible-path │ │ │ │ +buildapp-1.5.6 │ │ │ │ WRAPPER228 │ │ │ │ WRAPPER72 │ │ │ │ WRAPPER7 │ │ │ │ BEFORE199 │ │ │ │ CLEANUP-FUN-242 │ │ │ │ V-8QXZ()7695J │ │ │ │ CLEANUP-FUN-188 │ │ │ │ CLEANUP-FUN-336 │ │ │ │ CLEANUP-FUN-100 │ │ │ │ CLEANUP-FUN-69 │ │ │ │ CLEANUP-FUN-32 │ │ │ │ -bitmap describing the status of the action. │ │ │ │ -STAMP associated with the ACTION if it has been completed already in some │ │ │ │ -previous session or image, T if it was done and builtin the image, or NIL if it needs to be done. │ │ │ │ -the highest (operate-level) at which the action was needed │ │ │ │ -INDEX associated with the ACTION in the current session, │ │ │ │ -or NIL if no the status is considered outside of a specific plan. │ │ │ │ Forcing parameters for the session │ │ │ │ +8QXZ()7695J │ │ │ │ CLEANUP-FUN-24 │ │ │ │ -CLEANUP-FUN-57 │ │ │ │ +Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ Top level session that this is part of │ │ │ │ Memoize expensive computations │ │ │ │ Number of nested calls to operate we're under (for toplevel session only) │ │ │ │ Was ASDF already upgraded in this session - only valid for toplevel-asdf-session. │ │ │ │ -8QXZ()7695J │ │ │ │ -Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ sbcl-2.5.10.debian-linux-x86 │ │ │ │ undefined_alien_address │ │ │ │ alien_linkage_table_n_prelinked │ │ │ │ lisp_init_time │ │ │ │ sbcl_runtime │ │ │ │ posix_argv │ │ │ │ core_string │ │ │ │ @@ -38441,32 +38284,25 @@ │ │ │ │ invoking │ │ │ │ Don't know how to infer package dependencies for non-standard option │ │ │ │ while trying to define package-inferred-system │ │ │ │ High bound is not * or a rational or list of one rational: ~S │ │ │ │ Low bound is not * or a rational or list of one rational: ~S │ │ │ │ ~@ │ │ │ │ funcallable-structure-instance allocation with slots unimplemented │ │ │ │ -sb-aclrepl │ │ │ │ -sb-bsd-sockets │ │ │ │ -sb-capstone │ │ │ │ -sb-cltl2 │ │ │ │ -sb-concurrency │ │ │ │ -sb-cover │ │ │ │ -sb-executable │ │ │ │ -sb-grovel │ │ │ │ -sb-introspect │ │ │ │ -sb-posix │ │ │ │ -sb-queue │ │ │ │ -sb-rotate-byte │ │ │ │ -sb-simple-streams │ │ │ │ -sb-sprof │ │ │ │ -fiveam-asdf │ │ │ │ -asdf-tools │ │ │ │ -asdf-driver │ │ │ │ +close_current_thread_tlab │ │ │ │ +close_code_region │ │ │ │ +sb_get_os_thread_id │ │ │ │ +wifcontinued │ │ │ │ +wifstopped │ │ │ │ +unlockpt │ │ │ │ +wait_for_exec │ │ │ │ +gc_pathfind │ │ │ │ +gc_and_save │ │ │ │ asdf-package-system │ │ │ │ +n+y\LC* │ │ │ │ searching │ │ │ │ evaluated │ │ │ │ absolute │ │ │ │ directory. │ │ │ │ replace │ │ │ │ continue. │ │ │ │ the value of the most recent top level EVAL │ │ │ │ @@ -38639,78 +38475,235 @@ │ │ │ │ COMMON-LISP │ │ │ │ Converts any REAL to a float. If OTHER is not provided, it returns a │ │ │ │ SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the │ │ │ │ result is the same float format as OTHER. │ │ │ │ SLOT-SPECS │ │ │ │ 2(`o:p`% │ │ │ │ >EC^+|WM │ │ │ │ -/usr/lib/sbcl/contrib/sb-aclrepl.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-bsd-sockets.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-capstone.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-cltl2.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-concurrency.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-cover.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-executable.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-gmp.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-grovel.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-introspect.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-md5.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-mpfr.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-perf.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-posix.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-queue.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-rotate-byte.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-rt.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-simple-streams.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-sprof.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/contrib/fiveam-asdf/fiveam-asdf.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/tools/asdf-tools.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/uiop/asdf-driver.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/uiop/uiop.asd │ │ │ │ +Is X the name of a file that exists on the filesystem? │ │ │ │ +Launch program specified by COMMAND, │ │ │ │ +either a list of strings specifying a program and list of arguments, │ │ │ │ +or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on │ │ │ │ +Windows) _asynchronously_. │ │ │ │ +If OUTPUT is a pathname, a string designating a pathname, or NIL (the │ │ │ │ +default) designating the null device, the file at that path is used as │ │ │ │ +If it's :INTERACTIVE, output is inherited from the current process; │ │ │ │ +beware that this may be different from your *STANDARD-OUTPUT*, and │ │ │ │ +under SLIME will be on your *inferior-lisp* buffer. If it's T, output │ │ │ │ +goes to your current *STANDARD-OUTPUT* stream. If it's :STREAM, a new │ │ │ │ +stream will be made available that can be accessed via │ │ │ │ +PROCESS-INFO-OUTPUT and read from. Otherwise, OUTPUT should be a value │ │ │ │ +that the underlying lisp implementation knows how to handle. │ │ │ │ +IF-OUTPUT-EXISTS, which is only meaningful if OUTPUT is a string or a │ │ │ │ +pathname, can take the values :ERROR, :APPEND, and :SUPERSEDE (the │ │ │ │ +default). The meaning of these values and their effect on the case │ │ │ │ +where OUTPUT does not exist, is analogous to the IF-EXISTS parameter │ │ │ │ +to OPEN with :DIRECTION :OUTPUT. │ │ │ │ +ERROR-OUTPUT is similar to OUTPUT. T designates the *ERROR-OUTPUT*, │ │ │ │ +:OUTPUT means redirecting the error output to the output stream, │ │ │ │ +and :STREAM causes a stream to be made available via │ │ │ │ +PROCESS-INFO-ERROR-OUTPUT. │ │ │ │ +IF-ERROR-OUTPUT-EXISTS is similar to IF-OUTPUT-EXIST, except that it │ │ │ │ +affects ERROR-OUTPUT rather than OUTPUT. │ │ │ │ +INPUT is similar to OUTPUT, except that T designates the │ │ │ │ +*STANDARD-INPUT* and a stream requested through the :STREAM keyword │ │ │ │ +would be available through PROCESS-INFO-INPUT. │ │ │ │ +IF-INPUT-DOES-NOT-EXIST, which is only meaningful if INPUT is a string │ │ │ │ +or a pathname, can take the values :CREATE and :ERROR (the │ │ │ │ +default). The meaning of these values is analogous to the │ │ │ │ +IF-DOES-NOT-EXIST parameter to OPEN with :DIRECTION :INPUT. │ │ │ │ +ELEMENT-TYPE and EXTERNAL-FORMAT are passed on to your Lisp │ │ │ │ +implementation, when applicable, for creation of the output stream. │ │ │ │ +LAUNCH-PROGRAM returns a PROCESS-INFO object. │ │ │ │ +LAUNCH-PROGRAM currently does not smooth over all the differences between │ │ │ │ +implementations. Of particular note is when streams are provided for OUTPUT or │ │ │ │ +ERROR-OUTPUT. Some implementations don't support this at all, some support only │ │ │ │ +certain subclasses of streams, and some support any arbitrary │ │ │ │ +stream. Additionally, the implementations that support streams may have │ │ │ │ +differing behavior on how those streams are filled with data. If data is not │ │ │ │ +periodically read from the child process and sent to the stream, the child │ │ │ │ +could block because its output buffers are full. │ │ │ │ +Call the ESCAPER function on TOKEN string if it needs escaping as per │ │ │ │ +REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN, │ │ │ │ +using STREAM as output (or returning result as a string if NIL) │ │ │ │ +Given a COMMAND as a list of tokens, return a string of the │ │ │ │ +spaced, escaped tokens, using ESCAPER to escape. │ │ │ │ +On supported implementations (most that matter), or when invoked by a proper wrapper script, │ │ │ │ +return a string that for the name with which the program was invoked, i.e. argv[0] in C. │ │ │ │ +Otherwise, return NIL. │ │ │ │ +Die in error with some error message │ │ │ │ +Resolve as much of a pathname as possible │ │ │ │ +Return a default directory to use for temporary files │ │ │ │ + uyG3tBNr │ │ │ │ +Call FUN with an output stream that discards all output. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP │ │ │ │ +Handle a fatal CONDITION: │ │ │ │ +depending on whether *LISP-INTERACTION* is set, enter debugger or die │ │ │ │ +Where are the system files of the current installation of the CL implementation? │ │ │ │ +Bt#"LS%>K │ │ │ │ +Safe variant of FILE-WRITE-DATE that may return NIL rather than raise an error. │ │ │ │ +DEFAULTS0 │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Find the actual DEFAULTS to use for pathnames, including │ │ │ │ +resolving them with respect to GETCWD if the DEFAULTS were relative │ │ │ │ +Return a directory to use for temporary files │ │ │ │ +Pathname to a bit bucket device that discards any information written to it │ │ │ │ +and always returns EOF when read from │ │ │ │ +Print a backtrace, directly accessing the implementation │ │ │ │ +Variant of WRITE that also calls TERPRI afterwards │ │ │ │ +Evaluate a THUNK of code: │ │ │ │ +If a function, FUNCALL it without arguments. │ │ │ │ +If a constant literal and not a sequence, return it. │ │ │ │ +If a cons or a symbol, EVAL it. │ │ │ │ +If a string, repeatedly read and evaluate from it, returning the last values. │ │ │ │ +COMMON-LISP0 │ │ │ │ +MORE-ARG │ │ │ │ +Open FILE with option KEYS, read its contents as a string │ │ │ │ +Close any stream that the process might own. Needs to be run │ │ │ │ +whenever streams were requested by passing :stream to :input, :output, │ │ │ │ +or :error-output. │ │ │ │ +Open input FILE with option KEYS (except COUNT), │ │ │ │ +and read its contents as per SLURP-STREAM-FORMS with given COUNT. │ │ │ │ +If COUNT is null, read to the end of the stream; │ │ │ │ +if COUNT is an integer, stop after COUNT forms were read. │ │ │ │ +BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ +Extract a list of absolute directories from a user-configured environment variable, │ │ │ │ +as per native OS. Any empty entries in the environment variable X will be returned as │ │ │ │ +Given a string of pathnames specified in native OS syntax, separate them in a list, │ │ │ │ +check constraints and normalize each one as per ENSURE-PATHNAME, │ │ │ │ +where an empty string denotes NIL. │ │ │ │ +REST-ARG │ │ │ │ +Return a list of the entries in a directory by calling DIRECTORY. │ │ │ │ +Try to override the defaults to not resolving symlinks, if implementation allows. │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Escape a list of command-line arguments into a string suitable for parsing │ │ │ │ +by /bin/sh in POSIX │ │ │ │ +Cause the process to exit. To that end, the process may or may │ │ │ │ +not be sent a signal, which it will find harder (or even impossible) │ │ │ │ +to ignore if URGENT is T. On some platforms, it may also be subject to │ │ │ │ +race conditions. │ │ │ │ +CALL-NOW-P │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Regiter a hook function to be run when restoring a dumped image │ │ │ │ +Escape a command for the current operating system's shell │ │ │ │ +Call THUNK in a context where fatal conditions are appropriately handled │ │ │ │ +lisp_init_function │ │ │ │ +tot_gc_nsec │ │ │ │ +gc_coalesce_string_literals │ │ │ │ +Finish output on the main output streams as well as any specified one. │ │ │ │ +Useful for portably flushing I/O before user input or program exit. │ │ │ │ +Is the CONDITION fatal? │ │ │ │ +Portably read and evaluate forms from INPUT, return the last values. │ │ │ │ +Escape a string TOKEN within double-quotes if needed │ │ │ │ +for use within a POSIX Bourne shell, outputing to S. │ │ │ │ +COMMON-LISP │ │ │ │ +MORE-ARG │ │ │ │ +Just like format, but call finish-outputs before and after the output. │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Escape a string TOKEN within double-quotes if needed │ │ │ │ +for use within a MS Windows command-line, outputing to S. │ │ │ │ +CALL-NOW-P │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Register a the hook function to be run before to dump an image │ │ │ │ +Print a backtrace │ │ │ │ +Is X an "easy" character that does not require quoting by the shell? │ │ │ │ +If DIRECTORY isn't a logical pathname, return ENTRIES. If it is, │ │ │ │ +given ENTRIES in the DIRECTORY, remove the entries which are physical yet │ │ │ │ +when transformed by MERGER have a different TRUENAME. │ │ │ │ +Also remove duplicates as may appear with some translation rules. │ │ │ │ +This function is used as a helper to DIRECTORY-FILES to avoid invalid entries │ │ │ │ +when using logical-pathnames. │ │ │ │ +Extract an absolute directory pathname from a user-configured environment variable, │ │ │ │ +as per native OS │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP │ │ │ │ +MORE-ARG │ │ │ │ +Add a SUFFIX to the name of a PATHNAME, return a new pathname. │ │ │ │ +Further KEYS can be passed to MAKE-PATHNAME. │ │ │ │ +>,`W:0LmQ │ │ │ │ +Reads the specified line from the top of a file using a safe standardized syntax. │ │ │ │ +Extracts the line using READ-FILE-LINE, │ │ │ │ +within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ +From a native namestring suitable for use by the operating system, return │ │ │ │ +a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME │ │ │ │ +>,`W:0LmQ │ │ │ │ +Reads the specified form from the top of a file using a safe standardized syntax. │ │ │ │ +Extracts the form using READ-FILE-FORM, │ │ │ │ +within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ +Extract a pathname from a user-configured environment variable, as per native OS, │ │ │ │ +check constraints and normalize as per ENSURE-PATHNAME. │ │ │ │ +Find what the actual command line for this process was. │ │ │ │ +Open input FILE with option KEYS (except AT), │ │ │ │ +and read its contents as per SLURP-STREAM-LINE with given AT specifier. │ │ │ │ +BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ +Call FUN with an input stream that always returns end of file. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ +If the desired INPUT is a string, return that string; otherwise slurp the INPUT into a string │ │ │ │ +and return that │ │ │ │ +From a non-wildcard CL pathname, a return namestring suitable for passing to the operating system │ │ │ │ +Parse a VERSION-STRING as a series of natural numbers separated by dots. │ │ │ │ +Return a (non-null) list of integers if the string is valid; │ │ │ │ +otherwise return NIL. │ │ │ │ +When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL, │ │ │ │ +with format arguments explaining why the version is invalid. │ │ │ │ +ON-ERROR is also called if the version is not canonical │ │ │ │ +in that it doesn't print back to itself, but the list is returned anyway. │ │ │ │ Erase any data from a SYSTEM except its basic identity, then reinitialize it │ │ │ │ based on supplied KEYS. │ │ │ │ Clear all currently registered defined systems. │ │ │ │ Preloaded systems (including immutable ones) will be reset, other systems will be de-registered. │ │ │ │ :-@u:CQQ │ │ │ │ fmt$2Q680T │ │ │ │ Mark a component as preloaded. │ │ │ │ Return a list containing every registered system (as a system object). │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ ASDF/COMPONENT │ │ │ │ - NEW-VALUE0 │ │ │ │ +Call BODY while the POSIX current working directory is set to DIR │ │ │ │ +Evaluate BODY in a context when VAR is bound to an output stream that discards all output. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ +Given a deprecation LEVEL (a form to be EVAL'ed at macro-expansion time), instrument the │ │ │ │ +DEFUN and DEFMETHOD forms in DEFINITIONS to notify the programmer of the deprecation of the function │ │ │ │ +when it is compiled or called. │ │ │ │ +Increasing levels (as result from evaluating LEVEL) are: NIL (not deprecated yet), │ │ │ │ +:STYLE-WARNING (a style warning is issued when used), :WARNING (a full warning is issued when used), │ │ │ │ +:ERROR (a continuable error instead), and :DELETE (it's an error if the code is still there while │ │ │ │ +at that level). │ │ │ │ +Forms other than DEFUN and DEFMETHOD are not instrumented, and you can protect a DEFUN or DEFMETHOD │ │ │ │ +from instrumentation by enclosing it in a PROGN. │ │ │ │ +SB-DISASSEM │ │ │ │ +COMMON-LISP │ │ │ │ +ASDF/COMPONENT │ │ │ │ + SLOT-NAME │ │ │ │ SLOT-NAME │ │ │ │ Return SYSTEM's virtual SLOT-NAME value. │ │ │ │ If SYSTEM's SLOT-NAME value is NIL and SYSTEM is a secondary system, look in │ │ │ │ the primary one. │ │ │ │ -.A@cYH,f │ │ │ │ -ASDF/COMPONENT │ │ │ │ - SLOT-NAME │ │ │ │ + NEW-VALUE0 │ │ │ │ +Set an environment variable. │ │ │ │ EaTm+FeD} │ │ │ │ 8L@#$r`& │ │ │ │ The character ~S is a surrogate, which should not │ │ │ │ appear in an SBCL string. The line-breaking behavior of surrogates is undefined. │ │ │ │ $","("()@ │ │ │ │ -Set an environment variable. │ │ │ │ -WORD-ACCUM.PRINTER │ │ │ │ -COMMON-LISP │ │ │ │ PACKED-INFO-EQUALP │ │ │ │ SPLIT-ORDERED-LIST-EQUALP │ │ │ │ LAYOUT-EQUALP │ │ │ │ CLASSOID-CELL-EQUALP │ │ │ │ NAMED-TYPE-EQUALP │ │ │ │ DEFINITION-SOURCE-LOCATION-EQUALP │ │ │ │ STRUCTURE-CLASSOID-EQUALP │ │ │ │ UNION-TYPE-EQUALP │ │ │ │ NUMERIC-UNION-TYPE-EQUALP │ │ │ │ CONS-TYPE-EQUALP │ │ │ │ ARRAY-TYPE-EQUALP │ │ │ │ DEFSTRUCT-DESCRIPTION-EQUALP │ │ │ │ -Takes SYSTEM-NAME and returns an initialized SYSTEM object, or NIL. Made to be added to │ │ │ │ -*SYSTEM-DEFINITION-SEARCH-FUNCTIONS*. │ │ │ │ +.A@cYH,f │ │ │ │ COMMON-LISP8 │ │ │ │ Pre-combines some sequences of characters to make the sentence-break │ │ │ │ algorithm simpler.. │ │ │ │ Specifically, │ │ │ │ - Combines any character with the following extend of format characters │ │ │ │ - Combines CR + LF into '(CR LF) │ │ │ │ - Combines any run of :cp*:close* into one character │ │ │ │ @@ -38916,14 +38909,16 @@ │ │ │ │ Return the first DEFPACKAGE form in FILE. │ │ │ │ Return a list of packages depended on by the package │ │ │ │ defined in DEFPACKAGE-FORM. A package is depended upon if │ │ │ │ the DEFPACKAGE-FORM uses it or imports a symbol from it. │ │ │ │ SYSTEM should be the name of the system being defined, and │ │ │ │ PATHNAME should be the file which contains the DEFPACKAGE-FORM. │ │ │ │ These will be used to report errors when encountering an unknown defpackage argument. │ │ │ │ +Takes SYSTEM-NAME and returns an initialized SYSTEM object, or NIL. Made to be added to │ │ │ │ +*SYSTEM-DEFINITION-SEARCH-FUNCTIONS*. │ │ │ │ COMMON-LISP │ │ │ │ EXIT-CODE │ │ │ │ SIGNAL-CODE8& │ │ │ │ Escape a string token X within double-quotes │ │ │ │ for use within a MS Windows command-line, outputing to S. │ │ │ │ ?wfat0U6v │ │ │ │ Does this token require escaping, given the specification of │ │ │ │ @@ -38933,36 +38928,39 @@ │ │ │ │ for use within a POSIX Bourne shell, outputing to S; │ │ │ │ omit the outer double-quotes if key argument :QUOTE is NIL │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ Normalizes a portable I/O specifier for LAUNCH-PROGRAM into an implementation-dependent │ │ │ │ argument to pass to the internal RUN-PROGRAM │ │ │ │ o4Vcy7,_ │ │ │ │ +WORD-ACCUM.PRINTER │ │ │ │ +COMMON-LISP │ │ │ │ IMM-WORD-16.PREFILTER │ │ │ │ WIDTH.PRINTER │ │ │ │ COMMON-LISP │ │ │ │ SEG.PREFILTER │ │ │ │ +X66.PREFILTER │ │ │ │ WIDTH.PREFILTER │ │ │ │ IMM.PREFILTER │ │ │ │ WITHOUT-INTERRUPTS-BODY-3 │ │ │ │ CLEANUP-FUN-13 │ │ │ │ CLEANUP-FUN-21 │ │ │ │ /usr/share/common-lisp/source/cl-asdf/ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/ │ │ │ │ buildapp │ │ │ │ +CLEANUP-FUN-57 │ │ │ │ CLEANUP-FUN-181 │ │ │ │ Combine - with +, -, * │ │ │ │ 5N?.p:b