--- /tmp/rebuilderdPoBMuX/inputs/buildapp_1.5.6-3_riscv64.deb +++ /tmp/rebuilderdPoBMuX/out/buildapp_1.5.6-3_riscv64.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2021-11-10 19:52:07.000000 debian-binary │ -rw-r--r-- 0 0 0 800 2021-11-10 19:52:07.000000 control.tar.xz │ --rw-r--r-- 0 0 0 7620784 2021-11-10 19:52:07.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 7634224 2021-11-10 19:52:07.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./control │ │ │ @@ -1,12 +1,12 @@ │ │ │ Package: buildapp │ │ │ Version: 1.5.6-3 │ │ │ Architecture: riscv64 │ │ │ Maintainer: Debian Common Lisp Team │ │ │ -Installed-Size: 38013 │ │ │ +Installed-Size: 38046 │ │ │ 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 2021-11-10 19:52:07.000000 ./ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/bin/ │ │ │ --rwxr-xr-x 0 root (0) root (0) 38888408 2021-11-10 19:52:07.000000 ./usr/bin/buildapp │ │ │ +-rwxr-xr-x 0 root (0) root (0) 38921256 2021-11-10 19:52:07.000000 ./usr/bin/buildapp │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/doc/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/doc/buildapp/ │ │ │ -rw-r--r-- 0 root (0) root (0) 875 2021-11-10 19:52:07.000000 ./usr/share/doc/buildapp/changelog.Debian.gz │ │ │ -rw-r--r-- 0 root (0) root (0) 1607 2021-11-10 19:45:23.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 │ │ │ ├── strings --all --bytes=8 {} │ │ │ │ @@ -1732,70 +1732,71 @@ │ │ │ │ #4# #8C #4 │ │ │ │ #<# #0C │ │ │ │ #0# #4C #8 │ │ │ │ #0# #4C #8 │ │ │ │ #0# #4C │ │ │ │ #8C #4s │ │ │ │ #4# #8C #< │ │ │ │ -ScN-/@yO │ │ │ │ +ScN-/1yO │ │ │ │ #4# #8C # │ │ │ │ #0c #4C #8# #< │ │ │ │ #4# #0C │ │ │ │ #03 #4c #8 │ │ │ │ +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. │ │ │ │ #0# #4C #8 │ │ │ │ >>>>>>>> │ │ │ │ #0C #4# #8 │ │ │ │ ~~~~~~~~JJJJJJJJ │ │ │ │ #8# #>>>>>>> │ │ │ │ ~~~~~~~~JJJJJJJJ │ │ │ │ @@ -1803,43 +1804,43 @@ │ │ │ │ #0c #4C #8# #< │ │ │ │ #0c #4C #8# #< │ │ │ │ dfd f"dlg │ │ │ │ #4C #8C │ │ │ │ *#8s # │ │ │ │ GET-TIMEZONE │ │ │ │ MICROSECONDS-PER-INTERNAL-TIME-UNIT │ │ │ │ INTERRUPT-IT │ │ │ │ LIBC-NAME-FOR │ │ │ │ TIMEOUT-SECS │ │ │ │ *ON-DANGEROUS-WAIT* │ │ │ │ @@ -18361,16 +18362,14 @@ │ │ │ │ SLOT-DEFINITION-INFO │ │ │ │ VALID-WRAPPER-OF │ │ │ │ MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION │ │ │ │ FUNCTION-TYPE │ │ │ │ UNTAGGED │ │ │ │ CALL-OTHER-METHOD │ │ │ │ PRINT-FUNCTION │ │ │ │ -GLOSSARY │ │ │ │ -INITIALIZATION │ │ │ │ MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-MAKUNBOUND-METHOD-FUNCTION │ │ │ │ %BIGNUM-0-OR-PLUSP │ │ │ │ SIGN-DIGIT │ │ │ │ CARRY-DIGIT │ │ │ │ NEXT-DIGIT │ │ │ │ @@ -18475,28 +18474,30 @@ │ │ │ │ MAP-FRAME-ARGS │ │ │ │ UNTRACE-1 │ │ │ │ MAYBE-RETRACE │ │ │ │ EARLY-FRAME-ARGS │ │ │ │ ACTUAL-FUN │ │ │ │ FRAME-ARGS-AS-LIST │ │ │ │ PRINT-DEBUG-COMMAND │ │ │ │ +GLOSSARY │ │ │ │ +INITIALIZATION │ │ │ │ INCOMPATIBLE │ │ │ │ SLOW-METHOD │ │ │ │ *OVERHEAD* │ │ │ │ PRETTY-SOUT │ │ │ │ MAYBE-OUTPUT │ │ │ │ EXPAND-TABS │ │ │ │ TEMPORARY │ │ │ │ CAPITALIZE-FIRST │ │ │ │ CAPITALIZE │ │ │ │ SECTION-RELATIVE │ │ │ │ -STANDARD-INSTANCE │ │ │ │ STREAM-OPEN-P │ │ │ │ **TOKENIZE-CONTROL-STRING-CACHE-VECTOR**-STATS │ │ │ │ *SOFTWARE-VERSION* │ │ │ │ +STANDARD-INSTANCE │ │ │ │ NON-BASE-CHARS-EXIST-P │ │ │ │ ASDF-UNICODE │ │ │ │ COMMON-LISP │ │ │ │ IEEE-FLOATING-POINT │ │ │ │ SB-CORE-COMPRESSION │ │ │ │ SB-PACKAGE-LOCKS │ │ │ │ SB-THREAD │ │ │ │ @@ -18554,39 +18555,39 @@ │ │ │ │ IF-FEATURE │ │ │ │ IN-ORDER-TO │ │ │ │ AROUND-COMPILE │ │ │ │ PROPERTIES │ │ │ │ ENCODING │ │ │ │ DEFAULT-COMPONENT-CLASS │ │ │ │ NOTIFY-DEPRECATED-FUNCTION │ │ │ │ +INSTRUCTION-HOOKS │ │ │ │ +PERFORM-OPERAND-LOWERING │ │ │ │ MAINTAINER │ │ │ │ HOMEPAGE │ │ │ │ BUG-TRACKER │ │ │ │ LONG-NAME │ │ │ │ SOURCE-CONTROL │ │ │ │ BUILTIN-SYSTEM-P │ │ │ │ BUILD-PATHNAME │ │ │ │ ENTRY-POINT │ │ │ │ DEFSYSTEM-DEPENDS-ON │ │ │ │ PERFORMABLE-P │ │ │ │ FORCED-NOT │ │ │ │ -INSTRUCTION-HOOKS │ │ │ │ -PERFORM-OPERAND-LOWERING │ │ │ │ TRACE-INST │ │ │ │ EXTRACT-PREFIX-KEYWORDS │ │ │ │ STATIC-LIBRARY │ │ │ │ *PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ WRITER-METHOD-CLASS │ │ │ │ +EVAL-FORM │ │ │ │ METHOD-CLASS-SUPPLIED-P │ │ │ │ METHOD-COMBINATION-SUPPLIED-P │ │ │ │ -EVAL-FORM │ │ │ │ -READER-METHOD-CLASS │ │ │ │ DIRECT-SUPERCLASSES-P │ │ │ │ DIRECT-SLOTS-P │ │ │ │ DIRECT-DEFAULT-INITARGS-P │ │ │ │ +READER-METHOD-CLASS │ │ │ │ ENSURE-CLASS-USING-CLASS │ │ │ │ ADD-WRITER-METHOD │ │ │ │ ADD-READER-METHOD │ │ │ │ COMPUTE-SLOT-ACCESSOR-INFO │ │ │ │ COMPUTE-EFFECTIVE-SLOT-DEFINITION │ │ │ │ SLOT-ACCESSOR-STD-P │ │ │ │ SLOT-ACCESSOR-FUNCTION │ │ │ │ @@ -18596,23 +18597,23 @@ │ │ │ │ MAP-DEPENDENTS │ │ │ │ MAKE-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-READER-METHOD-FUNCTION │ │ │ │ COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS │ │ │ │ COMPUTE-APPLICABLE-METHODS-USING-CLASSES │ │ │ │ COMPATIBLE-META-CLASS-CHANGE-P │ │ │ │ ADD-DEPENDENT │ │ │ │ -COMPUTE-PRIMARY-METHODS │ │ │ │ *THE-CLASS-METHOD* │ │ │ │ *THE-CLASS-STRUCTURE-OBJECT* │ │ │ │ *THE-CLASS-STANDARD-OBJECT* │ │ │ │ *THE-CLASS-FUNCALLABLE-STANDARD-OBJECT* │ │ │ │ *THE-CLASS-T* │ │ │ │ OBJECT-CLASS │ │ │ │ METHOD-CLASS-FUNCTION │ │ │ │ DEPENDENTS │ │ │ │ +COMPUTE-PRIMARY-METHODS │ │ │ │ INVALID-QUALIFIERS │ │ │ │ NO-PRIMARY-METHOD │ │ │ │ REAL-GET-METHOD │ │ │ │ REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION │ │ │ │ REAL-ENSURE-GF-USING-CLASS--NULL │ │ │ │ REAL-MAKE-METHOD-LAMBDA │ │ │ │ REAL-MAKE-METHOD-LAMBDA-USING-SPECIALIZERS │ │ │ │ @@ -18658,39 +18659,61 @@ │ │ │ │ ASDF/INTERFACE │ │ │ │ COLLECT-DEPENDENCIES │ │ │ │ ON-WARNINGS │ │ │ │ ON-FAILURE │ │ │ │ OVERRIDE-CACHE │ │ │ │ OVERRIDE-FORCING │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-PROPERTY-NOTIFIED-P* │ │ │ │ -*DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ -PREVIOUS-SERIAL-COMPONENTS │ │ │ │ NEEDS-ASDF-P │ │ │ │ ASDF-SYSTEM-FILES │ │ │ │ ENTRY-FUNCTION-FORM │ │ │ │ ENTRY-FUNCTION-CHECK-FORM │ │ │ │ +*DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ +PREVIOUS-SERIAL-COMPONENTS │ │ │ │ MACROEXPANDS │ │ │ │ ARGUMENT-TEST │ │ │ │ IMPORTANT-RESULT-DISCARDED │ │ │ │ COMMAND-LINE-DEBUGGER │ │ │ │ NEGATIVE-INFINITY │ │ │ │ POSITIVE-INFINITY │ │ │ │ +KEY-INDEX- │ │ │ │ DUMP-FORM │ │ │ │ DIRECTORIZE │ │ │ │ DUMPER-ACTION-FORM │ │ │ │ -KEY-INDEX- │ │ │ │ -BODY-NAME- │ │ │ │ *LOAD-SEARCH-PATHS* │ │ │ │ *POST-INVOKE-DEBUGGER-HOOK* │ │ │ │ *SYSTEM-LOAD-OUTPUT* │ │ │ │ OBJ-SUPPLIED-P │ │ │ │ PARTIAL-MACROEXPANDER │ │ │ │ -***HERE*** │ │ │ │ +BODY-NAME- │ │ │ │ UPDATE-DEPENDENT │ │ │ │ STANDARD-INSTANCE-ACCESS │ │ │ │ +***HERE*** │ │ │ │ +DIRECTIVE-LIST │ │ │ │ +*DUMPABLE-FORMS* │ │ │ │ +DUMP-TO-FILE │ │ │ │ +ALL-ASDF-DIRECTORIES │ │ │ │ +DUMPABLE │ │ │ │ +ASDF-PATH-FILES │ │ │ │ +PSEUDOSYMBOL-CHECK-FORM │ │ │ │ +MANIFEST-FILE-FILES │ │ │ │ +SYSTEM-SEARCH-FUNCTION │ │ │ │ +FILE-LINES │ │ │ │ +GET-ARGS │ │ │ │ +ASDF-DIRECTIVE-FILES │ │ │ │ +DUMP-FILE-DEBUGGER │ │ │ │ +LOAD-FILE │ │ │ │ +DISPATCH-ENTRY │ │ │ │ +PRETTY-NAME │ │ │ │ +*SHORT-USAGE* │ │ │ │ +DUMPER-ACTION-FORMS │ │ │ │ +INVOKE-DEBUGGER-HOOK-WRAPPER │ │ │ │ +DISPATCHED-ENTRY-FORM │ │ │ │ +ASDF-TREE-FILES │ │ │ │ +BUILD-BUILDAPP │ │ │ │ SPECIALIZER-DIRECT-METHODS │ │ │ │ SPECIALIZER-DIRECT-GENERIC-FUNCTIONS │ │ │ │ SLOT-DEFINITION-TYPE │ │ │ │ SLOT-DEFINITION-WRITERS │ │ │ │ SLOT-DEFINITION-READERS │ │ │ │ SLOT-DEFINITION-INITFUNCTION │ │ │ │ SLOT-DEFINITION-INITFORM │ │ │ │ @@ -18717,36 +18740,14 @@ │ │ │ │ DIRECT-SLOT-DEFINITION-CLASS │ │ │ │ COMPUTE-SLOTS │ │ │ │ COMPUTE-DISCRIMINATING-FUNCTION │ │ │ │ COMPUTE-DEFAULT-INITARGS │ │ │ │ COMPUTE-CLASS-PRECEDENCE-LIST │ │ │ │ CLASS-PROTOTYPE │ │ │ │ CLASS-PRECEDENCE-LIST │ │ │ │ -DIRECTIVE-LIST │ │ │ │ -*DUMPABLE-FORMS* │ │ │ │ -DUMP-TO-FILE │ │ │ │ -ALL-ASDF-DIRECTORIES │ │ │ │ -DUMPABLE │ │ │ │ -ASDF-PATH-FILES │ │ │ │ -PSEUDOSYMBOL-CHECK-FORM │ │ │ │ -MANIFEST-FILE-FILES │ │ │ │ -SYSTEM-SEARCH-FUNCTION │ │ │ │ -FILE-LINES │ │ │ │ -GET-ARGS │ │ │ │ -ASDF-DIRECTIVE-FILES │ │ │ │ -DUMP-FILE-DEBUGGER │ │ │ │ -LOAD-FILE │ │ │ │ -DISPATCH-ENTRY │ │ │ │ -PRETTY-NAME │ │ │ │ -*SHORT-USAGE* │ │ │ │ -DUMPER-ACTION-FORMS │ │ │ │ -INVOKE-DEBUGGER-HOOK-WRAPPER │ │ │ │ -DISPATCHED-ENTRY-FORM │ │ │ │ -ASDF-TREE-FILES │ │ │ │ -BUILD-BUILDAPP │ │ │ │ CLASS-DIRECT-SUBCLASSES │ │ │ │ CLASS-DIRECT-SLOTS │ │ │ │ CLASS-DIRECT-DEFAULT-INITARGS │ │ │ │ CLASS-DEFAULT-INITARGS │ │ │ │ ADD-DIRECT-SUBCLASS │ │ │ │ ADD-DIRECT-METHOD │ │ │ │ AMBIGUOUS │ │ │ │ @@ -18811,21 +18812,19 @@ │ │ │ │ GOVERNMENT │ │ │ │ VARIANT-COST │ │ │ │ ARG-REFS │ │ │ │ RESULT-REFS │ │ │ │ *CURRENT-VOP* │ │ │ │ SEQUENCE-TYPE │ │ │ │ SINGLE-VALUE-RETURN │ │ │ │ -ENSURE-CLASS-FINALIZED │ │ │ │ PRE-IR2-OPTIMIZE │ │ │ │ +ENSURE-CLASS-FINALIZED │ │ │ │ PROGRESS │ │ │ │ STRUCTURE-ALLOC │ │ │ │ *CURRENT-FASL-GROUP* │ │ │ │ -SAFE-GF-DFUN-STATE │ │ │ │ -WRAPPER-SLOT-LIST │ │ │ │ SLOT-READER-NAME │ │ │ │ SLOT-BOUNDP-NAME │ │ │ │ SLOT-MAKUNBOUND-NAME │ │ │ │ SLOT-WRITER-NAME │ │ │ │ PPRINT-LENGTH-CHECK* │ │ │ │ EMIT-BYTES │ │ │ │ IF-AFTER │ │ │ │ @@ -18978,14 +18977,17 @@ │ │ │ │ *LOAD-DEPTH* │ │ │ │ LOAD-STREAM │ │ │ │ FOP-INT-CONST1 │ │ │ │ FOP-NAMED-CONSTANT-SET │ │ │ │ FOP-RPLACD │ │ │ │ FOP-NTHCDR │ │ │ │ FOP-COPY-SYMBOL-SAVE │ │ │ │ +SAFE-GF-DFUN-STATE │ │ │ │ +WRAPPER-SLOT-LIST │ │ │ │ +.NEXT-METHOD-CALL. │ │ │ │ *THE-CLASS-STANDARD-GENERIC-FUNCTION* │ │ │ │ EMIT-N-N-READERS │ │ │ │ EMIT-N-N-BOUNDPS │ │ │ │ EMIT-N-N-MAKUNBOUNDS │ │ │ │ EMIT-N-N-WRITERS │ │ │ │ EMIT-ONE-INDEX-READERS │ │ │ │ EMIT-ONE-INDEX-BOUNDPS │ │ │ │ @@ -19000,27 +19002,25 @@ │ │ │ │ EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ EMIT-ONE-CLASS-WRITER │ │ │ │ EMIT-CACHING │ │ │ │ EMIT-DEFAULT-ONLY │ │ │ │ DEFAULT-ONLY │ │ │ │ EMIT-CHECKING │ │ │ │ *THE-CLASS-STANDARD-CLASS* │ │ │ │ -.NEXT-METHOD-CALL. │ │ │ │ CLASSES-LIST │ │ │ │ OWRAPPER │ │ │ │ NWRAPPER │ │ │ │ NORMALIZED-P │ │ │ │ DEFINITION-SOURCE │ │ │ │ ENSURE-ACCESSOR │ │ │ │ +CALL-NO-NEXT-METHOD │ │ │ │ +EXIT-IF-NULL │ │ │ │ DONT-KNOW │ │ │ │ COMPUTE-CODE-FROM-RA │ │ │ │ ASSEMBLY-ROUTINE │ │ │ │ -EXIT-IF-NULL │ │ │ │ -CALL-NO-NEXT-METHOD │ │ │ │ -ENSURE-SPACE-IN-BUFFER │ │ │ │ SHADOWING-IMPORT-P │ │ │ │ NABATAEAN │ │ │ │ OTHER-DEFAULT-IGNORABLE-CODE-POINT │ │ │ │ OLD-SOGDIAN │ │ │ │ WANT-ABSOLUTE │ │ │ │ iso-8859-2 │ │ │ │ CORMANLISP │ │ │ │ @@ -19643,29 +19643,30 @@ │ │ │ │ COMMON-APPDATA │ │ │ │ ON-TOP-OF │ │ │ │ WHITE-SPACE │ │ │ │ iso-8859-11 │ │ │ │ PPC32-TARGET │ │ │ │ WALK-FORM │ │ │ │ UTILITY-FILE │ │ │ │ +ENSURE-SPACE-IN-BUFFER │ │ │ │ COMPILE-OR-LOAD-DEFGENERIC │ │ │ │ LOAD-DEFGENERIC │ │ │ │ SET-INITIAL-METHODS │ │ │ │ -GENERIC-FUNCTION-P │ │ │ │ *INITFUNCTIONS-FOR-THIS-DEFCLASS* │ │ │ │ *READERS-FOR-THIS-DEFCLASS* │ │ │ │ *WRITERS-FOR-THIS-DEFCLASS* │ │ │ │ *SLOT-NAMES-FOR-THIS-DEFCLASS* │ │ │ │ LOAD-DEFCLASS │ │ │ │ *THE-CLASS-STRUCTURE-CLASS* │ │ │ │ *LOOP-ANSI-UNIVERSE* │ │ │ │ LOAD-SHORT-DEFCOMBIN │ │ │ │ *COMPILING-OPTIMIZED-CONSTRUCTOR* │ │ │ │ -SET-SLOT-VALUE │ │ │ │ %DEFMETHOD-EXPANDER │ │ │ │ +SET-SLOT-VALUE │ │ │ │ +GENERIC-FUNCTION-P │ │ │ │ *ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ *DISASSEM-INST-SPACE* │ │ │ │ +CTOR-TABLE-MAX-SIZE+ │ │ │ │ +SLOT-UNBOUND+ │ │ │ │ +CTOR-LIST-MAX-SIZE+ │ │ │ │ COMPUTE-CACHE-INDEX │ │ │ │ MAKE-METHOD-INITARGS-FORM-INTERNAL1 │ │ │ │ @@ -20547,17 +20548,17 @@ │ │ │ │ WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ WALK-ARGLIST │ │ │ │ WALK-REPEAT-EVAL │ │ │ │ WALK-DECLARATIONS │ │ │ │ CONVERT-MACRO-TO-LAMBDA │ │ │ │ DCHUNK-EXTRACT │ │ │ │ NOTE-SIGNIFICANT-SPACE │ │ │ │ -N-ARRAY26 │ │ │ │ CANONIZE-TEST │ │ │ │ CANONIZE-KEY │ │ │ │ +N-ARRAY26 │ │ │ │ %COMPONENT-ENCODING │ │ │ │ %ADDITIONAL-INPUT-FILES │ │ │ │ MODULE-COMPONENTS-BY-NAME │ │ │ │ ACTION-OVERRIDE-P │ │ │ │ MERGE-ACTION-STATUS │ │ │ │ REQUIRED-MODULE │ │ │ │ PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ @@ -20579,17 +20580,17 @@ │ │ │ │ COMPENSATE-TIME │ │ │ │ *ENCLOSED-PROFILES* │ │ │ │ *ENCLOSED-GC-RUN-TIME* │ │ │ │ UNPROFILE-1-FUN │ │ │ │ PRINT-PROFILE-TABLE │ │ │ │ *TIMER-OVERHEAD-ITERATIONS* │ │ │ │ NORMALIZE-STRING │ │ │ │ +F-STREAM- │ │ │ │ TARGET-IF-DESIRABLE │ │ │ │ DISASSEMBLE-ASSEM-SEGMENT │ │ │ │ -F-STREAM- │ │ │ │ SYMBOL-MACRO77 │ │ │ │ DISASSEMBLE-MEMORY │ │ │ │ GET-COMPILED-FUNS │ │ │ │ DISASSEMBLE-CODE-COMPONENT │ │ │ │ MACROEXPAND-ALL │ │ │ │ EVAL-IN-NATIVE-ENVIRONMENT │ │ │ │ UNICODE-CHAR->NAME │ │ │ │ @@ -20619,19 +20620,19 @@ │ │ │ │ PPRINT-DEFPACKAGE │ │ │ │ PPRINT-TAGBODY │ │ │ │ PPRINT-LOOP │ │ │ │ PPRINT-DECLARE │ │ │ │ PPRINT-LAMBDA │ │ │ │ PPRINT-IF │ │ │ │ UNICODE-1-CHAR->NAME │ │ │ │ -NCLOSURE15 │ │ │ │ -STREAM-SYMBOL │ │ │ │ LOOP-STANDARD-EXPANSION │ │ │ │ ENQUEUE-TAB │ │ │ │ DISASSEMBLE-FUN │ │ │ │ +NCLOSURE15 │ │ │ │ +STREAM-SYMBOL │ │ │ │ ASSERT-NOT-STANDARD-PPRINT-DISPATCH-TABLE │ │ │ │ DEFER-TYPE-CHECKER │ │ │ │ COMPUTE-TEST-FN │ │ │ │ MAKE-DSTATE │ │ │ │ END-LOOP │ │ │ │ PPRINT-FUN-CALL │ │ │ │ PPRINT-ARRAY │ │ │ │ @@ -20946,14 +20947,19 @@ │ │ │ │ LOOP-MAKE-DESETQ │ │ │ │ LOOP-CONSTANT-FOLD-IF-POSSIBLE │ │ │ │ LOOP-TMEMBER │ │ │ │ KEYWORDS-AND-FORMS │ │ │ │ LOOP-ANSI-FOR-EQUALS │ │ │ │ *LOOP-DESETQ-TEMPORARY* │ │ │ │ MAP-NAME │ │ │ │ +*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ +COERCE-UNSIGNED │ │ │ │ +COERCE-SIGNED │ │ │ │ +LOAD-SIGNED-BYTE-32-IMMEDIATE │ │ │ │ +PRINT-REG │ │ │ │ PUSH-FUN │ │ │ │ EVAL-FLET │ │ │ │ EVAL-BLOCK │ │ │ │ MAKE-ENV-FROM-NATIVE-ENVIRONMENT │ │ │ │ PARSE-LAMBDA-HEADERS │ │ │ │ CALL-WITH-NEW-ENV │ │ │ │ EVAL-TAGBODY │ │ │ │ @@ -21111,15 +21117,15 @@ │ │ │ │ AT-SIGN-P │ │ │ │ SIDEWAY-OPERATION-DEPENDS-ON │ │ │ │ UPWARD-OPERATION-DEPENDS-ON │ │ │ │ BACKWARD-COMPATIBLE-DEPENDS-ON │ │ │ │ NEXT-METHOD │ │ │ │ CHECK-OPERATION-CONSTRUCTOR │ │ │ │ DOWNWARD-OPERATION-DEPENDS-ON │ │ │ │ -*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ +WALK-DEFINITIONS │ │ │ │ STATUS-LEVEL │ │ │ │ COLLECT-ACTION-DEPENDENCIES │ │ │ │ +VOID-BITS+ │ │ │ │ MAKE-ACTION-STATUS │ │ │ │ +NEED-BIT+ │ │ │ │ +TODO-BITS+ │ │ │ │ STATUS-BITS │ │ │ │ @@ -21133,15 +21139,14 @@ │ │ │ │ *MODULES-BEING-REQUIRED* │ │ │ │ FIRST-NAME │ │ │ │ RESTART-UPGRADED-ASDF │ │ │ │ DEFINITION-DEPENDENCIES-UP-TO-DATE-P │ │ │ │ *OLD-ASDF-SYSTEMS* │ │ │ │ FOUND-SYSTEM │ │ │ │ CHECK-NOT-OLD-ASDF-SYSTEM │ │ │ │ -WALK-DEFINITIONS │ │ │ │ %DEFINE-COMPONENT-INLINE-METHODS │ │ │ │ +ASDF-METHODS+ │ │ │ │ NORMALIZE-VERSION │ │ │ │ %REMOVE-COMPONENT-INLINE-METHODS │ │ │ │ OPERATION-NAME │ │ │ │ INVALID-PARSE │ │ │ │ ASD-NAME │ │ │ │ @@ -21219,46 +21224,14 @@ │ │ │ │ INITIAL-PACKAGE-INFERRED-SYSTEMS-TABLE │ │ │ │ DEFPACKAGE-FORM │ │ │ │ DEFPACKAGE-FORM-P │ │ │ │ PACKAGE-NAME-SYSTEM │ │ │ │ FILE-DEFPACKAGE-FORM │ │ │ │ STREAM-DEFPACKAGE-FORM │ │ │ │ SYSTEM-NAME │ │ │ │ -MACHINE-WORD │ │ │ │ -AMOSWAP.W │ │ │ │ -AMOSWAP.D │ │ │ │ -AMOADD.W │ │ │ │ -AMOADD.D │ │ │ │ -AMOXOR.W │ │ │ │ -AMOXOR.D │ │ │ │ -AMOAND.W │ │ │ │ -AMOAND.D │ │ │ │ -AMOMIN.W │ │ │ │ -AMOMIN.D │ │ │ │ -AMOMAX.W │ │ │ │ -AMOMAX.D │ │ │ │ -AMOMINU.W │ │ │ │ -AMOMINU.D │ │ │ │ -AMOMAXU.W │ │ │ │ -AMOMAXU.D │ │ │ │ -FCVTWU<- │ │ │ │ -FCVTLU<- │ │ │ │ -FCVTWU-> │ │ │ │ -COMPUTE-CODE-FROM-FN │ │ │ │ -COMPUTE-RA-FROM-CODE │ │ │ │ -SIMPLE-FUN-HEADER-WORD │ │ │ │ -.LAYOUT-ID-FIXUP │ │ │ │ -STORE-COVERAGE-MARK │ │ │ │ -C.ADDISP16 │ │ │ │ -C.ADDI4SPN │ │ │ │ -C.EBREAK │ │ │ │ -COERCE-UNSIGNED │ │ │ │ -COERCE-SIGNED │ │ │ │ -LOAD-SIGNED-BYTE-32-IMMEDIATE │ │ │ │ -PRINT-REG │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-RUN-SHELL-COMMAND-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-DEFINITION-PATHNAME-NOTIFIED-P* │ │ │ │ DESTINATION-DIRECTORY │ │ │ │ PRIMARY-SYSTEM │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-REGISTERED-P-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-EXPLAIN-NOTIFIED-P* │ │ │ │ @@ -21283,127 +21256,155 @@ │ │ │ │ FEATURE-SETS │ │ │ │ OS-MEZZANO-P │ │ │ │ FIRST-FEATURE │ │ │ │ *LINK-GUID* │ │ │ │ *LINK-INITIAL-DWORD* │ │ │ │ OS-OLDMAC-P │ │ │ │ EMIT-CB-ARITH-INST │ │ │ │ +AMOMIN.D │ │ │ │ +SIMPLE-FUN-HEADER-WORD │ │ │ │ %EMIT-S-INST │ │ │ │ +COMPUTE-RA-FROM-CODE │ │ │ │ *DISASSEM-USE-LISP-REG-NAMES* │ │ │ │ +FCVTWU<- │ │ │ │ TO-FORMAT │ │ │ │ %EMIT-CR-INST │ │ │ │ ANNOTATE-LOAD-STORE │ │ │ │ EMIT-U-INST │ │ │ │ +MACHINE-WORD │ │ │ │ RVC-REG-TN-ENCODING │ │ │ │ +AMOMAX.W │ │ │ │ CB-BRANCH │ │ │ │ EMIT-LONG-JUMP-AT-FUN │ │ │ │ RECONSTRUCT-S-IMMEDIATE │ │ │ │ M:AMOMIN │ │ │ │ %EMIT-CJ-INST │ │ │ │ %EMIT-I-INST │ │ │ │ SIGNED-VALUE │ │ │ │ +AMOADD.W │ │ │ │ PRINT-JALR-ANNOTATION │ │ │ │ %EMIT-CSS-32-INST │ │ │ │ EMIT-CSR-I-INST │ │ │ │ +C.EBREAK │ │ │ │ PRINT-LOAD-ANNOTATION │ │ │ │ PRINT-FLOAT-FMT │ │ │ │ PRINT-CIW-IMM │ │ │ │ MAYBE-AUGMENT │ │ │ │ M:AMOMAX │ │ │ │ %EMIT-B-INST │ │ │ │ EMIT-R-FLOAT-INST │ │ │ │ CSR-ENCODING │ │ │ │ %EMIT-CSS-64-INST │ │ │ │ MARK-INDEX │ │ │ │ +AMOAND.W │ │ │ │ RM-ENCODING │ │ │ │ PRINT-CSS-64-IMM │ │ │ │ %EMIT-U-INST │ │ │ │ %EMIT-CL/CS-32-INST │ │ │ │ PC-RELATIVE-EMITTER │ │ │ │ %EMIT-CI-LOAD-32-INST │ │ │ │ %EMIT-R-INST │ │ │ │ EMIT-CIW-INST │ │ │ │ EMIT-SHORT-JUMP-AT │ │ │ │ USE-CJ-LABEL │ │ │ │ CL/CS-32 │ │ │ │ PRINT-CSS-32-IMM │ │ │ │ PRINT-CL/CS-64-IMM │ │ │ │ RELATIVE-OFFSET │ │ │ │ +AMOSWAP.D │ │ │ │ M:AMOADD │ │ │ │ SRC-RELATIVE-EMITTER │ │ │ │ +C.ADDI4SPN │ │ │ │ PRINT-STORE-ANNOTATION │ │ │ │ EMIT-R-INST │ │ │ │ ENSURE-REG-TN-ENCODING │ │ │ │ +AMOMAX.D │ │ │ │ NOTE-PC-RELATIVE-U-INST │ │ │ │ DELTA-IF-AFTER │ │ │ │ FROM-FORMAT │ │ │ │ EMIT-MACHINE-WORD │ │ │ │ M:AMOXOR │ │ │ │ EMIT-I-INST │ │ │ │ EMIT-CI-LOAD-32-INST │ │ │ │ +C.ADDISP16 │ │ │ │ EMIT-FENCE-INST │ │ │ │ +AMOXOR.D │ │ │ │ M:AMOMINU │ │ │ │ RS3/FUNCT5 │ │ │ │ M:AMOAND │ │ │ │ EMIT-CI-LOAD-64-INST │ │ │ │ UNSIGNED-VALUE │ │ │ │ %EMIT-CIW-INST │ │ │ │ EMIT-CL/CS-64-INST │ │ │ │ %EMIT-CA-INST │ │ │ │ +AMOMIN.W │ │ │ │ PRINT-CI-IMM │ │ │ │ %EMIT-J-INST │ │ │ │ EMIT-B-INST │ │ │ │ USE-CB-LABEL │ │ │ │ +AMOXOR.W │ │ │ │ R-ATOMIC │ │ │ │ USE-B-LABEL │ │ │ │ EMIT-WORD │ │ │ │ +.LAYOUT-ID-FIXUP │ │ │ │ EMIT-S-INST │ │ │ │ %EMIT-CB-BRANCH-INST │ │ │ │ CL/CS-64 │ │ │ │ PARSE-ATOMIC-FLAGS │ │ │ │ PRINT-FENCE-ORDERING │ │ │ │ %EMIT-CL/CS-64-INST │ │ │ │ %EMIT-CB-ARITH-INST │ │ │ │ RD*/RS1* │ │ │ │ EMIT-COMPUTE │ │ │ │ +AMOMINU.D │ │ │ │ M:AMOSWAP │ │ │ │ M:LOAD-LAYOUT-ID │ │ │ │ CB-ARITH │ │ │ │ PRINT-FLOAT-RM │ │ │ │ +AMOMAXU.D │ │ │ │ +COMPUTE-CODE-FROM-FN │ │ │ │ TRAP-CODE │ │ │ │ EMIT-CJ-INST │ │ │ │ +STORE-COVERAGE-MARK │ │ │ │ SRC-RELATIVE-DELTA │ │ │ │ FENCE-ENCODING │ │ │ │ USE-J-LABEL │ │ │ │ M:AMOMAXU │ │ │ │ %EMIT-CI-INST │ │ │ │ EMIT-RELATIVE-BRANCH │ │ │ │ PRINT-FP-REG │ │ │ │ EMIT-CSS-64-INST │ │ │ │ PRINT-RVC-REG │ │ │ │ +AMOADD.D │ │ │ │ PRINT-A-ORDERING │ │ │ │ EMIT-J-INST │ │ │ │ EMIT-CB-BRANCH-INST │ │ │ │ NOTE-ABSOLUTE-U-INST │ │ │ │ +AMOAND.D │ │ │ │ +AMOSWAP.W │ │ │ │ EMIT-HEADER-DATA │ │ │ │ RD*/RS2* │ │ │ │ PRINT-S-IMM │ │ │ │ CURRENT-INSTRUCTION │ │ │ │ +FCVTWU-> │ │ │ │ EMIT-CSS-32-INST │ │ │ │ EMIT-CSR-INST │ │ │ │ FMT-FUNCT3 │ │ │ │ PRINT-CL/CS-32-IMM │ │ │ │ %EMIT-FENCE-INST │ │ │ │ EMIT-CL/CS-32-INST │ │ │ │ PC-RELATIVE-DELTA │ │ │ │ EMIT-CI-INST │ │ │ │ BREAK-CONTROL │ │ │ │ PRINT-CB-ARITH-IMM │ │ │ │ +AMOMINU.W │ │ │ │ REG-TN-ENCODING │ │ │ │ *NOTE-U-INST* │ │ │ │ +AMOMAXU.W │ │ │ │ +FCVTLU<- │ │ │ │ INSTRUCTION-OPCODE │ │ │ │ FUNCT3-PRINTER │ │ │ │ CHECK-ONE │ │ │ │ *WILD-DIRECTORY-COMPONENT* │ │ │ │ DEFAULTS-PATHNAME │ │ │ │ MAYBE-SUBPATH │ │ │ │ NORMALIZE-COMPONENT │ │ │ │ @@ -21442,16 +21443,14 @@ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-IN-SYSTEM-CONFIGURATION-DIRECTORY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-CONFIGURATION-DIRECTORIES-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COERCE-PATHNAME-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-USER-CONFIGURATION-DIRECTORIES-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-IN-FIRST-DIRECTORY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-IN-USER-CONFIGURATION-DIRECTORY-NOTIFIED-P* │ │ │ │ PROVIDED-VERSION │ │ │ │ -DECOMPOSE-STRING │ │ │ │ -CANONICALLY-COMPOSE │ │ │ │ OLD-BODY │ │ │ │ GET-WALKER-TEMPLATE │ │ │ │ REAL-ENV │ │ │ │ %VAR-DECLARATION │ │ │ │ NOTE-VAR-BINDING │ │ │ │ WALKER-INFO-TO-BOGO-FUN │ │ │ │ ENV-VAR-TYPE │ │ │ │ @@ -21484,14 +21483,16 @@ │ │ │ │ STOP-FORM │ │ │ │ NOTE-DECLARATION │ │ │ │ BOGO-FUN-TO-WALKER-INFO │ │ │ │ WITH-SEQUENCE-ITERATOR │ │ │ │ WITH-SEQUENCE-ITERATOR-FUNCTIONS │ │ │ │ DOSEQUENCE │ │ │ │ %COMPUTE-OPERATIONS-VALUE │ │ │ │ +DECOMPOSE-STRING │ │ │ │ +CANONICALLY-COMPOSE │ │ │ │ ONE-ITER- │ │ │ │ NCLOSURE23 │ │ │ │ LOOP-DESETQ-TEMP │ │ │ │ SPECIAL75 │ │ │ │ NOT-PRESENT78 │ │ │ │ OR-FUNCTION │ │ │ │ PERFORM-LISP-WARNINGS-CHECK │ │ │ │ @@ -21605,45 +21606,45 @@ │ │ │ │ POSTLUDEP │ │ │ │ LIST-INITARG-0 │ │ │ │ *!DELAYED-DEFMETHOD-ARGS* │ │ │ │ ARG-FOR-(BYTE 7 0)- │ │ │ │ ARG-FOR-(BYTE 5 7)- │ │ │ │ ARG-FOR-(BYTE 3 12)- │ │ │ │ ARG-FOR-(BYTE 5 15)- │ │ │ │ -ARG-FOR-(BYTE 12 20)- │ │ │ │ +ARG-FOR-(BYTE 5 20)- │ │ │ │ +ARG-FOR-(BYTE 7 25)- │ │ │ │ ARG-FOR-(BYTE 2 0)- │ │ │ │ ARG-FOR-(BYTE 5 2)- │ │ │ │ ARG-FOR-(BYTE 4 12)- │ │ │ │ -ARG-FOR-(BYTE 3 2)- │ │ │ │ -ARG-FOR-(BYTE 2 5)- │ │ │ │ -ARG-FOR-(BYTE 3 7)- │ │ │ │ -ARG-FOR-(BYTE 6 10)- │ │ │ │ -ARG-FOR-(BYTE 1 12)- │ │ │ │ -ARG-FOR-(BYTE 3 13)- │ │ │ │ -ARG-FOR-(BYTE 7 25)- │ │ │ │ -ARG-FOR-(BYTE 5 20)- │ │ │ │ ARG-FOR-(BYTE 1 2)- │ │ │ │ ARG-FOR-(BYTE 3 3)- │ │ │ │ ARG-FOR-(BYTE 1 6)- │ │ │ │ ARG-FOR-(BYTE 1 7)- │ │ │ │ ARG-FOR-(BYTE 1 8)- │ │ │ │ ARG-FOR-(BYTE 2 9)- │ │ │ │ ARG-FOR-(BYTE 1 11)- │ │ │ │ +ARG-FOR-(BYTE 1 12)- │ │ │ │ +ARG-FOR-(BYTE 3 13)- │ │ │ │ +ARG-FOR-(BYTE 12 20)- │ │ │ │ ARG-FOR-(BYTE 2 7)- │ │ │ │ ARG-FOR-(BYTE 4 9)- │ │ │ │ ARG-FOR-(BYTE 4 8)- │ │ │ │ ARG-FOR-(BYTE 6 25)- │ │ │ │ ARG-FOR-(BYTE 1 31)- │ │ │ │ +ARG-FOR-(BYTE 3 7)- │ │ │ │ ARG-FOR-(BYTE 3 10)- │ │ │ │ ARG-FOR-(BYTE 20 12)- │ │ │ │ +ARG-FOR-(BYTE 3 2)- │ │ │ │ ARG-FOR-(BYTE 1 5)- │ │ │ │ ARG-FOR-(BYTE 2 2)- │ │ │ │ ARG-FOR-(BYTE 3 4)- │ │ │ │ ARG-FOR-(BYTE 4 7)- │ │ │ │ ARG-FOR-(BYTE 2 11)- │ │ │ │ +ARG-FOR-(BYTE 2 5)- │ │ │ │ +ARG-FOR-(BYTE 6 10)- │ │ │ │ ARG-FOR-(BYTE 8 12)- │ │ │ │ ARG-FOR-(BYTE 1 20)- │ │ │ │ ARG-FOR-(BYTE 10 21)- │ │ │ │ ARG-FOR-(BYTE 2 3)- │ │ │ │ ARG-FOR-(BYTE 2 10)- │ │ │ │ ARG-FOR-(BYTE 4 20)- │ │ │ │ ARG-FOR-(BYTE 4 24)- │ │ │ │ @@ -22956,52 +22957,52 @@ │ │ │ │ If one is found, return the corresponding value, else return DEFAULT. │ │ │ │ LKbSX$Vs │ │ │ │ CONDITION-SLOT-EQUALP │ │ │ │ CTYPE-EQUALP │ │ │ │ SYS:SRC;CODE;TARGET-SXHASH.LISP │ │ │ │ SYS:SRC;CODE;THREAD.LISP │ │ │ │ SYS:SRC;CODE;TARGET-SIGNAL-COMMON.LISP │ │ │ │ +ELEMENTS0 │ │ │ │ Releasing ~S, owned by another thread: ~S │ │ │ │ Should not be called: ~S │ │ │ │ -ELEMENTS0 │ │ │ │ BIT-ARRAY │ │ │ │ MORE-ARG │ │ │ │ Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if │ │ │ │ none exists. │ │ │ │ Return the tail of LIST beginning with first element satisfying EQLity, │ │ │ │ :TEST, or :TEST-NOT with the given ITEM. │ │ │ │ Return true if OBJECT is a NULL, and NIL otherwise. │ │ │ │ SYS:SRC;COMPILER;ALIENCOMP.LISP │ │ │ │ NEW-KV-VECTOR │ │ │ │ HASH-TABLE-PAIRS-CAPACITY │ │ │ │ -SYS:SRC;CODE;TARGET-C-CALL.LISP │ │ │ │ A dimension is not a non-negative fixnum: ~S │ │ │ │ The first dimension is not a non-negative fixnum or NIL: ~S │ │ │ │ +SYS:SRC;CODE;TARGET-C-CALL.LISP │ │ │ │ Place ~S in PSETQ is not a SYMBOL │ │ │ │ Odd number of args to ~S. │ │ │ │ ~S called with too few arguments: ~S │ │ │ │ +Too many arguments (~D) to ~S ~S ~S: uses at most ~D. │ │ │ │ +Too few arguments (~D) to ~S ~S ~S: requires at least ~D. │ │ │ │ A list of function designators which are called in an unspecified │ │ │ │ order when a saved core image starts up, after the system itself has │ │ │ │ been initialized, but before non-user threads such as the finalizer │ │ │ │ thread have been started. │ │ │ │ Unused by SBCL itself: reserved for user and applications. │ │ │ │ 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. │ │ │ │ All DEBUG-CONDITIONs inherit from this type. These are serious conditions │ │ │ │ that must be handled, but they are not programmer errors. │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP │ │ │ │ -Too many arguments (~D) to ~S ~S ~S: uses at most ~D. │ │ │ │ -Too few arguments (~D) to ~S ~S ~S: requires at least ~D. │ │ │ │ Problem running ~A hook ~S: │ │ │ │ Problem running ~A hook ~S:~% ~A │ │ │ │ Skip this ~A hook. │ │ │ │ finalizer │ │ │ │ Exit Lock │ │ │ │ Allocator │ │ │ │ Make-Thread Lock │ │ │ │ @@ -24022,49 +24023,45 @@ │ │ │ │ ARG-NAMES( │ │ │ │ ARG-NAMES( │ │ │ │ ARG-NAMES( │ │ │ │ convert to simpler equality predicate │ │ │ │ avoid runtime dispatch on array element type │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -convert to inline logical operations │ │ │ │ bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ +convert to inline logical operations │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ automatically generated writer method │ │ │ │ automatically-generated reader method │ │ │ │ automatically-generated boundp method │ │ │ │ automatically-generated writer method │ │ │ │ Cannot unbind slot ~S in structure ~S │ │ │ │ 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 │ │ │ │ +SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ REST-ARG │ │ │ │ Construct and return a list containing the objects ARGS. │ │ │ │ -SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ -SYS:SRC;CODE;LIST.LISP │ │ │ │ -SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ the form currently being evaluated │ │ │ │ -function name │ │ │ │ -cannot define a compiler-macro for a special operator: ~S │ │ │ │ -COND clause is not a ~S: ~S │ │ │ │ -Ignoring legacy attribute UNSAFE. Replaced by its inverse: DX-SAFE. │ │ │ │ -function cannot have both good and bad attributes: ~S │ │ │ │ Wrong number of subscripts, ~W, for array of rank ~W. │ │ │ │ Wrong number of subscripts, ~W, for array of rank 1. │ │ │ │ ~@<~A~@:_ ~A~:> │ │ │ │ illegal function call │ │ │ │ shouldn't happen! (no-cmacro) │ │ │ │ ~@ │ │ │ │ note: ~A │ │ │ │ Calling an ignored function: ~S │ │ │ │ reading an ignored variable: ~S │ │ │ │ Error during compiler-macroexpansion │ │ │ │ ~@<~A of ~S. Use ~S to intercept. │ │ │ │ during macroexpansion │ │ │ │ No restart ~S is active~@[ for ~S~]. │ │ │ │ +SYS:SRC;CODE;LIST.LISP │ │ │ │ +SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ REST-ARG │ │ │ │ BIT-VECTOR │ │ │ │ COMMON-LISPH │ │ │ │ END-WORD) │ │ │ │ N-BITS-REMAINING1 │ │ │ │ N-BUCKETS( │ │ │ │ HASH-FUN-STATE │ │ │ │ @@ -24106,24 +24103,28 @@ │ │ │ │ A-KEY-ADDRESS │ │ │ │ COMMON-LISP0 │ │ │ │ CHANGED-BITS │ │ │ │ KEY-INDEX │ │ │ │ HASH-FUN0 │ │ │ │ HASH-FUN-STATE9 │ │ │ │ REST-ARG │ │ │ │ +function name │ │ │ │ +cannot define a compiler-macro for a special operator: ~S │ │ │ │ +COND clause is not a ~S: ~S │ │ │ │ +Ignoring legacy attribute UNSAFE. Replaced by its inverse: DX-SAFE. │ │ │ │ +function cannot have both good and bad attributes: ~S │ │ │ │ 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. │ │ │ │ Return a list with SE1 as the CAR and SE2 as the CDR. │ │ │ │ `$]$($0'g │ │ │ │ $9$0$`$= │ │ │ │ BIT-ARRAY │ │ │ │ NEW-VALUE │ │ │ │ MORE-ARG │ │ │ │ -SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ complex single float realpart │ │ │ │ complex double float realpart │ │ │ │ High bound is not * or a single-float or list of one single-float: ~S │ │ │ │ Low bound is not * or a single-float or list of one single-float: ~S │ │ │ │ High bound is not * or a double-float or list of one double-float: ~S │ │ │ │ Low bound is not * or a double-float or list of one double-float: ~S │ │ │ │ ?SBNn~f@ │ │ │ │ @@ -24167,27 +24168,27 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +~&~@ │ │ │ │ +A nested error within --disable-debugger error handling prevents printing the backtrace. Sorry, exiting. │ │ │ │ +A nested error within --disable-debugger error handling prevents displaying the original error. Attempting to print a backtrace. │ │ │ │ +unhandled condition in --disable-debugger mode, quitting │ │ │ │ +~&Unhandled ~S~@[ in thread ~S~]: │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -~&~@ │ │ │ │ -A nested error within --disable-debugger error handling prevents printing the backtrace. Sorry, exiting. │ │ │ │ -A nested error within --disable-debugger error handling prevents displaying the original error. Attempting to print a backtrace. │ │ │ │ -unhandled condition in --disable-debugger mode, quitting │ │ │ │ -~&Unhandled ~S~@[ in thread ~S~]: │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -24211,23 +24212,23 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP │ │ │ │ SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ SB-PROFILE │ │ │ │ public: the interface to the profiler │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ VALUE(5G4 │ │ │ │ When invoked, this function will turn off both the SBCL debugger │ │ │ │ and LDB (the low-level debugger). See also ENABLE-DEBUGGER. │ │ │ │ Enable all the default signals that Lisp knows how to deal with. │ │ │ │ Returns a SAP corresponding to the foreign symbol. DATAP must be true if the │ │ │ │ symbol designates a variable. May enter the symbol into the linkage-table. │ │ │ │ HASH-TABLE │ │ │ │ @@ -24420,20 +24421,20 @@ │ │ │ │ next line. (See PPRINT-INDENT.) │ │ │ │ COMMON-LISP@ │ │ │ │ If the symbol globally names a special form, return T, otherwise NIL. │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -complex single float imagpart │ │ │ │ -complex double float imagpart │ │ │ │ no translator for primitive alien type ~// │ │ │ │ no definition for alien type ~// │ │ │ │ unknown alien type: ~// │ │ │ │ +REST-ARG │ │ │ │ +complex single float imagpart │ │ │ │ +complex double float imagpart │ │ │ │ inline complex single-float creation │ │ │ │ inline complex double-float creation │ │ │ │ inline float coercion │ │ │ │ REST-ARG │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ @@ -24448,26 +24449,26 @@ │ │ │ │ MORE-ARG │ │ │ │ Return the least of its arguments; among EQUALP least, return │ │ │ │ the first. │ │ │ │ UxeR|cL+cM │ │ │ │ Coerce the Object to an object of type Output-Type-Spec. │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -COMMON-LISP@ │ │ │ │ Backtrace for: ~S │ │ │ │ Skip printing frame ~S │ │ │ │ while printing frame ~S. The partial output is: ~S │ │ │ │ method ~S not defined for ~S │ │ │ │ bogus stack frame │ │ │ │ ~&Enter a form to be evaluated: │ │ │ │ Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ Set PC-OFFSET to zero and continue backtrace. │ │ │ │ ~@ │ │ │ │ +COMMON-LISP@ │ │ │ │ SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ SYS:SRC;CODE;CLASS.LISP │ │ │ │ !=ME&zZ< │ │ │ │ COMMON-LISP0 │ │ │ │ Return the 1st object in a list. │ │ │ │ ARG-COUNT │ │ │ │ N-TEMPLATE │ │ │ │ @@ -24601,15 +24602,14 @@ │ │ │ │ during the execution of some debug commands. When evaluating arbitrary │ │ │ │ expressions in the debugger, the normal values of the printer control │ │ │ │ variables are in effect. │ │ │ │ Initially empty, *DEBUG-PRINT-VARIABLE-ALIST* is typically used to │ │ │ │ provide bindings for printer control variables. │ │ │ │ SYS:SRC;PCL;WRAPPER.LISP │ │ │ │ SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ -INSTANCE0 │ │ │ │ Proceed anyway │ │ │ │ ~@ │ │ │ │ Constant modification: attempt to ~@?. │ │ │ │ Modify the constant. │ │ │ │ Can't ~@?. │ │ │ │ Nihil ex nihil. (can't ~@?) │ │ │ │ Veritas aeterna. (can't ~@?) │ │ │ │ @@ -24650,25 +24650,26 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ CONTEXT` │ │ │ │ there is no ~S component. │ │ │ │ as the argument to FUNCTION │ │ │ │ ~S is not a legal function name. │ │ │ │ inline ASH │ │ │ │ +WITH-PRETTY-STREAM │ │ │ │ Type of CHARACTERs that aren't BASE-CHARs. │ │ │ │ Type corresponding to the characters required by the standard. │ │ │ │ The pprint-dispatch-table that controls how to pretty-print objects. │ │ │ │ -WITH-PRETTY-STREAM │ │ │ │ No matching closing slash │ │ │ │ Too many #\@ characters supplied │ │ │ │ Too many colons supplied │ │ │ │ Parameters found after #\: or #\@ modifier │ │ │ │ String ended before directive was found │ │ │ │ no host specified │ │ │ │ ~S is not a valid logical namestring: │ │ │ │ @@ -24738,58 +24739,58 @@ │ │ │ │ lexically apparent function definition in the enclosing environment. │ │ │ │ ~W is too big for a fixnum. │ │ │ │ unknown SC to SC-CASE for ~S: │ │ │ │ immediate structure-object ~S │ │ │ │ /build/reproducible-path/buildapp-1.5.6/dumper.lisp │ │ │ │ SYS:SRC;COMPILER;RISCV;SUBPRIM.LISP │ │ │ │ SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ +Unexpected %MAKE-HAIRY-TYPE │ │ │ │ SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -Unexpected %MAKE-HAIRY-TYPE │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ COMMON-LISP0 │ │ │ │ Means the same as the cdr of a list. │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP( │ │ │ │ COMPONENT │ │ │ │ $}$($0 8 │ │ │ │ CONSTRAINTSH │ │ │ │ CONSTRAINTSH │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPERATOR0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPH │ │ │ │ MEMBER-TYPE SB-KERNEL@4g< │ │ │ │ -COMMON-LISP@*gd │ │ │ │ -$($0$8$H │ │ │ │ -COMMON-LISP0 │ │ │ │ MEMBER type contains ~S │ │ │ │ bad thing to be a type specifier: ~// │ │ │ │ fmt$~36R │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ +COMMON-LISP@*gd │ │ │ │ +$($0$8$H │ │ │ │ +COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ @@ -24879,32 +24880,23 @@ │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ Unnamed restart does not have a report function: ~S │ │ │ │ ill-formed restart binding: ~S │ │ │ │ ill-formed ~S clause, no lambda-list: │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ inline comparison │ │ │ │ inline (unsigned-byte 64) comparison │ │ │ │ inline (signed-byte 64) comparison │ │ │ │ inline fixnum comparison │ │ │ │ inline float comparison │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -Define a new type, with syntax like DEFMACRO. │ │ │ │ -Define a compiler-macro for NAME. │ │ │ │ -If the first argument is not true, the rest of the forms are │ │ │ │ -evaluated as a PROGN. │ │ │ │ -If the first argument is true, the rest of the forms are │ │ │ │ -evaluated as a PROGN. │ │ │ │ UNDERLYING-STREAM@)g< │ │ │ │ DIVISOR@ │ │ │ │ COMMON-LISPH │ │ │ │ Return second result of FLOOR. │ │ │ │ Return T if X is NIL, otherwise return NIL. │ │ │ │ COMMON-LISP0 │ │ │ │ Return the total number of elements in the Array. │ │ │ │ @@ -24912,62 +24904,75 @@ │ │ │ │ qTbjdp~9 │ │ │ │ A"aoNG.5 │ │ │ │ COMMON-LISPP │ │ │ │ MORE-ARG │ │ │ │ Calls the function associated with the given restart, passing any given │ │ │ │ arguments. If the argument restart is not a restart or a currently active │ │ │ │ non-nil restart name, then a CONTROL-ERROR is signalled. │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -The SATISFIES predicate name is not a symbol: ~S │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +Recursion limit reached while expanding local macro ~// │ │ │ │ bad modulus specified for MOD type specifier: ~// │ │ │ │ bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ -Recursion limit reached while expanding local macro ~// │ │ │ │ Recursive lock attempt ~S. │ │ │ │ odd number of args to ~A: ~S │ │ │ │ -forced to do runtime allocation of alien-value structure │ │ │ │ +The SATISFIES predicate name is not a symbol: ~S │ │ │ │ +Define a new type, with syntax like DEFMACRO. │ │ │ │ +Define a compiler-macro for NAME. │ │ │ │ +If the first argument is not true, the rest of the forms are │ │ │ │ +evaluated as a PROGN. │ │ │ │ +If the first argument is true, the rest of the forms are │ │ │ │ +evaluated as a PROGN. │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ The name of the mutex. Setfable. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ REST-ARG │ │ │ │ +forced to do runtime allocation of alien-value structure │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SYS:SRC;CODE;SETF.LISP │ │ │ │ Package Table Lock │ │ │ │ Around spawn(). │ │ │ │ Lock for active processes. │ │ │ │ +IT%&|_();>~ │ │ │ │ +No corresponding close brace │ │ │ │ +Cannot finalize ~S. │ │ │ │ +undefined_alien_function │ │ │ │ +after-GC │ │ │ │ List of available buffers. │ │ │ │ The absolute pathname of the running SBCL core. │ │ │ │ The absolute pathname of the running SBCL runtime. │ │ │ │ Map from Lisp symbols to the alien callable functions they name. │ │ │ │ Default amount of seconds, if any, EXIT should wait for other │ │ │ │ threads to finish after terminating them. Default value is 60. NIL │ │ │ │ means to wait indefinitely. │ │ │ │ CONTEXTP │ │ │ │ fold identity operations │ │ │ │ convert (* x 0) to 0 │ │ │ │ -IT%&|_();>~ │ │ │ │ -No corresponding close brace │ │ │ │ -Cannot finalize ~S. │ │ │ │ -undefined_alien_function │ │ │ │ -after-GC │ │ │ │ +SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ +associate */(* /) of constants │ │ │ │ +COMMON-LISP │ │ │ │ +convert x*2^k to shift │ │ │ │ File descriptor must be opened either for input or output. │ │ │ │ Undefined external-format: ~S │ │ │ │ descriptor ~W │ │ │ │ ~&rehash: size=(~D -> ~D), ~D avg=~f │ │ │ │ The HOST argument doesn't match the pathname host: │ │ │ │ ~S and ~S. │ │ │ │ A LIST representing a pathname host is not supported in this implementation: │ │ │ │ @@ -24977,46 +24982,29 @@ │ │ │ │ illegal instruction at #X~X │ │ │ │ bus error at #X~X │ │ │ │ unknown rounding mode: ~S │ │ │ │ Invalid function name: ~S │ │ │ │ no non-whitespace characters in string ~S. │ │ │ │ no digits in string ~S │ │ │ │ junk in string ~S │ │ │ │ -SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ -SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ -associate */(* /) of constants │ │ │ │ CONDITION │ │ │ │ COMMON-LISP@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ Transfer control to a restart named CONTINUE, or return NIL if none exists. │ │ │ │ FUNCTION │ │ │ │ COMMON-LISPH │ │ │ │ MORE-ARG │ │ │ │ Call FUNCTION with the given ARGUMENTS. │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -Transfer control to a restart named MUFFLE-WARNING, signalling a │ │ │ │ - CONTROL-ERROR if none exists. │ │ │ │ +SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ SYS:SRC;CODE;FILESYS.LISP │ │ │ │ -ill-formed handler binding: ~S │ │ │ │ What case should the printer should use default? │ │ │ │ List of process structures for all active processes. │ │ │ │ -The elements of SEQUENCE are compared pairwise, and if any two match, │ │ │ │ - the one occurring earlier is discarded, unless FROM-END is true, in │ │ │ │ - which case the one later in the sequence is discarded. The resulting │ │ │ │ - sequence is returned. │ │ │ │ - The :TEST-NOT argument is deprecated. │ │ │ │ -CLOSURE SB-KERNEL │ │ │ │ -PERMIT-COPY │ │ │ │ -SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ -k!w#[&_' │ │ │ │ Can't find ~S │ │ │ │ Can't open ~S for output: is a directory │ │ │ │ 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. │ │ │ │ Return T │ │ │ │ @@ -25032,29 +25020,38 @@ │ │ │ │ invalid option: ~S │ │ │ │ couldn't duplicate file descriptor: ~A │ │ │ │ Direction must be either :INPUT or :OUTPUT, not ~S. │ │ │ │ couldn't create pipe: ~A │ │ │ │ ~s error processing ~s argument: │ │ │ │ Error using ~s for program input: │ │ │ │ couldn't SB-UNIX:UNIX-DUP ~W: ~A │ │ │ │ +ill-formed handler binding: ~S │ │ │ │ +SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ +k!w#[&_' │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +Transfer control to a restart named MUFFLE-WARNING, signalling a │ │ │ │ + CONTROL-ERROR if none exists. │ │ │ │ +The elements of SEQUENCE are compared pairwise, and if any two match, │ │ │ │ + the one occurring earlier is discarded, unless FROM-END is true, in │ │ │ │ + which case the one later in the sequence is discarded. The resulting │ │ │ │ + sequence is returned. │ │ │ │ + The :TEST-NOT argument is deprecated. │ │ │ │ +CLOSURE SB-KERNEL │ │ │ │ +PERMIT-COPY │ │ │ │ INPUT-TYPES@ │ │ │ │ REST-ARG │ │ │ │ How many elements at any level should be printed before abbreviating │ │ │ │ with "..."? │ │ │ │ How many levels should be printed before abbreviating with "#"? │ │ │ │ NEW-VALUEH │ │ │ │ COMMON-LISPP │ │ │ │ Set SYMBOL's value cell to NEW-VALUE. │ │ │ │ -COMMON-LISP │ │ │ │ -convert x*2^k to shift │ │ │ │ optimize multiplication by one │ │ │ │ -jq0htX0t │ │ │ │ -DEFAULTH │ │ │ │ - KV-VECTOR8 │ │ │ │ -TABLE0 g@)d$ │ │ │ │ Cache of existing lisp wrappers, indexed with SPECIFER. Used for memoization: │ │ │ │ we don't create new wrappers if one for the same specifier already exists. │ │ │ │ Maps SAPs to corresponding CALLBACK-INFO structures: contains all the │ │ │ │ information we need to manipulate callbacks after their creation. Used for │ │ │ │ changing the lisp-side function they point to, invalidation, etc. │ │ │ │ shared object list lock │ │ │ │ Cache of existing callback SAPs, indexed with (SPECIFER . FUNCTION). Used for │ │ │ │ @@ -25083,35 +25080,39 @@ │ │ │ │ optimization that doesn't introduce any new code. A finite limit is │ │ │ │ necessary, since type inference may take arbitrarily long to converge. │ │ │ │ control analysis deleted dead block │ │ │ │ Copy propagation deleted a move. │ │ │ │ hit *MAX-OPTIMIZE-ITERATIONS* limit │ │ │ │ If true, processing of the VALUES declaration is inhibited. │ │ │ │ default input stream │ │ │ │ +jq0htX0t │ │ │ │ +DEFAULTH │ │ │ │ + KV-VECTOR8 │ │ │ │ +TABLE0 g@)d$ │ │ │ │ EMPTY-KV-INDEX= │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPP │ │ │ │ KV-VECTOR0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP@ │ │ │ │ KV-VECTOR0 │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -SYS:SRC;CODE;COERCE.LISP │ │ │ │ Changing meta-class of ~S from ~S to ~S. │ │ │ │ ~S can't be coerced to a function. │ │ │ │ The length requested (~S) does not match the type restriction in ~S. │ │ │ │ weird type in S-T-L-M-ERROR │ │ │ │ ~S is too hairy for sequence functions. │ │ │ │ ~S is not defined for ~S │ │ │ │ ~S is not the name of a defined VOP. │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +SYS:SRC;CODE;COERCE.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 │ │ │ │ @@ -25312,36 +25313,35 @@ │ │ │ │ duplicate slot name ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ slot name of ~S indicates possible syntax error in DEFSTRUCT │ │ │ │ slot name of ~S indicates probable syntax error in DEFSTRUCT │ │ │ │ in DEFSTRUCT, ~S is not a legal slot description. │ │ │ │ The type of the slot ~s is the empty type NIL │ │ │ │ +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. │ │ │ │ +COMMON-P( │ │ │ │ +Incompatible array element types: ~a and ~a │ │ │ │ +The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ The ANSI Standard │ │ │ │ writeup for Issue ~A │ │ │ │ System Class ~S │ │ │ │ Glossary entry for ~S │ │ │ │ Section ~{~D~^.~} │ │ │ │ Macro ~S │ │ │ │ Special Operator ~S │ │ │ │ Function ~S │ │ │ │ The SBCL Manual │ │ │ │ Variable ~S │ │ │ │ Initialization of ~:(~A~) Metaobjects │ │ │ │ Generic Function ~S │ │ │ │ -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. │ │ │ │ -COMMON-P( │ │ │ │ -Incompatible array element types: ~a and ~a │ │ │ │ -The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ -SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ incompatibly redefining slots of structure class ~S │ │ │ │ Make sure any uses of affected accessors are recompiled: │ │ │ │ ~@[ These slots were moved to new positions: │ │ │ │ ~]~@[ These slots have new incompatible types: │ │ │ │ ~]~@[ These slots were deleted: │ │ │ │ NOT VALUES too confusing on ~S │ │ │ │ Off-heap MEMBER type member @ ~X │ │ │ │ @@ -25371,14 +25371,15 @@ │ │ │ │ Invalid syntax in DEFSTRUCT option ~S │ │ │ │ DEFSTRUCT option ~S ~[requires at least~;requires exactly~;accepts at most~] one argument │ │ │ │ More than one ~S option is not allowed │ │ │ │ The current │ │ │ │ the most recently loaded │ │ │ │ ~@ │ │ │ │ The most recently compiled │ │ │ │ +SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ malformed :INITIAL-CONTENTS: ~S should have dimensions ~S │ │ │ │ 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. │ │ │ │ slot name ~S not present in included structure │ │ │ │ @@ -25405,28 +25406,28 @@ │ │ │ │ bad dimension in array type: ~S │ │ │ │ array type with too many dimensions: ~S │ │ │ │ Array dimensions is not a list, integer or *: │ │ │ │ Arrays can't have a negative number of dimensions: ~S │ │ │ │ Invalid :TYPE for slot ~S in ~S ~S: ~A. │ │ │ │ There is no slot named ~S in ~S. │ │ │ │ type intersection │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ NCLOSURE │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ DEFAULTED-END- │ │ │ │ CUMULATIVE-OFFSET- │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ Supply a new value for ~S. │ │ │ │ ~S has an odd number of items in its property list. │ │ │ │ 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 │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ ~S was previously defined as a macro. │ │ │ │ proclaiming ~S as a function │ │ │ │ SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ uninterned │ │ │ │ * is not permitted as a type specifier │ │ │ │ bad float format: ~S │ │ │ │ bad float arg │ │ │ │ @@ -25451,33 +25452,26 @@ │ │ │ │ layout depth conflict: ~S │ │ │ │ ~@ │ │ │ │ Retry assertion │ │ │ │ with new value~P for ~{~S~^, ~}. │ │ │ │ Too many parameters, expected no more than ~W │ │ │ │ Unreachable ~S │ │ │ │ -SYS:SRC;COMPILER;MAIN.LISP │ │ │ │ Return a copy of SEQUENCE with elements satisfying the test (default is │ │ │ │ EQL) with ITEM removed. │ │ │ │ COMPLAINTH │ │ │ │ REST-ARG │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +SYS:SRC;COMPILER;MAIN.LISP │ │ │ │ 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 ~~<...~~> │ │ │ │ @ modifier not allowed in close directive of justification block (i.e. ~~<...~~@>. │ │ │ │ ~D illegal directive~:P found inside justification block │ │ │ │ while processing indirect format string: │ │ │ │ @@ -25485,14 +25479,21 @@ │ │ │ │ No previous argument │ │ │ │ ~S is not of type INTEGER. │ │ │ │ Can only specify one section │ │ │ │ Must specify exactly two sections │ │ │ │ No corresponding open bracket │ │ │ │ Attempt to use ~~:^ outside a ~~:{...~~} construct │ │ │ │ No corresponding open brace │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ @@ -25718,51 +25719,51 @@ │ │ │ │ Shared between all threads, unless locally bound. EXPERIMENTAL. │ │ │ │ The value of LONG-SITE-NAME. │ │ │ │ Either NIL, or a designator for a function callable without any │ │ │ │ arguments. Called when the system has been waiting for input for │ │ │ │ longer then *PERIODIC-POLLING-PERIOD* seconds. Shared between all │ │ │ │ threads, unless locally bound. EXPERIMENTAL. │ │ │ │ The value of SHORT-SITE-NAME. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ Malformed ~~/ directive │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ of the directory segment ~S. │ │ │ │ user homedir not known~@[ for ~S~]: ~A │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ 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 │ │ │ │ N-POLICY │ │ │ │ -The block name ~S is not a symbol. │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ @)hAAjT: │ │ │ │ $8$H$p$= │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ SYS:SRC;CODE;EARLY-FULL-EVAL.LISP │ │ │ │ -bounding index designator │ │ │ │ -SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ -info hashtable │ │ │ │ }vBxK%o, │ │ │ │ CONTEXTp │ │ │ │ COMMON-LISP │ │ │ │ CONDITION │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPH │ │ │ │ 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. │ │ │ │ $p$0$8$@$( │ │ │ │ NAMESPACE │ │ │ │ REPLACEMENTS │ │ │ │ SOFTWARE │ │ │ │ EXTERNAL-FORMAT │ │ │ │ +bounding index designator │ │ │ │ +SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ +info hashtable │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ +The block name ~S is not a symbol. │ │ │ │ Convert ALIEN to an Alien of the specified TYPE (not evaluated.) Both types │ │ │ │ must be Alien array, pointer or function types. │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ ~W :START c~W │ │ │ │ ~W :TAIL │ │ │ │ ~W :HEAD │ │ │ │ ~@ │ │ │ │ @@ -25897,19 +25898,19 @@ │ │ │ │ ERROR-CODE` │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ Cause a continuable error. ERROR-CODE is the error to cause. │ │ │ │ SB-IMPL1&'@+ │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP0 │ │ │ │ -REST-ARG │ │ │ │ -LISTS("g< │ │ │ │ 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 │ │ │ │ +REST-ARG │ │ │ │ +LISTS("g< │ │ │ │ Evaluate FORM and return the Nth value (zero based) │ │ │ │ without consing a temporary list of values. │ │ │ │ SYS:SRC;COMPILER;IR2TRAN.LISP │ │ │ │ COMMON-LISP0 │ │ │ │ $($0$8%g0 │ │ │ │ COMMON-LISP │ │ │ │ INDICATOR │ │ │ │ @@ -25923,19 +25924,14 @@ │ │ │ │ shouldn't happen? │ │ │ │ unknown bound type in MAKE-INTERVAL │ │ │ │ dv2[>GzHv │ │ │ │ Xl-'pQTI │ │ │ │ $}$($0 8 │ │ │ │ COMMON-LISP( │ │ │ │ OPTIONAL-ARGS │ │ │ │ - argument to │ │ │ │ -, ~S, is not a │ │ │ │ -DECLAIM where DECLARE was probably intended │ │ │ │ -Duplicate doc string ~S │ │ │ │ -variable ~S occurs more than once │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ $H$0$8$( │ │ │ │ INDEX-VAR │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ @@ -25947,14 +25943,15 @@ │ │ │ │ values from the first VALUES-FORM making up the first argument, etc. │ │ │ │ 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. │ │ │ │ Vars is not a list of symbols: ~S │ │ │ │ unrecognized instance type in ~S │ │ │ │ +~@ │ │ │ │ bL-*`o:0L │ │ │ │ 5@@\tT96 │ │ │ │ $($0$8$@$H │ │ │ │ ACCESSOR-NAME8 │ │ │ │ DEFAULTH │ │ │ │ COMMON-LISP0 │ │ │ │ Return the length of LIST, or NIL if LIST is circular. │ │ │ │ @@ -25970,15 +25967,14 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -~@ │ │ │ │ a subclass of the class METHOD │ │ │ │ not supplied │ │ │ │ a method combination object │ │ │ │ when initializing the generic function ~S: │ │ │ │ The ~S initialization argument was: ~A. │ │ │ │ It must be ~A. │ │ │ │ ~S structure class ~A │ │ │ │ @@ -25998,16 +25994,14 @@ │ │ │ │ has an invalid qualifier │ │ │ │ ~@ │ │ │ │ has too many qualifiers │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ 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: │ │ │ │ @@ -26050,40 +26044,42 @@ │ │ │ │ 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. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ :GENERIC-FUNCTION-CLASS argument │ │ │ │ :METHOD-CLASS argument │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ No applicable method found for ~S │ │ │ │ No primary method found for ~S among applicable methods: ~S │ │ │ │ +has no qualifiers │ │ │ │ +~@ │ │ │ │ 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 │ │ │ │ (SETF (DOCUMENTATION FUNC T) STRING) │ │ │ │ sets the documentation string stored in the function object. │ │ │ │ (DOCUMENTATION NAME 'FUNCTION) │ │ │ │ returns the documentation stored under the function name if any, and │ │ │ │ falls back on the documentation in the function object if necessary. │ │ │ │ -has no qualifiers │ │ │ │ -~@ │ │ │ │ Ignoring doc-type ~a for ~a. │ │ │ │ unsupported DOCUMENTATION: doc-type ~S for object of type ~S │ │ │ │ discarding unsupported DOCUMENTATION: doc-type ~S for object of type ~S │ │ │ │ #X~X..~X[~W]~:[ (#X~X)~;~*~]~@[ in ~S~] │ │ │ │ ~S~:[~;~:*~S~] │ │ │ │ ~S at ~S │ │ │ │ ~S~:[~;, interrupted~] │ │ │ │ @@ -26163,14 +26159,20 @@ │ │ │ │ Return destructively modified SEQUENCE or a freshly allocated │ │ │ │ sequence of the same class as SEQUENCE of length LENGTH. Elements │ │ │ │ of the returned sequence are initialized to INITIAL-ELEMENT, if │ │ │ │ supplied, initialized to INITIAL-CONTENTS if supplied, or identical │ │ │ │ to the elements of SEQUENCE if neither is supplied. Signals a │ │ │ │ PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not │ │ │ │ implemented for the class of SEQUENCE. │ │ │ │ +, depth │ │ │ │ +expected-type: │ │ │ │ +~@ │ │ │ │ +See also: │ │ │ │ +supplied both ~S and ~S to ~S │ │ │ │ +length mismatch in ~S │ │ │ │ Returns a sequence iterator for SEQUENCE or, if START and/or END │ │ │ │ are supplied, the subsequence bounded by START and END as nine │ │ │ │ values: │ │ │ │ 1. iterator state │ │ │ │ 2. limit │ │ │ │ 3. from-end │ │ │ │ 4. step function │ │ │ │ @@ -26180,20 +26182,14 @@ │ │ │ │ 8. index function │ │ │ │ 9. copy state function │ │ │ │ If FROM-END is NIL, the constructed iterator visits the specified │ │ │ │ elements in the order in which they appear in SEQUENCE. Otherwise, │ │ │ │ the elements are visited in the opposite order. │ │ │ │ Moves ITERATOR one position forward or backward in SEQUENCE │ │ │ │ depending on the iteration direction encoded in FROM-END. │ │ │ │ -, depth │ │ │ │ -expected-type: │ │ │ │ -~@ │ │ │ │ -See also: │ │ │ │ -supplied both ~S and ~S to ~S │ │ │ │ -length mismatch in ~S │ │ │ │ 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. │ │ │ │ Destructively modifies SEQUENCE by replacing the sequence element │ │ │ │ associated to position of ITERATOR with NEW-VALUE. │ │ │ │ @@ -26283,27 +26279,28 @@ │ │ │ │ RESTART-FRAME │ │ │ │ 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.) │ │ │ │ +LEXICAL-DEF │ │ │ │ +FUNCTIONAL-KIND-EQ │ │ │ │ SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ Simple equality transform │ │ │ │ 8(ZKXj u │ │ │ │ EXPR( g0 │ │ │ │ COMMON-LISPP │ │ │ │ N-RESULTP │ │ │ │ -SB-IMPL( │ │ │ │ (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. │ │ │ │ )[L?&4D^UzY │ │ │ │ (RESTART-BIND ({(case-name function {keyword value}*)}*) forms) │ │ │ │ @@ -26314,44 +26311,44 @@ │ │ │ │ (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. │ │ │ │ -LEXICAL-DEF │ │ │ │ -FUNCTIONAL-KIND-EQ │ │ │ │ ~S doesn't have a precise float representation. │ │ │ │ The RATIONAL value isn't known at compile time. │ │ │ │ The operands might not be the same type. │ │ │ │ environment argument present and not null │ │ │ │ can't open-code test of non-constant type │ │ │ │ -ALIEN-TYPE │ │ │ │ -SB-ALIEN-INTERNALS` │ │ │ │ -PREDICATE-NAMEP │ │ │ │ +attempt to GO to nonexistent tag: ~S │ │ │ │ +unknown alignment: ~S │ │ │ │ +unknown size: ~S │ │ │ │ +Continue, clobbering the old definition. │ │ │ │ +Incompatible alien record type definition~%Old: ~S~%New: ~S │ │ │ │ +~S is being set even though it was declared to be ignored. │ │ │ │ +~S is a constant and thus can't be set. │ │ │ │ ~S is already a predecessor of ~S. │ │ │ │ ~S already has successors. │ │ │ │ ~S has already ended. │ │ │ │ found macro name ~S ~A │ │ │ │ The ~(~S~) name ~S was found ~A. │ │ │ │ ~(~a~) ~s where a function is expected │ │ │ │ ~@<~S is not a proper list.~@:> │ │ │ │ confused about home lambda for ~S │ │ │ │ ~&quitting because IR1-TRANSFORM result was NIL │ │ │ │ ~&trying transform ~s for ~s │ │ │ │ The return value of ~A should not be discarded. │ │ │ │ ~&xform (~a) ~S │ │ │ │ + argument to │ │ │ │ +, ~S, is not a │ │ │ │ +DECLAIM where DECLARE was probably intended │ │ │ │ +Duplicate doc string ~S │ │ │ │ +variable ~S occurs more than once │ │ │ │ ~S is not a defined template. │ │ │ │ -attempt to GO to nonexistent tag: ~S │ │ │ │ -unknown alignment: ~S │ │ │ │ -unknown size: ~S │ │ │ │ -Continue, clobbering the old definition. │ │ │ │ -Incompatible alien record type definition~%Old: ~S~%New: ~S │ │ │ │ -~S is being set even though it was declared to be ignored. │ │ │ │ -~S is a constant and thus can't be set. │ │ │ │ Return five values needed by the SETF machinery: a list of temporary │ │ │ │ variables, a list of values with which to fill them, a list of temporaries │ │ │ │ for the new values, the setting function, and the accessing function. │ │ │ │ Construct and return a list by concatenating LISTS. │ │ │ │ COMMON-LISP │ │ │ │ Return CHAR converted to upper-case if that is possible. Don't convert │ │ │ │ lowercase eszet (U+DF). │ │ │ │ @@ -26386,45 +26383,42 @@ │ │ │ │ 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. │ │ │ │ ENVIRONMENT │ │ │ │ FORM SB-KERNEL │ │ │ │ +SB-IMPL( │ │ │ │ +ALIEN-TYPE │ │ │ │ +SB-ALIEN-INTERNALS` │ │ │ │ +PREDICATE-NAMEP │ │ │ │ optimize away %SAP-ALIEN │ │ │ │ STORE-VARS │ │ │ │ COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +MORE-ARG │ │ │ │ +Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ N"R@SdXzX │ │ │ │ +MORE-ARG │ │ │ │ +Initiate a garbage collection. │ │ │ │ +The default is to initiate a nursery collection, which may in turn │ │ │ │ +trigger a collection of one or more older generations as well. If FULL │ │ │ │ +is true, all generations are collected. If GEN is provided, it can be │ │ │ │ +used to specify the oldest generation guaranteed to be collected. │ │ │ │ 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. │ │ │ │ -CLEANUP-FUN-2 │ │ │ │ -CLEANUP-FUN-41 │ │ │ │ -CLEANUP-FUN-31 │ │ │ │ -CLEANUP-FUN-16 │ │ │ │ -CLEANUP-FUN-10 │ │ │ │ -CLEANUP-FUN-1 │ │ │ │ More subscripts for ~a (~a) than ~a (~a) │ │ │ │ -malformed arguments description │ │ │ │ -COMMON-LISP │ │ │ │ -MORE-ARG │ │ │ │ -Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ -MORE-ARG │ │ │ │ -Initiate a garbage collection. │ │ │ │ -The default is to initiate a nursery collection, which may in turn │ │ │ │ -trigger a collection of one or more older generations as well. If FULL │ │ │ │ -is true, all generations are collected. If GEN is provided, it can be │ │ │ │ -used to specify the oldest generation guaranteed to be collected. │ │ │ │ Arrange for the designated FUNCTION to be called when there │ │ │ │ are no more references to OBJECT, including references in │ │ │ │ FUNCTION itself. │ │ │ │ If DONT-SAVE is true, the finalizer will be cancelled when │ │ │ │ SAVE-LISP-AND-DIE is called: this is useful for finalizers │ │ │ │ deallocating system memory, which might otherwise be called │ │ │ │ with addresses from the old image. │ │ │ │ @@ -26621,26 +26615,24 @@ │ │ │ │ Short version: be careful out there. │ │ │ │ Return the value of the C library pseudo-variable named "errno". │ │ │ │ ARGUMENT │ │ │ │ Convert a command-line argument to a keyword symbol. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ DISPATCH-ENTRY │ │ │ │ -Should not happen │ │ │ │ -finite-base-string-out-misc needs an implementation │ │ │ │ MORE-ARG │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP@ │ │ │ │ Return a new sequence containing the same elements but in reverse order. │ │ │ │ -Return a random string with LENGTH characters. │ │ │ │ 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. │ │ │ │ Attempts to force any buffered output to be sent. Implements │ │ │ │ FORCE-OUTPUT. The default method does nothing. │ │ │ │ +Return a random string with LENGTH characters. │ │ │ │ {FD@=;753 │ │ │ │ Makes a new pathname from the component arguments. Note that host is │ │ │ │ a host-structure or string. │ │ │ │ Return a stream which reads from or writes to FILENAME. │ │ │ │ Defined keywords: │ │ │ │ :DIRECTION - one of :INPUT, :OUTPUT, :IO, or :PROBE │ │ │ │ :ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR │ │ │ │ @@ -26658,26 +26650,34 @@ │ │ │ │ space to the specified STREAM. │ │ │ │ Construct the full native (name)string form of PATHNAME. For │ │ │ │ file systems whose native conventions allow directories to be │ │ │ │ indicated as files, if AS-FILE is true and the name, type, and │ │ │ │ version components of PATHNAME are all NIL or :UNSPECIFIC, │ │ │ │ construct a string that names the directory according to the file │ │ │ │ system's syntax for files. │ │ │ │ +CLEANUP-FUN-2 │ │ │ │ +CLEANUP-FUN-41 │ │ │ │ +CLEANUP-FUN-31 │ │ │ │ +CLEANUP-FUN-16 │ │ │ │ +CLEANUP-FUN-10 │ │ │ │ +CLEANUP-FUN-1 │ │ │ │ Destructively sort SEQUENCE. PREDICATE should return non-NIL if │ │ │ │ ARG1 is to precede ARG2. │ │ │ │ OPTIONAL-ARGS │ │ │ │ SB-ALIEN8 │ │ │ │ PROCESS( │ │ │ │ CHECK-FOR-STOPPED │ │ │ │ PROCESS@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ Wait for PROCESS to quit running for some reason. When │ │ │ │ CHECK-FOR-STOPPED is T, also returns when PROCESS is stopped. Returns │ │ │ │ PROCESS. │ │ │ │ Removes HANDLER from the list of active handlers. │ │ │ │ +Should not happen │ │ │ │ +finite-base-string-out-misc needs an implementation │ │ │ │ COMMON-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. │ │ │ │ SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ COMMON-LISP` │ │ │ │ @@ -26687,31 +26687,32 @@ │ │ │ │ ALIEN-TYPE │ │ │ │ SB-ALIEN-INTERNALS8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP │ │ │ │ BOUND-FORMAT8 │ │ │ │ COMMON-LISP │ │ │ │ Return a copy of sequence with elements not satisfying PREDICATE removed. │ │ │ │ +malformed arguments description │ │ │ │ Breakpoints don't work on RISC-V │ │ │ │ ARG-~V,'0D │ │ │ │ ; Using form offset instead of character position. │ │ │ │ ; File has been modified since compilation: │ │ │ │ foreign function: #x~X │ │ │ │ foreign function: │ │ │ │ ??? Can't get name of debug-block's function. │ │ │ │ Source path no longer exists. │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;COMPILER;RISCV;ARITH.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;FLOAT.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +SYS:SRC;COMPILER;RISCV;ARITH.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;FLOAT.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -26744,17 +26745,22 @@ │ │ │ │ ~&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. │ │ │ │ can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ bogus argument style ~S in ~S │ │ │ │ +cannot make an alien of type ~S out of a SAP │ │ │ │ +unknown size for alien type ~S │ │ │ │ 1.0.53.11 │ │ │ │ 1.0.29.17 │ │ │ │ -cannot make an alien of type ~S out of a SAP │ │ │ │ +1.0.37.33 │ │ │ │ +The alignment of ~S is unknown. │ │ │ │ +The size of ~S is unknown. │ │ │ │ +cannot override the size of zero-dimensional arrays │ │ │ │ The element value ~S is used more than once. │ │ │ │ The enumeration element ~S is used more than once. │ │ │ │ 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. │ │ │ │ ~S is unsupported as of SBCL 0.8.13. See LOAD-SHARED-OBJECT. │ │ │ │ @@ -26772,24 +26778,17 @@ │ │ │ │ pthread_kill() failed │ │ │ │ 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 size for alien type ~S │ │ │ │ -The alignment of ~S is unknown. │ │ │ │ -The size of ~S is unknown. │ │ │ │ -cannot override the size of zero-dimensional arrays │ │ │ │ ~S is not a valid L-value. │ │ │ │ Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ Unknown barrier kind ~S │ │ │ │ -1.0.37.33 │ │ │ │ -SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ -SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ Argument passed to ~S, ~S, is an improper list. │ │ │ │ Invalid fill-pointer ~a │ │ │ │ INSTEAD not empty in INPUT-WRAPPER for ~S │ │ │ │ Parameters ~S and ~S must be disjoint but have common elements │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ Replacement byte, bytes, character, or string (evaluated): │ │ │ │ @@ -26800,14 +26799,16 @@ │ │ │ │ bad fallthrough in floating point reader │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ failed Unix fstat(2) on ~S │ │ │ │ ~S is not a stream associated with a file. │ │ │ │ +SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ +SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ no clauses in ~S │ │ │ │ Clause ~s is shadowed by ~s │ │ │ │ ~S is not a proper list │ │ │ │ ~@<~IBad ~S clause:~:@_ ~S~:@_~S allowed as the key designator only in the final otherwise-clause, not in a normal-clause. Use (~S) instead, or move the clause to the correct position.~:@> │ │ │ │ ~@<~IBad ~S clause:~:@_ ~S~:@_~S is allowed only in the final clause. Use T instead, or move the clause to the correct position.~:@> │ │ │ │ ~S -- bad clause in ~S │ │ │ │ Linkage-table full (~D entries): cannot link ~S. │ │ │ │ @@ -26884,23 +26885,23 @@ │ │ │ │ already nickname for ~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. │ │ │ │ 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ -SYS:SRC;CODE;MODULE.LISP │ │ │ │ ~S does not designate a package │ │ │ │ ~S does not designate a string │ │ │ │ Invalid use of ~S after ~S. │ │ │ │ Impossible case reached in PEEK-CHAR │ │ │ │ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ $$$$$$$ │ │ │ │ !"#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ logical host not yet defined: ~S │ │ │ │ +SYS:SRC;CODE;MODULE.LISP │ │ │ │ Expansion: │ │ │ │ ~A names a ~@[primitive~* ~]type-specifier: │ │ │ │ ~A was invoked with RECURSIVE-P being true outside ~ │ │ │ │ of a recursive read operation. │ │ │ │ 0123456789 │ │ │ │ Nothing appears after . in list. │ │ │ │ More than one object follows . in list. │ │ │ │ @@ -27003,14 +27004,15 @@ │ │ │ │ an alien variable │ │ │ │ an undefined variable │ │ │ │ ~S is neither a symbol nor a list of symbols. │ │ │ │ ~S is not a symbol. │ │ │ │ Slots with │ │ │ │ allocation: │ │ │ │ No slots. │ │ │ │ +STRING-DISPATCH-FUN │ │ │ │ ~@ │ │ │ │ double asterisk inside of logical ~ │ │ │ │ word: ~S │ │ │ │ couldn't read from ~S │ │ │ │ --script │ │ │ │ --sysinit │ │ │ │ --no-sysinit │ │ │ │ @@ -27033,15 +27035,14 @@ │ │ │ │ Ignore missing init file │ │ │ │ The specified ~A file ~A was not found. │ │ │ │ unexpected end of command line options │ │ │ │ Must label something more than just #~D# │ │ │ │ Multiply defined label: #~D= │ │ │ │ Missing label for #= │ │ │ │ Heap underflow │ │ │ │ -STRING-DISPATCH-FUN │ │ │ │ ~S ~[have~;has a~:;have~] bad file descriptor~:P. │ │ │ │ Go on, leaving handlers marked as bogus. │ │ │ │ Retry bogus handlers. │ │ │ │ Remove bogus handlers. │ │ │ │ a host name │ │ │ │ a directory name │ │ │ │ a file name │ │ │ │ @@ -27083,14 +27084,17 @@ │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ e"d" #!# │ │ │ │ TIOCPGRP ioctl failed: ~S │ │ │ │ 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 │ │ │ │ +SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ +SYS:SRC;CODE;SORT.LISP │ │ │ │ +SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ after REPL │ │ │ │ ~@ │ │ │ │ ~S is not positionable │ │ │ │ A numeric argument was ignored in #~W~A. │ │ │ │ %$%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" #!# │ │ │ │ @@ -27106,17 +27110,14 @@ │ │ │ │ failed to build float from ~a │ │ │ │ ~S cannot be represented relative to ~S. │ │ │ │ Bad fallthrough in ~S │ │ │ │ a user-defined │ │ │ │ ~A names ~A declaration. │ │ │ │ an SBCL-specific │ │ │ │ a standard │ │ │ │ -SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ -SYS:SRC;CODE;SORT.LISP │ │ │ │ -SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ The old value of ~S is ~S.~ │ │ │ │ ~%Do you want to supply a new value? │ │ │ │ ~&Type a form to be evaluated: │ │ │ │ #.(~S '~D :ELEMENT-TYPE ~S) │ │ │ │ inside extended token │ │ │ │ after escape character │ │ │ │ ~S is a bad type specifier for sequences. │ │ │ │ @@ -27192,14 +27193,15 @@ │ │ │ │ 0123456789 │ │ │ │ The object is a CONS. │ │ │ │ defining ~A as a type specifier │ │ │ │ illegal to redefine standard type: ~S │ │ │ │ The class ~S is being redefined to be a DEFTYPE. │ │ │ │ The loader tried loading the symbol named ~a into the package named ~a, but the package did not get defined, and does not exist. │ │ │ │ SYS:SRC;COMPILER;XREF.LISP │ │ │ │ +SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ from pinned object │ │ │ │ Path to │ │ │ │ Could not allocate ~D bytes for buffer. │ │ │ │ Supply a set of bytes to use in place of the invalid one. │ │ │ │ c%Q%W%]% │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ Invalid first argument to ~S: ~S │ │ │ │ @@ -27283,19 +27285,14 @@ │ │ │ │ strange FREE-VARS entry: ~S │ │ │ │ strange CONSTANTS entry: ~S │ │ │ │ strange FREE-FUNS entry: ~S │ │ │ │ Couldn't find REF? │ │ │ │ MORE-COST │ │ │ │ shouldn't happen! (defined-fun) │ │ │ │ Unknown vector type in IR2 conversion for ~S. │ │ │ │ -SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ -SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ -SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ -SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ -SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ unseen predecessor ~S in ~S │ │ │ │ bad predecessor link ~S in ~S │ │ │ │ The START of ~S has the wrong kind. │ │ │ │ Last node ~S of ~S has next ctran. │ │ │ │ PREV in ~S should be ~S. │ │ │ │ The interior ctran ~S in ~S has the wrong kind. │ │ │ │ BLOCK of ~S should be ~S. │ │ │ │ @@ -27313,14 +27310,19 @@ │ │ │ │ Duplicate definitions in ~S │ │ │ │ binding ~A as a local function │ │ │ │ The ~S definition spec ~S is malformed. │ │ │ │ ~&; compilation ~:[aborted after~;finished in~] ~A~& │ │ │ │ DEST-ENV │ │ │ │ Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ +SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ +SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ +SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ +SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ +SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ Can't preserve function source: ~A │ │ │ │ know how to dump │ │ │ │ Can't preserve function source - missing MAKE-LOAD-FORM methods? │ │ │ │ Unhandled functional-kind ~a │ │ │ │ deleting unused function~:[.~;~:*~% ~S~] │ │ │ │ ~<~@; ~S~:> │ │ │ │ Incompatible :initial-contents ~s for :element-type ~a. │ │ │ │ @@ -27392,52 +27394,14 @@ │ │ │ │ ~@<~S~[~; is a keyword and~; is not a symbol and~ │ │ │ │ ~] cannot be used as a ~A.~@:> │ │ │ │ deleting unreachable code │ │ │ │ attempt to dump invalid structure: │ │ │ │ How did this happen? │ │ │ │ ~:[A possible~;The~] binding of ~S │ │ │ │ N-SEQUENCE- │ │ │ │ -SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ -SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ -SYS:SRC;COMPILER;CONTROL.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. │ │ │ │ function called with ~R argument~:P, but wants exactly ~R │ │ │ │ info not constant; can't open code │ │ │ │ ~&~a derived to ~a │ │ │ │ ~S not found in REFS for ~S │ │ │ │ There should be at least ~W ~A in ~S, but there are only ~W. │ │ │ │ There should be ~W ~A in ~S, but are ~W. │ │ │ │ The target for ~S isn't in REFS for ~S. │ │ │ │ @@ -27479,14 +27443,53 @@ │ │ │ │ Bad fixup flavor ~s │ │ │ │ ~@ │ │ │ │ trampoline │ │ │ │ a hairy form │ │ │ │ deleted lambda ~S in Lambdas for ~S │ │ │ │ ~S form is too short: ~S │ │ │ │ multiple store variables for ~S │ │ │ │ +SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ +SYS:SRC;COMPILER;CONTROL.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. │ │ │ │ +SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ 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 │ │ │ │ The ~:R argument is not a constant. │ │ │ │ can't tell whether the ~:R argument is a constant ~S: │ │ │ │ The ~:R argument is not a constant ~S: │ │ │ │ @@ -27532,19 +27535,14 @@ │ │ │ │ can't determine sequence argument type │ │ │ │ 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. │ │ │ │ Bad fixup kind ~s │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ -ANSI-STREAM- │ │ │ │ --script │ │ │ │ compiled from ~S │ │ │ │ using ~A version ~A │ │ │ │ The default initial element ~S is not a ~S. │ │ │ │ ~S has ~S elements, vector length is ~S. │ │ │ │ ~S is an unknown type: ~S │ │ │ │ Invalid fill-pointer ~s for a vector of length ~s. │ │ │ │ @@ -27566,14 +27564,17 @@ │ │ │ │ Argument of type ~s cannot be used as a keyword. │ │ │ │ function called with odd number of arguments in keyword portion │ │ │ │ lambda ~@[~S ~]~:S │ │ │ │ optional-dispatch ~a ~S │ │ │ │ TL-XEP ~S │ │ │ │ IR1 block ~D~@[ start c~D~] │ │ │ │ Local alien info isn't constant? │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ +ANSI-STREAM- │ │ │ │ The function ~S called by ~S returns ~S but ~S is expected │ │ │ │ The function ~S is called by ~S with ~S but it accepts ~S. │ │ │ │ defining function ~S when ~S already has a SETF macro │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~&; compiling file ~S (written ~A): │ │ │ │ unknown phase in time specifier: ~S │ │ │ │ @@ -27707,14 +27708,15 @@ │ │ │ │ variable │ │ │ │ lambda list │ │ │ │ ~@ │ │ │ │ [Reoptimize Limit] │ │ │ │ Constraint │ │ │ │ SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;CALL.LISP │ │ │ │ ~:[u~;d~]v~D~@[ ~] │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~W more use~:P of undefined ~(~A~) ~S │ │ │ │ ~&compilation unit ~:[finished~;aborted~] │ │ │ │ ~& Undefined ~(~A~)~p: │ │ │ │ @@ -27794,52 +27796,57 @@ │ │ │ │ RETURN not at block end: ~S │ │ │ │ ~S is not in ENTRIES for its home LAMBDA. │ │ │ │ ~S is not the ENCLOSE for its FUN ~S. │ │ │ │ ~S has VALUE but no ENTRY. │ │ │ │ ~S is not in its ENTRY's EXITS. │ │ │ │ globally declaring ~A as a declaration proclamation │ │ │ │ the declaration to be recognized is not a symbol: │ │ │ │ -SYS:SRC;COMPILER;RISCV;CALL.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;PARMS.LISP │ │ │ │ -SYS:SRC;COMPILER;TN.LISP │ │ │ │ -redefining DEFTYPE type to be a class: ~// │ │ │ │ -Cannot redefine standard type ~//. │ │ │ │ -IR1-CONVERT- │ │ │ │ -a source transform │ │ │ │ Default expression ~S does not match ~S in ~S │ │ │ │ ~@ │ │ │ │ ~S has :MORE results with :TRANSLATE. │ │ │ │ ~&Before IR2-optimize: │ │ │ │ ~S was seen more than once. │ │ │ │ caught ~S: │ │ │ │ ~~@< ~~@;~~A~~:> │ │ │ │ +redefining DEFTYPE type to be a class: ~// │ │ │ │ +Cannot redefine standard type ~//. │ │ │ │ +IR1-CONVERT- │ │ │ │ +a source transform │ │ │ │ +SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;PARMS.LISP │ │ │ │ +SYS:SRC;COMPILER;TN.LISP │ │ │ │ +-OPTIMIZER │ │ │ │ Bad array dimensions: ~s │ │ │ │ ~&; Base: ~x Data: ~x │ │ │ │ Can't disassemble a special operator │ │ │ │ ; wrote ~A │ │ │ │ ~2&; wrote ~A │ │ │ │ globally declaring the FTYPE of ~A │ │ │ │ Cannot declare FTYPE of illegal function name ~S │ │ │ │ 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 │ │ │ │ __msan_unpoison │ │ │ │ bad EVAL-WHEN situation list: ~S │ │ │ │ --OPTIMIZER │ │ │ │ malformed SCs spec: ~S │ │ │ │ unknown kind ~S │ │ │ │ +Default number of frames to backtrace. Defaults to 1000. │ │ │ │ lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ note: ~3I~_ │ │ │ │ ~S is not a defined storage base. │ │ │ │ SC ~S has no :UNBOUNDED :SAVE-P NIL alternate SC. │ │ │ │ ~S is not a defined primitive type. │ │ │ │ defining ~S as a function │ │ │ │ Invalid designator for initial backtrace frame: ~S │ │ │ │ -Default number of frames to backtrace. Defaults to 1000. │ │ │ │ + [~{~(~A~)~^,~}] │ │ │ │ + source: ~S │ │ │ │ +SYS:SRC; │ │ │ │ +~& no source available for frame │ │ │ │ +~& error printing frame source: ~A │ │ │ │ +~& error finding frame source: ~A │ │ │ │ Determines how frames corresponding to method functions are represented in │ │ │ │ backtraces. Possible values are :MINIMAL, :NORMAL, and :FULL. │ │ │ │ :MINIMAL represents them as │ │ │ │ ( ...args...) │ │ │ │ if all arguments are available, and only a single method is applicable to │ │ │ │ the arguments -- otherwise behaves as :NORMAL. │ │ │ │ :NORMAL represents them as │ │ │ │ @@ -27878,27 +27885,21 @@ │ │ │ │ STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method │ │ │ │ which returns CHARACTER. │ │ │ │ This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given │ │ │ │ output STREAM. The default method does nothing. │ │ │ │ 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. │ │ │ │ - [~{~(~A~)~^,~}] │ │ │ │ - source: ~S │ │ │ │ -SYS:SRC; │ │ │ │ -~& no source available for frame │ │ │ │ -~& error printing frame source: ~A │ │ │ │ -~& error finding frame source: ~A │ │ │ │ -T case is not last in SC-CASE. │ │ │ │ -illegal SC-CASE clause: ~S │ │ │ │ -DEFSTRUCT: ~S is not a symbol. │ │ │ │ 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. │ │ │ │ +T case is not last in SC-CASE. │ │ │ │ +illegal SC-CASE clause: ~S │ │ │ │ +DEFSTRUCT: ~S is not a symbol. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ TYPE-SPEC@ │ │ │ │ CONDITION │ │ │ │ COMMON-LISPH │ │ │ │ @@ -27915,23 +27916,22 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ Return a copy of a subsequence of SEQUENCE starting with element number │ │ │ │ START and continuing to the end of SEQUENCE or the optional END. │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL8 │ │ │ │ REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -27940,71 +27940,72 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +COMMON-LISP │ │ │ │ CONDITION │ │ │ │ COMMON-LISP@ │ │ │ │ Transfers control to the STEP-CONTINUE restart associated with │ │ │ │ the condition, continuing execution without stepping. Signals a │ │ │ │ CONTROL-ERROR if the restart does not exist. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP@ │ │ │ │ Transfers control to the STEP-NEXT restart associated with the │ │ │ │ condition, executing the current form without stepping and continuing │ │ │ │ stepping with the next form. Signals CONTROL-ERROR if the restart does │ │ │ │ not exist. │ │ │ │ +This is T while in the debugger. │ │ │ │ +A function taking no parameters that starts the low-level debug loop. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP@ │ │ │ │ Transfers control to the STEP-INTO restart associated with the │ │ │ │ condition, stepping into the current form. Signals a CONTROL-ERROR if │ │ │ │ the restart does not exist. │ │ │ │ -This is T while in the debugger. │ │ │ │ -A function taking no parameters that starts the low-level debug loop. │ │ │ │ -inline (signed-byte 64) integer-length │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ This can't happen. │ │ │ │ invalid number of arguments │ │ │ │ invalid number of arguments: 0 │ │ │ │ invalid number of arguments: 1 │ │ │ │ invalid number of arguments: 2 │ │ │ │ Got to T branch in ~S │ │ │ │ Return from ~S. │ │ │ │ ~&Enter a form evaluating to a value of type ~a: │ │ │ │ ~s is not of type ~s │ │ │ │ ~&Your command, ~S, is ambiguous: │ │ │ │ ~&error flushed (because ~S is set) │ │ │ │ ~@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ Return the intersection of LIST1 and LIST2. │ │ │ │ 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. │ │ │ │ Make SYMBOL unbound, removing any value it may currently have. │ │ │ │ INSTANCE0 │ │ │ │ DIVISOR@ │ │ │ │ COMMON-LISPH │ │ │ │ Return second result of TRUNCATE. │ │ │ │ REST-ARG │ │ │ │ +inline (signed-byte 64) integer-length │ │ │ │ +public: algorithms for Unicode data │ │ │ │ SIZE-HIGHP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -public: algorithms for Unicode data │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ @@ -28055,19 +28056,21 @@ │ │ │ │ COMPARATORS │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ SQRT-Z+1 │ │ │ │ INSTANCE0 │ │ │ │ REAL-RESTART8 │ │ │ │ INSTANCE0 │ │ │ │ -REST-ARG │ │ │ │ STRUCTURE-CLASSOID- │ │ │ │ UNION-TYPE- │ │ │ │ NUMTYPE-ASPECTS- │ │ │ │ NUMERIC-TYPE- │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +TYPESH%gL │ │ │ │ $($0$8$@ │ │ │ │ OPERATION │ │ │ │ OPTIONAL0 │ │ │ │ REQUIRED( │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -28083,19 +28086,21 @@ │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ [eTxUEu, │ │ │ │ NEW-NAMESTRING0 │ │ │ │ OLD-NAMESTRING@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ -,/Fj4[6- │ │ │ │ -COMMON-LISP( │ │ │ │ ~@ │ │ │ │ +:NAMED option is incompatible with element type ~// │ │ │ │ +Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ +~@ │ │ │ │ BASE+BOUNDS │ │ │ │ -DD-NAMED │ │ │ │ +,/Fj4[6- │ │ │ │ +COMMON-LISP( │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISPH │ │ │ │ TYPE2`+g< │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP` │ │ │ │ COMMON-LISP │ │ │ │ @@ -28103,31 +28108,28 @@ │ │ │ │ ALIEN-TYPE-1(20 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISPH │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE0 │ │ │ │ TYPE2X.g0 │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ FORTHCOMING-INFO │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -TYPESH%gL │ │ │ │ INSTANCE0 │ │ │ │ $P$0$8$@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ XS>IZId? │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ CLASSOID-CELL- │ │ │ │ NAMED-TYPE- │ │ │ │ -SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ INSTANCE0 │ │ │ │ TYPE2`#g4 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ RAW-TYPE │ │ │ │ @@ -28140,18 +28142,14 @@ │ │ │ │ CLASSOID8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMPLEXP-SUPERTYPEH │ │ │ │ DIMENSIONS8 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -:NAMED option is incompatible with element type ~// │ │ │ │ -Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ -~@ │ │ │ │ -Attempt to remove :PRIMITIVE type: ~// │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ TYPE-CLASS │ │ │ │ COMMON-LISP │ │ │ │ DIMENSIONS │ │ │ │ INSTANCE0 │ │ │ │ @@ -28181,14 +28179,15 @@ │ │ │ │ COMMON-LISP8 │ │ │ │ ENUMERABLEH │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP( │ │ │ │ INSTANCE0 │ │ │ │ +DD-NAMED │ │ │ │ INSTANCE0 │ │ │ │ DEFSTRUCT │ │ │ │ COMMON-LISP@ │ │ │ │ INSTANCE0 │ │ │ │ CLASSOIDH │ │ │ │ SB-INT0!g< │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -28233,17 +28232,19 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ $($0$8$@ │ │ │ │ COMMON-LISPH │ │ │ │ SIMPLE-FUN SB-KERNEL8 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP@ │ │ │ │ SB-ALIEN │ │ │ │ +Attempt to remove :PRIMITIVE type: ~// │ │ │ │ COMMON-LISPH │ │ │ │ CODE-OBJ0"g4 │ │ │ │ NCLOSURE(Bg< │ │ │ │ +SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ $($0$8%g0 │ │ │ │ COMMON-LISPP │ │ │ │ $($0$8$@$H5g8 │ │ │ │ -OFFSETU │ │ │ │ SB-ALIENM │ │ │ │ $($0$8$@"g0 │ │ │ │ FROM-END` │ │ │ │ @@ -28330,33 +28331,32 @@ │ │ │ │ SB-ALIENU │ │ │ │ COMMON-LISP9 │ │ │ │ INSTANCE0 │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP(%g< │ │ │ │ -LAYOUTpAg< │ │ │ │ INSTANCE0 │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP` │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP8 │ │ │ │ +EXTRA-ID-WORDS │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ SB-ALIEN │ │ │ │ $($0$8$@$H5g8 │ │ │ │ -OFFSETM │ │ │ │ SB-ALIENE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ -EXTRA-ID-WORDS │ │ │ │ $($0$8 '0" │ │ │ │ INSTANCE` │ │ │ │ OUTPUT-TYPE-SPECH │ │ │ │ COMMON-LISP8 │ │ │ │ CODE-OBJ@ │ │ │ │ $H$0$8$@ │ │ │ │ COMMON-LISP │ │ │ │ @@ -28373,32 +28373,33 @@ │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP` │ │ │ │ SB-INT5 g │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP> │ │ │ │ COMMON-LISP │ │ │ │ +LAYOUTpAg< │ │ │ │ CONTEXT8 │ │ │ │ COMMON-LISP@ │ │ │ │ BODY-NAME` │ │ │ │ COMMON-LISP │ │ │ │ +MAX-INDEX │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ SB-C05gT │ │ │ │ Store NEWVAL as the component of SEQUENCE specified by INDEX. │ │ │ │ COMMON-LISPH │ │ │ │ $($0$8 '0" │ │ │ │ INSTANCE` │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP0 │ │ │ │ CODE-OBJ@ │ │ │ │ FUN-INDEX= │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ -MAX-INDEX │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ Return the class of the supplied object, which may be any Lisp object, not │ │ │ │ just a CLOS STANDARD-OBJECT. │ │ │ │ COMMON-LISP0 │ │ │ │ FUNCTION │ │ │ │ @@ -28427,27 +28428,17 @@ │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE0 │ │ │ │ $($0$8"'0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ COMMON-LISPp!g` │ │ │ │ FLET-NAME(%g< │ │ │ │ TEST-NOT(#g< │ │ │ │ +COMMON-LISP8 │ │ │ │ Can STREAM perform input operations? │ │ │ │ Can STREAM perform output operations? │ │ │ │ -~@ │ │ │ │ -Supply an object to be printed instead. │ │ │ │ -Print unreadably. │ │ │ │ -Unknown object type #x~x addr=~x │ │ │ │ -Too many result values from c-call. │ │ │ │ - usage is: │ │ │ │ - bytes overhead) │ │ │ │ -Control and binding stack usage is for the current thread only. │ │ │ │ -Garbage collection is currently │ │ │ │ -DISABLED │ │ │ │ -COMMON-LISP8 │ │ │ │ y&D4P "H$ │ │ │ │ COMMON-LISP@ │ │ │ │ SB-INT9 g │ │ │ │ INSTANCE SB-KERNELp │ │ │ │ NEW-VALUE` │ │ │ │ NEW-LENGTHH │ │ │ │ COMMON-LISPP │ │ │ │ @@ -28471,14 +28462,24 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ STREAMS8 │ │ │ │ BYTESPEC8 │ │ │ │ Return the size part of the byte specifier bytespec. │ │ │ │ 0wtzODD' │ │ │ │ @kJP`:b*.* │ │ │ │ QsFznCX: │ │ │ │ +~@ │ │ │ │ +Supply an object to be printed instead. │ │ │ │ +Print unreadably. │ │ │ │ +Unknown object type #x~x addr=~x │ │ │ │ +Too many result values from c-call. │ │ │ │ + usage is: │ │ │ │ + bytes overhead) │ │ │ │ +Control and binding stack usage is for the current thread only. │ │ │ │ +Garbage collection is currently │ │ │ │ +DISABLED │ │ │ │ COMMON-LISP( │ │ │ │ Convert ASH of word to %ASH/RIGHT │ │ │ │ Convert ASH of signed word to %ASH/RIGHT │ │ │ │ PREDPDg< │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -28489,25 +28490,22 @@ │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL0 │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ SBCL-HOMEDIR0&G4 │ │ │ │ COMMON-LISP@ │ │ │ │ -WEAK-POINTER │ │ │ │ -If WEAK-POINTER is valid, return the value of WEAK-POINTER and T. │ │ │ │ -If the referent of WEAK-POINTER has been garbage collected, │ │ │ │ -returns the values NIL and NIL. │ │ │ │ SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;PARMS.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ ~S and ~S don't have the same dimensions. │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ ~S is not a known slot of thread │ │ │ │ Breakdown for │ │ │ │ space total │ │ │ │ bytes for │ │ │ │ ~V:D bytes for ~V:D ~(~A~) object~2:*~P~*~:[~; ~:*(~A)~] │ │ │ │ There are ~W elements in the :INITIAL-CONTENTS, but the vector length is ~W. │ │ │ │ Summary of space │ │ │ │ @@ -28523,14 +28521,15 @@ │ │ │ │ **** Page │ │ │ │ , address │ │ │ │ EMIT-INLINE-CONSTANT called with ~S │ │ │ │ ~S is not a static symbol. │ │ │ │ Tried to fixup with ~a. │ │ │ │ Unaligned instruction? offset=#x~X. │ │ │ │ ~x: ~v,'0x~:[~; = ~@?~] │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ page_table │ │ │ │ SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ TEXT_SPACE_START │ │ │ │ next_free_page │ │ │ │ READ_ONLY_SPACE_START │ │ │ │ static_space_free_pointer │ │ │ │ text_space_highwatermark │ │ │ │ @@ -28556,19 +28555,14 @@ │ │ │ │ argument count discrepancy in :ARGUMENT-PRECEDENCE-ORDER clause. │ │ │ │ bad list length for ~S │ │ │ │ unsupported option ~S │ │ │ │ Ignoring unrecognized declaration in DEFGENERIC: ~S │ │ │ │ The declaration specifier ~S is not allowed inside DEFGENERIC. │ │ │ │ ~@ │ │ │ │ Dotted list ~S in DOLIST. │ │ │ │ -globaldb │ │ │ │ -~S can't be used to initialize an array of type ~//. │ │ │ │ -Objects of type ~// can't be dumped into fasl files. │ │ │ │ -~S is not one of :INTERNAL, :EXTERNAL, or :INHERITED. │ │ │ │ -At least one of :INTERNAL, :EXTERNAL, or :INHERITED must be supplied. │ │ │ │ SUB-CHAR must not be a decimal digit: ~S │ │ │ │ There is nothing left to pop. │ │ │ │ ~@ │ │ │ │ !"3/&i0(( │ │ │ │ jBcg %w4 │ │ │ │ Mh?!1B=) │ │ │ │ = &; < b │ │ │ │ @@ -28583,14 +28577,16 @@ │ │ │ │ Don't know how to ~S ~A. │ │ │ │ ~@ │ │ │ │ uninterning ~A │ │ │ │ ~S is not a ~S │ │ │ │ ~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ /proc/sys/kernel/osrelease │ │ │ │ +~S is not one of :INTERNAL, :EXTERNAL, or :INHERITED. │ │ │ │ +At least one of :INTERNAL, :EXTERNAL, or :INHERITED must be supplied. │ │ │ │ bogus DEFPACKAGE option: ~S │ │ │ │ :SIZE is not a positive integer: ~S │ │ │ │ ~S expects a single argument. Got ~S │ │ │ │ can't specify ~S more than once. │ │ │ │ PPRINT-EXIT-IF-LIST-EXHAUSTED must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ access-function │ │ │ │ ~S is an illegal form for a ~S varlist. │ │ │ │ @@ -28655,14 +28651,17 @@ │ │ │ │ Invalid place to CAS: ~S -> ~S │ │ │ │ a DEFSETF lambda list │ │ │ │ Ill-formed DEFSETF for ~S │ │ │ │ SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ Quoted type specifier in ~S: ~S │ │ │ │ PPRINT-POP must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ Something is wrong; local-alien-info not found: ~S │ │ │ │ +globaldb │ │ │ │ +~S can't be used to initialize an array of type ~//. │ │ │ │ +Objects of type ~// can't be dumped into fasl files. │ │ │ │ SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ SYS:SRC;COMPILER;LTN.LISP │ │ │ │ Basic qualities: │ │ │ │ Dependent qualities: │ │ │ │ Dribbling to ~s is enabled. │ │ │ │ :TOPLEVEL cannot be supplied when there are callable exports. │ │ │ │ Abort saving the core. │ │ │ │ @@ -28683,31 +28682,30 @@ │ │ │ │ ~S is not a policy quality │ │ │ │ ~S cannot be used with displaced arrays. Use ~S instead. │ │ │ │ objects, │ │ │ │ candidates, │ │ │ │ Unknown object type #x~x ~s │ │ │ │ Input is not a proper list of weak pointers. │ │ │ │ Could not stop all threads │ │ │ │ -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~^, ~} │ │ │ │ UNLOCKED-PACKAGES- │ │ │ │ SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ Malformed HASH-FUNCTION: ~S │ │ │ │ Cannot redefine standard hash table test ~S. │ │ │ │ TIME-LEFT- │ │ │ │ INFO-NUMBER- │ │ │ │ Unsupported on this platform. │ │ │ │ ~S is unsupported on this platform ~ │ │ │ │ (OS, CPU, whatever). │ │ │ │ N-HASH-TABLE- │ │ │ │ -Not a parser state: ~S │ │ │ │ +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~}~] = │ │ │ │ an ordinary lambda list │ │ │ │ ~@<~A: ~2I~_~A~:> │ │ │ │ The package ~S has been deleted. │ │ │ │ too few subexpressions in feature expression: ~S │ │ │ │ too many subexpressions in feature expression: ~S │ │ │ │ unknown operator in feature expression: ~S. │ │ │ │ @@ -28725,25 +28723,29 @@ │ │ │ │ ~2,'0D:~2,'0D │ │ │ │ ~2,'0D ~:@(~A~) ~D │ │ │ │ ~A: Unrecognized :style keyword value. │ │ │ │ ~D/~D/~D │ │ │ │ ~A: Timezone is not a second (1/3600) multiple. │ │ │ │ ~A: Timezone should be a rational between -24 and 24. │ │ │ │ ~A: Universal-Time should be an integer. │ │ │ │ +Not a parser state: ~S │ │ │ │ Bad size for the ~S type specifier: ~S. │ │ │ │ malformed ONCE-ONLY binding spec: ~S │ │ │ │ SYS:SRC;CODE;DEFMACRO.LISP │ │ │ │ bad option: ~S │ │ │ │ Bad size for ~S type specifier: ~S. │ │ │ │ malformed NAMED-LET variable spec: ~S │ │ │ │ F-METHOD- │ │ │ │ F-BUFFER- │ │ │ │ F-INDEX- │ │ │ │ EOF-VAL- │ │ │ │ not legal as a function name: ~S │ │ │ │ +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. │ │ │ │ interning ~A │ │ │ │ No such thing as DEBOOTSTRAP-PACKAGE │ │ │ │ deleted package │ │ │ │ ~@<~S can't be a ~A: ~2I~_It has been reset to ~S.~:> │ │ │ │ a VALUES type specifier │ │ │ │ a macro lambda list │ │ │ │ a destructuring lambda list │ │ │ │ @@ -28772,18 +28774,19 @@ │ │ │ │ invalid external alien name: ~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. │ │ │ │ ~S is valid only inside ~S. │ │ │ │ -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. │ │ │ │ OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ +WEAK-POINTER │ │ │ │ +If WEAK-POINTER is valid, return the value of WEAK-POINTER and T. │ │ │ │ +If the referent of WEAK-POINTER has been garbage collected, │ │ │ │ +returns the values NIL and NIL. │ │ │ │ ^DBJ;c/t& │ │ │ │ Return a copy of sequence with elements satisfying PREDICATE removed. │ │ │ │ dC6T><853.$ │ │ │ │ }~t>>lxL │ │ │ │ ~_eff~'{ │ │ │ │ -zz0|[;A^ │ │ │ │ SUPPLIED-P-P │ │ │ │ +The type declarations ~// and ~// for ~S conflict. │ │ │ │ +zz0|[;A^ │ │ │ │ NEW-VALUEP │ │ │ │ Set NAME's global function definition. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Synonym for COMPARE-AND-SWAP. │ │ │ │ Additionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be also used to │ │ │ │ define CAS-functions analogously to SETF-functions: │ │ │ │ @@ -31545,17 +31546,17 @@ │ │ │ │ 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. │ │ │ │ REST-ARG │ │ │ │ SYS:SRC;COMPILER;RISCV;TYPE-VOPS.LISP │ │ │ │ SYS:SRC;COMPILER;RISCV;MOVE.LISP │ │ │ │ +encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ SYS:SRC;CODE;CAS.LISP │ │ │ │ SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ -encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ QUOTE value │ │ │ │ Return VALUE without evaluating it. │ │ │ │ IF predicate then [else] │ │ │ │ If PREDICATE evaluates to true, evaluate THEN and return its values, │ │ │ │ otherwise evaluate ELSE and return its values. ELSE defaults to NIL. │ │ │ │ PROGN form* │ │ │ │ Evaluates each FORM in order, returning the values of the last form. With no │ │ │ │ @@ -31569,40 +31570,42 @@ │ │ │ │ MORE-ARG │ │ │ │ Return the sum of its arguments. With no args, returns 0. │ │ │ │ COMMON-LISP0 │ │ │ │ Return all but the first object in a list. │ │ │ │ COMMON-LISP@ │ │ │ │ Is this number zero? │ │ │ │ COMMON-LISP │ │ │ │ -@2RG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ GENERIC-FUNCTION │ │ │ │ @@ -31616,14 +31619,15 @@ │ │ │ │ SLOT-NAME@ │ │ │ │ COMMON-LISP8 │ │ │ │ SLOT-NAME@ │ │ │ │ COMMON-LISP8 │ │ │ │ SLOT-NAME@ │ │ │ │ COMMON-LISP8 │ │ │ │ SLOT-NAME@ │ │ │ │ +~@ │ │ │ │ ALLOCATION │ │ │ │ COMMLISP │ │ │ │ DIRECT-SLOTDS │ │ │ │ DOCUMENT │ │ │ │ INITARGS │ │ │ │ CLASSES@ │ │ │ │ GENERIC-FUNCTION │ │ │ │ @@ -31638,38 +31642,32 @@ │ │ │ │ NEW-VALUEP │ │ │ │ APPLICABLE-METHODS( │ │ │ │ COMMON-LISP │ │ │ │ ``$8$P$= │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISPp │ │ │ │ REST-ARG │ │ │ │ +SPECIALIZER-COUNT │ │ │ │ ``$8$P$= │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISPp │ │ │ │ REST-ARG │ │ │ │ -SPECIALIZER-COUNT │ │ │ │ Wdb&j!]HZ │ │ │ │ $($0$8$@ │ │ │ │ METHOD-LAMBDA` │ │ │ │ PROTO-GF │ │ │ │ PROTO-METHOD │ │ │ │ PROTO-GENERIC-FUNCTIONH │ │ │ │ SPECIALIZER-NAME8 │ │ │ │ SPECIALIZER-NAME8 │ │ │ │ SPECIALIZER-NAME8*g0 │ │ │ │ INITARGS@ │ │ │ │ METHOD-LAMBDA` │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ -~S ~S #X~8,'0X ~S ~// │ │ │ │ -~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ -~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ -~//, slot:~S, ~:S │ │ │ │ APPLICABLE-METHODSH │ │ │ │ COMMON-LISP │ │ │ │ TYPE-NAME8 │ │ │ │ │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ +~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ +~//, slot:~S, ~:S │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ MON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ @@ -31713,18 +31717,18 @@ │ │ │ │ dr!f7n{\ │ │ │ │ g"E4'5{uV │ │ │ │ L.,`o:00: │ │ │ │ a0 c:F.D │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ -`$"H9It,A │ │ │ │ -fmt$DOT6XAOY7ZSR │ │ │ │ Superclass of all Gray output streams whose element-type │ │ │ │ is a subtype of character. │ │ │ │ +`$"H9It,A │ │ │ │ +fmt$DOT6XAOY7ZSR │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$B0NCY3LJDL4 │ │ │ │ DFUN-INFOP │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$SLHNTOJ2K18F │ │ │ │ fmt$WJLN8FO1R5OK │ │ │ │ fmt$NX8AZZT9W09R │ │ │ │ @@ -31740,28 +31744,28 @@ │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR@ │ │ │ │ COMMON-LISP8 │ │ │ │ ITERATOR@ │ │ │ │ -Element-type: ~// │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR10H │ │ │ │ COMMON-LISP@ │ │ │ │ ITERATOR21H │ │ │ │ NEW-VALUE │ │ │ │ ITERATORH │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ B#HM:y A │ │ │ │ +Element-type: ~// │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$FRF53XELDXSD │ │ │ │ fmt$HHUAPATMV50T │ │ │ │ @@ -31840,87 +31844,84 @@ │ │ │ │ X │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -inline arithmetic │ │ │ │ -inline unsigned unboxed arithmetic │ │ │ │ -inline signed unboxed arithmetic │ │ │ │ REST-ARG │ │ │ │ +SYS:SRC;COMPILER;RISCV;PRED.LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -SYS:SRC;COMPILER;RISCV;PRED.LISP │ │ │ │ open-code INTEGER to RATIO comparison │ │ │ │ open-code RATIONAL to FLOAT comparison │ │ │ │ open-code FLOAT to RATIONAL comparison │ │ │ │ constant-fold INTEGER to RATIO comparison │ │ │ │ open code │ │ │ │ invert or open code │ │ │ │ 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. │ │ │ │ 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. │ │ │ │ DUMMIES( │ │ │ │ - DIRECTIONH │ │ │ │ -COMMON-LISP0 │ │ │ │ -FORM SB-KERNEL │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -FORM SB-KERNELH │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP0 │ │ │ │ +N-RESULT(!g< │ │ │ │ COMMON-LISPp │ │ │ │ COMMON-LISP0 │ │ │ │ FUNCTIONAL@ │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP8 │ │ │ │ Return SYMBOL's home package, or NIL if none. │ │ │ │ Return the printed representation of OBJECT as a string with │ │ │ │ slashification on. │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ If NAME names a compiler-macro in ENV, return the expansion function, else │ │ │ │ return NIL. Can be set with SETF when ENV is NIL. │ │ │ │ +ENVIRONMENT │ │ │ │ +FORM SB-KERNELP │ │ │ │ LEAFH g< │ │ │ │ MORE-ARG │ │ │ │ NAMESPACE │ │ │ │ COMMON-LISP0 │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ .(M$0hBkh7t │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH$` │ │ │ │ SB-INTA$] │ │ │ │ MORE-ARG │ │ │ │ Return a list of the arguments with last cons a dotted pair. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +@2RG (alien (* (array (signed 8) 10))) │ │ │ │ + (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ + (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ +Establish some local alien variables. Each BINDING is of the form: │ │ │ │ + VAR TYPE [ ALLOCATION ] [ INITIAL-VALUE | EXTERNAL-NAME ] │ │ │ │ + ALLOCATION should be one of: │ │ │ │ + :LOCAL (the default) │ │ │ │ + The alien is allocated on the stack, and has dynamic extent. │ │ │ │ + :EXTERN │ │ │ │ + No alien is allocated, but VAR is established as a local name for │ │ │ │ + the external alien given by EXTERNAL-NAME. │ │ │ │ COMMON-LISP@ │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP@"g4 │ │ │ │ COMMON-LISP0 │ │ │ │ ]#_}eoEeZ │ │ │ │ COMMON-LISP8 │ │ │ │ ~?1(p$0X │ │ │ │ Returns true if the alien is associated with a lisp-side callback, │ │ │ │ and a secondary return value of true if the callback is still valid. │ │ │ │ +Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ +:TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ +Input type (~//) and output type (~//) are unrelated? │ │ │ │ +could not find any input routine for ~// │ │ │ │ +~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ +~@:_Lambda-list: ~// │ │ │ │ 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).) │ │ │ │ @@ -32205,16 +32241,14 @@ │ │ │ │ Unloads the shared object loaded earlier using the designated PATHNAME with │ │ │ │ LOAD-SHARED-OBJECT, to the degree supported on the platform. │ │ │ │ Experimental. │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Call the foreign function ALIEN with the specified arguments. ALIEN's │ │ │ │ type specifies the argument and result types. │ │ │ │ -Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ -:TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ Return true if X (which must be an ALIEN pointer) is null, false otherwise. │ │ │ │ REST-ARG │ │ │ │ Unsupported as of SBCL 0.8.13. Please use LOAD-SHARED-OBJECT. │ │ │ │ Dispose of the storage pointed to by ALIEN. The ALIEN must have been │ │ │ │ allocated by MAKE-ALIEN, MAKE-ALIEN-STRING or malloc(3). │ │ │ │ INDICESP │ │ │ │ REST-ARG │ │ │ │ @@ -32302,46 +32336,14 @@ │ │ │ │ Else blocks until the semaphore can be decremented. Returns the new count of │ │ │ │ SEMAPHORE on success. │ │ │ │ If TIMEOUT is given, it is the maximum number of seconds to wait. If the count │ │ │ │ cannot be decremented in that time, returns NIL without decrementing the │ │ │ │ If NOTIFICATION is given, it must be a SEMAPHORE-NOTIFICATION object whose │ │ │ │ SEMAPHORE-NOTIFICATION-STATUS is NIL. If WAIT-ON-SEMAPHORE succeeds and │ │ │ │ decrements the count, the status is set to T. │ │ │ │ -Return the size of the alien type TYPE. UNITS specifies the units to │ │ │ │ - use and can be either :BITS, :BYTES, or :WORDS. │ │ │ │ -Allocate an alien of type TYPE in foreign heap, and return an alien │ │ │ │ -pointer to it. The allocated memory is not initialized, and may │ │ │ │ -contain garbage. The memory is allocated using malloc(3), so it can be │ │ │ │ -passed to foreign functions which use free(3), or released using │ │ │ │ -FREE-ALIEN. │ │ │ │ -For alien stack allocation, see macro WITH-ALIEN. │ │ │ │ -The TYPE argument is not evaluated. If SIZE is supplied, how it is │ │ │ │ -interpreted depends on TYPE: │ │ │ │ - * When TYPE is a foreign array type, an array of that type is │ │ │ │ - allocated, and a pointer to it is returned. Note that you │ │ │ │ - must use DEREF to first access the array through the pointer. │ │ │ │ - If supplied, SIZE is used as the first dimension for the array. │ │ │ │ - * When TYPE is any other foreign type, then an object for that │ │ │ │ - type is allocated, and a pointer to it is returned. So │ │ │ │ - (make-alien int) returns a (* int). │ │ │ │ - If SIZE is specified, then a block of that many objects is │ │ │ │ - allocated, with the result pointing to the first one. │ │ │ │ -Examples: │ │ │ │ - (defvar *foo* (make-alien (array char 10))) │ │ │ │ - (type-of *foo*) ; => (alien (* (array (signed 8) 10))) │ │ │ │ - (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ - (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ -Establish some local alien variables. Each BINDING is of the form: │ │ │ │ - VAR TYPE [ ALLOCATION ] [ INITIAL-VALUE | EXTERNAL-NAME ] │ │ │ │ - ALLOCATION should be one of: │ │ │ │ - :LOCAL (the default) │ │ │ │ - The alien is allocated on the stack, and has dynamic extent. │ │ │ │ - :EXTERN │ │ │ │ - No alien is allocated, but VAR is established as a local name for │ │ │ │ - the external alien given by EXTERNAL-NAME. │ │ │ │ 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. │ │ │ │ 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 │ │ │ │ @@ -32362,14 +32364,22 @@ │ │ │ │ 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. │ │ │ │ SESSION` g< │ │ │ │ C-THREAD8 │ │ │ │ TIMEOUT0 │ │ │ │ +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. │ │ │ │ Atomically release MUTEX and start waiting on QUEUE until another thread │ │ │ │ wakes us up using either CONDITION-NOTIFY or CONDITION-BROADCAST on │ │ │ │ QUEUE, at which point we re-acquire MUTEX and return T. │ │ │ │ Spurious wakeups are possible. │ │ │ │ If TIMEOUT is given, it is the maximum number of seconds to wait, │ │ │ │ including both waiting for the wakeup and the time to re-acquire │ │ │ │ MUTEX. When neither a wakeup nor a re-acquisition occurs within the │ │ │ │ @@ -32404,25 +32414,25 @@ │ │ │ │ Returns T if a WAIT-ON-SEMAPHORE or TRY-SEMAPHORE using │ │ │ │ SEMAPHORE-NOTIFICATION has succeeded since the notification object was created │ │ │ │ or cleared. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Returns the current count of the semaphore INSTANCE. │ │ │ │ jmi'@nP, │ │ │ │ Returns the main thread of the process. │ │ │ │ -Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ Create a waitqueue. │ │ │ │ Create a new thread of NAME that runs FUNCTION with the argument │ │ │ │ list designator provided (defaults to no argument). Thread exits when │ │ │ │ the function returns. The return values of FUNCTION are kept around │ │ │ │ and can be retrieved by JOIN-THREAD. │ │ │ │ Invoking the initial ABORT restart established by MAKE-THREAD │ │ │ │ terminates the thread. │ │ │ │ See also: RETURN-FROM-THREAD, ABORT-THREAD. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP8 │ │ │ │ +Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP( │ │ │ │ UNPARSED │ │ │ │ COMMON-LISP( │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -32435,22 +32445,14 @@ │ │ │ │ EOF-VALUEP │ │ │ │ COMMON-LISPH │ │ │ │ PROCESS8,g< │ │ │ │ COMMON-LISP │ │ │ │ EXPRX3g8 │ │ │ │ Signals a timeout condition while inhibiting further timeouts due to │ │ │ │ deadlines while the condition is being handled. │ │ │ │ -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. │ │ │ │ COMMON-LISP( g< │ │ │ │ @0&2bRK0Y │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ SUB-CHAR │ │ │ │ SUB-TABLEP │ │ │ │ 2)${$?8+k\l │ │ │ │ @@ -32474,16 +32476,14 @@ │ │ │ │ 9&(0F!b= │ │ │ │ COMMON-LISP( │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ COMMON-LISPH │ │ │ │ Removes NAME's encapsulation of the specified TYPE if such exists. │ │ │ │ s.Y2cxa` │ │ │ │ -KEY-TMP(#g< │ │ │ │ -ADDRESS` │ │ │ │ ( X 8 H │ │ │ │ COMMON-LISP( │ │ │ │ REPLACEMENTH │ │ │ │ COMMON-LISP │ │ │ │ FU1)$'+Ll │ │ │ │ TEST-NOT8 │ │ │ │ COMMON-LISPP │ │ │ │ @@ -32513,14 +32513,16 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ NAMESPACE │ │ │ │ COMMON-LISP │ │ │ │ FD-STREAM │ │ │ │ #0|>/ │ │ │ │ COMMON-LISP( │ │ │ │ SXSTATE@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPP │ │ │ │ LEXENV SB-KERNEL │ │ │ │ -CODE-VAR │ │ │ │ -SHIFTEDpEg< │ │ │ │ +~@:_Declared type: ~// │ │ │ │ +~@:_Argument precedence order: ~// │ │ │ │ X 8 H ( │ │ │ │ COMMON-LISP( │ │ │ │ REPLACEMENTH │ │ │ │ SB-INT) g, │ │ │ │ EXTERNAL-FORMAT@)g4 │ │ │ │ IFPOsKlv │ │ │ │ 4L{.L=L'_ │ │ │ │ @@ -32706,14 +32706,15 @@ │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP8 │ │ │ │ Returns T if SEQUENCE is an empty sequence and NIL │ │ │ │ otherwise. Signals an error if SEQUENCE is not a sequence. │ │ │ │ COMMON-LISP │ │ │ │ +DESCRIPTOR-IDX │ │ │ │ fmt$OI9BCQTGW3C1 │ │ │ │ fmt$LKZRPQVMP0RO │ │ │ │ fmt$YFX2UA6FQMD0 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPH │ │ │ │ SB-CN2gh │ │ │ │ #i'[(R("hEB[ │ │ │ │ @@ -32745,14 +32746,16 @@ │ │ │ │ COMMON-LISP │ │ │ │ WRAPPER(Bg@ │ │ │ │ COMMON-LISP │ │ │ │ START1:'@9 │ │ │ │ vo (PF`p=@U │ │ │ │ SB-INT) g, │ │ │ │ COMMON-LISPp │ │ │ │ + PREDICATE │ │ │ │ +COMMON-LISP │ │ │ │ )i(]CzA' │ │ │ │ aMjf$)Hj │ │ │ │ |x `>1F/ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ NEW-LIST0 │ │ │ │ PEpq?t!7 │ │ │ │ @@ -32784,16 +32787,14 @@ │ │ │ │ If SERVE-EVENTS is true (the default), events on other FDs are served while │ │ │ │ waiting. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ $H$0$($@ │ │ │ │ ITERATOR( │ │ │ │ COMMON-LISP@ │ │ │ │ - PREDICATE │ │ │ │ -COMMON-LISP │ │ │ │ 37CF7>2; │ │ │ │ COMMON-LISPH │ │ │ │ SB-CNCgh │ │ │ │ CODE-OBJ0 │ │ │ │ 'w; (pd& │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -32808,39 +32809,22 @@ │ │ │ │ fmt$1KL7BBTPCFXY │ │ │ │ 5DEGR5%Y$} │ │ │ │ fmt$QXSSWPWLQZAE │ │ │ │ fmt$J8DY08OKZTYD │ │ │ │ fmt$NSUYYLCVJJIR │ │ │ │ $H$0$8$( │ │ │ │ REPLACEMENT-SPEC │ │ │ │ -~&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. │ │ │ │ -~@:_Derived type: ~// │ │ │ │ -~@:_(~A ~{~S ~}~//) │ │ │ │ -~@:_~:(~A~) type: ~// │ │ │ │ -~#[~;Use ~// instead.~;Use ~// or ~// instead.~:;Use~@{~#[~; or~] ~//~^,~} instead.~] │ │ │ │ -~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP@ │ │ │ │ COMPILER-P` │ │ │ │ CLOSURE SB-KERNEL@ │ │ │ │ NVALUESM5'X& │ │ │ │ -Assignment to virtual DISPATCH-TABLES slot not allowed │ │ │ │ INDICATORP │ │ │ │ COMMON-LISP │ │ │ │ +Assignment to virtual DISPATCH-TABLES slot not allowed │ │ │ │ COMMON-LISP@ │ │ │ │ SB-CN*gp │ │ │ │ EXTERNAL-FORMATH │ │ │ │ Q4Hze62G2` │ │ │ │ COMMON-LISP) │ │ │ │ ENTRY-POINTS0 │ │ │ │ USPNLIGBA@<;89%db`_]Y,VTRNJGDBA@> │ │ │ │ @@ -32855,14 +32839,32 @@ │ │ │ │ $P$($8$@ │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP │ │ │ │ (PF`p=@U │ │ │ │ COMMON-LISPP │ │ │ │ SUB-CHARH │ │ │ │ COMMON-LISPP │ │ │ │ +~&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. │ │ │ │ +~@:_Derived type: ~// │ │ │ │ +~@:_(~A ~{~S ~}~//) │ │ │ │ +~@:_~:(~A~) type: ~// │ │ │ │ +~#[~;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~} │ │ │ │ KEY-TMP( │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP │ │ │ │ CONDITION │ │ │ │ COMMON-LISPP │ │ │ │ FORM SB-KERNEL8 │ │ │ │ OPERATION │ │ │ │ @@ -32895,14 +32897,15 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ COMMON-LISPH │ │ │ │ 6 (PF`p=@U │ │ │ │ SB-INT) g, │ │ │ │ COMMON-LISP@ │ │ │ │ +COMMON-LISP` │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH │ │ │ │ REST-ARG │ │ │ │ ( X 8 H │ │ │ │ COMMON-LISP( │ │ │ │ REPLACEMENTH │ │ │ │ ^OD/,FYw+lR │ │ │ │ @@ -32911,15 +32914,14 @@ │ │ │ │ Y-EL0"'8 │ │ │ │ COMMON-LISP │ │ │ │ ( X 8 H │ │ │ │ COMMON-LISP( │ │ │ │ REPLACEMENTH │ │ │ │ COMMON-LISP │ │ │ │ zm (PF`p=@U │ │ │ │ -COMMON-LISP` │ │ │ │ DESCRIPTOR0 │ │ │ │ DIRECTIONH │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISPX │ │ │ │ COMMON-LISP( │ │ │ │ COMMON-LISP │ │ │ │ @@ -33052,19 +33054,14 @@ │ │ │ │ ARRAY-FORM │ │ │ │ OTHER-FORM │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP`?g< │ │ │ │ FIRST-CLAUSE`;g< │ │ │ │ DEFINITION0 │ │ │ │ COMMON-LISP@ │ │ │ │ -~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ -~:[This~;~:*~A~] is not a ~< │ │ │ │ -~9T~:;~//:~> │ │ │ │ -~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ -~9T~:;not a ~//.~> │ │ │ │ COMMON-LISP@ │ │ │ │ P2AMO7 │ │ │ │ +~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ +~9T~:;not a ~//.~> │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ CLAMBDAS │ │ │ │ COMPONENT8 │ │ │ │ DID-SOMETHING │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33250,15 +33252,14 @@ │ │ │ │ tuW}4Cf │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SOURCE-INFO │ │ │ │ COMMON-LISP@ │ │ │ │ gnPDaI?w' │ │ │ │ -ORIGINAL-FUN │ │ │ │ CONSTANTSH │ │ │ │ COMMON-LISP0 │ │ │ │ CURRENT8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ 0lwS#C0?- │ │ │ │ COMMON-LISP` │ │ │ │ @@ -33382,16 +33383,17 @@ │ │ │ │ oT"akRY^ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ DEFINITION-SOURCE-LOCATION- │ │ │ │ x1c │ │ │ │ REST-ARG │ │ │ │ ,$I$~4zsg-K │ │ │ │ <*pYc|WUE'Y9 │ │ │ │ DEST-FUN-NAMES │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ |tB]{+a/ │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ REST-ARG │ │ │ │ NEW-BLOCK8 │ │ │ │ -TARGET-ENV │ │ │ │ REST-ARG │ │ │ │ +~@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMPONENT │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPH │ │ │ │ @@ -33487,14 +33488,15 @@ │ │ │ │ COMMON-LISP0#g< │ │ │ │ REST-ARG │ │ │ │ ))Pos05gf" │ │ │ │ $($`$0$8$@ │ │ │ │ COMPONENT │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +without-hashing │ │ │ │ $P$0$8$@ │ │ │ │ CONTEXT@ │ │ │ │ SB-ASSEM0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -33533,15 +33535,14 @@ │ │ │ │ REST-ARG │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ TEMP SB-KERNEL0 │ │ │ │ SB-ALIEN │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ -without-hashing │ │ │ │ EXPANSION@ │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ RES-TYPEP │ │ │ │ COMMON-LISP │ │ │ │ $H$`$P$8.gH │ │ │ │ BIT-ARRAY-1X │ │ │ │ @@ -33550,31 +33551,14 @@ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ UNIVERSE │ │ │ │ JiVfe[X"8 │ │ │ │ REST-ARG │ │ │ │ -Assignment to argument: ~S │ │ │ │ - prevents use of assertion from function type ~A: │ │ │ │ -The result type from ~A: │ │ │ │ -conflicts with the definition's result type: │ │ │ │ -Not a function type: ~// │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -violating package lock on ~// │ │ │ │ -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 │ │ │ │ -~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ -~@ │ │ │ │ -using the lexical binding of the symbol ~//, not the │ │ │ │ -dynamic binding │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ _QJPy'MF1 │ │ │ │ +?NWKh@UwV │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPP │ │ │ │ @@ -33598,15 +33582,14 @@ │ │ │ │ TYPE-SPECIFIER SB-KERNEL8 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ MORE-ARG │ │ │ │ $($0$8$@$H#g0 │ │ │ │ ARG-LOCS │ │ │ │ COMMON-LISP │ │ │ │ -N-SIMPLE-FUNS │ │ │ │ COMMON-LISP@ │ │ │ │ COMPONENT │ │ │ │ COMPONENT │ │ │ │ FOR-VALUE │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISPP%gD │ │ │ │ REST-ARG │ │ │ │ @@ -33623,24 +33606,42 @@ │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ +N-SIMPLE-FUNS │ │ │ │ FASL-OUTPUTH │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ Zc&U[$(@ │ │ │ │ $($0$8%g0 │ │ │ │ VAR-LOCS │ │ │ │ DERIVED-TYPE( │ │ │ │ DERIVED-VALUES-TYPE( │ │ │ │ LEAF-TYPEH │ │ │ │ REST-ARG │ │ │ │ +Assignment to argument: ~S │ │ │ │ + prevents use of assertion from function type ~A: │ │ │ │ +The result type from ~A: │ │ │ │ +conflicts with the definition's result type: │ │ │ │ +Not a function type: ~// │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +violating package lock on ~// │ │ │ │ +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 │ │ │ │ +~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ +~@ │ │ │ │ +using the lexical binding of the symbol ~//, not the │ │ │ │ +dynamic binding │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ HASH-TABLE │ │ │ │ @@ -33796,16 +33797,14 @@ │ │ │ │ CTYPE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ $($0$8$@$H$P$` │ │ │ │ COMMON-LISP │ │ │ │ -undefined ~(~A~): ~// │ │ │ │ -Bad bounding indices ~s, ~s for ~// │ │ │ │ FALLBACK │ │ │ │ INDEX-TYPE │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ $($0$8 ' │ │ │ │ SAME-LEAF8 │ │ │ │ COMMON-LISP0,g< │ │ │ │ @@ -33861,26 +33860,29 @@ │ │ │ │ ]r$F}X(v │ │ │ │ -,*)('%$#" │ │ │ │ tnljhfh10 │ │ │ │ ENVIRONMENT │ │ │ │ FORM SB-KERNEL │ │ │ │ Zy9[+-gP │ │ │ │ %s796jr' │ │ │ │ -COMPONENT-LAMBDA │ │ │ │ -COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ COMMON-LISP` │ │ │ │ CONTEXT8 │ │ │ │ REST-ARG │ │ │ │ 2BLOCKP2g` │ │ │ │ TZXt.) j │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ CONTEXT8 │ │ │ │ 2BDH!)R%- │ │ │ │ SB-ALIEN@ │ │ │ │ +undefined ~(~A~): ~// │ │ │ │ +Bad bounding indices ~s, ~s for ~// │ │ │ │ +COMPONENT-LAMBDA │ │ │ │ +COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ +TAILP-LVAR │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPH │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP03g< │ │ │ │ f`jy`;7]P │ │ │ │ REST-ARG │ │ │ │ COMPONENT │ │ │ │ @@ -33984,17 +33986,14 @@ │ │ │ │ FILE-INFO0 │ │ │ │ NAMEH'g< │ │ │ │ PREDICATE │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ CALLEE0?g< │ │ │ │ -TAILP-LVAR │ │ │ │ -LAMBDA-LIST │ │ │ │ -NEXT-VAR │ │ │ │ COMMON-LISP │ │ │ │ Pff(Zi(J │ │ │ │ DS-LAMBDA-LIST │ │ │ │ REST-VAR │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ R.dw?y#& │ │ │ │ @@ -34011,14 +34010,15 @@ │ │ │ │ FASL-OUTPUT@ │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPH │ │ │ │ NEGATIVE0 │ │ │ │ REST-ARG │ │ │ │ +ORIGINAL-START │ │ │ │ g,rUY;lw │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP@ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP` │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ @@ -34037,16 +34037,17 @@ │ │ │ │ YrU!\5F23 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMPONENT │ │ │ │ COMMON-LISPH │ │ │ │ +LAMBDA-LIST │ │ │ │ +NEXT-VAR │ │ │ │ COMMON-LISP │ │ │ │ -ORIGINAL-START │ │ │ │ REST-ARG │ │ │ │ SAME-LEAFP │ │ │ │ NEW-LEAF │ │ │ │ OLD-LEAF │ │ │ │ DEFINITIONS │ │ │ │ WRITE-P0 │ │ │ │ 8`~ng9]J │ │ │ │ @@ -34112,25 +34113,27 @@ │ │ │ │ SOURCE-LOC0 │ │ │ │ DEPRECATED-NAMES0 │ │ │ │ SITUATIONS │ │ │ │ N-RES(=g< │ │ │ │ NAME`$g< │ │ │ │ N-BYTES8 │ │ │ │ N-RES(0g< │ │ │ │ +Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ + method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ Define a function at top level. │ │ │ │ N-SRC()g< │ │ │ │ Move SRC into DST (unless they are location=. │ │ │ │ SOURCE-LOC@ │ │ │ │ $8UT*L{u │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP0 │ │ │ │ LET ({(var [value]) | var}*) declaration* form* │ │ │ │ During evaluation of the FORMS, bind the VARS to the result of evaluating the │ │ │ │ VALUE forms. The variables are bound in parallel after all of the VALUES forms │ │ │ │ have been evaluated. │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP0 │ │ │ │ SC-NUMBER5 │ │ │ │ COMMON-LISP │ │ │ │ POSITION │ │ │ │ COMMON-LISP8 │ │ │ │ SOURCE-LOCH │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -34156,16 +34159,14 @@ │ │ │ │ :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. │ │ │ │ -Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ - method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP@ │ │ │ │ Return a sequence of the same elements in reverse order; the argument │ │ │ │ is destroyed. │ │ │ │ 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. │ │ │ │ @@ -34197,27 +34198,27 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ SYS:SRC;CODE;STUBS.LISP │ │ │ │ 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. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -COMMON-LISP8 │ │ │ │ Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ Repeated labels in ASSEMBLE body │ │ │ │ ~:@(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. │ │ │ │ Undefined instruction: ~s in │ │ │ │ Undefined instruction: ~s in~% ~s │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +COMMON-LISP8 │ │ │ │ Oversized code component? │ │ │ │ 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. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ GENERIC-FUNCTION │ │ │ │ @@ -34266,24 +34267,22 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ fold division by 1 │ │ │ │ convert integer division to multiplication │ │ │ │ convert division by 2^k to shift │ │ │ │ INSTANCE0 │ │ │ │ +SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ -UB~D-BASH-COPY │ │ │ │ -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. │ │ │ │ INSTANCE0 │ │ │ │ +UB~D-BASH-COPY │ │ │ │ +automatically-generated makunbound method │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -34320,45 +34319,47 @@ │ │ │ │ NEW-VALUE │ │ │ │ SB-C0-gX │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP@ │ │ │ │ NEW-VALUE │ │ │ │ NEW-VALUE0 │ │ │ │ INSTANCE0 │ │ │ │ -COMMON-LISP │ │ │ │ -VALUE-TN │ │ │ │ +INSTANCE0 │ │ │ │ +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. │ │ │ │ +OPTIMIZE-DECL │ │ │ │ SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ -OPTIMIZE-DECL │ │ │ │ -automatically-generated makunbound method │ │ │ │ BEFORE-USES │ │ │ │ raw instance store │ │ │ │ SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ #.$V$_*P7 │ │ │ │ -bytes_allocated │ │ │ │ inline float round/truncate │ │ │ │ +COMMON-LISP │ │ │ │ +VALUE-TN │ │ │ │ TRUSTEDP │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPH │ │ │ │ -INSTANCE0 │ │ │ │ +raw instance access │ │ │ │ +bytes_allocated │ │ │ │ +d ^"{";#X# │ │ │ │ +inline array access │ │ │ │ +inline array store │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ NEWVAL("g0 │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP │ │ │ │ Return the name (a STRING) for a CHARACTER object. │ │ │ │ COMMON-LISPH │ │ │ │ NEW-VALUE │ │ │ │ CHAR-BAG` │ │ │ │ COMMON-LISPP │ │ │ │ -raw instance access │ │ │ │ -d ^"{";#X# │ │ │ │ -inline array access │ │ │ │ -inline array store │ │ │ │ P*[r=^cb │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ SB-ALIEN │ │ │ │ $P$($H$= │ │ │ │ ERROR-CODE` │ │ │ │ COMMON-LISPP │ │ │ │ @@ -34383,15 +34384,14 @@ │ │ │ │ SB-ALIEN(0gH │ │ │ │ TN-OFFSET │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISPP │ │ │ │ v:TC4F/tB │ │ │ │ NEW-VALUEH │ │ │ │ NEW-VALUEP │ │ │ │ -FLAG-TN` g< │ │ │ │ Implements CL:MAP for extended sequences. │ │ │ │ RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:MAP 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:MAP │ │ │ │ call. RESULT-PROTOTYPE may not be fully initialized and thus │ │ │ │ @@ -34404,27 +34404,45 @@ │ │ │ │ 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. │ │ │ │ -SYS:SRC;CODE;WEAK.LISP │ │ │ │ + ~V@<~//~> ~V:D bytes, ~V:D object~:P. │ │ │ │ +close_current_thread_tlab │ │ │ │ +close_code_region │ │ │ │ +wrapped_environ │ │ │ │ +wifcontinued │ │ │ │ +wifstopped │ │ │ │ +unlockpt │ │ │ │ +wait_for_exec │ │ │ │ +gc_pathfind │ │ │ │ +gc_and_save │ │ │ │ +setting the compiler-macro-function of ~A │ │ │ │ +~S names a special form. │ │ │ │ +can't SETF COMPILER-MACRO-FUNCTION when ENV is non-NIL │ │ │ │ +setting the macro-function of ~S │ │ │ │ +Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ +Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ +Cannot compare-and-swap slot ~S on: ~S │ │ │ │ +Using ~A as the class-name argument in ~ │ │ │ │ + (SETF FIND-CLASS) │ │ │ │ compiled function │ │ │ │ generic-function │ │ │ │ funcallable-instance │ │ │ │ interpreted function │ │ │ │ compiled closure │ │ │ │ The object is a │ │ │ │ Lambda-list │ │ │ │ Closed over values │ │ │ │ +FLAG-TN` g< │ │ │ │ N-STACK()g< │ │ │ │ Move the TN Reg-Or-Stack into Reg if it isn't already there. │ │ │ │ COMMON-LISPP │ │ │ │ - ~V@<~//~> ~V:D bytes, ~V:D object~:P. │ │ │ │ SB-ALIEN( │ │ │ │ S6!}k12Q │ │ │ │ PRIM-TYPE-NAME` │ │ │ │ )IzDe │ │ │ │ ~@<~S of ~S is an improper list.~@:> │ │ │ │ ~@<~S, in ~S ~S, is not a ~S.~@:> │ │ │ │ ~@ │ │ │ │ ~@<~S of ~S is neither ~S nor a ~S.~@:> │ │ │ │ ~S structure class │ │ │ │ ~Aconstructor │ │ │ │ -SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ error in ~S │ │ │ │ ~S is not a STANDARD-CLASS. │ │ │ │ -WRAPPER4 │ │ │ │ OTHER-SPECIALIZERS │ │ │ │ +WRAPPER4 │ │ │ │ # │ │ │ │ Tuple ~S not found │ │ │ │ loading │ │ │ │ -H0e`Nc`1 │ │ │ │ operation. │ │ │ │ operation │ │ │ │ resetting │ │ │ │ configuration. │ │ │ │ +H0e`Nc`1 │ │ │ │ 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. │ │ │ │ These functions were not called: │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ NEW-VALUE │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ -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. │ │ │ │ -SYS:SRC;COMPILER;RISCV;CHAR.LISP │ │ │ │ The dimension list is not constant; cannot open code array creation. │ │ │ │ ~S is not a ~S. │ │ │ │ ~@<~S is not a ~S (which is the ~S of ~S).~@:> │ │ │ │ ELEMENT-TYPE ~s is not a known type │ │ │ │ ELEMENT-TYPE is not constant. │ │ │ │ Can't specify :DISPLACED-TO and ~S │ │ │ │ :DISPLACED-TO potentially used with ~S │ │ │ │ +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. │ │ │ │ +SYS:SRC;COMPILER;RISCV;CHAR.LISP │ │ │ │ +SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ SYS:SRC;COMPILER;VMDEF.LISP │ │ │ │ INDEX-~D │ │ │ │ +SYS:SRC;PCL;DLISP3.LISP │ │ │ │ +CLEANUP-FUN-20 │ │ │ │ sb_getrusage │ │ │ │ sb_select │ │ │ │ sb_clock_gettime │ │ │ │ sb_utimes │ │ │ │ Starting a ~A without a timeout while interrupts are disabled. │ │ │ │ ~&=== Starting a ~A without a timeout while interrupts are disabled. === │ │ │ │ -SYS:SRC;PCL;DLISP3.LISP │ │ │ │ SB-ALIEN │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP@ │ │ │ │ TEMPLATE-BUFFER8 │ │ │ │ TEMPLATE-STRING │ │ │ │ @@ -36955,27 +36966,18 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -CLEANUP-FUN-20 │ │ │ │ +ARGS-MINIMAL │ │ │ │ ~@ │ │ │ │ -Structure slots can't be unbound. │ │ │ │ -structure-object │ │ │ │ -The object is a STRUCTURE-OBJECT of type │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP8 │ │ │ │ -ARGS-MINIMAL │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ DEBUG-FUN │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ @@ -36990,14 +36992,17 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +can't dump wrapper for anonymous class: │ │ │ │ +Structure slots can't be unbound. │ │ │ │ +~@ │ │ │ │ BREAKPOINT0 │ │ │ │ DEBUG-VAR │ │ │ │ NEW-VALUE │ │ │ │ OLD-VALUE(&gD │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ @@ -37026,20 +37031,18 @@ │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNELH │ │ │ │ -VALUE SB-KERNEL@ │ │ │ │ -can't dump wrapper for anonymous class: │ │ │ │ -~@ │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP8 │ │ │ │ +COMMON-LISP8 │ │ │ │ You can't change the class of ~S to ~S │ │ │ │ because it isn't already an instance with metaclass ~S. │ │ │ │ ~S called on ~S, which is not yet finalized. │ │ │ │ standard-object │ │ │ │ Loading │ │ │ │ Don't know how to allocate ~S │ │ │ │ of type │ │ │ │ @@ -37083,36 +37086,43 @@ │ │ │ │ monolithic │ │ │ │ ASDF definition for system │ │ │ │ ;;; Built for │ │ │ │ character │ │ │ │ base-char │ │ │ │ standard-char │ │ │ │ The object is a STANDARD-OBJECT of type │ │ │ │ -SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ -SYS:SRC;CODE;C-CALL.LISP │ │ │ │ +Cannot allocate an instance of ~S. │ │ │ │ +The object is a SYMBOL. │ │ │ │ +Function │ │ │ │ +The object is a STRUCTURE-OBJECT of type │ │ │ │ +structure-object │ │ │ │ +COMMON-LISP │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNELH │ │ │ │ +VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ +SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ +SYS:SRC;CODE;C-CALL.LISP │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ SEMAPHORE0 │ │ │ │ -Cannot allocate an instance of ~S. │ │ │ │ -The object is a SYMBOL. │ │ │ │ -Function │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37151,27 +37161,20 @@ │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -SYS:SRC;CODE;BARRIER.LISP │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +a method lambda list │ │ │ │ +SYS:SRC;CODE;BARRIER.LISP │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ 3J6+8k8}A │ │ │ │ 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;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ @@ -37182,16 +37185,23 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ -a method lambda list │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37204,89 +37214,89 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ -NEW-CELLS │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ COMMON-LISP0 │ │ │ │ NEW-VALUE │ │ │ │ +NEW-CELLS │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ NEW-ALIST8 │ │ │ │ COMMON-LISP0 │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ +lisp_package_vector │ │ │ │ +SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL8 │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ -lisp_package_vector │ │ │ │ SB-IMPL@ │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ SB-IMPL( │ │ │ │ NEW-VALUE │ │ │ │ SB-IMPL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +SYS:SRC;COMPILER;ENVANAL.LISP │ │ │ │ +7'4/;1AAoGGW │ │ │ │ +SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ +Q}SbV>X Y │ │ │ │ +e7ilq2yR| │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ -SYS:SRC;COMPILER;ENVANAL.LISP │ │ │ │ -7'4/;1AAoGGW │ │ │ │ -SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ -Q}SbV>X Y │ │ │ │ -e7ilq2yR| │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -37318,29 +37328,28 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -~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? │ │ │ │ -encountered the non-standard lambda list keyword ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +LAST-LOSE │ │ │ │ +COALESCED │ │ │ │ +encountered the non-standard lambda list keyword ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37367,51 +37376,55 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +SYS:SRC;COMPILER;DFO.LISP │ │ │ │ +SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ +SYS:SRC;COMPILER;GTN.LISP │ │ │ │ +SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ +~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? │ │ │ │ +~&New code(~Db,~A): ~A │ │ │ │ +jit-code.txt │ │ │ │ +~&; Logging code allocation to ~S │ │ │ │ +ORIGINAL-KIND │ │ │ │ +SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ +SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -SYS:SRC;COMPILER;DFO.LISP │ │ │ │ -SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ -SYS:SRC;COMPILER;GTN.LISP │ │ │ │ -SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ -SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ -SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -LAST-LOSE │ │ │ │ -COALESCED │ │ │ │ -ORIGINAL-KIND │ │ │ │ -LAST-POP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +LAST-POP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37432,35 +37445,36 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -SYS:SRC;COMPILER;STACK.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +SYS:SRC;COMPILER;STACK.LISP │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ PHYSICAL-NWORDS │ │ │ │ JUMPTABLE-WORD │ │ │ │ Argument and/or result bit arrays are not the same length:~ │ │ │ │ ~% ~S~% ~S ~% ~S │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ +BLOCK-DELETE-P │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37489,15 +37503,14 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -BLOCK-DELETE-P │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -37528,37 +37541,34 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ -~&New code(~Db,~A): ~A │ │ │ │ -jit-code.txt │ │ │ │ -~&; Logging code allocation to ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -$&%B%X%m& │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +$&%B%X%m& │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -37572,16 +37582,14 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -load TN allocated, but no move function?~@ │ │ │ │ - VM definition is inconsistent, recompile and try again. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -37591,14 +37599,17 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +load TN allocated, but no move function?~@ │ │ │ │ + VM definition is inconsistent, recompile and try again. │ │ │ │ +TEMPLATE-CONDITIONAL-P │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37615,36 +37626,27 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -TEMPLATE-CONDITIONAL-P │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ more-arg-context │ │ │ │ -address ~X not in the code component ~S │ │ │ │ -; Jump table (~d entries) @ ~X │ │ │ │ -; ~vt~v,'02x = ~a │ │ │ │ -~@ │ │ │ │ -error printing ~a {~x} │ │ │ │ -error printing object │ │ │ │ -~@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37677,14 +37679,23 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ COMMON-LISP │ │ │ │ SYS:SRC;COMPILER;PACK.LISP │ │ │ │ +address ~X not in the code component ~S │ │ │ │ +; Jump table (~d entries) @ ~X │ │ │ │ +; ~vt~v,'02x = ~a │ │ │ │ +~@ │ │ │ │ +error printing ~a {~x} │ │ │ │ +error printing object │ │ │ │ +~@ │ │ │ │ +~S cannot handle the second argument ~S. │ │ │ │ SEGMENT0 │ │ │ │ SECTION0 │ │ │ │ STATEMENT@ │ │ │ │ SB-IMPLP │ │ │ │ SB-IMPLH8g@ │ │ │ │ Return the current position for LABEL. Chooser maybe-shrink functions │ │ │ │ should supply IF-AFTER and DELTA in order to ensure correct results. │ │ │ │ @@ -37724,15 +37735,14 @@ │ │ │ │ SLOT-NAMEP │ │ │ │ SLOT-NAMEP │ │ │ │ SLOT-NAMEP │ │ │ │ the current number of recursive LOADs │ │ │ │ Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ fold identity operation │ │ │ │ T+:j&mT8 │ │ │ │ -~S cannot handle the second argument ~S. │ │ │ │ ~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.) │ │ │ │ ~W~:[~;[~W~]] │ │ │ │ unknown TRACE option: ~S │ │ │ │ invoking debugger command while outside the debugger │ │ │ │ (The HELP string is stored in ~S.) │ │ │ │ @@ -37773,40 +37783,56 @@ │ │ │ │ Can't restart ~S: no function for frame. │ │ │ │ ~@ │ │ │ │ dynamic-extent: ~S │ │ │ │ error printing dynamic-extent object │ │ │ │ more unavailable arguments │ │ │ │ frame number: │ │ │ │ The ~A of the stack was encountered. │ │ │ │ -FORM SB-KERNELP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ -03c DQLE │ │ │ │ -inline non-SIMPLE-vector-handling logic │ │ │ │ -SYS:SRC;CODE;NTRACE.LISP │ │ │ │ -Tests if STRING is normalized to FORM │ │ │ │ -COMMON-LISP( │ │ │ │ -METHOD-CELLH │ │ │ │ -MORE-ARG │ │ │ │ -RESTART-FRAME │ │ │ │ -LIST-LOCALS │ │ │ │ ~@<~S ~_= ~:[; No values~;~:*~{~S~^, ~}~]~:> │ │ │ │ ; No values │ │ │ │ missing argument to ~S TRACE option │ │ │ │ ~S is not a valid ~A ~S type. │ │ │ │ can't figure out the function for this frame │ │ │ │ ; No debug variables for current frame: using EVAL instead of EVAL-IN-FRAME. │ │ │ │ Function is not TRACEd: ~S │ │ │ │ unavailable lambda list │ │ │ │ unavailable &REST argument │ │ │ │ unavailable &MORE argument │ │ │ │ The argument specification ~S is out of range. │ │ │ │ invalid &REST argument before n'th argument │ │ │ │ unused &REST argument before n'th argument │ │ │ │ -because │ │ │ │ +FORM SB-KERNELP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ +03c DQLE │ │ │ │ +inline non-SIMPLE-vector-handling logic │ │ │ │ +Tests if STRING is normalized to FORM │ │ │ │ +COMMON-LISP( │ │ │ │ +METHOD-CELLH │ │ │ │ +MORE-ARG │ │ │ │ +SYS:SRC;CODE;NTRACE.LISP │ │ │ │ +RESTART-FRAME │ │ │ │ +LIST-LOCALS │ │ │ │ +SYS:SRC;CODE;SHOW.LISP │ │ │ │ result type unsuitable │ │ │ │ +RESULT-TYPE argument not constant │ │ │ │ +can't analyze sequence type relationship │ │ │ │ +non-trivial :KEY or :TEST │ │ │ │ +gc_card_table_mask │ │ │ │ +gc_card_mark │ │ │ │ +SYS:SRC;CODE;ICF.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;SAP.LISP │ │ │ │ +Dynamic space │ │ │ │ +Read-only space │ │ │ │ +Static space │ │ │ │ +Control stack │ │ │ │ +Binding stack │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISPH │ │ │ │ +COMMON-LISP0 │ │ │ │ X|!bMXg) │ │ │ │ }T*4p]1>< │ │ │ │ n>S7Auh7 │ │ │ │ T*4p]1>< │ │ │ │ }T*4p*W │ │ │ │ 4"YsOpG6 │ │ │ │ Rrvcgvg w │ │ │ │ @@ -38402,63 +38428,83 @@ │ │ │ │ qRr,'KHY │ │ │ │ tr`^m"R6 │ │ │ │ r|t."@rSU │ │ │ │ ^,=(Q,gD │ │ │ │ h]m2_]rxc] │ │ │ │ |8wfyQS8 │ │ │ │ H>p|[by6 │ │ │ │ -RESULT-TYPE argument not constant │ │ │ │ -can't analyze sequence type relationship │ │ │ │ -non-trivial :KEY or :TEST │ │ │ │ -gc_card_table_mask │ │ │ │ -gc_card_mark │ │ │ │ -SYS:SRC;CODE;ICF.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;SAP.LISP │ │ │ │ -SYS:SRC;CODE;SHOW.LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISPH │ │ │ │ COMMON-LISP0 │ │ │ │ -COMMON-LISP0 │ │ │ │ -Dynamic space │ │ │ │ -Read-only space │ │ │ │ -Static space │ │ │ │ -Control stack │ │ │ │ -Binding stack │ │ │ │ -The array has dimensions ~S, ~W is too large. │ │ │ │ -The array dimensions are unknown; must call ARRAY-DIMENSION at runtime. │ │ │ │ -The axis is not constant. │ │ │ │ -w~]sqo|zxNALT │ │ │ │ -a generic function lambda list │ │ │ │ -FORMAT-ARG2 SB-FORMAT │ │ │ │ -COMMON-LISP │ │ │ │ -'kZsp@*Pd │ │ │ │ HOST SB-KERNEL │ │ │ │ TRANSLATIONS │ │ │ │ Set the translations list for the logical host argument. │ │ │ │ COMMON-LISP0 │ │ │ │ -U`m< │ │ │ │ -WS7Auh7v │ │ │ │ -}U~A+%vg) │ │ │ │ -SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;SANCTIFY.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;INSTS.LISP │ │ │ │ -% )T+Q.e0 │ │ │ │ -SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ COMMON-LISP8 │ │ │ │ SB-IMPLP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP8 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP@ │ │ │ │ READTABLE │ │ │ │ COMMON-LISPH │ │ │ │ +lisp_init_function │ │ │ │ +tot_gc_nsec │ │ │ │ +gc_coalesce_string_literals │ │ │ │ +because │ │ │ │ +a generic function lambda list │ │ │ │ +U`m< │ │ │ │ +WS7Auh7v │ │ │ │ +}U~A+%vg) │ │ │ │ +Multiple ~S options in DEFCLASS ~S. │ │ │ │ +~S is not a legal :documentation value │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~S is not a legal defclass option. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +The array has dimensions ~S, ~W is too large. │ │ │ │ +The array dimensions are unknown; must call ARRAY-DIMENSION at runtime. │ │ │ │ +The axis is not constant. │ │ │ │ +$($0$8$@ │ │ │ │ +COMMON-LISP8 │ │ │ │ +COMMON-LISP0 │ │ │ │ + NEW-VALUE │ │ │ │ +SB-C( g| │ │ │ │ +COMMON-LISP@ │ │ │ │ +COMMON-LISP0 │ │ │ │ +SEQUENCE │ │ │ │ +COMMON-LISPH │ │ │ │ + SLOT-NAME │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISPH │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISPH │ │ │ │ +COMMON-LISP@ │ │ │ │ +$M$0$p$U │ │ │ │ + BIT-ARRAY │ │ │ │ + NEW-VALUE │ │ │ │ +MORE-ARG │ │ │ │ +COMMON-LISPH │ │ │ │ + NEW-VALUE@ │ │ │ │ +COMMON-LISPH │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +w~]sqo|zxNALT │ │ │ │ +FORMAT-ARG2 SB-FORMAT │ │ │ │ +COMMON-LISP │ │ │ │ +'kZsp@*Pd │ │ │ │ +Replace the function binding │ │ │ │ +SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;SANCTIFY.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;INSTS.LISP │ │ │ │ +% )T+Q.e0 │ │ │ │ +SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ +SYS:SRC;CODE;MISC.LISP │ │ │ │ End-Selected-Area │ │ │ │ Message-Waiting │ │ │ │ Start-String │ │ │ │ Application-Program-Command │ │ │ │ Device-Control-String │ │ │ │ Privacy-Message │ │ │ │ No-Break-Permitted │ │ │ │ @@ -38481,44 +38527,38 @@ │ │ │ │ Set-Transmit-State │ │ │ │ End-Guarded-Area │ │ │ │ Control-Sequence-Introducer │ │ │ │ Private-Use-Two │ │ │ │ Character-Tabulation-With-Justification │ │ │ │ Linefeed │ │ │ │ Reverse-Linefeed │ │ │ │ -$($0$8$@ │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP0 │ │ │ │ - NEW-VALUE │ │ │ │ -SB-C( g| │ │ │ │ -COMMON-LISP@ │ │ │ │ -COMMON-LISP0 │ │ │ │ -SEQUENCE │ │ │ │ -COMMON-LISPH │ │ │ │ - SLOT-NAME │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISPH │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISPH │ │ │ │ -COMMON-LISP@ │ │ │ │ -$M$0$p$U │ │ │ │ - BIT-ARRAY │ │ │ │ - NEW-VALUE │ │ │ │ -MORE-ARG │ │ │ │ -COMMON-LISPH │ │ │ │ - NEW-VALUE@ │ │ │ │ -COMMON-LISPH │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ +COMMON-LISP(A'< │ │ │ │ +TRUSTEDP │ │ │ │ COMMON-LISP0 │ │ │ │ NEW-VALUE( │ │ │ │ READTABLE │ │ │ │ COMMON-LISP0'gt │ │ │ │ Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE. │ │ │ │ SB-ALIEN( │ │ │ │ +SYS:SRC;CODE;LINUX-OS.LISP │ │ │ │ +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. │ │ │ │ +KV-VECTOR-SUPPLEMENT │ │ │ │ +loading ~S │ │ │ │ +loading stuff from ~S │ │ │ │ +;;;;;;;;;;;;;;;; │ │ │ │ +SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ +~S outside of a effective method form │ │ │ │ +dynamic_space_size │ │ │ │ +inline (unsigned-byte 64) logcount │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN( │ │ │ │ SB-ALIEN(3gD │ │ │ │ SB-ALIEN( │ │ │ │ NEW-VALUEH │ │ │ │ READTABLE │ │ │ │ @@ -38537,88 +38577,61 @@ │ │ │ │ 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 │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIENN │ │ │ │ -SYS:SRC;CODE;MISC.LISP │ │ │ │ -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. │ │ │ │ -Multiple ~S options in DEFCLASS ~S. │ │ │ │ -~S is not a legal :documentation value │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~S is not a legal defclass option. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -Replace the function binding │ │ │ │ -loading ~S │ │ │ │ -loading stuff from ~S │ │ │ │ -;;;;;;;;;;;;;;;; │ │ │ │ -SYS:SRC;CODE;LINUX-OS.LISP │ │ │ │ -KV-VECTOR-SUPPLEMENT │ │ │ │ -COMMON-LISP(A'< │ │ │ │ -TRUSTEDP │ │ │ │ -~S outside of a effective method form │ │ │ │ -inline (unsigned-byte 64) logcount │ │ │ │ -SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ -dynamic_space_size │ │ │ │ -SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ -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;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ -SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ COMMON-LISP0 │ │ │ │ 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. │ │ │ │ SB-ALIEN@ │ │ │ │ SB-ALIEN │ │ │ │ +SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ +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;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ +SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +pv table index lock │ │ │ │ +Specializer lock │ │ │ │ +second argument type too vague │ │ │ │ ENTRIESH │ │ │ │ NUMBER-MATCHABLE-P0 │ │ │ │ ONLY-INITIAL-ENTRIES8 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP` │ │ │ │ $($0$8$@ │ │ │ │ DEFAULT-PRINTER8 │ │ │ │ COMMON-LISP0 │ │ │ │ $($0$8$@ │ │ │ │ COMMON-LISPP │ │ │ │ MNEMONIC8 │ │ │ │ OPERANDS@ │ │ │ │ -PATTERN8 │ │ │ │ -SIZE0%g4 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -pv table index lock │ │ │ │ -Specializer lock │ │ │ │ -second argument type too vague │ │ │ │ 'Mz6iM;lA │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +PATTERN8 │ │ │ │ +SIZE0%g4 │ │ │ │ $P$0$8$@ │ │ │ │ ALIGNMENT0 │ │ │ │ MAYBE-SHRINK8 │ │ │ │ WORST-CASE-FUN@%g4 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ ALIGNMENTH │ │ │ │ ARGUMENT-COLUMN0 │ │ │ │ FUN-HOOKS8 │ │ │ │ $($0$8$@$H │ │ │ │ $($0$8$@ │ │ │ │ PRIORITY0 │ │ │ │ TEST-FN@ │ │ │ │ @@ -38628,39 +38641,39 @@ │ │ │ │ MACRO-ENVIRONMENT0 │ │ │ │ SOURCE-CODEH │ │ │ │ UNIVERSE8 │ │ │ │ $($0$8$@ │ │ │ │ GENERATOR0 │ │ │ │ GENERATOR-LAMBDA8 │ │ │ │ GENSYMSP │ │ │ │ -ACCESSOR-TYPE@ │ │ │ │ -ACCESSOR-TYPEH │ │ │ │ -WRAPPER08 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +ACCESSOR-TYPE@ │ │ │ │ +ACCESSOR-TYPEH │ │ │ │ +WRAPPER08 │ │ │ │ $($0$8$@ │ │ │ │ ACCESSOR-TYPEP │ │ │ │ WRAPPER08 │ │ │ │ WRAPPER1@ │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Yod';og{ │ │ │ │ COMMON-LISP │ │ │ │ Convert a LIST into hash-table that has the same elements when viewed as a set, │ │ │ │ up to the given equality TEST │ │ │ │ +0P`1:F?? │ │ │ │ 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. │ │ │ │ -0P`1:F?? │ │ │ │ R{-eBy8$ │ │ │ │ OarWSxF! │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP8 │ │ │ │ OLD-CONSH │ │ │ │ REST-ARG │ │ │ │ @@ -38669,59 +38682,59 @@ │ │ │ │ character tagging │ │ │ │ signed word to integer coercion │ │ │ │ unsigned word to integer coercion │ │ │ │ SAP to pointer coercion │ │ │ │ float to pointer coercion │ │ │ │ complex single float to pointer coercion │ │ │ │ complex double float to pointer coercion │ │ │ │ -What a funky instruction. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ +~//~:[~:; ~:S~] │ │ │ │ +can't tell the rank at compile time │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ +Returns a sequence iterator for SEQUENCE, START, END and FROM-END │ │ │ │ + as three values: │ │ │ │ + 1. iterator state │ │ │ │ + 2. limit │ │ │ │ + 3. from-end │ │ │ │ + The returned iterator can be used with the generic iterator │ │ │ │ + functions ITERATOR-STEP, ITERATOR-ENDP, ITERATOR-ELEMENT, (SETF │ │ │ │ + ITERATOR-ELEMENT), ITERATOR-INDEX and ITERATOR-COPY. │ │ │ │ +Implements CL:CONCATENATE for extended sequences. │ │ │ │ + RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:CONCATENATE │ │ │ │ + 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. │ │ │ │ .DOLIST-CAREFULLY. │ │ │ │ COMMON-LISP │ │ │ │ QUALIFIERS │ │ │ │ .DOLIST-CAREFULLY. │ │ │ │ COMMON-LISP │ │ │ │ SPECIALIZERS │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ $($0$`$! │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP │ │ │ │ INITARGS │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPP │ │ │ │ DSLOTDSH │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP` │ │ │ │ -can't tell the rank at compile time │ │ │ │ -Returns a sequence iterator for SEQUENCE, START, END and FROM-END │ │ │ │ - as three values: │ │ │ │ - 1. iterator state │ │ │ │ - 2. limit │ │ │ │ - 3. from-end │ │ │ │ - The returned iterator can be used with the generic iterator │ │ │ │ - functions ITERATOR-STEP, ITERATOR-ENDP, ITERATOR-ELEMENT, (SETF │ │ │ │ - ITERATOR-ELEMENT), ITERATOR-INDEX and ITERATOR-COPY. │ │ │ │ -Implements CL:CONCATENATE for extended sequences. │ │ │ │ - RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:CONCATENATE │ │ │ │ - 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. │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP` │ │ │ │ SPECIALIZERS │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP` │ │ │ │ SPECIALIZERS │ │ │ │ COMMON-LISP@ │ │ │ │ CONTEXTP │ │ │ │ METHOD-LAMBDAH │ │ │ │ EARLY-METHOD82g4 │ │ │ │ @@ -38737,15 +38750,14 @@ │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ SLOT-NAME@ │ │ │ │ fmt$RI26G7LGHF5S │ │ │ │ $g>q=S$ │ │ │ │ TEST-NOT0 │ │ │ │ -~//~:[~:; ~:S~] │ │ │ │ Copy the contents of the INPUT stream into the OUTPUT stream. │ │ │ │ If LINEWISE is true, then read and copy the stream line by line, with an optional PREFIX. │ │ │ │ Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE. │ │ │ │ Read the contents of the INPUT stream as a string │ │ │ │ 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. │ │ │ │ @@ -38793,64 +38805,63 @@ │ │ │ │ and NIL NAME, TYPE and VERSION components │ │ │ │ Given a pathname designator PATH, return an absolute pathname as specified by PATH │ │ │ │ considering the DEFAULTS, or, if not possible, use CALL-FUNCTION on the specified ON-ERROR behavior, │ │ │ │ with a format control-string and other arguments as arguments │ │ │ │ FUNCTION │ │ │ │ COMMON-LISPH │ │ │ │ Call a HOOK around the execution of FUNCTION │ │ │ │ -/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ -CLEANUP-FUN-134 │ │ │ │ ASDF/COMPONENT@ │ │ │ │ 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), │ │ │ │ a SYMBOL (designing its name, downcased), or a STRING (designing itself). │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ ASDF/COMPONENT │ │ │ │ Return a system of given NAME that was registered already, │ │ │ │ if such a system exists. NAME is a system designator, to be │ │ │ │ normalized by COERCE-NAME. The value returned is a system object, │ │ │ │ or NIL if not found. │ │ │ │ +/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ +CLEANUP-FUN-134 │ │ │ │ Checks whether a feature expression X is true with respect to the *FEATURES* set, │ │ │ │ as per the CLHS standard for #+ and #-. Beware that just like the CLHS, │ │ │ │ we assume symbols from the KEYWORD package are used, but that unless you're using #+/#- │ │ │ │ your reader will not have magically used the KEYWORD package, so you need specify │ │ │ │ keywords explicitly. │ │ │ │ COMPONENT │ │ │ │ ASDF/COMPONENTP │ │ │ │ DEP-SPECH │ │ │ │ fmt$ZR8OSH9NP4N │ │ │ │ Given a plan, an action, and a function that given the plan accesses a set of overrides, │ │ │ │ i.e. force or force-not, see if the override applies to the current action. │ │ │ │ +1__CDKk │ │ │ │ Reduce the direct dependencies to a value computed by iteratively calling COMBINATOR │ │ │ │ for each dependency action on the dependency's operation and component and an accumulator │ │ │ │ initialized with SEED. │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPP │ │ │ │ Given a system designator NAME, return the name of the corresponding │ │ │ │ primary system, after which the .asd file in which it is defined is named. │ │ │ │ If given a string or symbol (to downcase), do it syntactically │ │ │ │ by stripping anything from the first slash on. │ │ │ │ If given a component, do it semantically by extracting │ │ │ │ the system-primary-system-name of its system from its source-file if any, │ │ │ │ falling back to the syntactic criterion if none. │ │ │ │ Return the earliest status later than both status1 and status2 │ │ │ │ -1__CDKk │ │ │ │ -lnT oY0( │ │ │ │ -ERROR-PH │ │ │ │ -OPTIONAL-ARGS │ │ │ │ fmt$TY0UJ631N0JS │ │ │ │ fmt$3DBTSA9LSREW │ │ │ │ Tf)s5\ [> │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP0 │ │ │ │ Try to upgrade of ASDF. If a different version was used, return T. │ │ │ │ We need do that before we operate on anything that may possibly depend on ASDF. │ │ │ │ Given a SYSTEM object, register it. │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ +lnT oY0( │ │ │ │ +ERROR-PH │ │ │ │ +OPTIONAL-ARGS │ │ │ │ COMMON-LISP@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ 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: │ │ │ │ @@ -38896,14 +38907,15 @@ │ │ │ │ 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. │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ Reset the counters for all profiled functions. │ │ │ │ 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. │ │ │ │ @@ -38912,65 +38924,59 @@ │ │ │ │ ARGUMENTS` │ │ │ │ COMMON-LISPp │ │ │ │ REST-ARG │ │ │ │ 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 │ │ │ │ one of :MANIFEST-FILE, :ASDF-PATH, or :ASDF-TREE. │ │ │ │ +DISPATCHED-ENTRIES │ │ │ │ +PSEUDOSYMBOL │ │ │ │ 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. │ │ │ │ If names are supplied, wrap profiling code around the named functions. │ │ │ │ As in TRACE, the names are not evaluated. A symbol names a function. │ │ │ │ A string names all the functions named by symbols in the named │ │ │ │ package. If a function is already profiled, then unprofile and │ │ │ │ reprofile (useful to notice function redefinition.) If a name is │ │ │ │ undefined, then we give a warning and ignore it. See also │ │ │ │ UNPROFILE, REPORT and RESET. │ │ │ │ -DISPATCHED-ENTRIES │ │ │ │ -PSEUDOSYMBOL │ │ │ │ convert (- 0 x) to negate │ │ │ │ The type is not constant at compile time; can't open code. │ │ │ │ COMMON-LISP` │ │ │ │ SECONDS0 │ │ │ │ -FUNCTION doc-type is not supported. │ │ │ │ +COMMON-LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;SYSTEM.LISP │ │ │ │ ;; loading file │ │ │ │ ;; loading system │ │ │ │ +FUNCTION doc-type is not supported. │ │ │ │ +~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ 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 │ │ │ │ ~2&Assembler input: │ │ │ │ ~:@(~A~) ~{~A~^, ~}~A │ │ │ │ # Unused labels: │ │ │ │ # end of input │ │ │ │ # postit ~S~A │ │ │ │ # ~{~@[~A~^, ~]~} │ │ │ │ (notused) │ │ │ │ ~A~{~A: ~}~A │ │ │ │ -IN-WITHOUT-SCHEDULING │ │ │ │ -No encoder for ~S │ │ │ │ 1.0.11.18 │ │ │ │ Load the fasl file anyway │ │ │ │ -COMMON-LISP │ │ │ │ +FOP stack underflow │ │ │ │ SECONDS0 │ │ │ │ -COMMON-LISP │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -COMMON-LISP │ │ │ │ -$}$8 P g< │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -SYS:SRC;COMPILER;RISCV;SYSTEM.LISP │ │ │ │ -$}$8 P g< │ │ │ │ -OPTIONAL-ARGS │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ @@ -39040,18 +39046,22 @@ │ │ │ │ COMMON-LISP │ │ │ │ NUMBER-REQUIRED8 │ │ │ │ SPECIALIZED-POSITIONS`*g< │ │ │ │ OPTIONAL-ARGS │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ +OPTIONAL-ARGS │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ +$}$8 P g< │ │ │ │ +OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ SPECIALIZER │ │ │ │ REST-ARG │ │ │ │ jbN6rEWB │ │ │ │ @@ -39067,14 +39077,16 @@ │ │ │ │ COMMON-LISP │ │ │ │ SYSTEM-NAME8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ +$}$8 P g< │ │ │ │ +OPTIONAL-ARGS │ │ │ │ COMMON-LISPH │ │ │ │ ASDF/COMPONENT │ │ │ │ INSTANCE SB-KERNEL` │ │ │ │ NEW-CLASSP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -39085,74 +39097,75 @@ │ │ │ │ COMPONENT8 │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ +COMMON-LISP │ │ │ │ zjM{ 1t6m │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISPH │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ wrong number of arguments; expected ~W, got ~W │ │ │ │ can't tell function type at compile time │ │ │ │ +~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ Non-list or improper list spliced in ~ │ │ │ │ the middle of a backquoted list. │ │ │ │ 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. │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~// is undefined, not tracing. │ │ │ │ +MISS-FN- │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ -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. │ │ │ │ -MISS-FN- │ │ │ │ WITHOUT-INTERRUPTS-BODY-1 │ │ │ │ bffffffF │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~// is undefined, not tracing. │ │ │ │ can't compile TYPEP of anonymous or undefined class: │ │ │ │ TEMP-VAR8 │ │ │ │ -SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ 5l:d9+~ │ │ │ │ +SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ ASMSTREAM`4g< │ │ │ │ ~$|hgW`[/ │ │ │ │ +START-LVAR │ │ │ │ +NODE-BLOCK │ │ │ │ Returns as multiple values a descriptive name for the function responsible │ │ │ │ for FRAME, arguments that that function, and a list providing additional │ │ │ │ information about the frame. │ │ │ │ Unavailable arguments are represented using dummy-objects printing as │ │ │ │ #. │ │ │ │ METHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames │ │ │ │ corresponding to method functions are printed. Possible values │ │ │ │ are :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more │ │ │ │ information. │ │ │ │ If REPLACE-DYNAMIC-EXTENT-OBJECTS is true, objects allocated on the stack of │ │ │ │ the current thread are replaced with dummy objects which can safely escape. │ │ │ │ FUNCTION │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP@ │ │ │ │ -START-LVAR │ │ │ │ -NODE-BLOCK │ │ │ │ fixnum untagging │ │ │ │ integer to untagged word coercion │ │ │ │ word integer move │ │ │ │ constant load │ │ │ │ word integer argument move │ │ │ │ character untagging │ │ │ │ character move │ │ │ │ @@ -39170,25 +39183,24 @@ │ │ │ │ complex double-float arg move │ │ │ │ SYS:SRC;PCL;SLOT-NAME.LISP │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISPH │ │ │ │ EARLY-METHOD85g4 │ │ │ │ kYF}*Ba` │ │ │ │ -LAYOUT SB-KERNELP │ │ │ │ -FOP stack underflow │ │ │ │ ~&; While loading ~S: │ │ │ │ ~&~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 │ │ │ │ ~@ │ │ │ │ +LAYOUT SB-KERNELP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ tsS+F'6S*~^ │ │ │ │ DEFAULT8 │ │ │ │ UWP-BLOCK │ │ │ │ @@ -39202,29 +39214,27 @@ │ │ │ │ FRAME@$g4 │ │ │ │ LOCATIONP │ │ │ │ ARG-COUNT │ │ │ │ ESCAPED8 │ │ │ │ POINTER(5g@ │ │ │ │ $p$($`$8 │ │ │ │ ENCAPSULATED │ │ │ │ -SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ &G4D(E │ │ │ │ -~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ +)krp(lW- │ │ │ │ +STRING1( │ │ │ │ +RMYANCB_V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ Backspace │ │ │ │ COMMON-LISP8 g\ │ │ │ │ ~@?#N"KO │ │ │ │ -)krp(lW- │ │ │ │ -STRING1( │ │ │ │ RETURN-TYPE(B'<[ │ │ │ │ strength reduce large variable right shift │ │ │ │ Convert %ASH/RIGHT by constant back to ASH │ │ │ │ 1Vb\nG&Q │ │ │ │ expand inline │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH │ │ │ │ @@ -39239,66 +39249,65 @@ │ │ │ │ 5Tb|oG&Q │ │ │ │ COMMON-LISP │ │ │ │ SINGLE-WORD │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISPH │ │ │ │ DIMENSION( │ │ │ │ +~@ │ │ │ │ +~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP` │ │ │ │ SB-C5$'D │ │ │ │ -WITHOUT-GCING-BODY-8 │ │ │ │ -CLEANUP-FUN-9 │ │ │ │ -WITHOUT-GCING-BODY-0 │ │ │ │ -:FROM-END is not constant. │ │ │ │ OPTIONAL-ARGS │ │ │ │ ENVIRONMENT │ │ │ │ KEYWORDS-AND-FORMS │ │ │ │ UNIVERSE │ │ │ │ Q │ │ │ │ cannot use optimized accessor in safe code │ │ │ │ Cannot make slot ~S in ~S unbound. │ │ │ │ slot name is not an interned symbol │ │ │ │ +Something strange where symbol or class expected. │ │ │ │ +No SLOT-INFO for ~S in ~S │ │ │ │ +early method with no method-function │ │ │ │ +Retry calling the generic function. │ │ │ │ Unexpectedly small N-RANDOM-CHUNK-BITS │ │ │ │ ~S is an illegal control arg to BOOLE. │ │ │ │ BOOLE code is not a constant. │ │ │ │ Uknown upgraded array element type of the result │ │ │ │ The function doesn't have a fixed argument count. │ │ │ │ This shouldn't happen. │ │ │ │ Aliens of type ~S cannot be represented immediately. │ │ │ │ The alien type is not constant, so access cannot be open coded. │ │ │ │ auxiliary │ │ │ │ -SPECIALIZER │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ SYS:SRC;PCL;DLISP.LISP │ │ │ │ -The RESTP argument is not constant. │ │ │ │ illegal kind argument to ~S: ~S │ │ │ │ More than one method of type ~S ~ │ │ │ │ with the same specializers. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ Not a property list: ~S │ │ │ │ @@ -39386,35 +39395,40 @@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ bad argument to TYPE-CLASS │ │ │ │ ~S is not a standard-class │ │ │ │ ~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ -No generic function named ~S. │ │ │ │ The width of instruction bytes. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ SPECIALIZER │ │ │ │ +SPECIALIZER │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ +No generic function named ~S. │ │ │ │ +~@ │ │ │ │ +Cannot make structure slots unbound │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39426,246 +39440,80 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ w-=+Rnf` │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -~@ │ │ │ │ -Cannot make structure slots unbound │ │ │ │ -RESULT-CTYPE │ │ │ │ - SEQ-NAMES │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +RESULT-CTYPE │ │ │ │ + SEQ-NAMES │ │ │ │ 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. │ │ │ │ +/build/reproducible-path/sbcl-2.4.10/contrib/asdf/asdf.lisp │ │ │ │ Unpacked some operand TN. │ │ │ │ +)%D9ZI : │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP@ │ │ │ │ Like CL:FIND-PACKAGE, but by default raises a UIOP:NO-SUCH-PACKAGE-ERROR if the │ │ │ │ package is not found. │ │ │ │ OBJECT SB-KERNEL@ │ │ │ │ -)%D9ZI : │ │ │ │ +SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ What least subtype of CHARACTER can contain all the elements of all the STRINGS? │ │ │ │ PREDECESSOR0 │ │ │ │ STMT(&g0 │ │ │ │ -v\I8Zn/sgD │ │ │ │ -COMMON-LISP@ │ │ │ │ -SEGMENTH │ │ │ │ -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. │ │ │ │ -unexpected special form ~S │ │ │ │ -SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ -/build/reproducible-path/sbcl-2.4.10/contrib/asdf/asdf.lisp │ │ │ │ -load TN allocated, but no move function? │ │ │ │ -VM definition is inconsistent, recompile and try again. │ │ │ │ -SEGMENTP │ │ │ │ -SEGMENTP │ │ │ │ -$($H$8$0 │ │ │ │ -sR)V6`iCeF │ │ │ │ -$($0$H$P │ │ │ │ -$($0$H$P │ │ │ │ -$($0$H$P │ │ │ │ -$($0$H$P │ │ │ │ -$($0$H$P │ │ │ │ -$($0$H$P │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($`$8$0 │ │ │ │ -$($`$8$0 │ │ │ │ -$($`$8$0 │ │ │ │ -$($`$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$@ │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$0 │ │ │ │ -$($H$8$@ │ │ │ │ -$($H$8$@ │ │ │ │ -$($H$8$@ │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -SEGMENTP │ │ │ │ --NtyU}_Ucr │ │ │ │ -$($H$0$@ │ │ │ │ -$($H$0$@ │ │ │ │ -$($H$0$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$($P$`$8 │ │ │ │ -$}$($0$8 @ p │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8 @ p │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H P │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H P │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H P │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H P │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$($0$8$H │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$`$@ │ │ │ │ -$($0$8$H │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$($0$8$H │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@ ` │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H$P X │ │ │ │ -RS1`2@30 │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H$P X │ │ │ │ -RS1`2@30 │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H$P X │ │ │ │ -RS1`2@30 │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -$}$($0$8$@$H$P X │ │ │ │ -RS1`2@30 │ │ │ │ -SEGMENT( │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -SEGMENT@ │ │ │ │ -LAYOUT SB-KERNELH │ │ │ │ -SEGMENTP │ │ │ │ -.ANONYMOUS. │ │ │ │ -MARK-INDEX │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -$($0$H$@ │ │ │ │ -SEGMENT` │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -RD*/RS1* │ │ │ │ -SEGMENT` │ │ │ │ SIGNED-VALUE │ │ │ │ UNSIGNED-VALUE │ │ │ │ IMMEDIATE │ │ │ │ COMMON-LISPH │ │ │ │ METHOD-ARGSH │ │ │ │ PV-TABLE@ │ │ │ │ +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. │ │ │ │ +unexpected special form ~S │ │ │ │ +load TN allocated, but no move function? │ │ │ │ +VM definition is inconsistent, recompile and try again. │ │ │ │ 1 [}]I{XSx │ │ │ │ FORM SB-KERNEL │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ -$($0$8$` │ │ │ │ -ALLOW-OTHER-KEYS │ │ │ │ -MORE-CONTEXT │ │ │ │ measuring PROFILE overhead.. │ │ │ │ ignoring undefined function ~S │ │ │ │ ~S is already profiled, so unprofiling it first. │ │ │ │ ~@ │ │ │ │ +$($0$8$` │ │ │ │ +ALLOW-OTHER-KEYS │ │ │ │ +MORE-CONTEXT │ │ │ │ +WRAPPER7 │ │ │ │ +The function to call if there are errors in the command-line │ │ │ │ +buildapp application. │ │ │ │ sec/call │ │ │ │ | | Total │ │ │ │ estimated total profiling overhead: │ │ │ │ seconds │ │ │ │ overhead estimation parameters: │ │ │ │ s/call, │ │ │ │ s total profiling, │ │ │ │ s internal profiling │ │ │ │ ~&~@{ ~v:@<~A~>~^|~} │ │ │ │ ~S is not a profiled function. │ │ │ │ -WRAPPER7 │ │ │ │ -The function to call if there are errors in the command-line │ │ │ │ -buildapp application. │ │ │ │ /build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ VALUE`(g< │ │ │ │ INSTANCE SB-KERNEL@ │ │ │ │ -INSTANCE SB-KERNEL@ │ │ │ │ -LAMBDA-LISTH │ │ │ │ -LAMBDA-LIST@ │ │ │ │ -Return a list of forms to implement DUMPER's actions, i.e. the │ │ │ │ ---load, --load-system, --require, and --eval arguments. │ │ │ │ Save the forms of DUMPER to FILE. │ │ │ │ Return a list of all ASDF files in the directory tree at ROOT. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP@ │ │ │ │ Return a list of all system files contained in FILE. The syntax is │ │ │ │ one namestring per line. Relative namestrings are resolved relative to │ │ │ │ the truename of FILE. │ │ │ │ @@ -39673,71 +39521,73 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ ~]_#`~vj │ │ │ │ fmt$HQW0VPZFK1ML │ │ │ │ The function to call if there are errors when loading the dump file. │ │ │ │ fmt$M2JW6DDFPH9J │ │ │ │ Search for FILE in *LOAD-SEARCH-PATHS* and, if found, load │ │ │ │ it. If an exact filename is not found, file.lisp is also tried. │ │ │ │ +Return a list of forms to implement DUMPER's actions, i.e. the │ │ │ │ +--load, --load-system, --require, and --eval arguments. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$BPL3C5LP3DEM │ │ │ │ Load ASDF system identified by NAME. │ │ │ │ EXECUTABLE │ │ │ │ OPTIONAL-ARGS │ │ │ │ +INSTANCE SB-KERNEL@ │ │ │ │ +LAMBDA-LISTH │ │ │ │ +LAMBDA-LIST@ │ │ │ │ CHOOSERX │ │ │ │ SEGMENT` │ │ │ │ -GENERIC-FUNCTION │ │ │ │ -COMMON-LISP8 │ │ │ │ -WRAPPER0 │ │ │ │ $($0$8$@ │ │ │ │ APPLICATOR │ │ │ │ OPCODES1 │ │ │ │ OPCODES2 │ │ │ │ SEGMENTX │ │ │ │ SEGMENTP │ │ │ │ SEGMENT0 │ │ │ │ .FASL-INPUT.@ │ │ │ │ !C@D(P"r │ │ │ │ .FASL-INPUT.P │ │ │ │ .FASL-INPUT.H │ │ │ │ +.FASL-INPUT. │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP01g< │ │ │ │ +.FASL-INPUT. │ │ │ │ +.FASL-INPUT. │ │ │ │ +TBL-SLOT │ │ │ │ `a,@fLL) │ │ │ │ +COMMON-LISPP │ │ │ │ autom4te.cache │ │ │ │ cover_db │ │ │ │ -COMMON-LISPP │ │ │ │ +WRAPPER6 │ │ │ │ CONSTANTS │ │ │ │ COMMON-LISP( │ │ │ │ -WRAPPER6 │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ + ARG-NAMES( │ │ │ │ SKIPPING │ │ │ │ no unbounded alternate for SC ~S │ │ │ │ SC ~S doesn't have any :UNBOUNDED alternate SCs, but is │ │ │ │ a SC for primitive-type ~S. │ │ │ │ SC ~S doesn't have any :UNBOUNDED alternate SCs. │ │ │ │ failed to pack restricted TN ~S in its SC ~S │ │ │ │ ~&; Size: ~a bytes. Origin: #x~x~@[ (segment 1 of ~D)~] │ │ │ │ ~&; Origin #x~x (segment ~D of ~D) │ │ │ │ (&MORE ~s) │ │ │ │ (&OPTIONAL ~s) │ │ │ │ (XEP ~s) │ │ │ │ ~@ │ │ │ │ - ARG-NAMES( │ │ │ │ LENGTH-CHECKED-P@ │ │ │ │ Eh{0x|m\w │ │ │ │ convert to EQ test │ │ │ │ -Z0qx"3%Ve │ │ │ │ -.FASL-INPUT. │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP01g< │ │ │ │ -SYS:SRC;PCL;ECD.LISP │ │ │ │ -.FASL-INPUT. │ │ │ │ -.FASL-INPUT. │ │ │ │ -TBL-SLOT │ │ │ │ Continue using :external-format :default │ │ │ │ ~@ │ │ │ │ +SYS:SRC;PCL;ECD.LISP │ │ │ │ +Z0qx"3%Ve │ │ │ │ .FASL-INPUT. │ │ │ │ .FASL-INPUT. │ │ │ │ .FASL-INPUT. │ │ │ │ .FASL-INPUT.@ │ │ │ │ FASL-INPUTH │ │ │ │ NEW-VALUE │ │ │ │ TABLE8~}~:> │ │ │ │ FUN-NAME │ │ │ │ $($0$8$@ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ LOCATION@ │ │ │ │ +COMMON-LISP@ │ │ │ │ +MACRO-FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ LAYOUTSHMgH │ │ │ │ -~:<~W~^ ~3I~:_~W~^~1I~@{~:@_~:<~^~W~^ ~:I~@_~@{~W~^ ~_~}~:>~}~:> │ │ │ │ CLOSURE-VARIABLES │ │ │ │ COMMON-LISPp/gD │ │ │ │ -convert NTHCDR to CAxxR │ │ │ │ -HASH-KEYS │ │ │ │ -HASH-VALUES │ │ │ │ -EXTERNAL-SYMBOL │ │ │ │ -PRESENT-SYMBOL │ │ │ │ -PRESENT-SYMBOLS │ │ │ │ -named ~// │ │ │ │ -New lambda-list ~// is incompatible with existing methods of ~S. │ │ │ │ -Old lambda-list ~// │ │ │ │ -~@~@:> │ │ │ │ SYS:SRC;COMPILER;RISCV;CELL.LISP │ │ │ │ SYS:SRC;COMPILER;RISCV;ARRAY.LISP │ │ │ │ SYS:SRC;COMPILER;RISCV;DEBUG.LISP │ │ │ │ SYS:SRC;COMPILER;RISCV;ALLOC.LISP │ │ │ │ +convert NTHCDR to CAxxR │ │ │ │ SYS:SRC;ASSEMBLY;RISCV;ALLOC.LISP │ │ │ │ Invalid Huffman-code: ~S │ │ │ │ -Not a variable declaration the walker cares about: ~S │ │ │ │ -.~A ~S~:[~:A~;~] │ │ │ │ +RMYANCB_ │ │ │ │ +V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ 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 │ │ │ │ +Not a variable declaration the walker cares about: ~S │ │ │ │ +.~A ~S~:[~:A~;~] │ │ │ │ +multiple specializing masters: ~S │ │ │ │ +~@ │ │ │ │ +;;; [~W] │ │ │ │ +.SKIP ~D │ │ │ │ SEQUENCE-TYPE@ │ │ │ │ CHAR-BAG( │ │ │ │ SB-IMPL0?'~@:> │ │ │ │ +~@ │ │ │ │ +ELEMENT-TYPE( │ │ │ │ +REQUESTED-TYPE@ │ │ │ │ NAME(1g@ │ │ │ │ +CHAR-BAG( │ │ │ │ +SB-IMPL0?' │ │ │ │ CLASSES-LIST │ │ │ │ OPTIONAL-ARGS │ │ │ │ FORM SB-KERNEL8 │ │ │ │ BASE-POLICY0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ TABLE8;g< │ │ │ │ APPLICABLE-METHODS │ │ │ │ ALL-CPDS │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ -SI-AROUND │ │ │ │ -~@ │ │ │ │ 03mSVu>v │ │ │ │ CAM-METHODS │ │ │ │ E(`F@E6zA]F │ │ │ │ LINE-SIZE │ │ │ │ VECTOR-LENGTH │ │ │ │ CLASS-DEFAULT-INITARGS │ │ │ │ SUPPLIED-INITARGS │ │ │ │ @@ -39953,20 +39806,23 @@ │ │ │ │ COMMON-LISP │ │ │ │ $`$($0$@ │ │ │ │ FORM SB-KERNEL │ │ │ │ NEW-VALUEH │ │ │ │ REQUIRED-PARAMETERS │ │ │ │ SLOT-NAMEH │ │ │ │ LAMBDA-LISTX │ │ │ │ + SLOT-NAMEH │ │ │ │ +tV r │ │ │ │ METHOD-CALLp │ │ │ │ REQUIRED-ARGS+REST-ARG`+g< │ │ │ │ ]a*f_V1- │ │ │ │ ALL-CPDS( │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ 13r&7r"s2 │ │ │ │ @@ -40080,18 +39932,16 @@ │ │ │ │ COMMON-LISPP │ │ │ │ SLOT-NAMEH │ │ │ │ COMMON-LISP │ │ │ │ EARLY-METHOD8Dg4 │ │ │ │ PV-TABLE │ │ │ │ PV-WRAPPERS │ │ │ │ SLOT-NAME-LISTS │ │ │ │ -multiple specializing masters: ~S │ │ │ │ -~@ │ │ │ │ -;;; [~W] │ │ │ │ -.SKIP ~D │ │ │ │ + BYTE-SPECH │ │ │ │ +COMMON-LISP │ │ │ │ #X~2,'0x │ │ │ │ #x~8,'0x: ~a~@[ +~d~] │ │ │ │ loading to/from SCs that aren't alternates? │ │ │ │ VM definition is inconsistent, try recompiling. │ │ │ │ no load function defined to save SC ~S in its alternate SC ~S │ │ │ │ no load function defined to load SC ~S from its alternate SC ~S │ │ │ │ loading from an invalid constant SC? │ │ │ │ @@ -40187,25 +40037,17 @@ │ │ │ │ Can't bind constant symbol: ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ignoring unknown optimization quality ~S in ~S │ │ │ │ ~@ │ │ │ │ Tried to set a symbol-macrolet! │ │ │ │ +SYS:SRC;COMPILER;RISCV;TARGET-INSTS.LISP │ │ │ │ REST-ARG │ │ │ │ - BYTE-SPECH │ │ │ │ -COMMON-LISP │ │ │ │ -Invalid rounding mode mnemonic ~a. │ │ │ │ -~S isn't a register. │ │ │ │ STANDARD method combination accepts no options. │ │ │ │ -SYS:SRC;COMPILER;RISCV;TARGET-INSTS.LISP │ │ │ │ -CLEANUP-FUN-0 │ │ │ │ -CLEANUP-FUN-62 │ │ │ │ -CLEANUP-FUN-92 │ │ │ │ -CLEANUP-FUN-3 │ │ │ │ Strip a string X from any ending CR, LF or CRLF. │ │ │ │ Return two values, the stripped string and the ending that was stripped, │ │ │ │ or the original value and NIL if no stripping took place. │ │ │ │ Since our STRCAT accepts NIL as empty string designator, │ │ │ │ the two results passed to STRCAT always reconstitute the original string │ │ │ │ From an AT specification, extract a COUNT of maximum number │ │ │ │ of sub-objects to read as per ACCESS-AT │ │ │ │ @@ -40245,22 +40087,37 @@ │ │ │ │ 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. │ │ │ │ COUNTER@ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ +CLEANUP-FUN-0 │ │ │ │ +CLEANUP-FUN-62 │ │ │ │ +CLEANUP-FUN-92 │ │ │ │ +CLEANUP-FUN-3 │ │ │ │ Call FUN on all the valid dependencies of the given action in the given plan │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ RESOLVED(5'<~ │ │ │ │ NORMALIZED-NAMESTRING@ │ │ │ │ if X is a logical pathname, use translate-logical-pathname on it. │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ +Call the functions in *CLEAR-CONFIGURATION-HOOK* │ │ │ │ +Is this action valid to include amongst dependencies? │ │ │ │ +Detect circular dependencies │ │ │ │ +Return the same status but with the need bit set, for the given level │ │ │ │ +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. │ │ │ │ +MORE-ARG │ │ │ │ Given a system designator SYSTEM, return T if it designates a primary system, or else NIL. │ │ │ │ If given a string, do it syntactically and return true if the name does not contain a slash. │ │ │ │ If given a symbol, downcase to a string then fallback to previous case (NB: for NIL return T). │ │ │ │ If given a component, do it semantically and return T if it's a SYSTEM and its primary-system-name │ │ │ │ is the same as its component-name. │ │ │ │ Given a system NAME designator, try to locate where to load the system from. │ │ │ │ Returns six values: FOUNDP FOUND-SYSTEM PATHNAME PREVIOUS PREVIOUS-TIME PREVIOUS-PRIMARY │ │ │ │ @@ -40272,55 +40129,38 @@ │ │ │ │ PREVIOUS when not null is a previously loaded SYSTEM object of same name. │ │ │ │ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded. │ │ │ │ PREVIOUS-PRIMARY when not null is the primary system for the PREVIOUS system. │ │ │ │ Are the two pathnames P1 and P2 reasonably equal in the paths they denote? │ │ │ │ Load system definitions from PATHNAME. │ │ │ │ NAME if supplied is the name of a system expected to be defined in that file. │ │ │ │ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD. │ │ │ │ -Call the functions in *CLEAR-CONFIGURATION-HOOK* │ │ │ │ -Is this action valid to include amongst dependencies? │ │ │ │ -Detect circular dependencies │ │ │ │ -Return the same status but with the need bit set, for the given level │ │ │ │ -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. │ │ │ │ -MORE-ARG │ │ │ │ A partial test of the values of a component. │ │ │ │ Remove a list of keys from a plist │ │ │ │ \x-H|,lQm │ │ │ │ COMPONENT │ │ │ │ ASDF/COMPONENT@ │ │ │ │ COMMON-LISPH │ │ │ │ Is the PATHNAME under the current installation of the CL implementation? │ │ │ │ Parse the dependency defs in DD-LIST into canonical form by translating all │ │ │ │ system names contained using COERCE-NAME. Return the result. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ NEW-VALUE │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ $($0$8$@ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -LOCATION@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ - NEW-VALUE │ │ │ │ -$($0$8$@ │ │ │ │ SB-DISASSEM │ │ │ │ COMMON-LISP │ │ │ │ Given a SYSTEM and a GOAL-OPERATION (default LOAD-OP), traverse the dependencies and │ │ │ │ return a list of the components involved in building the desired action. │ │ │ │ Transform a portable ENCODING keyword to an implementation-dependent EXTERNAL-FORMAT, │ │ │ │ going through all the proper hooks. │ │ │ │ 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. │ │ │ │ -CLEANUP-FUN-48 │ │ │ │ SYSTEM-DESIGNATOR8 │ │ │ │ Return a pathname object corresponding to the directory │ │ │ │ in which the system specification (.asd file) is located. │ │ │ │ Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ ASDF/COMPONENTH │ │ │ │ Coerce a system designator NAME into a string suitable as a filename component. │ │ │ │ The (current) transformation is to replace characters /:\ each by --, │ │ │ │ @@ -40408,14 +40248,17 @@ │ │ │ │ For the latter case, we ought pick a random suffix and atomically open it. │ │ │ │ Combine a list of FASLs INPUTS into a single FASL OUTPUT │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP( │ │ │ │ PATHNAMES │ │ │ │ Ensure that for every pathname in PATHNAMES, we ensure its directories exist │ │ │ │ Portable wrapper around LOAD that properly handles loading from a stream. │ │ │ │ +*ASDF-VERSION* │ │ │ │ +*ASDF-REVISION* │ │ │ │ +CLEANUP-FUN-48 │ │ │ │ RESOLVE-SYMLINKS in PATH iff *RESOLVE-SYMLINKS* is T (the default). │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP` '< │ │ │ │ FILEP '< │ │ │ │ COMPONENT │ │ │ │ OPERATION` │ │ │ │ Compute a list of the direct dependencies of the action within the plan │ │ │ │ @@ -40441,14 +40284,19 @@ │ │ │ │ Variant of PRINC that also calls TERPRI afterwards │ │ │ │ This function takes a PATHNAME and a SUBPATH and a TYPE. │ │ │ │ If SUBPATH is already a PATHNAME object (not namestring), │ │ │ │ and is an absolute pathname at that, it is returned unchanged; │ │ │ │ otherwise, SUBPATH is turned into a relative pathname with given TYPE │ │ │ │ as per PARSE-UNIX-NAMESTRING with :WANT-RELATIVE T :TYPE TYPE, │ │ │ │ then it is merged with the PATHNAME-DIRECTORY-PATHNAME of PATHNAME. │ │ │ │ +$($0$8$@ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +LOCATION@ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ + NEW-VALUE │ │ │ │ SB-C0$g4 │ │ │ │ $($1$@$9 │ │ │ │ COMMON-LISPP │ │ │ │ MORE-ARG │ │ │ │ zwTD&N$S │ │ │ │ $H$($@$9 │ │ │ │ ADDRESS0 │ │ │ │ @@ -40457,16 +40305,14 @@ │ │ │ │ surplus arguments: ~S │ │ │ │ ENCODINGH │ │ │ │ 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* │ │ │ │ -V-8QXZ()7695JUITGPFK │ │ │ │ -OHED21430WSL │ │ │ │ sb-aclrepl │ │ │ │ sb-bsd-sockets │ │ │ │ sb-capstone │ │ │ │ sb-cltl2 │ │ │ │ sb-concurrency │ │ │ │ sb-cover │ │ │ │ sb-executable │ │ │ │ @@ -40476,52 +40322,44 @@ │ │ │ │ sb-queue │ │ │ │ sb-rotate-byte │ │ │ │ sb-simple-streams │ │ │ │ sb-sprof │ │ │ │ fiveam-asdf │ │ │ │ asdf-tools │ │ │ │ asdf-driver │ │ │ │ -*ASDF-VERSION* │ │ │ │ -*ASDF-REVISION* │ │ │ │ +c4Tw p(cD │ │ │ │ thread.~(~A~) │ │ │ │ Not written yet │ │ │ │ +Invalid rounding mode mnemonic ~a. │ │ │ │ breakpoint trap │ │ │ │ pending interrupt trap │ │ │ │ halt trap │ │ │ │ function end breakpoint trap │ │ │ │ single-step trap (around) │ │ │ │ single-step trap (before) │ │ │ │ Invalid argument count trap │ │ │ │ cerror trap │ │ │ │ +~S isn't a register. │ │ │ │ Illegal function call in method body: │ │ │ │ while handling code walker REPEAT: │ │ │ │ │ │ │ │ ran into STOP while still in REPEAT template │ │ │ │ -c4Tw p(cD │ │ │ │ +FROM-END- │ │ │ │ j``3N&qE/ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPH │ │ │ │ REST-ARG │ │ │ │ -FROM-END- │ │ │ │ +V-8QXZ()7695JUITGPFK │ │ │ │ +OHED21430WSL │ │ │ │ COMMON-LISP@ │ │ │ │ DECLARATION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP@ │ │ │ │ -DECLARATION │ │ │ │ -COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ -WRAPPER10 │ │ │ │ -searching │ │ │ │ -evaluated │ │ │ │ -absolute │ │ │ │ -directory. │ │ │ │ -replace │ │ │ │ -continue. │ │ │ │ SLOTS-TAIL8 │ │ │ │ GENERAL@ │ │ │ │ COMMON-LISPH │ │ │ │ ALIGNMENT │ │ │ │ PREFIX-LEN │ │ │ │ COMMON-LISP │ │ │ │ SEGMENT@ │ │ │ │ @@ -40529,15 +40367,19 @@ │ │ │ │ COMMON-LISPH │ │ │ │ Ln+C i ][: │ │ │ │ CUR-OFFS │ │ │ │ COMMON-LISP │ │ │ │ BYTE-OFFSET> │ │ │ │ INST0 gX │ │ │ │ SC+OFFSET │ │ │ │ +DECLARATION │ │ │ │ +COMMON-LISP │ │ │ │ +SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ COMMON-LISPP │ │ │ │ +WRAPPER10 │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ ADDRESSH │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPA │ │ │ │ ADDRESS@ │ │ │ │ DSTATE`)gd │ │ │ │ @@ -40585,15 +40427,14 @@ │ │ │ │ FORM SB-KERNEL │ │ │ │ FORMAT-ARGSP │ │ │ │ FORMAT-STRING` │ │ │ │ REST-ARG │ │ │ │ ANSWER-VARIABLE │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ -common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ STEPPER0 │ │ │ │ NEGATE SB-KERNEL │ │ │ │ $`$0$($@ │ │ │ │ DATA-TYPE │ │ │ │ FORM SB-KERNELH │ │ │ │ COMMON-LISP@ │ │ │ │ RESTRICTIVE │ │ │ │ @@ -40613,26 +40454,27 @@ │ │ │ │ COMMON-LISPP │ │ │ │ FUNCTION-DEF │ │ │ │ SPECIALS │ │ │ │ BINDING8 │ │ │ │ SPECIALS8.g8 │ │ │ │ BINDING0 │ │ │ │ Predicate that is true for an empty sequence │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +INSTRUCTION │ │ │ │ +SB-DISASSEM@ │ │ │ │ i\Ga wA> │ │ │ │ SITUATION0%g@ │ │ │ │ FORM SB-KERNELH │ │ │ │ PREVIOUS-EXP8'gD │ │ │ │ DECLARED-SPECIALS │ │ │ │ COMMON-LISP │ │ │ │ SPEC@)g< │ │ │ │ COMMON-LISP │ │ │ │ $X$0$8$@$H$P$($p$` │ │ │ │ OBJECT KERNEL@ │ │ │ │ -TMP2`&g< │ │ │ │ -Append onto list │ │ │ │ COMMON-LISP0 │ │ │ │ FORMAT-ARGUMENTS` │ │ │ │ FORMAT-CONTROL SB-KERNELp │ │ │ │ REST-ARG │ │ │ │ DECLARATIONS │ │ │ │ SPECIALS`+g@ │ │ │ │ DEFINITION` │ │ │ │ @@ -40643,14 +40485,35 @@ │ │ │ │ Return the first character of a non-empty string S, or NIL │ │ │ │ COMMON-LISP │ │ │ │ Does STRING end with SUFFIX? │ │ │ │ NAME-DESIGNATORH''< │ │ │ │ Given a NAME-DESIGNATOR for a symbol, if it is a symbol, convert it to a string using STRING; │ │ │ │ if it is a string, use STRING-UPCASE on an ANSI CL platform, or STRING on a so-called "modern" │ │ │ │ platform such as Allegro with modern syntax. │ │ │ │ +common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ +TMP2`&g< │ │ │ │ +Append onto list │ │ │ │ +Macro to keep code nesting and indentation under control. │ │ │ │ +Evaluate BODY at compile- load- and run- times, with DEFUN and DEFGENERIC modified │ │ │ │ +to also declare the functions NOTINLINE and to accept a wrapping the function name │ │ │ │ +specification into a list with keyword argument SUPERSEDE (which defaults to T if the name │ │ │ │ +is not wrapped, and NIL if it is wrapped). If SUPERSEDE is true, call UNDEFINE-FUNCTION │ │ │ │ +to supersede any previous definition. │ │ │ │ +Shorthand syntax for CALL-WITH-MUFFLED-CONDITIONS │ │ │ │ +Load the UIOP debug utility at compile-time as well as runtime │ │ │ │ +COLLECTORS should be a list of names for collections. A collector │ │ │ │ +defines a function that, when applied to an argument inside BODY, will │ │ │ │ +add its argument to the corresponding collection. Returns multiple values, │ │ │ │ +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). │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ Push the HOOK function (a designator as per ENSURE-FUNCTION) onto the hook VARIABLE. │ │ │ │ When CALL-NOW-P is true, also call the function immediately. │ │ │ │ Return the last character of a non-empty string S, or NIL │ │ │ │ Converts a boolean VALUE to a form suitable for testing with #+. │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -40900,38 +40763,14 @@ │ │ │ │ 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 │ │ │ │ -Macro to keep code nesting and indentation under control. │ │ │ │ -Evaluate BODY at compile- load- and run- times, with DEFUN and DEFGENERIC modified │ │ │ │ -to also declare the functions NOTINLINE and to accept a wrapping the function name │ │ │ │ -specification into a list with keyword argument SUPERSEDE (which defaults to T if the name │ │ │ │ -is not wrapped, and NIL if it is wrapped). If SUPERSEDE is true, call UNDEFINE-FUNCTION │ │ │ │ -to supersede any previous definition. │ │ │ │ -Shorthand syntax for CALL-WITH-MUFFLED-CONDITIONS │ │ │ │ -Load the UIOP debug utility at compile-time as well as runtime │ │ │ │ -COLLECTORS should be a list of names for collections. A collector │ │ │ │ -defines a function that, when applied to an argument inside BODY, will │ │ │ │ -add its argument to the corresponding collection. Returns multiple values, │ │ │ │ -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). │ │ │ │ -common-lisp │ │ │ │ -sbcl-2.4.10.debian-linux-rv64g │ │ │ │ -Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ -Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS │ │ │ │ -Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS │ │ │ │ -VALUE(&'0-(0F0N │ │ │ │ Initialize output translations in a way that maps every file to itself, │ │ │ │ effectively disabling the output translation facility. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ ASDF/COMPONENT │ │ │ │ REQUESTED │ │ │ │ @@ -41224,54 +41040,79 @@ │ │ │ │ Query the environment, as in C getenv. │ │ │ │ Beware: may return empty string if a variable is present but empty; │ │ │ │ use getenvp to return NIL in such a case. │ │ │ │ Read a number in little-endian format from an byte (octet) stream S, │ │ │ │ the number having BYTES octets (defaulting to 4). │ │ │ │ The CPU architecture of the current host │ │ │ │ Change current directory, as per POSIX chdir(2), to a given pathname object │ │ │ │ +$`$0$8$($H$P │ │ │ │ +RD*/RS1* │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 5 15)- │ │ │ │ +$($0$8$@$H;g0 │ │ │ │ +ARG-FOR-(BYTE 5 7)-= │ │ │ │ +SEGMENT` │ │ │ │ +$($0$8$@ │ │ │ │ X$@$H$P$8$0, │ │ │ │ $($0$8$@$H$PFg0? │ │ │ │ +ARG-FOR-(BYTE 12 20)- │ │ │ │ +$($0$8$@$H$PFg0? │ │ │ │ ARG-FOR-(BYTE 2 7)-= │ │ │ │ -PATHNAME-VAR │ │ │ │ -Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ +$p$0$`$8$( │ │ │ │ COMMON-LISPH │ │ │ │ $X$0$8$@$H$P, │ │ │ │ ARG-FOR-(BYTE 5 15)- │ │ │ │ +$X$0$8$@$p$H$($` │ │ │ │ +RS3/FUNCT5 │ │ │ │ $($0$8$@$H$PFg0? │ │ │ │ ARG-FOR-(BYTE 3 7)-= │ │ │ │ $($0$8$@0g0 │ │ │ │ ARG-FOR-(BYTE 20 12)- │ │ │ │ $($0$8$@$H$P$p$`\g< │ │ │ │ ARG-FOR-(BYTE 3 7)-M │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 5 7)-E │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 5 15)- │ │ │ │ +$`$0$8$($H │ │ │ │ +$p$0$8$@$H$($` │ │ │ │ +SB-ALIEN │ │ │ │ +$`$0$($@$H │ │ │ │ +$`$0$($P │ │ │ │ +$`$0$($@$H │ │ │ │ $($0$8$@$H$P$p$`\g< │ │ │ │ ARG-FOR-(BYTE 4 7)-M │ │ │ │ +$`$0$8$@$($P │ │ │ │ +RD*/RS2* │ │ │ │ +$($0$8$@$H$PFg0? │ │ │ │ +ARG-FOR-(BYTE 3 7)-E │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 10 21)- │ │ │ │ $X$0$8$@$H$P, │ │ │ │ ARG-FOR-(BYTE 3 7)-M │ │ │ │ COMMON-LISPE │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 3 7)-E │ │ │ │ $($0$8$@$H$P$`Qg4 │ │ │ │ ARG-FOR-(BYTE 3 7)-= │ │ │ │ COMMON-LISPH │ │ │ │ SB-DISASSEM0 │ │ │ │ +$($0$8$@$H$PFg0? │ │ │ │ +ARG-FOR-(BYTE 5 7)-= │ │ │ │ REGNAME( │ │ │ │ COMMON-LISP │ │ │ │ +$`$0$8$($P │ │ │ │ COMMON-LISPP │ │ │ │ $`$0$($@ │ │ │ │ COMMON-LISP@ │ │ │ │ +$`$0$8$($P │ │ │ │ +$`$0$8$@$( │ │ │ │ $($0$8$@$H$P$p$`\g< │ │ │ │ ARG-FOR-(BYTE 5 15)- │ │ │ │ +$`$0$($@$P │ │ │ │ Given a PATHNAME, return a pathname that has representations of its HOST and DEVICE components │ │ │ │ added to its DIRECTORY component. This is useful for output translations. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ return a pathname with the same host as given PATHNAME, and all other fields NIL │ │ │ │ returns NIL if the base pathname is NIL, otherwise like SUBPATHNAME. │ │ │ │ is X a pathname that is not a logical-pathname? │ │ │ │ @@ -41431,17 +41272,14 @@ │ │ │ │ COMMON-LISP@ '< │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ ASDF/SYSTEM │ │ │ │ YSS[Yp]4 │ │ │ │ -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. │ │ │ │ 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. │ │ │ │ $($0$8$@$H │ │ │ │ @@ -41456,22 +41294,44 @@ │ │ │ │ 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. │ │ │ │ From a native namestring suitable for use by the operating system, return │ │ │ │ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME │ │ │ │ Escape a command for the current operating system's shell │ │ │ │ +PATHNAME-VAR │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ + NFROM-8 │ │ │ │ +SEQUENCE │ │ │ │ +COMMON-LISP │ │ │ │ +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. │ │ │ │ Is X the name of a file that exists on the filesystem? │ │ │ │ CALL-NOW-PH │ │ │ │ OPTIONAL-ARGS │ │ │ │ Regiter a hook function to be run when restoring a dumped image │ │ │ │ Extract a pathname from a user-configured environment variable, as per native OS, │ │ │ │ check constraints and normalize as per ENSURE-PATHNAME. │ │ │ │ MORE-ARG │ │ │ │ Open FILE with option KEYS, read its contents as a string │ │ │ │ +SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ 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. │ │ │ │ TOKENH '` │ │ │ │ OPTIONAL-ARGS │ │ │ │ Escape a token for the current operating system shell │ │ │ │ OPTIONAL-ARGS │ │ │ │ @@ -41585,14 +41445,17 @@ │ │ │ │ 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. │ │ │ │ + CHARACTER │ │ │ │ +COMMON-LISP8 │ │ │ │ +Returns the canonical combining class (CCC) of CHARACTER │ │ │ │ DIRECTORY-PATHNAME8 │ │ │ │ Delete an empty directory │ │ │ │ fJ"%m)e │ │ │ │ Call FUN with an input stream that always returns end of file. │ │ │ │ The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ 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. │ │ │ │ @@ -41710,62 +41573,14 @@ │ │ │ │ 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. │ │ │ │ Where are the system files of the current installation of the CL implementation? │ │ │ │ Open input FILE with option KEYS (except AT), │ │ │ │ and read its contents as per SLURP-STREAM-FORM with given AT specifier. │ │ │ │ BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ -SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ -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. │ │ │ │ - NFROM-8 │ │ │ │ -SEQUENCE │ │ │ │ -COMMON-LISP │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ -Call BODY while the POSIX current working directory is set to DIR │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -Establish safe CL reader options around the evaluation of BODY │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ Extract an absolute directory pathname from a user-configured environment variable, │ │ │ │ as per native OS │ │ │ │ Given a COMMAND as a list of tokens, return a string of the │ │ │ │ spaced, escaped tokens, using ESCAPER to escape. │ │ │ │ CONSTRAINTS │ │ │ │ REST-ARG │ │ │ │ ON-ERROR │ │ │ │ @@ -41797,80 +41612,110 @@ │ │ │ │ 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. │ │ │ │ Call the hook functions registered to be run before to dump an image │ │ │ │ Call the hook functions registered to be run when restoring a dumped image │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ +Call BODY while the POSIX current working directory is set to DIR │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +Establish safe CL reader options around the evaluation of BODY │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ /[ 'df(P<2 │ │ │ │ (@%Ux%*f │ │ │ │ +V-8QXZ()7695JUI │ │ │ │ +D21430WSL │ │ │ │ 0qC!R(N0 │ │ │ │ 0 *8"f.1} │ │ │ │ GipvEG{@ │ │ │ │ q]+k`e%0 │ │ │ │ Argument and result bit arrays are not the same length:~ │ │ │ │ ~% ~S~% ~S │ │ │ │ CLEANUP-FUN-14 │ │ │ │ +contrib/debug.lisp │ │ │ │ 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. │ │ │ │ +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. │ │ │ │ +CLEANUP-FUN-38 │ │ │ │ +CLEANUP-FUN-24 │ │ │ │ +BEFORE83 │ │ │ │ +WRAPPER257 │ │ │ │ fmt$PQO6WSUMIMFX │ │ │ │ Mark a component as preloaded. │ │ │ │ Return a list containing every registered system (as a system object). │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ ASDF/COMPONENT │ │ │ │ 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. │ │ │ │ -contrib/debug.lisp │ │ │ │ +COMMON-LISPH │ │ │ │ +CLEANUP-FUN-53 │ │ │ │ +CLEANUP-FUN-274 │ │ │ │ +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. │ │ │ │ +Forcing parameters for the session │ │ │ │ Is F a build report file containing, e.g., warnings to check? │ │ │ │ COMMON-LISP8 │ │ │ │ SB-C1"g< │ │ │ │ -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. │ │ │ │ -CLEANUP-FUN-38 │ │ │ │ -CLEANUP-FUN-24 │ │ │ │ -BEFORE83 │ │ │ │ -WRAPPER257 │ │ │ │ -CLEANUP-FUN-274 │ │ │ │ -CLEANUP-FUN-53 │ │ │ │ -CLEANUP-FUN-45 │ │ │ │ -CLEANUP-FUN-34 │ │ │ │ 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 │ │ │ │ -ASDF/COMPONENT( │ │ │ │ - SLOT-NAME │ │ │ │ -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. │ │ │ │ -Forcing parameters for the session │ │ │ │ -COMMON-LISPH │ │ │ │ -Set an environment variable. │ │ │ │ COMMON-LISP │ │ │ │ PRE-TAIL@ │ │ │ │ COMMON-LISP@!g │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ ~l?>>>=== │ │ │ │ b[X"KdYp* │ │ │ │ -V-8QXZ()7695JU │ │ │ │ -D21430WS │ │ │ │ sEU*{~H4 │ │ │ │ WR4VZn9( │ │ │ │ COMMON-LISPP │ │ │ │ +ASDF/COMPONENT( │ │ │ │ + SLOT-NAME │ │ │ │ +CLEANUP-FUN-45 │ │ │ │ +CLEANUP-FUN-34 │ │ │ │ COMMON-LISP01gl │ │ │ │ COMMON-LISPP │ │ │ │ RAW-LOCALE │ │ │ │ COMMON-LISP8 │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP8 │ │ │ │ Returns the mirror image of CHARACTER if it exists. │ │ │ │ @@ -42061,36 +41906,50 @@ │ │ │ │ (Proper ELEMENT-TYPE treatment since ASDF 3.3.4 only.) │ │ │ │ Otherwise, signal an error. │ │ │ │ COMMON-LISP0 │ │ │ │ EXIT-CODEH │ │ │ │ SIGNAL-CODE@ │ │ │ │ Escape a string token X within double-quotes │ │ │ │ for use within a MS Windows command-line, outputing to S. │ │ │ │ +Does this token require escaping, given the specification of │ │ │ │ +either good chars that don't need escaping or bad chars that do need escaping, │ │ │ │ +as either a recognizing function or a sequence of characters. │ │ │ │ +Escape a string TOKEN within double-quotes │ │ │ │ +for use within a POSIX Bourne shell, outputing to S; │ │ │ │ +omit the outer double-quotes if key argument :QUOTE is NIL │ │ │ │ +COMMON-LISP@ │ │ │ │ +COMMON-LISP@ │ │ │ │ +Normalizes a portable I/O specifier for LAUNCH-PROGRAM into an implementation-dependent │ │ │ │ +argument to pass to the internal RUN-PROGRAM │ │ │ │ + NEW-VALUE8 │ │ │ │ +Set an environment variable. │ │ │ │ WRAPPER76 │ │ │ │ /tmp/.cache/common-lisp/sbcl-2.4.10.debian-linux-rv64g/build/reproducible-path/buildapp-1.5.6/buildapp.fasl │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/ │ │ │ │ +V-8QXZ()7695JU │ │ │ │ +D21430WS │ │ │ │ VERTEX-SC │ │ │ │ CLEANUP-FUN-4 │ │ │ │ CLEANUP-FUN-259 │ │ │ │ CLEANUP-FUN-212 │ │ │ │ CLEANUP-FUN-370 │ │ │ │ -BEFORE200 │ │ │ │ -V-8QXZ()7695J │ │ │ │ -CLEANUP-FUN-26 │ │ │ │ -CLEANUP-FUN-59 │ │ │ │ -CLEANUP-FUN-203 │ │ │ │ -$@$($0$8 │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/ │ │ │ │ +$($0$8$@ │ │ │ │ SB-DISASSEM │ │ │ │ COMMON-LISP │ │ │ │ $($0$8$@ │ │ │ │ SB-DISASSEM │ │ │ │ COMMON-LISP │ │ │ │ -$($0$8$@ │ │ │ │ +BEFORE200 │ │ │ │ +CLEANUP-FUN-26 │ │ │ │ +CLEANUP-FUN-59 │ │ │ │ +$@$($0$8 │ │ │ │ SB-DISASSEM │ │ │ │ COMMON-LISP │ │ │ │ +V-8QXZ()7695J │ │ │ │ +CLEANUP-FUN-203 │ │ │ │ 8QXZ()7695J │ │ │ │ /usr/share/common-lisp/source/cl-asdf/header.lisp │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/package.lisp │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/common-lisp.lisp │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/utility.lisp │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/version.lisp │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/os.lisp │ │ │ │ @@ -42149,44 +42008,24 @@ │ │ │ │ bytes_consed_between_gcs │ │ │ │ auto_gc_trigger │ │ │ │ gc_logfile │ │ │ │ generations │ │ │ │ lisp_startup_options │ │ │ │ internal_errors_enabled │ │ │ │ DUMMY-NODE-P │ │ │ │ -close_current_thread_tlab │ │ │ │ -close_code_region │ │ │ │ -wrapped_environ │ │ │ │ -wifcontinued │ │ │ │ -wifstopped │ │ │ │ -unlockpt │ │ │ │ -wait_for_exec │ │ │ │ -gc_pathfind │ │ │ │ -gc_and_save │ │ │ │ -asdf-package-system │ │ │ │ +HASH-KEYS │ │ │ │ +HASH-VALUES │ │ │ │ +EXTERNAL-SYMBOL │ │ │ │ +PRESENT-SYMBOL │ │ │ │ +PRESENT-SYMBOLS │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -lisp_init_function │ │ │ │ -tot_gc_nsec │ │ │ │ -gc_coalesce_string_literals │ │ │ │ -Does this token require escaping, given the specification of │ │ │ │ -either good chars that don't need escaping or bad chars that do need escaping, │ │ │ │ -as either a recognizing function or a sequence of characters. │ │ │ │ -Escape a string TOKEN within double-quotes │ │ │ │ -for use within a POSIX Bourne shell, outputing to S; │ │ │ │ -omit the outer double-quotes if key argument :QUOTE is NIL │ │ │ │ -COMMON-LISP@ │ │ │ │ -COMMON-LISP@ │ │ │ │ -Normalizes a portable I/O specifier for LAUNCH-PROGRAM into an implementation-dependent │ │ │ │ -argument to pass to the internal RUN-PROGRAM │ │ │ │ - NEW-VALUE8 │ │ │ │ -$($0$8$@ │ │ │ │ -SB-DISASSEM │ │ │ │ -COMMON-LISP │ │ │ │ +asdf-package-system │ │ │ │ +What a funky instruction. │ │ │ │ A&QDn{ z │ │ │ │ PACKED-INFO-EQUALP │ │ │ │ SPLIT-ORDERED-LIST-EQUALP │ │ │ │ A SB-KERNELH │ │ │ │ LAYOUT-EQUALP │ │ │ │ CLASSOID-CELL-EQUALP │ │ │ │ NAMED-TYPE-EQUALP │ │ │ │ @@ -42198,20 +42037,182 @@ │ │ │ │ NUMERIC-TYPE-EQUALP │ │ │ │ NUMTYPE-ASPECTS-EQUALP │ │ │ │ ALIEN-RECORD-TYPE-EQUALP │ │ │ │ A SB-KERNELP │ │ │ │ A SB-KERNEL │ │ │ │ ANSI-STREAM-EQUALP │ │ │ │ A SB-KERNELP │ │ │ │ +v\I8Zn/sgD │ │ │ │ +COMMON-LISP@ │ │ │ │ +SEGMENTH │ │ │ │ +SEGMENTP │ │ │ │ +SEGMENTP │ │ │ │ +$($H$8$0 │ │ │ │ +sR)V6`iCeF │ │ │ │ +$($0$H$P │ │ │ │ +$($0$H$P │ │ │ │ +$($0$H$P │ │ │ │ +$($0$H$P │ │ │ │ +$($0$H$P │ │ │ │ +$($0$H$P │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($`$8$0 │ │ │ │ +$($`$8$0 │ │ │ │ +$($`$8$0 │ │ │ │ +$($`$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$@ │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$0 │ │ │ │ +$($H$8$@ │ │ │ │ +$($H$8$@ │ │ │ │ +$($H$8$@ │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +SEGMENTP │ │ │ │ +-NtyU}_Ucr │ │ │ │ +$($H$0$@ │ │ │ │ +$($H$0$@ │ │ │ │ +$($H$0$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$($P$`$8 │ │ │ │ +$}$($0$8 @ p │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8 @ p │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H P │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H P │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H P │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H P │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$($0$8$H │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$`$@ │ │ │ │ +$($0$8$H │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$($0$8$H │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@ ` │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H$P X │ │ │ │ +RS1`2@30 │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H$P X │ │ │ │ +RS1`2@30 │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H$P X │ │ │ │ +RS1`2@30 │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +$}$($0$8$@$H$P X │ │ │ │ +RS1`2@30 │ │ │ │ +SEGMENT( │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +SEGMENT@ │ │ │ │ +LAYOUT SB-KERNELH │ │ │ │ +SEGMENTP │ │ │ │ +.ANONYMOUS. │ │ │ │ +MARK-INDEX │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +$($0$H$@ │ │ │ │ +SEGMENT` │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +RD*/RS1* │ │ │ │ +SEGMENT` │ │ │ │ SB-DISASSEM8 │ │ │ │ SB-DISASSEM( │ │ │ │ SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ -BRANCH-IF should not be needed on RISC-V. │ │ │ │ +$($0$8$@ │ │ │ │ +SB-DISASSEM │ │ │ │ +COMMON-LISP │ │ │ │ Combine %negate/* │ │ │ │ Eliminate %negate/%negate of rationals │ │ │ │ +BRANCH-IF should not be needed on RISC-V. │ │ │ │ nvalues is 1 │ │ │ │ CODE.PREFILTER │ │ │ │ COMMON-LISP │ │ │ │ athjDd(*H │ │ │ │ HwtdS#59m1a$ │ │ │ │ HdPto8C3 │ │ │ │ BSP-TEMP