--- /srv/rebuilderd/tmp/rebuilderddZg4aM/inputs/buildapp_1.5.6-5_i386.deb +++ /srv/rebuilderd/tmp/rebuilderddZg4aM/out/buildapp_1.5.6-5_i386.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2025-11-20 21:39:21.000000 debian-binary │ -rw-r--r-- 0 0 0 800 2025-11-20 21:39:21.000000 control.tar.xz │ --rw-r--r-- 0 0 0 8433060 2025-11-20 21:39:21.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 8443012 2025-11-20 21:39:21.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./control │ │ │ @@ -1,12 +1,12 @@ │ │ │ Package: buildapp │ │ │ Version: 1.5.6-5 │ │ │ Architecture: i386 │ │ │ Maintainer: Debian Common Lisp Team │ │ │ -Installed-Size: 26872 │ │ │ +Installed-Size: 26868 │ │ │ Depends: libc6 (>= 2.38), libzstd1 (>= 1.5.5), sbcl │ │ │ Section: lisp │ │ │ Priority: optional │ │ │ Homepage: https://www.xach.com/lisp/buildapp/ │ │ │ Description: application to create common lisp images │ │ │ Buildapp is an application for SBCL that configures and saves an │ │ │ executable Common Lisp image. It is similar to cl-launch and │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── file list │ │ │ @@ -1,11 +1,11 @@ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/bin/ │ │ │ --rwxr-xr-x 0 root (0) root (0) 27479340 2025-11-20 21:39:21.000000 ./usr/bin/buildapp │ │ │ +-rwxr-xr-x 0 root (0) root (0) 27475240 2025-11-20 21:39:21.000000 ./usr/bin/buildapp │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/doc/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-11-20 21:39:21.000000 ./usr/share/doc/buildapp/ │ │ │ -rw-r--r-- 0 root (0) root (0) 924 2025-11-20 21:39:21.000000 ./usr/share/doc/buildapp/changelog.Debian.gz │ │ │ -rw-r--r-- 0 root (0) root (0) 1607 2025-11-20 16:58:04.000000 ./usr/share/doc/buildapp/copyright │ │ │ -rw-r--r-- 0 root (0) root (0) 19096 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/index.html │ │ │ -rw-r--r-- 0 root (0) root (0) 1168 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/style.css │ │ ├── ./usr/bin/buildapp │ │ │┄ File has been modified after NT_GNU_BUILD_ID has been applied. │ │ │ ├── strings --all --bytes=8 {} │ │ │ │ @@ -1718,48 +1718,47 @@ │ │ │ │ .got.plt │ │ │ │ .gnu_debuglink │ │ │ │ hostname-id-1762874790 │ │ │ │ Warning condition related to definition of obsolete OPERATION objects. │ │ │ │ Error condition related to definition of incorrect OPERATION objects. │ │ │ │ Warning class for issues related to upgrading or loading ASDF. │ │ │ │ condition signaled when a system is detected as being out of date │ │ │ │ ->d>l@|A@BL │ │ │ │ -KlKpLLMd │ │ │ │ -3)4Y3a7]5 │ │ │ │ -U[WKXgYG │ │ │ │ +KlK4LLMd │ │ │ │ +j[jok_jGn │ │ │ │ A pair of operation and component uniquely identifies a node in the dependency graph │ │ │ │ of steps to be performed while building a system. │ │ │ │ (I)_)-+s │ │ │ │ An operation designates itself. NIL designates a context-dependent current operation, │ │ │ │ and a class-name or class designates the canonical instance of the designated class. │ │ │ │ This pathname is merged with the output parameter to produce the │ │ │ │ final output executable name. It's meant to automatically include │ │ │ │ the executable suffix .EXE on Windows. │ │ │ │ +How should ASDF react if it encounters a warning when compiling a file? │ │ │ │ +Valid values are :error, :warn, and :ignore. │ │ │ │ +How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) │ │ │ │ +when compiling a file, which includes any non-style-warning warning. │ │ │ │ +Valid values are :error, :warn, and :ignore. │ │ │ │ +Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling. │ │ │ │ +default element-type for open (depends on the current CL implementation) │ │ │ │ Default :external-format argument to pass to CL:OPEN and also │ │ │ │ CL:LOAD or CL:COMPILE-FILE to best process a UTF-8 encoded file. │ │ │ │ On modern implementations, this will decode UTF-8 code points as CL characters. │ │ │ │ On legacy implementations, it may fall back on some 8-bit encoding, │ │ │ │ with non-ASCII code points being read as several CL characters; │ │ │ │ hopefully, if done consistently, that won't affect program behavior too much. │ │ │ │ -default element-type for open (depends on the current CL implementation) │ │ │ │ Hook for output translations. │ │ │ │ This function needs to be idempotent, so that actions can work │ │ │ │ whether their inputs were translated or not, │ │ │ │ which they will be if we are composing operations. e.g. if some │ │ │ │ create-lisp-op creates a lisp file from some higher-level input, │ │ │ │ you need to still be able to use compile-op on that lisp file. │ │ │ │ The default plan class to use when building with ASDF │ │ │ │ -How should ASDF react if it encounters a warning when compiling a file? │ │ │ │ -Valid values are :error, :warn, and :ignore. │ │ │ │ -How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) │ │ │ │ -when compiling a file, which includes any non-style-warning warning. │ │ │ │ -Valid values are :error, :warn, and :ignore. │ │ │ │ -Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling. │ │ │ │ 3333%3333 │ │ │ │ %@S6zOw6_ │ │ │ │ +< =A>q?1@ │ │ │ │ M+LKPsN#Q │ │ │ │ \|Z4]\\\ │ │ │ │ A list that controls the ways that ASDF looks for system definitions. │ │ │ │ It contains symbols to be funcalled in order, with a requested system name as argument, │ │ │ │ until one returns a non-NIL result (if any), which must then be a fully initialized system object │ │ │ │ with that name. │ │ │ │ A specification as per RESOLVE-LOCATION of where the user keeps his FASL cache │ │ │ │ @@ -1822,14 +1821,15 @@ │ │ │ │ system names to pathnames of .asd files │ │ │ │ Should :tree entries of the source-registry recurse in subdirectories │ │ │ │ after having found a .asd file? True by default. │ │ │ │ the original error output stream at startup │ │ │ │ the original standard input stream at startup │ │ │ │ the original standard output stream at startup │ │ │ │ Functions to call (in reverse order) when the image is restored │ │ │ │ +3333%3333 │ │ │ │ Is this a dumped image? As a standalone executable? │ │ │ │ a function with which to restart the dumped image when execution is restored from it. │ │ │ │ User-configurable location for temporary files │ │ │ │ Is this an interactive Lisp environment, or is it batch processing? │ │ │ │ Functions to call (in order) before an image is dumped │ │ │ │ Command-line arguments │ │ │ │ a form to evaluate, or string containing forms to read and evaluate │ │ │ │ @@ -1845,15 +1845,15 @@ │ │ │ │ For instance, to can deliver an image with many systems precompiled, that *will not* check the │ │ │ │ filesystem for them every time a user loads an extension, what more risk a problematic upgrade │ │ │ │ or catastrophic downgrade, before you dump an image, you may use: │ │ │ │ (map () 'asdf:register-immutable-system (asdf:already-loaded-systems)) │ │ │ │ Note that direct access to this variable from outside ASDF is not supported. │ │ │ │ Please call REGISTER-IMMUTABLE-SYSTEM to add new immutable systems, and │ │ │ │ contact maintainers if you need a stable API to do more than that. │ │ │ │ -3333%3333 │ │ │ │ +8b8B9":B │ │ │ │ !Q 1$q$1 │ │ │ │ Registration table for preloaded systems. │ │ │ │ SYS:make-target-2-load.lisp │ │ │ │ The list of system virtual slot names. │ │ │ │ The standard readtable, implementing the syntax specified by the CLHS. │ │ │ │ It must never be modified, though only good implementations will even enforce that. │ │ │ │ Has the image been restored? A boolean, or :in-progress while restoring, :in-regress while dumping │ │ │ │ @@ -5681,14 +5681,15 @@ │ │ │ │ CONDITION-AFTER │ │ │ │ PRINT-AFTER │ │ │ │ BREAK-AFTER │ │ │ │ UNTRACED │ │ │ │ START-BREAKPOINT │ │ │ │ COPY-ENV │ │ │ │ NATIVE-LEXENV │ │ │ │ +FUNCTIONALITY │ │ │ │ COUNTER-P │ │ │ │ OVERFLOW │ │ │ │ PROFILE-INFO-P │ │ │ │ READ-STATS-FUN │ │ │ │ ENCAPSULATION-FUN │ │ │ │ CLEAR-STATS-FUN │ │ │ │ ENCAPSULATED-FUN │ │ │ │ @@ -5698,18 +5699,18 @@ │ │ │ │ GC-RUN-TIME │ │ │ │ PROCESS-P │ │ │ │ %EXIT-CODE │ │ │ │ PRIORITY-QUEUE-P │ │ │ │ CONTENTS │ │ │ │ CATCH-UP │ │ │ │ EXPIRE-TIME │ │ │ │ +ANCESTOR │ │ │ │ ADDITIONAL-INPUT-FILES │ │ │ │ BUILD-OPERATION │ │ │ │ DEPENDS-ON │ │ │ │ -REQUIRED-BY │ │ │ │ REQUIRES │ │ │ │ WEAKLY-DEPENDS-ON │ │ │ │ EXTERNAL-SYMBOLS │ │ │ │ MRU-TABLE-INDEX │ │ │ │ %SHADOWING-SYMBOLS │ │ │ │ %USED-BY │ │ │ │ RI-INITARGS │ │ │ │ @@ -5767,15 +5768,14 @@ │ │ │ │ SIMPLE-CONDITION-FORMAT-CONTROL │ │ │ │ SIMPLE-CONDITION-FORMAT-ARGUMENTS │ │ │ │ DEFCONSTANT-UNEQL-NAME │ │ │ │ DEFCONSTANT-UNEQL-OLD-VALUE │ │ │ │ DEFCONSTANT-UNEQL-NEW-VALUE │ │ │ │ IMPLICIT-GENERIC-FUNCTION-NAME │ │ │ │ PACKAGE-ERROR-PACKAGE │ │ │ │ -EXTRA-INFO │ │ │ │ ALIEN-INTEGER-TYPE-TRANSLATOR │ │ │ │ MAKE-DEFSTRUCT-ALLOCATION-FUNCTION │ │ │ │ IDENTITY │ │ │ │ ALIEN-FUNCTION-TYPE-TRANSLATOR │ │ │ │ IR1-CONVERT-FUNCTION │ │ │ │ INVALID-ALIEN-CALLBACK │ │ │ │ /-DERIVE-TYPE-OPTIMIZER │ │ │ │ @@ -6177,30 +6177,30 @@ │ │ │ │ SUPERCLASS │ │ │ │ CPD-SUPERS │ │ │ │ CPD-AFTER │ │ │ │ END-BREAKPOINT │ │ │ │ ENCAPSULATED │ │ │ │ EXPANDERS │ │ │ │ SYMBOL-EXPANSIONS │ │ │ │ -FUNCTIONALITY │ │ │ │ INTERACTIVE-THREAD │ │ │ │ OTHER-THREADS │ │ │ │ CONTEXT-FORMAT │ │ │ │ CONTEXT-ARGUMENTS │ │ │ │ CORE-DUMPED │ │ │ │ SERVE-EVENT-PIPE │ │ │ │ CLOSED-P │ │ │ │ STATUS-HOOK │ │ │ │ REPEAT-INTERVAL │ │ │ │ INTERRUPT-FUNCTION │ │ │ │ CANCEL-FUNCTION │ │ │ │ -ANCESTOR │ │ │ │ +REQUIRED-BY │ │ │ │ PARAMETERS │ │ │ │ ACTIONS-R │ │ │ │ DEP-COMPONENT │ │ │ │ +EXTRA-INFO │ │ │ │ MAKE-DEBUG-SOURCE │ │ │ │ %MAKE-PACKAGE │ │ │ │ DEFINE-ALIEN-TYPE-TRANSLATOR │ │ │ │ FMAKUNBOUND │ │ │ │ INSTRUCTIONS │ │ │ │ ALIEN-MEM-BLOCK-TYPE-ALIGNMENT │ │ │ │ ALIEN-MEM-BLOCK-TYPE-BITS │ │ │ │ @@ -17522,14 +17522,15 @@ │ │ │ │ LIST-INEQUALITY │ │ │ │ LIST-EQUALITY │ │ │ │ UNPARSED │ │ │ │ LINE-LIMIT-ABBREVIATION-HAPPENED │ │ │ │ *CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P* │ │ │ │ INHERITED │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-REQUIRE-SYSTEM-NOTIFIED-P* │ │ │ │ +FORTHCOMING-DEFCLASS-TYPE │ │ │ │ GEN-LABEL │ │ │ │ ANNOTATION-POSN │ │ │ │ ANNOTATION-INDEX │ │ │ │ LABEL-INDEX │ │ │ │ LABEL-POSN │ │ │ │ LABEL-COMMENT │ │ │ │ LABEL-USEDP │ │ │ │ @@ -17689,25 +17690,14 @@ │ │ │ │ DSTATE-NOTES │ │ │ │ DSTATE-CURRENT-VALID-LOCATIONS │ │ │ │ PPRINT-BLOCK │ │ │ │ %MAKE-VERTEX │ │ │ │ %MAKE-INTERFERENCE-GRAPH │ │ │ │ MAKE-BINARY-NODE │ │ │ │ MAKE-NODE │ │ │ │ -MAKE-BLOCK-END │ │ │ │ -QUEUED-OP-POSN │ │ │ │ -MAKE-NEWLINE │ │ │ │ -SECTION-START-SECTION-END │ │ │ │ -SECTION-START-DEPTH │ │ │ │ -SECTION-START-POSN │ │ │ │ -MAKE-LOGICAL-BLOCK │ │ │ │ -MAKE-INDENTATION │ │ │ │ -MAKE-BLOCK-START │ │ │ │ -MAKE-TAB │ │ │ │ -MAKE-PPRINT-DISPATCH-ENTRY │ │ │ │ EA-INDEX │ │ │ │ EA-SCALE │ │ │ │ VERTEX-NUMBER │ │ │ │ VERTEX-FULL-INCIDENCE │ │ │ │ VERTEX-NEIGHBOR-COLORS │ │ │ │ VERTEX-NEIGHBOR-COLOR-COUNTS │ │ │ │ VERTEX-INITIAL-DOMAIN │ │ │ │ @@ -17724,16 +17714,20 @@ │ │ │ │ BINARY-NODE-%LEFT │ │ │ │ BINARY-NODE-%RIGHT │ │ │ │ TERNARY-NODE-LEFT │ │ │ │ TERNARY-NODE-KEY1 │ │ │ │ TERNARY-NODE-MIDDLE │ │ │ │ TERNARY-NODE-KEY2 │ │ │ │ TERNARY-NODE-RIGHT │ │ │ │ +QUEUED-OP-POSN │ │ │ │ BLOCK-END-POSN │ │ │ │ BLOCK-END-SUFFIX │ │ │ │ +SECTION-START-POSN │ │ │ │ +SECTION-START-DEPTH │ │ │ │ +SECTION-START-SECTION-END │ │ │ │ NEWLINE-POSN │ │ │ │ NEWLINE-DEPTH │ │ │ │ NEWLINE-SECTION-END │ │ │ │ NEWLINE-KIND │ │ │ │ LOGICAL-BLOCK-START-COLUMN │ │ │ │ LOGICAL-BLOCK-SECTION-COLUMN │ │ │ │ LOGICAL-BLOCK-PER-LINE-PREFIX-END │ │ │ │ @@ -17745,14 +17739,21 @@ │ │ │ │ INDENTATION-AMOUNT │ │ │ │ BLOCK-START-POSN │ │ │ │ BLOCK-START-DEPTH │ │ │ │ BLOCK-START-SECTION-END │ │ │ │ BLOCK-START-BLOCK-END │ │ │ │ BLOCK-START-PREFIX │ │ │ │ BLOCK-START-SUFFIX │ │ │ │ +MAKE-BLOCK-END │ │ │ │ +MAKE-NEWLINE │ │ │ │ +MAKE-LOGICAL-BLOCK │ │ │ │ +MAKE-INDENTATION │ │ │ │ +MAKE-BLOCK-START │ │ │ │ +MAKE-TAB │ │ │ │ +MAKE-PPRINT-DISPATCH-ENTRY │ │ │ │ TAB-POSN │ │ │ │ TAB-SECTIONP │ │ │ │ TAB-RELATIVEP │ │ │ │ TAB-COLNUM │ │ │ │ TAB-COLINC │ │ │ │ PPRINT-DISPATCH-ENTRY-TYPE │ │ │ │ PPRINT-DISPATCH-ENTRY-TEST-FN │ │ │ │ @@ -17812,14 +17813,23 @@ │ │ │ │ LOOP-COLLECTOR-NAME │ │ │ │ LOOP-COLLECTOR-CLASS │ │ │ │ LOOP-COLLECTOR-HISTORY │ │ │ │ LOOP-COLLECTOR-TEMPVARS │ │ │ │ LOOP-COLLECTOR-SPECIFIED-TYPE │ │ │ │ LOOP-COLLECTOR-DTYPE │ │ │ │ LOOP-COLLECTOR-DATA │ │ │ │ +LOOP-MINIMAX-ANSWER-VARIABLE │ │ │ │ +LOOP-MINIMAX-TYPE │ │ │ │ +LOOP-MINIMAX-TEMP-VARIABLE │ │ │ │ +LOOP-MINIMAX-FLAG-VARIABLE │ │ │ │ +LOOP-MINIMAX-OPERATIONS │ │ │ │ +LOOP-MINIMAX-INFINITY-DATA │ │ │ │ +LOOP-UNIVERSE-KEYWORDS │ │ │ │ +LOOP-UNIVERSE-ITERATION-KEYWORDS │ │ │ │ +LOOP-UNIVERSE-FOR-KEYWORDS │ │ │ │ MAKE-LOOP-MINIMAX-INTERNAL │ │ │ │ MAKE-LOOP-PATH │ │ │ │ MAKE-FGEN │ │ │ │ %MAKE-CACHE │ │ │ │ MAKE-METHOD-CALL │ │ │ │ MAKE-CONSTANT-METHOD-CALL │ │ │ │ METHOD-CALL-CALL-METHOD-ARGS │ │ │ │ @@ -17842,23 +17852,14 @@ │ │ │ │ ONE-CLASS-WRAPPER0 │ │ │ │ ONE-CLASS-INDEX │ │ │ │ ONE-CLASS-ACCESSOR-TYPE │ │ │ │ ONE-CLASS-CACHE │ │ │ │ CHECKING-DFUN-INFO │ │ │ │ CACHING-DFUN-INFO │ │ │ │ CONSTANT-VALUE-DFUN-INFO │ │ │ │ -LOOP-MINIMAX-ANSWER-VARIABLE │ │ │ │ -LOOP-MINIMAX-TYPE │ │ │ │ -LOOP-MINIMAX-TEMP-VARIABLE │ │ │ │ -LOOP-MINIMAX-FLAG-VARIABLE │ │ │ │ -LOOP-MINIMAX-OPERATIONS │ │ │ │ -LOOP-MINIMAX-INFINITY-DATA │ │ │ │ -LOOP-UNIVERSE-KEYWORDS │ │ │ │ -LOOP-UNIVERSE-ITERATION-KEYWORDS │ │ │ │ -LOOP-UNIVERSE-FOR-KEYWORDS │ │ │ │ LOOP-UNIVERSE-PATH-KEYWORDS │ │ │ │ LOOP-PATH-NAMES │ │ │ │ LOOP-PATH-PREPOSITION-GROUPS │ │ │ │ LOOP-PATH-INCLUSIVE-PERMITTED │ │ │ │ LOOP-PATH-FUNCTION │ │ │ │ LOOP-PATH-USER-DATA │ │ │ │ FGEN-GENSYMS │ │ │ │ @@ -17949,41 +17950,39 @@ │ │ │ │ COMPILE-CONDITION-DESCRIPTION │ │ │ │ CONDITION-LOCATION │ │ │ │ CONDITION-FORMAT │ │ │ │ CONDITION-ARGUMENTS │ │ │ │ DUPLICATE-NAMES-NAME │ │ │ │ CLASS-SLOT-CELLS │ │ │ │ OPERATION-DESIGNATOR │ │ │ │ +MAKE-COUNTER │ │ │ │ +MAKE-PROFILE-INFO │ │ │ │ +MAKE-OVERHEAD │ │ │ │ +MAKE-TIME-INFO │ │ │ │ COUNTER-WORD │ │ │ │ COUNTER-OVERFLOW │ │ │ │ PROFILE-INFO-NAME │ │ │ │ PROFILE-INFO-ENCAPSULATED-FUN │ │ │ │ PROFILE-INFO-ENCAPSULATION-FUN │ │ │ │ PROFILE-INFO-READ-STATS-FUN │ │ │ │ PROFILE-INFO-CLEAR-STATS-FUN │ │ │ │ -MAKE-COUNTER │ │ │ │ -MAKE-PROFILE-INFO │ │ │ │ -MAKE-OVERHEAD │ │ │ │ -MAKE-TIME-INFO │ │ │ │ OVERHEAD-CALL │ │ │ │ OVERHEAD-INTERNAL │ │ │ │ OVERHEAD-TOTAL │ │ │ │ TIME-INFO-NAME │ │ │ │ TIME-INFO-CALLS │ │ │ │ TIME-INFO-SECONDS │ │ │ │ TIME-INFO-CONSING │ │ │ │ TIME-INFO-GC-RUN-TIME │ │ │ │ CONDITION-OPERATION │ │ │ │ CONDITION-COMPONENT │ │ │ │ CONDITION-ACTION │ │ │ │ NON-SYSTEM-SYSTEM-NAME │ │ │ │ NON-SYSTEM-SYSTEM-CLASS-NAME │ │ │ │ NON-TOPLEVEL-SYSTEM-PARENT │ │ │ │ -NON-TOPLEVEL-SYSTEM-NAME │ │ │ │ -SOURCE-FILE │ │ │ │ VARIABLE-LENGTH │ │ │ │ ANY-ALIGNMENT-BETWEEN-P │ │ │ │ ASSEMBLE │ │ │ │ SEGMENT-CONTENTS-AS-VECTOR │ │ │ │ ADD-STMT-LABELS │ │ │ │ LABEL-POSITION │ │ │ │ APPEND-SECTIONS │ │ │ │ @@ -18014,14 +18013,16 @@ │ │ │ │ COMPUTE-FEATURES-AFFECTING-FASL-FORMAT │ │ │ │ GET-ASM-ROUTINE │ │ │ │ +FASL-FILE-VERSION+ │ │ │ │ KNOWN-LAYOUT-FOP │ │ │ │ +BACKEND-FASL-FILE-IMPLEMENTATION+ │ │ │ │ +FASL-HEADER-STRING-STOP-CHAR-CODE+ │ │ │ │ *FASL-FILE-TYPE* │ │ │ │ +NON-TOPLEVEL-SYSTEM-NAME │ │ │ │ +SOURCE-FILE │ │ │ │ ERROR-SYSTEM │ │ │ │ ERROR-PATHNAME │ │ │ │ COMPATFMT │ │ │ │ CLAUSE-HEAD │ │ │ │ ERROR-OPTION │ │ │ │ CLAUSE-REST │ │ │ │ ERROR-ARGUMENTS │ │ │ │ @@ -18062,14 +18063,16 @@ │ │ │ │ FIND-SLOT-CELL │ │ │ │ SLOT-DEFINITION-ALWAYS-BOUND-P │ │ │ │ SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION │ │ │ │ SLOT-DEFINITION-NAME │ │ │ │ SET-FUN-NAME │ │ │ │ CHECK-WRAPPER-VALIDITY │ │ │ │ SLOT-DEFINITION-INFO │ │ │ │ +TYPES-FROM-ARGS │ │ │ │ +COMPUTE-APPLICABLE-METHODS-USING-TYPES │ │ │ │ WALK-UNEXPECTED-DECLARE │ │ │ │ UNIX-STAT │ │ │ │ RU-NIVCSW │ │ │ │ UNIX-KILL │ │ │ │ ST-NLINK │ │ │ │ SIGVTALRM │ │ │ │ UNIX-POLL │ │ │ │ @@ -18162,18 +18165,15 @@ │ │ │ │ MAKE-STRUCTURE-SLOT-MAKUNBOUND-FUNCTION │ │ │ │ CAN-MAKUNBOUND │ │ │ │ CANNOT-MAKUNBOUND │ │ │ │ MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION │ │ │ │ MAKE-OPTIMIZED-STD-MAKUNBOUND-METHOD-FUNCTION │ │ │ │ -TYPES-FROM-ARGS │ │ │ │ -COMPUTE-APPLICABLE-METHODS-USING-TYPES │ │ │ │ INACTIVE │ │ │ │ -FORTHCOMING-DEFCLASS-TYPE │ │ │ │ CALL-OTHER-METHOD │ │ │ │ INCOMPATIBLE │ │ │ │ UNINITIALIZED │ │ │ │ PRINT-FUNCTION │ │ │ │ SIGALRM-HANDLER │ │ │ │ ADDRESS-SANITIZER │ │ │ │ *OVERHEAD* │ │ │ │ @@ -18205,20 +18205,24 @@ │ │ │ │ ENQUEUE-INDENT │ │ │ │ ENSURE-NON-STANDARD-CLASS │ │ │ │ NOTIFY-DEPRECATED-FUNCTION │ │ │ │ MANDATORY │ │ │ │ COMPLEX-TOPLEVEL │ │ │ │ SPECIAL-BIND │ │ │ │ DECLARED-VERIFY │ │ │ │ +CLASS-FINALIZED-P │ │ │ │ +CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P │ │ │ │ +FINALIZE-INHERITANCE │ │ │ │ +%FORCE-CACHE-FLUSHES │ │ │ │ MORE-CONTEXT │ │ │ │ MORE-COUNT │ │ │ │ +UNBOUNDED │ │ │ │ FORCE-TO-STACK │ │ │ │ FULL-CALL │ │ │ │ LOCAL-CALL │ │ │ │ -UNBOUNDED │ │ │ │ DEBUG-ENVIRONMENT │ │ │ │ SAVE-ONCE │ │ │ │ ARG-PASS │ │ │ │ MORE-ARGUMENT │ │ │ │ MORE-RESULT │ │ │ │ DOWNCASE │ │ │ │ PRESERVE │ │ │ │ @@ -18255,14 +18259,15 @@ │ │ │ │ ENTRY-POINT │ │ │ │ DEFSYSTEM-DEPENDS-ON │ │ │ │ PERFORMABLE-P │ │ │ │ FORCED-NOT │ │ │ │ REG-REG/MEM-DIR │ │ │ │ REG/MEM-IMM │ │ │ │ ACCUM-IMM │ │ │ │ +STATIC-LIBRARY │ │ │ │ ALIEN-CALLBACKS │ │ │ │ C-STACK-IS-CONTROL-STACK │ │ │ │ COMPARE-AND-SWAP-VOPS │ │ │ │ CYCLE-COUNTER │ │ │ │ FP-AND-PC-STANDARD-SAVE │ │ │ │ GENERATIONAL │ │ │ │ LARGEFILE │ │ │ │ @@ -18271,39 +18276,41 @@ │ │ │ │ OS-PROVIDES-POSIX-SPAWN │ │ │ │ OS-PROVIDES-SUSECONDS-T │ │ │ │ SB-LINKABLE-RUNTIME │ │ │ │ SB-SOURCE-LOCATIONS │ │ │ │ SB-XREF-FOR-INTERNALS │ │ │ │ STACK-GROWS-DOWNWARD-NOT-UPWARD │ │ │ │ UNWIND-TO-FRAME-AND-CALL-VOP │ │ │ │ -STATIC-LIBRARY │ │ │ │ SYMBOLIC-ASM │ │ │ │ +LOOP-DESETQ │ │ │ │ +BIND-ARGS │ │ │ │ +BIND-FAST-LEXICAL-METHOD-FUNCTIONS │ │ │ │ +FAST-LEXICAL-METHOD-FUNCTIONS │ │ │ │ +LOOP-COLLECT-RPLACD │ │ │ │ +WITH-LOOP-LIST-COLLECTION-HEAD │ │ │ │ +LOOP-COLLECT-ANSWER │ │ │ │ +WITH-SUM-COUNT │ │ │ │ +POST-ENV │ │ │ │ +POST-REST │ │ │ │ +POST-MORE │ │ │ │ +CLASSES-LIST │ │ │ │ +NEW-CLASS │ │ │ │ NON-BASE-CHARS-EXIST-P │ │ │ │ ASDF-UNICODE │ │ │ │ COMMON-LISP │ │ │ │ IEEE-FLOATING-POINT │ │ │ │ SB-CORE-COMPRESSION │ │ │ │ SB-PACKAGE-LOCKS │ │ │ │ SB-THREAD │ │ │ │ SB-UNICODE │ │ │ │ BUILDAPP-INIT │ │ │ │ %VARIABLE-REBINDING │ │ │ │ %PARAMETER │ │ │ │ SAFE-GF-DFUN-STATE │ │ │ │ -LOOP-DESETQ │ │ │ │ -BIND-ARGS │ │ │ │ -BIND-FAST-LEXICAL-METHOD-FUNCTIONS │ │ │ │ -FAST-LEXICAL-METHOD-FUNCTIONS │ │ │ │ -LOOP-COLLECT-RPLACD │ │ │ │ -WITH-LOOP-LIST-COLLECTION-HEAD │ │ │ │ -LOOP-COLLECT-ANSWER │ │ │ │ -WITH-SUM-COUNT │ │ │ │ -POST-ENV │ │ │ │ -POST-REST │ │ │ │ -POST-MORE │ │ │ │ +SOURCE-TRANSFORM │ │ │ │ WALK-DEFUN │ │ │ │ WALK-LOAD-TIME-VALUE │ │ │ │ WALK-LET │ │ │ │ WALK-LET* │ │ │ │ WALK-SETQ │ │ │ │ WALK-MACROLET │ │ │ │ WALK-SYMBOL-MACROLET │ │ │ │ @@ -18311,17 +18318,14 @@ │ │ │ │ WALK-LOCALLY │ │ │ │ WALK-NAMED-LAMBDA │ │ │ │ MACROEXPANDS │ │ │ │ ARGUMENT-TEST │ │ │ │ UNWINNAGE-FUN │ │ │ │ IMPORTANT-RESULT-DISCARDED │ │ │ │ *THE-CLASS-STANDARD-GENERIC-FUNCTION* │ │ │ │ -CLASSES-LIST │ │ │ │ -NEW-CLASS │ │ │ │ -SOURCE-TRANSFORM │ │ │ │ *THE-CLASS-STANDARD-OBJECT* │ │ │ │ *THE-CLASS-STRUCTURE-OBJECT* │ │ │ │ *THE-CLASS-T* │ │ │ │ EMIT-CACHING │ │ │ │ EMIT-DEFAULT-ONLY │ │ │ │ DEFAULT-ONLY │ │ │ │ EMIT-CHECKING │ │ │ │ @@ -18333,66 +18337,61 @@ │ │ │ │ *CURRENT-DESTINATION* │ │ │ │ OBSOLETE │ │ │ │ SET-SLOT-VALUE │ │ │ │ STREAM-OPEN-P │ │ │ │ *SBCL-HOMEDIR-PATHNAME* │ │ │ │ *SOFTWARE-VERSION* │ │ │ │ CALL-NO-NEXT-METHOD │ │ │ │ -CLASS-FINALIZED-P │ │ │ │ -CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P │ │ │ │ -FINALIZE-INHERITANCE │ │ │ │ -%FORCE-CACHE-FLUSHES │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ FUN-START │ │ │ │ INITIALIZATION │ │ │ │ SLOT-READER-NAME │ │ │ │ SLOT-BOUNDP-NAME │ │ │ │ SLOT-MAKUNBOUND-NAME │ │ │ │ SLOT-WRITER-NAME │ │ │ │ GENERIC-FUNCTION-METHOD-CLASS │ │ │ │ PPRINT-LENGTH-CHECK* │ │ │ │ +NO-CONSTRUCTOR-DEFUN │ │ │ │ EQL-SPECIALIZER-P │ │ │ │ EQL-SPECIALIZER-OBJECT │ │ │ │ MAKE-SEQUENCE-ITERATOR │ │ │ │ SIGINT-HANDLER │ │ │ │ %INSTALL-HANDLER │ │ │ │ SIGTERM-HANDLER │ │ │ │ -NO-CONSTRUCTOR-DEFUN │ │ │ │ SIGILL-HANDLER │ │ │ │ SIGURG-HANDLER │ │ │ │ SIGCHLD-HANDLER │ │ │ │ SIGBUS-HANDLER │ │ │ │ ENSURE-CLASS-FINALIZED │ │ │ │ CLASS-PROTOTYPE │ │ │ │ ENSURE-ACCESSOR │ │ │ │ NORMALIZED-P │ │ │ │ DEFINITION-SOURCE │ │ │ │ GENERIC-FUNCTION-NAME │ │ │ │ -ENSURE-SPACE-IN-BUFFER │ │ │ │ +METACLASS │ │ │ │ +REGISTERED │ │ │ │ ABSOLUTE │ │ │ │ RELATIVE │ │ │ │ WILD-INFERIORS │ │ │ │ -METACLASS │ │ │ │ -REGISTERED │ │ │ │ *PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ FOREIGN-FUNCTION │ │ │ │ +ENSURE-SPACE-IN-BUFFER │ │ │ │ SET-FUNCALLABLE-INSTANCE-FUNCTION │ │ │ │ -SESSION-OPERATE-LEVEL │ │ │ │ RELATIVE-TO │ │ │ │ INVALID-KEYS │ │ │ │ SMALL-SAFE │ │ │ │ NON-LOCAL-ENTRY │ │ │ │ SINGLE-VALUE-RETURN │ │ │ │ CALL-SITE │ │ │ │ NON-LOCAL-EXIT │ │ │ │ UNKNOWN-RETURN │ │ │ │ SETF-SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ -SIGNALED │ │ │ │ *THE-CLASS-STANDARD-METHOD* │ │ │ │ *STANDARD-METHOD-COMBINATION* │ │ │ │ +SIGNALED │ │ │ │ SLOT-DEFINITION-LOCATION │ │ │ │ SLOT-DEFINITION-WRITERS │ │ │ │ SLOT-DEFINITION-READERS │ │ │ │ SPECIALIZER-CLASS │ │ │ │ SPECIALIZER-OBJECT │ │ │ │ ACCESSOR-METHOD-SLOT-NAME │ │ │ │ OBJECT-PLIST │ │ │ │ @@ -18401,23 +18400,23 @@ │ │ │ │ SIGNAL-CODE │ │ │ │ PREFIX-LISP-OBJECT-FILES │ │ │ │ POSTFIX-LISP-OBJECT-FILES │ │ │ │ EXTRA-OBJECT-FILES │ │ │ │ EXTRA-BUILD-ARGS │ │ │ │ PACKAGE-STRING │ │ │ │ SYMBOL-STRING │ │ │ │ +***HERE*** │ │ │ │ +AMBIGUOUS │ │ │ │ BINARY-NAME │ │ │ │ DISPATCHED-ENTRIES │ │ │ │ ASDF-DIRECTIVES │ │ │ │ LOAD-PATHS │ │ │ │ DUMPFILE-COPY │ │ │ │ CORE-ONLY │ │ │ │ COMPRESS-CORE │ │ │ │ -***HERE*** │ │ │ │ -AMBIGUOUS │ │ │ │ INTERPRET │ │ │ │ INTERRUPTED │ │ │ │ ISO-8859-8 │ │ │ │ ISO-8859-6 │ │ │ │ EXISTENCE │ │ │ │ ISO-8859-3 │ │ │ │ UTF-32BE │ │ │ │ @@ -18489,32 +18488,30 @@ │ │ │ │ CLASS-DIRECT-SLOTS │ │ │ │ CLASS-DIRECT-DEFAULT-INITARGS │ │ │ │ CLASS-DEFAULT-INITARGS │ │ │ │ ADD-DIRECT-SUBCLASS │ │ │ │ ADD-DIRECT-METHOD │ │ │ │ ADD-DEPENDENT │ │ │ │ DIVIDE-BY-ZERO │ │ │ │ -PARTIAL-MACROEXPANDER │ │ │ │ AS-FILES │ │ │ │ WAIT-FOR-INPUT │ │ │ │ READ-ERROR │ │ │ │ -UTF-16BE │ │ │ │ -STANDARD-INSTANCE │ │ │ │ -MAKE-CACHE │ │ │ │ -%STRUCT-TYPECASE-MISS │ │ │ │ ASSUMED-TYPE │ │ │ │ WIRED-TLS │ │ │ │ WALKER-TEMPLATE │ │ │ │ MACRO-EXPANSION │ │ │ │ TRANSLATOR │ │ │ │ PREDICATE-FOR │ │ │ │ PREDICATE-TRUTH-CONSTRAINT │ │ │ │ FORWARD-REFERENCES │ │ │ │ ALIEN-INFO │ │ │ │ TYPED-STRUCTURE │ │ │ │ +UTF-16BE │ │ │ │ +MAKE-CACHE │ │ │ │ +%STRUCT-TYPECASE-MISS │ │ │ │ RANDOM-DOCUMENTATION │ │ │ │ SYMBOL-MACRO │ │ │ │ SET-FILE-POSITION │ │ │ │ REMAINING │ │ │ │ CAPITALIZE-FIRST │ │ │ │ SECTION-RELATIVE │ │ │ │ LINE-RELATIVE │ │ │ │ @@ -18530,14 +18527,16 @@ │ │ │ │ *SYMBOL-MACRO* │ │ │ │ *CURRENT-VOP* │ │ │ │ ARG-CHECK │ │ │ │ EVENTUALLY │ │ │ │ ARG-LVARS │ │ │ │ KNOWN-FUN │ │ │ │ PENTIUM4 │ │ │ │ +STANDARD-INSTANCE │ │ │ │ +PARTIAL-MACROEXPANDER │ │ │ │ ALIGNED-STACK │ │ │ │ CODE-OBJECT │ │ │ │ CARD-TABLE-INDEX-MASK │ │ │ │ ASSEMBLY-ROUTINE │ │ │ │ FOREIGN-DATAREF │ │ │ │ CHECKGEN │ │ │ │ GOVERNMENT │ │ │ │ @@ -18557,23 +18556,30 @@ │ │ │ │ *INITFUNCTIONS-FOR-THIS-DEFCLASS* │ │ │ │ *READERS-FOR-THIS-DEFCLASS* │ │ │ │ *WRITERS-FOR-THIS-DEFCLASS* │ │ │ │ *SLOT-NAMES-FOR-THIS-DEFCLASS* │ │ │ │ LOAD-DEFCLASS │ │ │ │ *THE-CLASS-STRUCTURE-CLASS* │ │ │ │ LOAD-SHORT-DEFCOMBIN │ │ │ │ -USE-LABELS │ │ │ │ -RENAME-AND-DELETE │ │ │ │ -NEW-VERSION │ │ │ │ -IGNORE-THIS-ARG │ │ │ │ UNSUPPLIED │ │ │ │ NO-ERROR │ │ │ │ +USE-LABELS │ │ │ │ UNTRACE-1 │ │ │ │ UNTRACE-PACKAGE │ │ │ │ %DEFMETHOD-EXPANDER │ │ │ │ +RENAME-AND-DELETE │ │ │ │ +NEW-VERSION │ │ │ │ +IGNORE-THIS-ARG │ │ │ │ +PROCESS-GROUP │ │ │ │ +PTY-PROCESS-GROUP │ │ │ │ +*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ +*DISASSEM-INST-SPACE* │ │ │ │ +ACCEPT-RUNTIME-OPTIONS │ │ │ │ +*OLD-DEBUGGER-HOOK* │ │ │ │ +PSEUDO-STATIC │ │ │ │ GENERIC-FUNCTION-P │ │ │ │ EARLY-CLASS-PRECEDENCE-LIST │ │ │ │ EARLY-METHOD-STANDARD-ACCESSOR-P │ │ │ │ EARLY-METHOD-SPECIALIZERS │ │ │ │ EARLY-SLOT-DEFINITION-LOCATION │ │ │ │ FIND-SLOT-DEFINITION │ │ │ │ SLOT-ACCESSOR-STD-P │ │ │ │ @@ -18596,28 +18602,27 @@ │ │ │ │ CHECKING-MISS │ │ │ │ PRINT-BACKTRACE │ │ │ │ INSTRUCTION-HOOKS │ │ │ │ PERFORM-OPERAND-LOWERING │ │ │ │ TRACE-INST │ │ │ │ EXTRACT-PREFIX-KEYWORDS │ │ │ │ %OBSOLETE-INSTANCE-TRAP │ │ │ │ -PROCESS-GROUP │ │ │ │ -PTY-PROCESS-GROUP │ │ │ │ -*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ -*DISASSEM-INST-SPACE* │ │ │ │ -ACCEPT-RUNTIME-OPTIONS │ │ │ │ -*OLD-DEBUGGER-HOOK* │ │ │ │ -PSEUDO-STATIC │ │ │ │ -EXIT-IF-NULL │ │ │ │ +SAFE-METHOD-SPECIALIZERS │ │ │ │ +SPECIALIZER-APPLICABLE-USING-TYPE-P │ │ │ │ +SORT-APPLICABLE-METHODS │ │ │ │ +SAFE-GENERIC-FUNCTION-METHODS │ │ │ │ +%MAKE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ DENORMALIZED-OPERAND │ │ │ │ UNDERFLOW │ │ │ │ TRACE-CALL │ │ │ │ ABBREVIATED │ │ │ │ +EXIT-IF-NULL │ │ │ │ INTERRUPTION │ │ │ │ ALLOW-FORMS │ │ │ │ +*LOOP-ANSI-UNIVERSE* │ │ │ │ EMIT-N-N-MAKUNBOUNDS │ │ │ │ EMIT-N-N-READERS │ │ │ │ EMIT-N-N-WRITERS │ │ │ │ EMIT-N-N-BOUNDPS │ │ │ │ EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ EMIT-ONE-INDEX-READERS │ │ │ │ EMIT-ONE-INDEX-WRITERS │ │ │ │ @@ -18626,14 +18631,15 @@ │ │ │ │ EMIT-TWO-CLASS-READER │ │ │ │ EMIT-TWO-CLASS-WRITER │ │ │ │ EMIT-TWO-CLASS-BOUNDP │ │ │ │ EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ EMIT-ONE-CLASS-READER │ │ │ │ EMIT-ONE-CLASS-WRITER │ │ │ │ EMIT-ONE-CLASS-BOUNDP │ │ │ │ +ALLOCATE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ EMIT-BYTES │ │ │ │ IF-AFTER │ │ │ │ PROCESS-BACK-PATCHES │ │ │ │ COMPACT-SEGMENT-BUFFER │ │ │ │ OPCODES1 │ │ │ │ │ │ │ │ STATEMENT │ │ │ │ @@ -18884,15 +18890,14 @@ │ │ │ │ INSTANCE-READ │ │ │ │ COPY-CACHE │ │ │ │ STANDARD-SLOT-VALUE/DSLOTD │ │ │ │ LOAD-LONG-DEFCOMBIN │ │ │ │ NIL-NOT-SLOT-OBJECT │ │ │ │ SLOT-LAYOUTS-COMPATIBLE-P │ │ │ │ *NON-SYSTEM-TYPEP-COST* │ │ │ │ -%MAKE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ GF-HAS-METHOD-WITH-NONSTANDARD-SPECIALIZER-P │ │ │ │ GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION │ │ │ │ CONSTANT-CONVERTER │ │ │ │ *STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD* │ │ │ │ FIND-STANDARD-CLASS-ACCESSOR-METHOD │ │ │ │ NON-EMPTY-OR │ │ │ │ *CONDITION-SLOT-BOUNDP-USING-CLASS-METHOD* │ │ │ │ @@ -19045,15 +19050,14 @@ │ │ │ │ .METH-LIST. │ │ │ │ AUGMENT-TYPE │ │ │ │ ALL-APPLICABLE-P │ │ │ │ .FUNCTION. │ │ │ │ ADD-SLOT-ACCESSORS │ │ │ │ ORDER-MATTERS-TEST │ │ │ │ MAKE-OPTIMIZED-STD-SLOT-MAKUNBOUND-USING-CLASS-METHOD-FUNCTION │ │ │ │ -SPECIALIZER-APPLICABLE-USING-TYPE-P │ │ │ │ MAKE-FINAL-DFUN-INTERNAL │ │ │ │ MEMF-TEST-CONVERTER │ │ │ │ INTERCEPT │ │ │ │ GET-ACCESSOR-METHOD-FUNCTION │ │ │ │ PREVIOUS │ │ │ │ COERCE-TO-CLASS │ │ │ │ MAP-ALL-GENERIC-FUNCTIONS │ │ │ │ @@ -19102,15 +19106,14 @@ │ │ │ │ PUSHNEW-IN-CTORS │ │ │ │ MAKE-CTOR │ │ │ │ .MORE-CONTEXT. │ │ │ │ WRAPPER-INFO │ │ │ │ CLASS-INCOMPATIBLE-SUPERCLASS-LIST │ │ │ │ EFFECTIVE-METHOD-GENSYM-0 │ │ │ │ INSTALL-INITIAL-CONSTRUCTOR │ │ │ │ -SAFE-METHOD-SPECIALIZERS │ │ │ │ INSTANCE-MAKUNBOUND │ │ │ │ TRUE-VALUE │ │ │ │ PCL-COMPILE │ │ │ │ MAKE-OPTIMIZED-STRUCTURE-SLOT-MAKUNBOUND-USING-CLASS-METHOD-FUNCTION │ │ │ │ *STANDARD-SLOT-VALUE-USING-CLASS-METHOD* │ │ │ │ CTOR-DEFAULT-INITARGS │ │ │ │ METHOD-PROTOTYPE-FOR-GF │ │ │ │ @@ -19271,15 +19274,14 @@ │ │ │ │ EARLY-SLOT-DEFINITION-NAME │ │ │ │ *SLOT-VECTOR-SYMBOLS* │ │ │ │ SHORT-COMPUTE-EFFECTIVE-METHOD │ │ │ │ CHECK-INITARGS-2-LIST │ │ │ │ INSTANCE-WRITE-STANDARD │ │ │ │ STANDARD-COMPUTE-EFFECTIVE-METHOD │ │ │ │ INSTANCE-BOUNDP-STANDARD │ │ │ │ -ALLOCATE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ .MORE-COUNT. │ │ │ │ REAL-BODY │ │ │ │ GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION │ │ │ │ CONDITION-TYPE-P │ │ │ │ GROUP-COND-CLAUSE │ │ │ │ PV-WRAPPERS-FROM-PV-ARGS │ │ │ │ ARG-NUMBER │ │ │ │ @@ -19363,15 +19365,14 @@ │ │ │ │ %MAKE-METHOD-FUNCTION │ │ │ │ CTOR-LIST-TO-TABLE │ │ │ │ FORMAT-CYCLE-REASONS │ │ │ │ EMIT-CACHE-LOOKUP │ │ │ │ FIND-CTOR │ │ │ │ OPTIMIZE-SLOT-BOUNDP │ │ │ │ INVOKE-FAST-METHOD-CALL/MORE │ │ │ │ -SORT-APPLICABLE-METHODS │ │ │ │ EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY │ │ │ │ GF-DFUN-STATE │ │ │ │ OLD-CLASS │ │ │ │ MAKE-EFFECTIVE-METHOD-FUNCTION1 │ │ │ │ READER-FN │ │ │ │ INITKEYS │ │ │ │ VALUES-FOR-ADD-METHOD │ │ │ │ @@ -19568,15 +19569,14 @@ │ │ │ │ STANDARD-SORT-METHODS │ │ │ │ REAL-MAKE-A-METHOD │ │ │ │ FIND-SUPERCLASS-CHAIN │ │ │ │ OLD-CTOR │ │ │ │ INSTALL-OPTIMIZED-CONSTRUCTOR │ │ │ │ MAKE-FALLBACK-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-CTOR-INLINE-CACHE-FORM │ │ │ │ -SAFE-GENERIC-FUNCTION-METHODS │ │ │ │ FIND-IN-SUPERCLASSES │ │ │ │ %SLOT-DEFINITION-DOCUMENTATION │ │ │ │ WEAK-HASHSET-MEMBERP │ │ │ │ LL-KEYP-OR-RESTP │ │ │ │ *TYPECHECK-STACK* │ │ │ │ REMOVE-WRITER-METHOD │ │ │ │ MAKE-CTOR-PARAMETER-LIST │ │ │ │ @@ -19831,18 +19831,20 @@ │ │ │ │ PPRINT-DEFPACKAGE │ │ │ │ PPRINT-DECLARE │ │ │ │ PPRINT-ARRAY-P │ │ │ │ OUTPUT-PRETTY-OBJECT │ │ │ │ NOTE-SIGNIFICANT-SPACE │ │ │ │ KEEP-OPERATION │ │ │ │ KEEP-COMPONENT │ │ │ │ +SESSION-OPERATE-LEVEL │ │ │ │ PRINT-REG │ │ │ │ PRINT-REG/MEM │ │ │ │ PRINT-SIZED-REG/MEM │ │ │ │ -*LOOP-ANSI-UNIVERSE* │ │ │ │ +KEY-OR-VALUE │ │ │ │ +KEY-AND-VALUE │ │ │ │ LFL-INSERT/T │ │ │ │ SO-FIND/STRING │ │ │ │ SO-FINDER │ │ │ │ %SO-DELETE/ADDR │ │ │ │ LFL-SEARCH/FIXNUM │ │ │ │ SO-INSERTER │ │ │ │ *DESIRED-ELTS-PER-BIN* │ │ │ │ @@ -19922,17 +19924,16 @@ │ │ │ │ %SO-EQ-SET-PHASE2-INSERT │ │ │ │ SO-MAPLIST │ │ │ │ MAKE-MARKED-REF │ │ │ │ MAKE-SO-MAP/STRING │ │ │ │ C-SO-FIND/ADDR │ │ │ │ LFL-DELETE*/T │ │ │ │ LFL-INSERT*/T │ │ │ │ +ELSEWHERE │ │ │ │ BODY-NAME- │ │ │ │ -WORD-IMM │ │ │ │ -BYTE-IMM │ │ │ │ GROK-SYMBOL-SLOT-REF │ │ │ │ ADD-SEGMENT-LABELS │ │ │ │ TRAILING-SPACE │ │ │ │ PRINT-NOTE │ │ │ │ ADD-DEBUGGING-HOOKS │ │ │ │ FIND-VALID-STORAGE-LOCATION │ │ │ │ PRINT-BLOCK-BOUNDARY │ │ │ │ @@ -20055,14 +20056,15 @@ │ │ │ │ EXT-REG/MEM-NO-WIDTH+IMM8 │ │ │ │ PRINT-SIZE-P │ │ │ │ EMIT-BIT-TEST-AND-MUMBLE │ │ │ │ FADD-STI │ │ │ │ COND-SET │ │ │ │ EXTRA-ADDEND │ │ │ │ SHIFT-INST │ │ │ │ +WORD-IMM │ │ │ │ EMIT-DWORD-DISPLACEMENT-BACKPATCH │ │ │ │ REG-NO-WIDTH │ │ │ │ FLOATING-POINT-FP │ │ │ │ PREFILTER-REG/MEM │ │ │ │ DELTA-IF-AFTER │ │ │ │ FLOATING-POINT-3 │ │ │ │ NEAR-COND-JUMP │ │ │ │ @@ -20116,14 +20118,15 @@ │ │ │ │ ENTER-FORMAT │ │ │ │ ALIGN-OF │ │ │ │ FLOATING-POINT-NO │ │ │ │ DWORD-REG-P │ │ │ │ STRING-OP │ │ │ │ FLOATING-POINT-5 │ │ │ │ BREAK-CONTROL │ │ │ │ +BYTE-IMM │ │ │ │ FLOATING-POINT-ST │ │ │ │ PRINT-LABEL │ │ │ │ FSUBP-STI │ │ │ │ STACK-DELTA │ │ │ │ *DEFAULT-ADDRESS-SIZE* │ │ │ │ NO-LOAD-FUN-ERROR │ │ │ │ INSERT-CONFLICT-EDGES │ │ │ │ @@ -20606,26 +20609,25 @@ │ │ │ │ ELSE-FORM │ │ │ │ FROB-SUBSTRINGS │ │ │ │ SESSION-ANCESTOR │ │ │ │ %COMPONENT-ENCODING │ │ │ │ %ADDITIONAL-INPUT-FILES │ │ │ │ PROLOGUE-CODE │ │ │ │ EPILOGUE-CODE │ │ │ │ -ELSEWHERE │ │ │ │ STATUS-BITS │ │ │ │ STATUS-LEVEL │ │ │ │ MODULE-COMPONENTS-BY-NAME │ │ │ │ REQUIRED-MODULE │ │ │ │ +PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ US-ASCII │ │ │ │ ANSI_X3.4-1968 │ │ │ │ ISO-646-US │ │ │ │ ISO-8859-1 │ │ │ │ ISO8859-1 │ │ │ │ x-mac-cyrillic │ │ │ │ -PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ iso-8859-2 │ │ │ │ iso-8859-3 │ │ │ │ iso-8859-4 │ │ │ │ iso-8859-5 │ │ │ │ iso-8859-6 │ │ │ │ iso-8859-7 │ │ │ │ iso-8859-8 │ │ │ │ @@ -20661,45 +20663,45 @@ │ │ │ │ COMPILER │ │ │ │ DATA-DEPENDENCY │ │ │ │ !MAKE-FOREIGN-THREAD │ │ │ │ GET-FILE-POSITION │ │ │ │ INTERACTIVE-P │ │ │ │ RESET-UNICODE-P │ │ │ │ NORMALIZE-STRING │ │ │ │ -MACROEXPAND-ALL │ │ │ │ F-STREAM- │ │ │ │ +MACROEXPAND-ALL │ │ │ │ SYMBOL-MACRO77 │ │ │ │ -IMMOBILE-SYMBOL │ │ │ │ COVERAGE-MARKS │ │ │ │ -UNICODE-CHAR->NAME │ │ │ │ -UNICODE-1-CHAR->NAME │ │ │ │ +IMMOBILE-SYMBOL │ │ │ │ RESULT-REFS │ │ │ │ VARIANT-COST │ │ │ │ ARG-REFS │ │ │ │ +DEBUGGER-FRAME │ │ │ │ DOUBLE-FLOAT-BITS │ │ │ │ +UNICODE-CHAR->NAME │ │ │ │ +UNICODE-1-CHAR->NAME │ │ │ │ MISER-WIDTH │ │ │ │ READABLY │ │ │ │ RIGHT-MARGIN │ │ │ │ SUPPRESS-ERRORS │ │ │ │ -KEY-OR-VALUE │ │ │ │ -KEY-AND-VALUE │ │ │ │ -DEBUGGER-FRAME │ │ │ │ -FINISHED │ │ │ │ -DONT-KNOW │ │ │ │ -ASDF/INTERFACE │ │ │ │ -*IN-MAKE-OPERATION* │ │ │ │ +WALKER-ENVIRONMENT-BIND-1 │ │ │ │ +WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ +WALK-ARGLIST │ │ │ │ +WALK-REPEAT-EVAL │ │ │ │ +WALK-DECLARATIONS │ │ │ │ +CONVERT-MACRO-TO-LAMBDA │ │ │ │ +DECOMPOSE-STRING │ │ │ │ +CANONICALLY-COMPOSE │ │ │ │ VAR-SPECIAL-P │ │ │ │ DEFINE-WALKER-TEMPLATE │ │ │ │ VAR-GLOBALLY-SPECIAL-P │ │ │ │ WALK-FORM │ │ │ │ VAR-LEXICAL-P │ │ │ │ *WALK-FORM-EXPAND-MACROS-P* │ │ │ │ VAR-DECLARATION │ │ │ │ -NEGATIVE-INFINITY │ │ │ │ -POSITIVE-INFINITY │ │ │ │ LOW-SURROGATES │ │ │ │ NCONCING │ │ │ │ NABATAEAN │ │ │ │ UIOP/VERSION │ │ │ │ UPGRADING-P │ │ │ │ HIGH-SURROGATES │ │ │ │ STREAM-EASY-P │ │ │ │ @@ -20717,14 +20719,15 @@ │ │ │ │ IPA-EXTENSIONS │ │ │ │ CJK-UNIFIED-IDEOGRAPHS-EXTENSION-B │ │ │ │ ASDF/OPERATION │ │ │ │ LATIN-EXTENDED-C │ │ │ │ WARNINGS-FILE │ │ │ │ GLAGOLITIC-SUPPLEMENT │ │ │ │ WANT-PATHNAME │ │ │ │ +POSITIVE-INFINITY │ │ │ │ ASDF/LISP-ACTION │ │ │ │ BOPOMOFO-EXTENDED │ │ │ │ BASSA-VAH │ │ │ │ INSCRIPTIONAL-PARTHIAN │ │ │ │ SB-POSIX │ │ │ │ IGNORE-ERROR-STATUS │ │ │ │ SINGLE-QUOTE │ │ │ │ @@ -20750,14 +20753,15 @@ │ │ │ │ ORIGINAL-SOURCE │ │ │ │ UNIFIED-CANADIAN-ABORIGINAL-SYLLABICS │ │ │ │ VARIATION-SELECTORS-SUPPLEMENT │ │ │ │ SUPPLEMENTAL-ARROWS-C │ │ │ │ NAMED-CONSTANT │ │ │ │ JAVA-1.5 │ │ │ │ ARABIC-PRESENTATION-FORMS-A │ │ │ │ +ASDF/INTERFACE │ │ │ │ OS-HAIKU │ │ │ │ LISPWORKS │ │ │ │ LATIN-EXTENDED-G │ │ │ │ BOPOMOFO │ │ │ │ EAT-SPACES │ │ │ │ PALMYRENE │ │ │ │ OTHER-ID-CONTINUE │ │ │ │ @@ -20859,14 +20863,15 @@ │ │ │ │ ON-FAILURE │ │ │ │ KANA-SUPPLEMENT │ │ │ │ NFKC-QC-MAYBE │ │ │ │ KANA-EXTENDED-A │ │ │ │ USER-CACHE │ │ │ │ BAMUM-SUPPLEMENT │ │ │ │ IF-NO-COMPONENT │ │ │ │ +NEGATIVE-INFINITY │ │ │ │ REHOME-SYMBOL │ │ │ │ ASDF/FORCING │ │ │ │ CONDITION-ALL │ │ │ │ JAVA-1.7 │ │ │ │ WANT-FILE │ │ │ │ HANIFI-ROHINGYA │ │ │ │ SYMBOLICS │ │ │ │ @@ -20903,14 +20908,15 @@ │ │ │ │ DOWNFROM │ │ │ │ VARIATION-SELECTOR │ │ │ │ CORMANLISP │ │ │ │ OLD-TURKIC │ │ │ │ NAG-MUNDARI │ │ │ │ DEVANAGARI-EXTENDED │ │ │ │ PPC32-TARGET │ │ │ │ +FINISHED │ │ │ │ SUPPLEMENTAL-ARROWS-B │ │ │ │ SCONTINUE │ │ │ │ OLD-SOGDIAN │ │ │ │ QUOTATION-MARK │ │ │ │ LISP-INTERACTION │ │ │ │ UIOP/CONFIGURATION │ │ │ │ OLD-PERSIAN │ │ │ │ @@ -21056,14 +21062,15 @@ │ │ │ │ ARABIC-MATHEMATICAL-ALPHABETIC-SYMBOLS │ │ │ │ REF-KNOWN │ │ │ │ LATIN-EXTENDED-D │ │ │ │ OUTPUT-TRANSLATIONS │ │ │ │ IN-PROGRESS │ │ │ │ CAUCASIAN-ALBANIAN │ │ │ │ PHAISTOS-DISC │ │ │ │ +DONT-KNOW │ │ │ │ COMBINING-DIACRITICAL-MARKS-FOR-SYMBOLS │ │ │ │ MATHEMATICAL-ALPHANUMERIC-SYMBOLS │ │ │ │ SYMBOLS-FOR-LEGACY-COMPUTING │ │ │ │ CJK-SYMBOLS-AND-PUNCTUATION │ │ │ │ ENABLE-USER-CACHE │ │ │ │ ARABIC-EXTENDED-B │ │ │ │ TANGUT-COMPONENTS │ │ │ │ @@ -21251,29 +21258,21 @@ │ │ │ │ ASDF/PACKAGE-INFERRED-SYSTEM │ │ │ │ INVALID-FORM-REPORTER │ │ │ │ OTHER-DEFAULT-IGNORABLE-CODE-POINT │ │ │ │ UIOP-DIRECTORY │ │ │ │ PAHAWH-HMONG │ │ │ │ UIOP/COMMON-LISP │ │ │ │ KEY-INDEX- │ │ │ │ -WALKER-ENVIRONMENT-BIND-1 │ │ │ │ -WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ -WALK-ARGLIST │ │ │ │ -WALK-REPEAT-EVAL │ │ │ │ -WALK-DECLARATIONS │ │ │ │ -CONVERT-MACRO-TO-LAMBDA │ │ │ │ -DECOMPOSE-STRING │ │ │ │ -CANONICALLY-COMPOSE │ │ │ │ -COLLECT-DEPENDENCIES │ │ │ │ +*IN-MAKE-OPERATION* │ │ │ │ SYSTEM-NAME │ │ │ │ NEW-STATUS │ │ │ │ -NEW-LEVEL │ │ │ │ LOOP-DESETQ-TEMP │ │ │ │ SPECIAL75 │ │ │ │ NOT-PRESENT78 │ │ │ │ +COLLECT-DEPENDENCIES │ │ │ │ DELETE-PACKAGE* │ │ │ │ SYMBOL-SHADOWING-P │ │ │ │ MAKE-SYMBOL* │ │ │ │ SYMBOL-CALL │ │ │ │ UNINTERN* │ │ │ │ FRESH-PACKAGE-NAME │ │ │ │ FIND-PACKAGE* │ │ │ │ @@ -21291,46 +21290,42 @@ │ │ │ │ UNREIFY-SYMBOL │ │ │ │ ENSURE-PACKAGE │ │ │ │ ENSURE-PACKAGE-UNUSED │ │ │ │ FIND-SYMBOL* │ │ │ │ HOME-PACKAGE-P │ │ │ │ UNREIFY-PACKAGE │ │ │ │ REIFY-SYMBOL │ │ │ │ -%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ ITERATOR-COPY │ │ │ │ -ADJUST-SEQUENCE │ │ │ │ -ENTRY-FUNCTION-FORM │ │ │ │ PROPERTY │ │ │ │ SERIAL-P │ │ │ │ +ADJUST-SEQUENCE │ │ │ │ +ENTRY-FUNCTION-FORM │ │ │ │ NEEDS-ASDF-P │ │ │ │ ENTRY-FUNCTION-CHECK-FORM │ │ │ │ ITERATOR-ELEMENT │ │ │ │ ITERATOR-ENDP │ │ │ │ MAKE-SIMPLE-SEQUENCE-ITERATOR │ │ │ │ GATHER-TYPE │ │ │ │ ITERATOR-STEP │ │ │ │ *DEFAULT-OUTPUT-TRANSLATIONS* │ │ │ │ *MODULES-BEING-REQUIRED* │ │ │ │ +*DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ ASDF-SYSTEM-FILES │ │ │ │ ITERATOR-INDEX │ │ │ │ -*DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ +GOOD-BITS+ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-EXPLAIN-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-TRAVERSE-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-PROPERTY-NOTIFIED-P* │ │ │ │ +DONE-BIT+ │ │ │ │ -COMMAND-LINE-DEBUGGER │ │ │ │ +%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ +CHARACTER-MISC-DATABASE+ │ │ │ │ +COMMAND-LINE-DEBUGGER │ │ │ │ *KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ ONE-ITER- │ │ │ │ WALK-DEFINITIONS │ │ │ │ -CANONIZE-KEY │ │ │ │ -GET-ARGS │ │ │ │ -DISPATCHED-ENTRY-FORM │ │ │ │ -INHERIT-OUTPUT-TRANSLATIONS │ │ │ │ UNPROFILE │ │ │ │ CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ CHECK-FLAG │ │ │ │ REIFIED-DEFERRED-WARNINGS │ │ │ │ SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P │ │ │ │ REIFY-UNDEFINED-WARNING │ │ │ │ ADJUSTMENT │ │ │ │ @@ -21447,14 +21442,15 @@ │ │ │ │ SYSTEM-SEARCH-TABLE │ │ │ │ MANIFEST-FILE-FILES │ │ │ │ DIRECTORIZE │ │ │ │ SYSTEM-SEARCH-FUNCTION │ │ │ │ *LOAD-SEARCH-PATHS* │ │ │ │ *SYSTEM-LOAD-OUTPUT* │ │ │ │ FILE-LINES │ │ │ │ +GET-ARGS │ │ │ │ FILE-OPS │ │ │ │ CALL-WITH-TEMPORARY-OPEN-FILE │ │ │ │ WRITE-DUMPFILE │ │ │ │ TRAVERSE │ │ │ │ DEBUGGER │ │ │ │ *LOGFILE-OUTPUT* │ │ │ │ DUMPER-ACTION-FORM │ │ │ │ @@ -21468,14 +21464,15 @@ │ │ │ │ DISPATCH-ENTRY │ │ │ │ DEFAULT-ENTRY-P │ │ │ │ PRETTY-NAME │ │ │ │ *SHORT-USAGE* │ │ │ │ RANDOM-STRING │ │ │ │ DUMPER-ACTION-FORMS │ │ │ │ INVOKE-DEBUGGER-HOOK-WRAPPER │ │ │ │ +DISPATCHED-ENTRY-FORM │ │ │ │ ASDF-TREE-FILES │ │ │ │ MAKE-PSEUDOSYMBOL │ │ │ │ *ASDF-SYSTEMS-TABLE* │ │ │ │ *ALPHABET* │ │ │ │ COMMAND-LINE-DUMPER │ │ │ │ BUILD-BUILDAPP │ │ │ │ %COMPUTE-PLAN-CLASS-VALUE │ │ │ │ @@ -21488,47 +21485,43 @@ │ │ │ │ MAKE-ACTION-STATUS │ │ │ │ COMPUTE-ACTION-STATUS │ │ │ │ MERGE-ACTION-STATUS │ │ │ │ +KEEP-BIT+ │ │ │ │ %COMPUTE-DEFAULT-OUTPUT-TRANSLATIONS-VALUE │ │ │ │ *OUTPUT-TRANSLATIONS-FILE* │ │ │ │ PROCESS-OUTPUT-TRANSLATIONS-DIRECTIVE │ │ │ │ +INHERIT-OUTPUT-TRANSLATIONS │ │ │ │ *OUTPUT-TRANSLATIONS-DIRECTORY* │ │ │ │ SET-OUTPUT-TRANSLATIONS │ │ │ │ %COMPUTE-DEFAULT-SOURCE-REGISTRIES-VALUE │ │ │ │ PROCESS-SOURCE-REGISTRY-DIRECTIVE │ │ │ │ PATHNAME-KEY │ │ │ │ REGISTRY │ │ │ │ PROCESS-SOURCE-REGISTRY-CACHE │ │ │ │ *SOURCE-REGISTRY-FILE* │ │ │ │ PATHNAME-DIRECTORY-DEPTH │ │ │ │ RECURSEP │ │ │ │ *SOURCE-REGISTRY-DIRECTORY* │ │ │ │ PREFERRED-SOURCE-PATH-P │ │ │ │ +NEW-LEVEL │ │ │ │ +CANONIZE-KEY │ │ │ │ DEFINITION-DEPENDENCIES-UP-TO-DATE-P │ │ │ │ PERFORM-LISP-WARNINGS-CHECK │ │ │ │ BUNDLE-OUTPUT-FILES │ │ │ │ PATHNAME-TYPE-EQUAL-FUNCTION │ │ │ │ SPACE-FOR-CRLF │ │ │ │ CANONIZE-TEST │ │ │ │ DOWNWARD-OPERATION-DEPENDS-ON │ │ │ │ UPWARD-OPERATION-DEPENDS-ON │ │ │ │ ACTION-OVERRIDE-P │ │ │ │ -N-ARRAY23 │ │ │ │ SELFWARD-OPERATION-DEPENDS-ON │ │ │ │ SIDEWAY-OPERATION-DEPENDS-ON │ │ │ │ BACKWARD-COMPATIBLE-DEPENDS-ON │ │ │ │ CHECK-OPERATION-CONSTRUCTOR │ │ │ │ -WALK-FORM-INTERNAL │ │ │ │ -WALK-BINDINGS-1 │ │ │ │ -LET*-BINDINGS │ │ │ │ -NOTE-VAR-BINDING │ │ │ │ -WALKED-VAR-DECLARATION-P │ │ │ │ -NOTE-DECLARATION │ │ │ │ -VARIABLE-SYMBOL-MACRO-P │ │ │ │ +N-ARRAY23 │ │ │ │ CALL-WITHOUT-REDEFINITION-WARNINGS │ │ │ │ OS-HAIKU-P │ │ │ │ FEATURE-SETS │ │ │ │ OS-MEZZANO-P │ │ │ │ FIRST-FEATURE │ │ │ │ *LINK-GUID* │ │ │ │ *LINK-INITIAL-DWORD* │ │ │ │ @@ -21597,62 +21590,68 @@ │ │ │ │ *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 │ │ │ │ +WALK-FORM-INTERNAL │ │ │ │ +WALK-BINDINGS-1 │ │ │ │ +LET*-BINDINGS │ │ │ │ +NOTE-VAR-BINDING │ │ │ │ +WALKED-VAR-DECLARATION-P │ │ │ │ +NOTE-DECLARATION │ │ │ │ +VARIABLE-SYMBOL-MACRO-P │ │ │ │ +ENV-WALK-FUNCTION │ │ │ │ +ENV-LEXICAL-VARIABLES │ │ │ │ +WALK-TAGBODY-1 │ │ │ │ +HUFFMAN-DECODE │ │ │ │ +ENV-LOCK │ │ │ │ +WALKER-INFO-TO-BOGO-FUN │ │ │ │ +RELIST-INTERNAL │ │ │ │ +RECORD-NEW-SOURCE-PATH │ │ │ │ +DECOMPOSE-CHAR │ │ │ │ +COMBINING-CLASS │ │ │ │ +PRIMARY-COMPOSITION │ │ │ │ OLD-BODY │ │ │ │ GET-WALKER-TEMPLATE │ │ │ │ REAL-ENV │ │ │ │ %VAR-DECLARATION │ │ │ │ -WALKER-INFO-TO-BOGO-FUN │ │ │ │ ENV-VAR-TYPE │ │ │ │ -RECORD-NEW-SOURCE-PATH │ │ │ │ QUASIQUOTE-P │ │ │ │ WALK-TEMPLATE-HANDLE-REPEAT │ │ │ │ WALKER-INFO │ │ │ │ WALK-TEMPLATE-HANDLE-REPEAT-1 │ │ │ │ MAGIC-TAG │ │ │ │ -RELIST-INTERNAL │ │ │ │ REPEAT-TEMPLATE │ │ │ │ *BOGO-FUN-MAGIC-TAG* │ │ │ │ OLD-FORM │ │ │ │ BOGO-FUN │ │ │ │ DOC-STRING-P │ │ │ │ ENVIRONMENT-MACRO │ │ │ │ DESTRUCTURINGP │ │ │ │ -ENV-LOCK │ │ │ │ WALK-LET*-BINDINGS │ │ │ │ -ENV-LEXICAL-VARIABLES │ │ │ │ -ENV-WALK-FUNCTION │ │ │ │ *WALK-FORM-PRESERVE-SOURCE* │ │ │ │ -WALK-TAGBODY-1 │ │ │ │ WALK-TEMPLATE │ │ │ │ STOP-FORM │ │ │ │ BOGO-FUN-TO-WALKER-INFO │ │ │ │ WITH-SEQUENCE-ITERATOR │ │ │ │ WITH-SEQUENCE-ITERATOR-FUNCTIONS │ │ │ │ DOSEQUENCE │ │ │ │ %COMPUTE-OPERATIONS-VALUE │ │ │ │ *OLD-ASDF-SYSTEMS* │ │ │ │ FOUND-SYSTEM │ │ │ │ CHECK-NOT-OLD-ASDF-SYSTEM │ │ │ │ -HUFFMAN-DECODE │ │ │ │ -DECOMPOSE-CHAR │ │ │ │ -COMBINING-CLASS │ │ │ │ -PRIMARY-COMPOSITION │ │ │ │ REPORT-FILE-P │ │ │ │ DEFINE-SYSTEM-VIRTUAL-SLOT-READERS │ │ │ │ SYSTEM-VIRTUAL-SLOT-VALUE │ │ │ │ *SYSTEM-VIRTUAL-SLOTS* │ │ │ │ SYSTEM-DESIGNATOR │ │ │ │ DEFINE-SYSTEM-VIRTUAL-SLOT-READER │ │ │ │ *IMAGE-RESTORED-P* │ │ │ │ -*!DELAYED-DEFMETHOD-ARGS* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-LOAD-SYSDEF-NOTIFIED-P* │ │ │ │ CHAR-FOLDCASE │ │ │ │ SENTENCE-PREBREAK │ │ │ │ COLLATION-KEY │ │ │ │ SORT-KEY │ │ │ │ CHAR-DECOMPOSITION │ │ │ │ LINE-PREBREAK │ │ │ │ @@ -21756,26 +21755,27 @@ │ │ │ │ OVERRIDE-ACCESSOR │ │ │ │ OR-FUNCTION │ │ │ │ FORCE-NOT-P │ │ │ │ POSTLUDEP │ │ │ │ LISP-OBJECT-FILES │ │ │ │ PRELUDEP │ │ │ │ ENTRY-POINT-P │ │ │ │ -LIST-INITARG-0 │ │ │ │ +*!DELAYED-DEFMETHOD-ARGS* │ │ │ │ RESULT-WIDTH-NAME- │ │ │ │ -ARG-FOR-(BYTE 2 6)- │ │ │ │ -ARG-FOR-(BYTE 3 3)- │ │ │ │ +LIST-INITARG-0 │ │ │ │ ARG-FOR-(BYTE 3 0)- │ │ │ │ +ARG-FOR-(BYTE 3 3)- │ │ │ │ +ARG-FOR-(BYTE 2 6)- │ │ │ │ !DECODE-FOP │ │ │ │ EMF-N-59 │ │ │ │ EMF-N-63 │ │ │ │ +!HAIRY-DATA-VECTOR-REFFER-INIT │ │ │ │ EMF-N-69 │ │ │ │ EMF-N-95 │ │ │ │ EMF-N-107 │ │ │ │ -!HAIRY-DATA-VECTOR-REFFER-INIT │ │ │ │ .SLOTS.97 │ │ │ │ EMF-N-9598 │ │ │ │ (! $ #(! $(+(! $(,(! $(+(! $(+(! $( │ │ │ │ alloc_list │ │ │ │ call_into_c │ │ │ │ debug_print │ │ │ │ os_get_errno │ │ │ │ @@ -22806,20 +22806,20 @@ │ │ │ │ LVAR-FUNCTION-DESIGNATOR-ANNOTATION-EQUALP │ │ │ │ LVAR-SEQUENCE-BOUNDS-ANNOTATION-EQUALP │ │ │ │ LVAR-TYPE-ANNOTATION-EQUALP │ │ │ │ LVAR-FUNCTION-ANNOTATION-EQUALP │ │ │ │ LVAR-LAMBDA-VAR-ANNOTATION-EQUALP │ │ │ │ NODE-EQUALP │ │ │ │ VALUED-NODE-EQUALP │ │ │ │ +CLOOP-EQUALP │ │ │ │ +CBLOCK-EQUALP │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@<~S fell through ~S expression.~@[ ~:_Wanted one of (~//).~]~:> │ │ │ │ -CLOOP-EQUALP │ │ │ │ -CBLOCK-EQUALP │ │ │ │ COMPONENT-EQUALP │ │ │ │ CLEANUP-EQUALP │ │ │ │ A SB-KERNEL │ │ │ │ B SB-KERNEL0 │ │ │ │ ENVIRONMENT-EQUALP │ │ │ │ TAIL-SET-EQUALP │ │ │ │ A SB-KERNEL │ │ │ │ @@ -22968,26 +22968,26 @@ │ │ │ │ by the compiler that the user might wish to know, but which does not merit │ │ │ │ a STYLE-WARNING (or any more serious condition). │ │ │ │ A condition type signalled when the compiler deletes code that the user │ │ │ │ has written, having proved that it is unreachable. │ │ │ │ TWO-WAY-STREAM-EQUALP │ │ │ │ CONCATENATED-STREAM-EQUALP │ │ │ │ ECHO-STREAM-EQUALP │ │ │ │ +STRING-INPUT-STREAM-EQUALP │ │ │ │ +FINITE-BASE-STRING-OUTPUT-STREAM-EQUALP │ │ │ │ +CASE-FROB-STREAM-EQUALP │ │ │ │ +STUB-STREAM-EQUALP │ │ │ │ ~@<~@(~D~) call~:P to ~// ~2:*~[~;was~:;were~] compiled before a compiler-macro was defined for it. A declaration of NOTINLINE at the call site~:P will eliminate this warning, as will defining the compiler-macro before its first potential use.~@:> │ │ │ │ ~A elements in ~2I~_~:S ~I~_to satisfy lambda list ~2I~_~//: ~I~_ │ │ │ │ ~@<~S ~S causes name-conflicts in ~S between the following symbols: ~2I~@:_~{~//~^, ~}~:@> │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~&Error during printing. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -STRING-INPUT-STREAM-EQUALP │ │ │ │ -FINITE-BASE-STRING-OUTPUT-STREAM-EQUALP │ │ │ │ -CASE-FROB-STREAM-EQUALP │ │ │ │ -STUB-STREAM-EQUALP │ │ │ │ FASL-INPUT-EQUALP │ │ │ │ FASL-GROUP-EQUALP │ │ │ │ A SB-KERNEL0 │ │ │ │ B SB-KERNEL │ │ │ │ DEADLINE-EQUALP │ │ │ │ FORMAT-DIRECTIVE-EQUALP │ │ │ │ FMT-CONTROL-PROXY-EQUALP │ │ │ │ @@ -23343,17 +23343,18 @@ │ │ │ │ Keep ~S accessible in ~A (shadowing ~S). │ │ │ │ forced to do runtime allocation of alien-value structure │ │ │ │ COND clause is not a ~S: ~S │ │ │ │ Class is not a structure class: ~S │ │ │ │ Class is not yet defined or was undefined: ~S │ │ │ │ malformed :INITIAL-CONTENTS: ~S should have dimensions ~S │ │ │ │ Unexpected %MAKE-HAIRY-TYPE │ │ │ │ -0 2)"(/T │ │ │ │ -0 2)"({3 │ │ │ │ -COMPLEX-FLOAT-VALUE VOP failure │ │ │ │ +type intersection │ │ │ │ +Topological sort failed due to constraint on ~S. │ │ │ │ +~@ │ │ │ │ │ │ │ │ SB-DISASSEM │ │ │ │ private: stuff related to the implementation of the disassembler │ │ │ │ P.Q7U,W>X │ │ │ │ e1gAr5sfu │ │ │ │ mzn7phzy{j │ │ │ │ @@ -23381,31 +23382,35 @@ │ │ │ │ /build/reproducible-path/buildapp-1.5.6/dumper.lisp │ │ │ │ Comma not inside a backquote. │ │ │ │ SYS:SRC;PCL;PRE-WARM.LISP │ │ │ │ /W~(}D~ 3 │ │ │ │ u_Q1._w( │ │ │ │ Return a copy of SEQUENCE with elements satisfying the test (default is │ │ │ │ EQL) with ITEM removed. │ │ │ │ -no translator for primitive alien type ~// │ │ │ │ -no definition for alien type ~// │ │ │ │ -unknown alien type: ~// │ │ │ │ -Recursion limit reached while expanding local macro ~// │ │ │ │ @@f8;Dfn$E │ │ │ │ [IN"e/\b │ │ │ │ nrjWspyI │ │ │ │ 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. │ │ │ │ COMMON-LISP │ │ │ │ E`[(p$(iL │ │ │ │ DERIVE-FUN │ │ │ │ fR@,Pu:0 │ │ │ │ RB+PW:03u5" │ │ │ │ +no translator for primitive alien type ~// │ │ │ │ +no definition for alien type ~// │ │ │ │ +unknown alien type: ~// │ │ │ │ +Recursion limit reached while expanding local macro ~// │ │ │ │ +~S can't be converted to type ~//. │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ Acquire MUTEX for the current thread. If WAITP is true (the default) and │ │ │ │ the mutex is not immediately available, sleep until it is available. │ │ │ │ If TIMEOUT is given, it specifies a relative timeout, in seconds, on how long │ │ │ │ GRAB-MUTEX should try to acquire the lock in the contested case. │ │ │ │ If GRAB-MUTEX returns T, the lock acquisition was successful. In case of WAITP │ │ │ │ being NIL, or an expired TIMEOUT, GRAB-MUTEX may also return NIL which denotes │ │ │ │ that GRAB-MUTEX did -not- acquire the lock. │ │ │ │ @@ -23450,18 +23455,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ If SYMBOL names a macro in ENV, returns the expansion function, │ │ │ │ else returns NIL. If ENV is unspecified or NIL, use the global environment │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ &Q;)Pu:@ │ │ │ │ -~S can't be converted to type ~//. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ COMMON-LISP │ │ │ │ Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset │ │ │ │ options to MAKE-ARRAY, or NIL and 0 if not a displaced array. │ │ │ │ Return the greatest of its arguments; among EQUALP greatest, return │ │ │ │ the first. │ │ │ │ Return the least of its arguments; among EQUALP least, return │ │ │ │ the first. │ │ │ │ @@ -23501,16 +23502,17 @@ │ │ │ │ convert x/2^k to shift │ │ │ │ SB-ALIEN0 │ │ │ │ fold zero arg │ │ │ │ fold identity operations │ │ │ │ SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ SYS:SRC;CODE;DEFTYPES-FOR-TARGET.LISP │ │ │ │ SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ -[^ZR[aaj │ │ │ │ -ill-formed handler binding: ~S │ │ │ │ +0 2)"(/T │ │ │ │ +0 2)"({3 │ │ │ │ +COMPLEX-FLOAT-VALUE VOP failure │ │ │ │ bounding index designator │ │ │ │ SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ associate //(* /) of constants │ │ │ │ convert to multiplication by reciprocal │ │ │ │ 2=Ya1q)! │ │ │ │ OBJECT SB-KERNEL8 │ │ │ │ ARGUMENTS │ │ │ │ @@ -23570,20 +23572,18 @@ │ │ │ │ Consequences are unspecified if serious conditions occur during EXIT │ │ │ │ excepting errors from *EXIT-HOOKS*, which cause warnings and stop │ │ │ │ execution of the hook that signaled, but otherwise allow the exit │ │ │ │ process to continue normally. │ │ │ │ SYS:SRC;PCL;DOCUMENTATION.LISP │ │ │ │ SYS:SRC;CODE;DESCRIBE.LISP │ │ │ │ SYS:SRC;CODE;INSPECT.LISP │ │ │ │ +[^ZR[aaj │ │ │ │ +ill-formed handler binding: ~S │ │ │ │ SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-RANDOM.LISP │ │ │ │ -type intersection │ │ │ │ -Topological sort failed due to constraint on ~S. │ │ │ │ -~@ │ │ │ │ @@ -23649,14 +23649,15 @@ │ │ │ │ defining ~s as a constructor for ~s structure │ │ │ │ defining ~s as an accessor for ~s structure │ │ │ │ defining ~s as a copier for ~s structure │ │ │ │ defining ~s as a predicate for ~s structure │ │ │ │ 1-0"0-%2h │ │ │ │ The SATISFIES predicate name is not a symbol: ~S │ │ │ │ SUBTYPEP is illegal on this type: │ │ │ │ +SYS:SRC;CODE;CLASS.LISP │ │ │ │ /$"24.!%(9)!$ │ │ │ │ ]ZWaNXedan │ │ │ │ /dev/urandom │ │ │ │ NOT CONSTANT too confusing on ~S │ │ │ │ The current │ │ │ │ the most recently loaded │ │ │ │ ~@ │ │ │ │ @@ -23699,19 +23700,17 @@ │ │ │ │ :PREDICATE cannot be used with :TYPE unless :NAMED is also specified. │ │ │ │ :OFFSET can't be specified unless :TYPE is specified. │ │ │ │ ++$pG_G'G5'PFpG'a's │ │ │ │ K?'tH3{! │ │ │ │ Set specified value and use it. │ │ │ │ while restarting unbound variable │ │ │ │ :TYPE'd DEFSTRUCT ~S not found for inclusion. │ │ │ │ +}F-3#B> ? │ │ │ │ X[sa]sgc │ │ │ │ EPXRVddXY\XRbkpX │ │ │ │ -}F-3#B> ? │ │ │ │ -SYS:SRC;CODE;CLASS.LISP │ │ │ │ -SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ ~S is not a defined type class. │ │ │ │ W^abWddaje{]TQkeb^^[ │ │ │ │ Keyword type description is not a two-list: ~S. │ │ │ │ making ~(~A~) class ~S writable │ │ │ │ NOT VALUES too confusing on ~S │ │ │ │ ~A~%BREAK was entered because of *BREAK-ON-SIGNALS* ~ │ │ │ │ (now rebound to NIL). │ │ │ │ @@ -23742,26 +23741,27 @@ │ │ │ │ Key-Info-Set │ │ │ │ ~&ctype cache metrics: Count LF Seek Hit maxPSL Mask │ │ │ │ ~&Alien: │ │ │ │ ~16a: ~7D ~5,1,2F%~#[~:; ~:[ ~;~:*~8D~] ~:[ ~;~:*~4,1,2f%~]~ │ │ │ │ ~6D ~6X~]~% │ │ │ │ ~16A: ~7D │ │ │ │ r2"%,$(5)2 │ │ │ │ +after-GC │ │ │ │ UkUOeOU\YU_o[ │ │ │ │ NUdRVcXa │ │ │ │ Bad type specifier: ~a │ │ │ │ -after-GC │ │ │ │ trying to use CHECK-FOR-CIRCULARITY when circularity checking isn't initiated │ │ │ │ unsealing sealed class ~S in order to subclass it │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ ~S does not designate a condition class. │ │ │ │ odd-length initializer list: ~S. │ │ │ │ * is not permitted as a type specifier~@[ in the context ~S~] │ │ │ │ * is not permitted as an argument to the ~S type specifier │ │ │ │ +SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ unknown internal error: ~S │ │ │ │ ~S can't be coerced to a function. │ │ │ │ ~S isn't an integer type? │ │ │ │ ~S is not a character output stream. │ │ │ │ undeclaring functions for old subclasses of ~S: │ │ │ │ uninterned │ │ │ │ ~S is not a binary output stream. │ │ │ │ @@ -23940,17 +23940,19 @@ │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ DEFSTRUCT │ │ │ │ COMMON-LISP89 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ +bad thing to be a type specifier: ~// │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ +INSTANCE │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ f_(5)SJ) │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -23984,44 +23986,50 @@ │ │ │ │ An array of all callback aliens indexed by their order of creation. │ │ │ │ A hashtable used to detect cycles while comparing record types. │ │ │ │ shared object list lock │ │ │ │ Spinlock type. │ │ │ │ A function which is called with the function argument to SB-THREAD:INTERRUPT-THREAD │ │ │ │ when the interrupt is ready to run. │ │ │ │ The default behavior is to use FUNCALL. │ │ │ │ -List of available buffers. │ │ │ │ Package Table Lock │ │ │ │ finalizer │ │ │ │ +List of available buffers. │ │ │ │ +A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ Scheduler lock │ │ │ │ Package Graph Lock │ │ │ │ -A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ -Around spawn(). │ │ │ │ List of all the currently active handlers for file descriptors │ │ │ │ +Around spawn(). │ │ │ │ List of all available output routines. Each element is a list of the │ │ │ │ element-type output, the kind of buffering, the function name, and the number │ │ │ │ of bytes per element. │ │ │ │ List of process structures for all active processes. │ │ │ │ A function of no arguments returning a function of one argument NOPRINT │ │ │ │ that provides the REPL for the system. Assumes that *STANDARD-INPUT* and │ │ │ │ *STANDARD-OUTPUT* are set up. │ │ │ │ -Default number of bytes per buffer. │ │ │ │ Lock for active processes. │ │ │ │ +Default number of bytes per buffer. │ │ │ │ how deep we are into backquotes │ │ │ │ If true, processing of the VALUES declaration is inhibited. │ │ │ │ *REOPTIMIZE-AFTER-TYPE-CHECK-MAX* exceeded. │ │ │ │ Coalesced LTN numbers for a more operand to meet LOCAL-TN-LIMIT. │ │ │ │ control analysis deleted dead block │ │ │ │ Allocate heap value cell for lexical var. │ │ │ │ IR1-OPTIMIZE-UNTIL-DONE called │ │ │ │ Copy propagation deleted a move. │ │ │ │ hit *MAX-OPTIMIZE-ITERATIONS* limit │ │ │ │ Split an IR2 block to meet LOCAL-TN-LIMIT. │ │ │ │ The upper limit on the number of times that we will consecutively do IR1 │ │ │ │ optimization that doesn't introduce any new code. A finite limit is │ │ │ │ necessary, since type inference may take arbitrarily long to converge. │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ +WRAPPER18 │ │ │ │ +WRAPPER14 │ │ │ │ +WRAPPER8 │ │ │ │ +WRAPPER2 │ │ │ │ When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will │ │ │ │ enter the debugger prior to signalling that condition. │ │ │ │ the previous value of ++ │ │ │ │ Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE? │ │ │ │ the exclusive upper bound on any given dimension of an array │ │ │ │ the radix that Lisp reads numbers in │ │ │ │ the previous value of / │ │ │ │ @@ -24236,16 +24244,14 @@ │ │ │ │ A real number designating the number of seconds to wait for input │ │ │ │ at maximum, before calling the *PERIODIC-POLLING-FUNCTION* (if any.) │ │ │ │ Shared between all threads, unless locally bound. EXPERIMENTAL. │ │ │ │ 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. │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ SYS:SRC;CODE;UNIX.LISP │ │ │ │ >AF_G`H6I │ │ │ │ RbVIW │ │ │ │ @@ -24325,22 +24327,18 @@ │ │ │ │ unrecognized instance type │ │ │ │ Nevermind and recurse. │ │ │ │ ~@<~4IProblem forcing cache flushes. Please report ~ │ │ │ │ to sbcl-devel.~ │ │ │ │ ~% Owrapper: ~S~ │ │ │ │ ~% Wrapper-of: ~S~ │ │ │ │ ~% Class-wrapper: ~S~%~:@> │ │ │ │ -FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ -Evaluate the BODY-FORMS with local function definitions. The bindings do │ │ │ │ -not enclose the definitions; any use of NAME in the FORMS will refer to the │ │ │ │ -lexically apparent function definition in the enclosing environment. │ │ │ │ +shouldn't happen? │ │ │ │ Place ~S in PSETQ is not a SYMBOL │ │ │ │ Odd number of args to ~S. │ │ │ │ ~S called with too few arguments: ~S │ │ │ │ -shouldn't happen? │ │ │ │ The HOST argument doesn't match the pathname host: │ │ │ │ ~S and ~S. │ │ │ │ A LIST representing a pathname host is not supported in this implementation: │ │ │ │ ~@ │ │ │ │ logical host not yet defined: ~S │ │ │ │ ~S is not defined for ~S │ │ │ │ ~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ @@ -24354,37 +24352,39 @@ │ │ │ │ generic-function │ │ │ │ funcallable-instance │ │ │ │ interpreted function │ │ │ │ compiled closure │ │ │ │ The object is a │ │ │ │ Lambda-list │ │ │ │ Closed over values │ │ │ │ +FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ +Evaluate the BODY-FORMS with local function definitions. The bindings do │ │ │ │ +not enclose the definitions; any use of NAME in the FORMS will refer to the │ │ │ │ +lexically apparent function definition in the enclosing environment. │ │ │ │ defaulted │ │ │ │ -bad thing to be a type specifier: ~// │ │ │ │ ~eSf0 zeG │ │ │ │ ~eSf0 zeG │ │ │ │ Convert ASH of word to %ASH/RIGHT │ │ │ │ Convert ASH of signed word to %ASH/RIGHT │ │ │ │ COMMON-LISP │ │ │ │ [1MN1m"| │ │ │ │ :.9r:&Mr │ │ │ │ Return the product of its arguments. With no args, returns 1. │ │ │ │ +Simple equality transform │ │ │ │ +INSTANCE │ │ │ │ Impossible: fixnum ASH should not be called with │ │ │ │ constant shift greater than word length │ │ │ │ Package Locks │ │ │ │ Idiosyncrasies │ │ │ │ Handling of Types │ │ │ │ standard readtable │ │ │ │ standard pprint dispatch table │ │ │ │ Deprecation Conditions │ │ │ │ -Simple equality transform │ │ │ │ -INSTANCE │ │ │ │ INSTANCE │ │ │ │ Return the name of the given restart object. │ │ │ │ -Q et-k-9 │ │ │ │ SYS:SRC;COMPILER;X86;FLOAT.LISP │ │ │ │ SYS:SRC;CODE;LATE-EXTENSIONS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-ALIENEVAL.LISP │ │ │ │ SYS:SRC;CODE;COLD-INIT.LISP │ │ │ │ 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: │ │ │ │ @@ -24419,37 +24419,34 @@ │ │ │ │ not a function designator. │ │ │ │ NUMERIC-UNION-TYPE- │ │ │ │ CLASSOID-CELL- │ │ │ │ STRUCTURE-CLASSOID- │ │ │ │ UNION-TYPE- │ │ │ │ CONS-TYPE- │ │ │ │ ARRAY-TYPE- │ │ │ │ +Q et-k-9 │ │ │ │ BASE+BOUNDS │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -INSTANCE │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ 4UzA9%y │ │ │ │ -:NAMED option is incompatible with element type ~// │ │ │ │ -Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ -~@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +~@ │ │ │ │ 5dAUeg 6 │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ sOmJ#2s │ │ │ │ G1%(PJ@h │ │ │ │ INSTANCE │ │ │ │ @@ -24486,44 +24483,44 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ 6R?,`W:0 │ │ │ │ COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ ENUMERABLE │ │ │ │ COMMON-LISP │ │ │ │ M3v|cszybl │ │ │ │ +COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE │ │ │ │ REAL-RESTART0, │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ L+%`o:00 │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ +INSTANCE │ │ │ │ Changing meta-class of ~S from ~S to ~S. │ │ │ │ Derived type ~s is not a suitable index for ~s. │ │ │ │ Can't fill ~a into ~a │ │ │ │ b&&3)!? │ │ │ │ b&&3)!? │ │ │ │ b&&3)!? │ │ │ │ Incompatible :initial-contents ~s for :element-type ~a. │ │ │ │ :initial-contents has an element ~s incompatible with :element-type ~a. │ │ │ │ d\bgadRa`\ │ │ │ │ pjm\F3jdXE3d^dgvod │ │ │ │ DD-NAMED │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ `G{)!)w9 │ │ │ │ @@ -24560,29 +24557,35 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ DEFSTRUCT │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ +:NAMED option is incompatible with element type ~// │ │ │ │ +Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ +~@ │ │ │ │ +VALUES type illegal in this context: │ │ │ │ +Attempt to remove :PRIMITIVE type: ~// │ │ │ │ +Can't displace an array of type ~// into another of type ~// │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ KV-VECTOR │ │ │ │ CLAUSE-INDEX │ │ │ │ LAYOUT-LISTS │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -NAMED-TYPE- │ │ │ │ -SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ -SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ Return T if X and Y are EQL or if they are structured components whose │ │ │ │ elements are EQUAL. Strings and bit-vectors are EQUAL if they are the same │ │ │ │ length and have identical components. Other arrays must be EQ to be EQUAL. │ │ │ │ ]xI#n$x( │ │ │ │ FORTHCOMING-INFO │ │ │ │ +NAMED-TYPE- │ │ │ │ +SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ +SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ W'(R$:'u │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ @@ -24619,43 +24622,40 @@ │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ Store NEWVAL as the component of SEQUENCE specified by INDEX. │ │ │ │ INSTANCE │ │ │ │ Enable all the default signals that Lisp knows how to deal with. │ │ │ │ COMMON-LISP │ │ │ │ -MAX-INDEX │ │ │ │ -EXTRA-ID-WORDS │ │ │ │ -VALUES type illegal in this context: │ │ │ │ -Attempt to remove :PRIMITIVE type: ~// │ │ │ │ -Can't displace an array of type ~// into another of type ~// │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ INPUT-TYPES │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE │ │ │ │ +MAX-INDEX │ │ │ │ +EXTRA-ID-WORDS │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ TYPE-SPECIFIER │ │ │ │ INSTANCE │ │ │ │ o4nq@)/J │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP0 │ │ │ │ +CODE-OBJ0 │ │ │ │ + FUN-INDEX │ │ │ │ +SB-ALIEN │ │ │ │ TEST-NOT │ │ │ │ FLET-NAME │ │ │ │ STORE-VARS │ │ │ │ COMMON-LISP │ │ │ │ -CODE-OBJ0 │ │ │ │ - FUN-INDEX │ │ │ │ -SB-ALIEN │ │ │ │ OBJECT0' │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0, │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP0 │ │ │ │ "M+%`o:0 │ │ │ │ @@ -24713,22 +24713,22 @@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ -COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;X86;ARITH.LISP │ │ │ │ =8@@64Bb │ │ │ │ INSTANCE │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ k=_/ >hk │ │ │ │ +SYS:SRC;COMPILER;X86;ARITH.LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP1 │ │ │ │ SB-ALIEN │ │ │ │ NEW-LENGTH │ │ │ │ COMMON-LISP │ │ │ │ @@ -24787,24 +24787,24 @@ │ │ │ │ V4UKb6P5 │ │ │ │ M/Wb^"uiS │ │ │ │ <)PW:03c │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE │ │ │ │ -NRZONTR^ │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ -SYS:SRC;COMPILER;X86;SYSTEM.LISP │ │ │ │ +NRZONTR^ │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE │ │ │ │ INSTANCE │ │ │ │ COMMON-LISP │ │ │ │ +SYS:SRC;COMPILER;X86;SYSTEM.LISP │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ tw}@:&[= │ │ │ │ z))5]x1JK │ │ │ │ hH5a,h │ │ │ │ shadowing symbol~P ~{~A~^, ~} │ │ │ │ uninterning ~A │ │ │ │ shadowing-importing symbol~P ~ │ │ │ │ ~{~A~^, ~} │ │ │ │ importing symbol~P ~{~A~^, ~} │ │ │ │ no non-whitespace characters in string ~S. │ │ │ │ @@ -25021,57 +25024,51 @@ │ │ │ │ unrecognized declaration ~S │ │ │ │ ~S is a constant and so can't be declared special. │ │ │ │ ~S is an alien variable and so can't be declared special. │ │ │ │ The lists of keys and data are of unequal length. │ │ │ │ method ~S not defined for ~S │ │ │ │ Axis number ~W is too big; ~S only has ~D dimension~:P. │ │ │ │ Vector axis is not zero: ~S │ │ │ │ +of the directory segment ~S. │ │ │ │ +user homedir not known~@[ for ~S~]: ~A │ │ │ │ +a host name │ │ │ │ +a directory name │ │ │ │ +a file name │ │ │ │ +a file type │ │ │ │ +a positive integer, * or NEWEST │ │ │ │ +expected a positive integer, ~ │ │ │ │ + got ~S │ │ │ │ +extra stuff after end of file name │ │ │ │ +expecting a dot, got ~S. │ │ │ │ +expecting ~A, got ~:[nothing~;~S~]. │ │ │ │ +called PARSE-NATIVE-NAMESTRING using a logical host: ~S │ │ │ │ +called NATIVE-NAMESTRING using a logical host: ~S │ │ │ │ +invalid directory component: ~S │ │ │ │ +cannot specify the version without a type: ~S │ │ │ │ +type component can't have a #. inside: ~S │ │ │ │ +cannot specify the type without a file: ~S │ │ │ │ +too many dots in the name: ~S │ │ │ │ +There are ~W elements in the :INITIAL-CONTENTS, but the vector length is ~W. │ │ │ │ +Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ ~W is too big for a fixnum. │ │ │ │ -~S is not a defined storage class. │ │ │ │ ~@ │ │ │ │ Can't LOAD a directory: ~s. │ │ │ │ unbinding the symbol ~A │ │ │ │ Can't make ~A variable unbound: ~S │ │ │ │ removing the function or macro definition of ~A │ │ │ │ unknown code location │ │ │ │ setting the macro-function of ~S │ │ │ │ ~S names a special form. │ │ │ │ Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ undefined function │ │ │ │ bogus stack frame │ │ │ │ -shouldn't get here │ │ │ │ -malformed arguments description │ │ │ │ -; Using form offset instead of character position. │ │ │ │ -; File has been modified since compilation: │ │ │ │ -URYe\Re[UOWdm │ │ │ │ -URPY\Re[UOWd │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -Read the next Lisp value from STREAM, and return it. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -CATEGORY │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +Component name: designator for a string composed of portable pathname characters │ │ │ │ Return the last N conses (not the last element!) of a list. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ )BJCut$SQ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25342,26 +25339,14 @@ │ │ │ │ L%g#-V%9 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -parameter specializer name │ │ │ │ -Extensible Sequences │ │ │ │ -Saving a Core Image │ │ │ │ -SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ -SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ -SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ -k!w#[&_' │ │ │ │ -SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ -SYS:SRC;CODE;CAS.LISP │ │ │ │ -SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ -SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25401,14 +25386,26 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ +parameter specializer name │ │ │ │ +Extensible Sequences │ │ │ │ +Saving a Core Image │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ +SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ +SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ +k!w#[&_' │ │ │ │ +SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ +SYS:SRC;CODE;CAS.LISP │ │ │ │ +SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ +SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ J$%JBISE │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25476,30 +25473,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ Return two values indicating the relationship between type1 and type2. │ │ │ │ If values are T and T, type1 definitely is a subtype of type2. │ │ │ │ If values are NIL and T, type1 definitely is not a subtype of type2. │ │ │ │ If values are NIL and NIL, it couldn't be determined. │ │ │ │ MORE-ARG │ │ │ │ Return all arguments, in order, as values. │ │ │ │ Return an abbreviated pathname sufficient to identify PATHNAME │ │ │ │ @@ -25520,14 +25501,29 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ 2)E8|m#`x │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25686,28 +25682,28 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ *:'VJ)eJ) │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ +Evaluate the BODY-FORMS with local function definitions. The bindings enclose │ │ │ │ +the new definitions, so the defined functions can call themselves or each │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* │ │ │ │ -Evaluate the BODY-FORMS with local function definitions. The bindings enclose │ │ │ │ -the new definitions, so the defined functions can call themselves or each │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25831,24 +25827,25 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -25985,20 +25982,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NEW-VALUE │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26042,14 +26033,19 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26196,14 +26192,18 @@ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ +called NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26256,14 +26256,20 @@ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +Return the integer that makes DEBUG-VAR's name and package unique │ │ │ │ + with respect to other DEBUG-VARs in the same function. │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ Output a newline, the mostly READable printed representation of OBJECT, and │ │ │ │ space to the specified STREAM. │ │ │ │ COMMON-LISP0 │ │ │ │ Return non-NIL if SYMBOL is bound to a value. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -26282,24 +26288,14 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Print a message and invoke the debugger without allowing any possibility │ │ │ │ of condition handling occurring. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ T if OBJECT is a PROCESS, NIL otherwise. │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ -called NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -Return the integer that makes DEBUG-VAR's name and package unique │ │ │ │ - with respect to other DEBUG-VARs in the same function. │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Return whether debug-block represents elsewhere code. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Returns the list of possible code-locations where execution may continue │ │ │ │ @@ -26510,38 +26506,44 @@ │ │ │ │ COMMON-LISP │ │ │ │ STRUCTURE │ │ │ │ COMMON-LISP0 │ │ │ │ SYNTAX-CHECKER │ │ │ │ The primary return value indicates whether NAME is a valid function │ │ │ │ name; if it is, the second return value will be a symbol suitable for │ │ │ │ use as a BLOCK name in the function in question. │ │ │ │ -Component name: designator for a string composed of portable pathname characters │ │ │ │ the default value for the :ENCAPSULATE option to TRACE │ │ │ │ the default value for the :REPORT option to TRACE │ │ │ │ Superclass of all Gray streams whose element-type │ │ │ │ is a subtype of unsigned-byte or signed-byte. │ │ │ │ Superclass of all Gray streams whose element-type is a subtype of character. │ │ │ │ Superclass of all Gray output streams. │ │ │ │ Superclass of all Gray input streams whose element-type │ │ │ │ is a subtype of unsigned-byte or signed-byte. │ │ │ │ Superclass of all Gray input streams whose element-type │ │ │ │ is a subtype of character. │ │ │ │ +shouldn't get here │ │ │ │ +malformed arguments description │ │ │ │ +; Using form offset instead of character position. │ │ │ │ +; File has been modified since compilation: │ │ │ │ ARG-~V,'0D │ │ │ │ +URYe\Re[UOWdm │ │ │ │ +URPY\Re[UOWd │ │ │ │ foreign function: #x~X │ │ │ │ foreign function: │ │ │ │ ** pc-offset ~S not in code obj ~S? │ │ │ │ ??? Can't get name of debug-block's function. │ │ │ │ Source path no longer exists. │ │ │ │ XX[k s+, │ │ │ │ \hXgpRRgt │ │ │ │ :FUN-END breakpoints are currently unsupported for the known return convention on low debug. │ │ │ │ cannot make a breakpoint at an unknown code location: ~S │ │ │ │ cannot activate a deleted breakpoint: ~S │ │ │ │ Don't know how to use a DEBUG-SOURCE without a namestring or a form. │ │ │ │ redefining ~A ~S to be: │ │ │ │ +%PATHNAME- │ │ │ │ can't deposit aliens of type ~S (unknown size) │ │ │ │ ~A: malloc() of ~S bytes failed. │ │ │ │ XcRMr^XdR │ │ │ │ Continue, clobbering the old definition. │ │ │ │ Incompatible alien record type definition~%Old: ~S~%New: ~S │ │ │ │ unknown alignment: ~S │ │ │ │ unknown size: ~S │ │ │ │ @@ -26566,43 +26568,29 @@ │ │ │ │ New type is: │ │ │ │ Create new alien callable (old alien callable gets freed). │ │ │ │ Ignore the error and continue as if closing succeeded. │ │ │ │ dlerror() returned an error while trying to close ~ │ │ │ │ ~:[runtime~;shared object ~:*~S~]: ~S │ │ │ │ Double free of callable alien ~A. │ │ │ │ Trying to free a callable alien ~A not allocated by Lisp. │ │ │ │ -unknown size for alien type ~S │ │ │ │ -aXVUPhYZ │ │ │ │ -KddqWp`fQ[Lkcm^QT │ │ │ │ -can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ -bogus argument style ~S in ~S │ │ │ │ -_OMVV_gn{ │ │ │ │ -QaXONV[RUONY_ │ │ │ │ -cannot make an alien of type ~S out of a SAP │ │ │ │ -VYgmUXR[RVX^ │ │ │ │ -The alignment of ~S is unknown. │ │ │ │ -The size of ~S is unknown. │ │ │ │ -cannot override the size of zero-dimensional arrays │ │ │ │ "[g _\tuX │ │ │ │ +unknown size for alien type ~S │ │ │ │ attempt to shadow definition of ~A ~S │ │ │ │ Returning structs by value is unsupported on this platform. │ │ │ │ ~&Enter pathname (evaluated): │ │ │ │ ~&Error: invalid pathname. │ │ │ │ Specify a different pathname to load the shared object from. │ │ │ │ Retry loading this shared object. │ │ │ │ Skip this shared object and continue. │ │ │ │ too many indices when DEREF'ing ~S: ~W │ │ │ │ incorrect number of indices when DEREF'ing ~S: ~W │ │ │ │ Passing structs by value is unsupported on this platform. │ │ │ │ 1.0.53.11 │ │ │ │ 1.0.37.33 │ │ │ │ 1.0.29.17 │ │ │ │ -SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ -SYS:SRC;CODE;TARGET-CHAR.LISP │ │ │ │ -SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ cannot extract ~W-bit integers │ │ │ │ ~S is unsupported as of SBCL 0.8.13. See LOAD-SHARED-OBJECT. │ │ │ │ =7ZAc=c] │ │ │ │ wrong number of arguments for ~S │ │ │ │ expected ~W, got ~W │ │ │ │ ~S is not an alien function. │ │ │ │ ~S is unsupported as of SBCL 0.8.13. Please use LOAD-SHARED-OBJECT. │ │ │ │ @@ -26622,20 +26610,35 @@ │ │ │ │ main thread │ │ │ │ Resuming thread ~A │ │ │ │ ~& Bin Size Allocated Count Cum% │ │ │ │ ~& ~2d ~10@a ~13d ~9d ~7,2,2f │ │ │ │ ~& Tot ~23d ~9d │ │ │ │ ; ~D unboxed + ~D boxed bytes (~,1,2F% + ~,1,2F%) │ │ │ │ GET-MUTEX won't get a mutex on behalf of a different thread │ │ │ │ -Unknown barrier kind ~S │ │ │ │ -YJPgUUP\\U^PeHfJgQ\mUPFkWpp │ │ │ │ ~S received an improper list of arguments: ~S │ │ │ │ +aXVUPhYZ │ │ │ │ +KddqWp`fQ[Lkcm^QT │ │ │ │ +can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ +bogus argument style ~S in ~S │ │ │ │ +_OMVV_gn{ │ │ │ │ +QaXONV[RUONY_ │ │ │ │ +cannot make an alien of type ~S out of a SAP │ │ │ │ +VYgmUXR[RVX^ │ │ │ │ +The alignment of ~S is unknown. │ │ │ │ +The size of ~S is unknown. │ │ │ │ +cannot override the size of zero-dimensional arrays │ │ │ │ +Unknown barrier kind ~S │ │ │ │ Invalid fill-pointer ~a │ │ │ │ INSTEAD not empty in INPUT-WRAPPER for ~S │ │ │ │ Parameters ~S and ~S must be disjoint but have common elements │ │ │ │ +SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ +SYS:SRC;CODE;TARGET-CHAR.LISP │ │ │ │ +SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ +SB-PROFILE │ │ │ │ +public: the interface to the profiler │ │ │ │ P_VXaay_ │ │ │ │ Cannot use COMPARE-AND-SWAP with structure accessor for a read-only slot: ~S │ │ │ │ Cannot use COMPARE-AND-SWAP with structure accessor for a typed slot: ~S │ │ │ │ c%Q%W%]% │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ bad fallthrough in floating point reader │ │ │ │ ~@ │ │ │ │ @@ -26665,19 +26668,20 @@ │ │ │ │ Unexpected blocking in WRITE-OUTPUT-FROM-QUEUE. │ │ │ │ ~S can not be encapsulated │ │ │ │ ~S is undefined │ │ │ │ defining ~A as a type specifier │ │ │ │ illegal to redefine standard type: ~S │ │ │ │ The class ~S is being redefined to be a DEFTYPE. │ │ │ │ couldn't SB-UNIX:UNIX-DUP ~W: ~A │ │ │ │ -^RVm_mX_lXp │ │ │ │ ~S is too hairy for sequence functions. │ │ │ │ The object is a proper list of length ~S.~% │ │ │ │ The object is an improper list of length ~S.~% │ │ │ │ The object is a long list (more than ~S elements).~% │ │ │ │ +YJPgUUP\\U^PeHfJgQ\mUPFkWpp │ │ │ │ +^RVm_mX_lXp │ │ │ │ Element sizes for input (~S:~S) and output (~S:~S) differ? │ │ │ │ could not find any output routine for ~S buffered ~S │ │ │ │ Improper list in REMF. │ │ │ │ Odd-length list in REMF. │ │ │ │ c%Q%W%]%{ │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ SBCL_HOME │ │ │ │ @@ -26773,16 +26777,14 @@ │ │ │ │ p+2V2\2\2 │ │ │ │ +2G12M12\5 │ │ │ │ tp+2V2\5 │ │ │ │ +2Gi+2S/ │ │ │ │ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ $$$$$$$ │ │ │ │ !"#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ -SB-PROFILE │ │ │ │ -public: the interface to the profiler │ │ │ │ SB-WALKER │ │ │ │ internal: a code walker used by PCL │ │ │ │ SB-SEQUENCE │ │ │ │ semi-public: implements something which might eventually │ │ │ │ be submitted as a CDR │ │ │ │ SYS:SRC;CODE;EARLY-STEP.LISP │ │ │ │ SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ @@ -26831,15 +26833,14 @@ │ │ │ │ Replacement byte, bytes, character, or string (evaluated): │ │ │ │ Supply a replacement string. │ │ │ │ ~@ │ │ │ │ Jbj8bfYW │ │ │ │ ~S is not acceptable to ~S. │ │ │ │ ~S contains a splicing comma after a dot │ │ │ │ Nothing appears before . in list. │ │ │ │ -YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ no dispatch function defined for ~S │ │ │ │ ~S is not a dispatching macro character. │ │ │ │ power-vector too short │ │ │ │ 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ │ │ │ │ ~@ │ │ │ │ D / ; │ │ │ │ in #S ~S, the use of non-keywords as slot specifiers is deprecated: ~S. │ │ │ │ @@ -26868,14 +26869,15 @@ │ │ │ │ Try opening a different file. │ │ │ │ Retry opening. │ │ │ │ Reopen with :if-exists :append │ │ │ │ Reopen with :if-exists :rename │ │ │ │ Reopen with :if-exists :overwrite │ │ │ │ Reopen with :if-exists :supersede │ │ │ │ Reopen with :if-does-not-exist :create │ │ │ │ +YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ too many colons after ~S name │ │ │ │ invalid constituent │ │ │ │ after reading a colon │ │ │ │ illegal terminating character after a colon: ~S │ │ │ │ too many colons in ~S │ │ │ │ The symbol ~S is not external in the ~A package. │ │ │ │ Symbol ~S not found in the ~A package. │ │ │ │ @@ -26922,16 +26924,18 @@ │ │ │ │ a compiled function │ │ │ │ a generic function │ │ │ │ a special operator │ │ │ │ ~A names an undefined function │ │ │ │ Must label something more than just #~D# │ │ │ │ Multiply defined label: #~D= │ │ │ │ Missing label for #= │ │ │ │ -STRING-DISPATCH-FUN │ │ │ │ 1+U4RA&R │ │ │ │ +STRING-DISPATCH-FUN │ │ │ │ +XLzZUzZZnzfgsny^btXYwwa │ │ │ │ +X\asW_ds │ │ │ │ Heap underflow │ │ │ │ ~S ~[have~;has a~:;have~] bad file descriptor~:P. │ │ │ │ Go on, leaving handlers marked as bogus. │ │ │ │ Retry bogus handlers. │ │ │ │ Remove bogus handlers. │ │ │ │ Error opening directory ~S │ │ │ │ 1,$K&!lW'_' │ │ │ │ @@ -26962,19 +26966,14 @@ │ │ │ │ R - Redisplay current inspected object. │ │ │ │ U - Move upward/backward to previous inspected object. │ │ │ │ ?, H, Help - Show this help. │ │ │ │ - Evaluate the input as an expression. │ │ │ │ Within the inspector, the special variable SB-EXT:*INSPECTED* is bound │ │ │ │ to the current inspected object, so that it can be referred to in │ │ │ │ evaluated expressions. │ │ │ │ -XLzZUzZZnzfgsny^btXYwwa │ │ │ │ -X\asW_ds │ │ │ │ -SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ -SYS:SRC;CODE;SORT.LISP │ │ │ │ -SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ │ │ │ │ failed to build ratio │ │ │ │ defining ~S as a hash table test │ │ │ │ Redefining hash table test ~S. │ │ │ │ Cannot register ~S has a hash table test: undefined function. │ │ │ │ ~S is not a well-formed backquote expression │ │ │ │ TIOCPGRP ioctl failed: ~S │ │ │ │ @@ -26985,14 +26984,17 @@ │ │ │ │ Couldn't find host: ~S │ │ │ │ after REPL │ │ │ │ ~@ │ │ │ │ ~S is not positionable │ │ │ │ X}HUUERt │ │ │ │ couldn't read from ~S │ │ │ │ A numeric argument was ignored in #~W~A. │ │ │ │ +SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ +SYS:SRC;CODE;SORT.LISP │ │ │ │ +SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ %$%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" #!# │ │ │ │ string-output-stream maximum length exceeded │ │ │ │ Can't STEP-OUT: No STEP-IN on the call-stack │ │ │ │ Step into call │ │ │ │ Step over call │ │ │ │ @@ -27090,16 +27092,21 @@ │ │ │ │ abcdefghi │ │ │ │ jklmnopqr │ │ │ │ ~stuvwxyz │ │ │ │ {ABCDEFGHI │ │ │ │ }JKLMNOPQR │ │ │ │ STUVWXYZ │ │ │ │ 0123456789 │ │ │ │ -SYS:SRC;CODE;FORMAT.LISP │ │ │ │ The object is a CONS. │ │ │ │ +SYS:SRC;CODE;FORMAT.LISP │ │ │ │ +SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;CALL.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ +SYS:SRC;COMPILER;TN.LISP │ │ │ │ +b^RPXXmjMo^RPXXg │ │ │ │ The loader tried loading the symbol named ~a into the package named ~a, but the package did not get defined, and does not exist. │ │ │ │ hT?rCkWm[^h │ │ │ │ dcRf[j^mw │ │ │ │ Multiple expressions in --eval option: ~S │ │ │ │ Skip rest of --eval and --load options. │ │ │ │ Ignore runtime option --load ~S. │ │ │ │ Ignore runtime option --eval ~S. │ │ │ │ @@ -27139,15 +27146,16 @@ │ │ │ │ Direct subclasses │ │ │ │ (unboxed) │ │ │ │ Class precedence-list │ │ │ │ illegal character for logical pathname:~% ~S │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ e"d" #!# │ │ │ │ -b^RPXXmjMo^RPXXg │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ \XqXqS_XwdqNLHPUPX_XXXL_^k │ │ │ │ OkTGzsvkgjtpb^kWkddpw^poXavm │ │ │ │ kdtihhdsd │ │ │ │ RPXRTJXm │ │ │ │ Too many parameters, expected none │ │ │ │ Unreachable ~S │ │ │ │ Too many parameters, expected no more than ~W │ │ │ │ @@ -27164,69 +27172,54 @@ │ │ │ │ mhjQOs{rvkd │ │ │ │ ~S is not of type INTEGER. │ │ │ │ Can only specify one section │ │ │ │ Must specify exactly two sections │ │ │ │ Attempt to use ~~:^ outside a ~~:{...~~} construct │ │ │ │ No corresponding close brace │ │ │ │ No corresponding open brace │ │ │ │ -No corresponding close paren │ │ │ │ -no corresponding open paren │ │ │ │ -Index ~W is out of bounds. It should have been between 0 and ~W. │ │ │ │ -~~; not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ -while processing indirect format string: │ │ │ │ -~S is not of type CHARACTER. │ │ │ │ -' Xk{%1# │ │ │ │ -cmPNkbcRL^[RU^K^rQ │ │ │ │ -T case is not last in SC-CASE. │ │ │ │ -illegal SC-CASE clause: ~S │ │ │ │ -mjYM[XRVebeNRV^ddhh │ │ │ │ -malformed SCs spec: ~S │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ seconds │ │ │ │ ~8d ~:{~:[~2*~18@t~;~:* ~2d ~6,2f ~5,1,2f%~] |~} ~a │ │ │ │ can't reconstitute key of deleted finalizer node │ │ │ │ -SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;CALL.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ -SYS:SRC;COMPILER;TN.LISP │ │ │ │ -SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;PARMS.LISP │ │ │ │ -SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ -SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ ~&Unhashed: │ │ │ │ ~&Hashed: │ │ │ │ │ │ │ │ ~D ~X ~S │ │ │ │ Number too large to print in old Roman numerals: ~:D │ │ │ │ +No corresponding close paren │ │ │ │ fmt$~36R │ │ │ │ negative │ │ │ │ No package named ~S │ │ │ │ Malformed ~~/ directive │ │ │ │ Unknown directive ~@[(character: ~A)~] │ │ │ │ │ │ │ │ 6W7eG3/* │ │ │ │ hundred │ │ │ │ No corresponding close bracket │ │ │ │ Number too large to print in English: ~:D │ │ │ │ FORMAT-ARG │ │ │ │ Number too large to print in Roman numerals: ~:D │ │ │ │ +~S is not of type CHARACTER. │ │ │ │ +~~; not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ +no corresponding open paren │ │ │ │ Unknown format directive ~@[(character: ~A)~] │ │ │ │ +while processing indirect format string: │ │ │ │ +' Xk{%1# │ │ │ │ ~~> without a matching ~~< │ │ │ │ Misuse of justification and pprint directives │ │ │ │ HNUH29IH2>SH2>:O*(H7 │ │ │ │ :+#,@v'V- │ │ │ │ No matching closing slash │ │ │ │ Too many #\@ characters supplied │ │ │ │ Too many colons supplied │ │ │ │ Parameters found after #\: or #\@ modifier │ │ │ │ String ended before directive was found │ │ │ │ The value of mincol is ~A, should be a non-negative integer │ │ │ │ The value of colinc is ~A, should be a positive integer │ │ │ │ The ~{~A~^ and the ~} modifier~P cannot be used ~:*~[~;~;simultaneously ~]with this directive. │ │ │ │ +Index ~W is out of bounds. It should have been between 0 and ~W. │ │ │ │ Too many segments for ~~<...~~:> │ │ │ │ No parameters can be supplied with ~~<...~~:>. │ │ │ │ Cannot include format directives inside the ~:[suffix~;prefix~] segment of ~~<...~~:> │ │ │ │ defining ~S as a function │ │ │ │ ~S is not a defined primitive type. │ │ │ │ globally declaring the FTYPE of ~A │ │ │ │ Cannot declare FTYPE of illegal function name ~S │ │ │ │ @@ -27237,14 +27230,19 @@ │ │ │ │ INPUT-FILE and OUTPUT-FILE refer to the same file: ~s │ │ │ │ ~D:~2,'0D:~2,'0D.~3,'0D │ │ │ │ ~&; compilation ~:[finished in~;aborted after~] ~A~& │ │ │ │ note: ~3I~_ │ │ │ │ globally declaring the TYPE of ~A │ │ │ │ Cannot proclaim TYPE of a non-symbol: ~S │ │ │ │ Need ~D fraction bits for divisor ~D and ~D bit dividend │ │ │ │ +cmPNkbcRL^[RU^K^rQ │ │ │ │ +T case is not last in SC-CASE. │ │ │ │ +illegal SC-CASE clause: ~S │ │ │ │ +mjYM[XRVebeNRV^ddhh │ │ │ │ +malformed SCs spec: ~S │ │ │ │ \\U[~[Pq │ │ │ │ a source transform │ │ │ │ FYUU)#:o"^Se │ │ │ │ Xy[^c~X}T │ │ │ │ -OPTIMIZER │ │ │ │ kweXYXXdd\xfzfa │ │ │ │ scX_hRkii[[ │ │ │ │ @@ -27258,16 +27256,25 @@ │ │ │ │ [[Xa[_X[dbhm[bhsT[ │ │ │ │ IR1-CONVERT- │ │ │ │ UiUPkmd` │ │ │ │ SC ~S has no :UNBOUNDED :SAVE-P NIL alternate SC. │ │ │ │ ~S is not a defined template. │ │ │ │ ~S is not a defined storage base. │ │ │ │ bad EVAL-WHEN situation list: ~S │ │ │ │ +SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;PARMS.LISP │ │ │ │ +SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ +SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ +SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;XREF.LISP │ │ │ │ +SYS:SRC;COMPILER;SEQTRAN.LISP │ │ │ │ ~&; Base: ~x Data: ~x │ │ │ │ Can't disassemble a special operator │ │ │ │ +~S is not a defined storage class. │ │ │ │ iY{Z N │ │ │ │ __msan_unpoison │ │ │ │ │ │ │ │ ~S is not a known argument keyword. │ │ │ │ ~@<~{~S~^, ~} and ~S are not a known argument keywords.~:@> │ │ │ │ can't understand type ~S │ │ │ │ Local alien info isn't constant? │ │ │ │ @@ -27379,21 +27386,14 @@ │ │ │ │ KvWagcy[EUXURU[R │ │ │ │ Can't push ~a into ~a │ │ │ │ :0" 6f0F │ │ │ │ YVOtKXm^gZX │ │ │ │ no move function defined to ~:[save~;load~] SC ~S ~:[to~;from~] from SC ~S │ │ │ │ SC ~S has no alternate~:[~; or constant~] SCs, yet it is │ │ │ │ mentioned in the restriction for operand ~S │ │ │ │ -SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;XREF.LISP │ │ │ │ -SYS:SRC;COMPILER;SEQTRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ -SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ │ │ │ │ 3$**=!#& │ │ │ │ 5!oVCV\_ │ │ │ │ ~@ │ │ │ │ function called with ~R argument~:P, but wants at least ~R │ │ │ │ function called with ~R argument~:P, but wants at most ~R │ │ │ │ (during macroexpansion of ~A) │ │ │ │ @@ -27516,14 +27516,20 @@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ '1'! sBJ" │ │ │ │ ;;;; IR2 component: ~S │ │ │ │ entries: │ │ │ │ ~4TL~D: ~S~:[~; [closure]~] │ │ │ │ strange TN live at head of ~S: ~S │ │ │ │ +SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ +SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ +SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ +SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ +SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ What? No ir2 blocks have a non-nil number? │ │ │ │ ~@<~2I~_~S ~_not found in ~_~S~:> │ │ │ │ ~&; [Last message occurs ~W times.] │ │ │ │ Leftover args: ~S │ │ │ │ local variable │ │ │ │ ~@<~S~[~; is a keyword and~; is not a symbol and~ │ │ │ │ ~] cannot be used as a ~A.~@:> │ │ │ │ @@ -27599,15 +27605,14 @@ │ │ │ │ ~@ │ │ │ │ 3 │ │ │ │ -T_QYHOHO^dgg │ │ │ │ can't local-call functions with &MORE args │ │ │ │ function called with unknown argument keyword ~S │ │ │ │ non-constant :ALLOW-OTHER-KEYS value │ │ │ │ non-constant keyword in keyword call │ │ │ │ function called with odd number of arguments in keyword portion │ │ │ │ c]'&fch'&i]8= │ │ │ │ The ~:R argument of type ~s cannot be used as a keyword. │ │ │ │ @@ -27617,55 +27622,14 @@ │ │ │ │ know how to dump │ │ │ │ Can't preserve function source - missing MAKE-LOAD-FORM methods? │ │ │ │ '2'*i$A4P │ │ │ │ ~S was seen more than once. │ │ │ │ IR1 block ~D~@[ start c~D~] │ │ │ │ *INLINE-EXPANSION-LIMIT* (~W) was exceeded while inlining ~s │ │ │ │ TN-CONFLICTS │ │ │ │ -SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ -SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ -SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ -SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ -SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ -SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ -Control whether the compiler should check for constant │ │ │ │ -modification. Defaults to SAFETY. │ │ │ │ -Control the way to perform runtime type checking: │ │ │ │ -0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ -2: fast checks are performed: declared types are weakened to │ │ │ │ - FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ -3: declared types are fully checked (several exceptions exist; │ │ │ │ - see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ - Implementation Limitations for details). │ │ │ │ -Control inline-substitution of used-once local functions. │ │ │ │ -Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ -more reliable bactracing across foreign calls. │ │ │ │ -Enables possibility of returning from stack frames with the debugger. │ │ │ │ -The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ -When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ -FOO ...) is considered to be the reference to the function being │ │ │ │ -defined. Calls to FOO are compiled as local. This allows better │ │ │ │ -optimization and type checking, but TRACE will not show recursive │ │ │ │ -calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ -bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ -recursive. │ │ │ │ -When disabled, internal references to a function FOO will be │ │ │ │ -considered ti be a call of a function, bound to the symbol at │ │ │ │ -run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ -case of renaming described above, calls to FOO will not be recursive │ │ │ │ -and will refer to the new function, bound to FOO. │ │ │ │ -Control instrumentation of code, enabling single-stepping through │ │ │ │ -it in the debugger. │ │ │ │ -This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ -When disabled, LET variable, which is never set and is referenced │ │ │ │ -exactly once, is eliminated and the reference is substituted with the │ │ │ │ -initial value. This allows better type inference and some algebraic │ │ │ │ -optimizations. │ │ │ │ -When enabled, the variable is preserved and can be seen in the │ │ │ │ -debugger. │ │ │ │ ,AGrWRz_ │ │ │ │ This shouldn't happen! Bug? │ │ │ │ argument types invalid │ │ │ │ argument primitive types:~% ~S │ │ │ │ argument type assertions:~% ~S │ │ │ │ template guard failed │ │ │ │ The template isn't safe, yet we were counting on it. │ │ │ │ @@ -27691,15 +27655,14 @@ │ │ │ │ none of the SCs allowed by the operand type ~S can directly be loaded │ │ │ │ into any of the restriction's SCs: │ │ │ │ ~S~:[~; │ │ │ │ [* type operand must allow T's SCs.]~] │ │ │ │ ~:[Result~;Argument~] ~A to VOP ~S │ │ │ │ has SC restriction ~S which is not allowed by the operand type: │ │ │ │ #30<%c0);4S │ │ │ │ -(:#7%%5HU │ │ │ │ @ $"! 0g +.! ?*2&< ;+''< ;< ; │ │ │ │ ~S has VALUE but no ENTRY. │ │ │ │ ~S is not in its ENTRY's EXITS. │ │ │ │ ~S is not the ENCLOSE for its FUN ~S. │ │ │ │ ~S is not in ENTRIES for its home LAMBDA. │ │ │ │ RETURN not at block end: ~S │ │ │ │ JUMP-TABLE not at block end: ~S │ │ │ │ @@ -27710,14 +27673,16 @@ │ │ │ │ function ~S in a local mv-combination ~S is not of kind :MV-LET │ │ │ │ function ~S in a local mv-combination ~S is not local │ │ │ │ function in a local mv-combination is not a LEAF: ~S │ │ │ │ :TOPLEVEL-XEP ref in non-top-level component: ~S │ │ │ │ --script │ │ │ │ compiled from ~S │ │ │ │ using ~A version ~A │ │ │ │ +T_QYHOHO^dgg │ │ │ │ +(:#7%%5HU │ │ │ │ FROM-END argument value not known at compile time │ │ │ │ sequence type not known at compile time │ │ │ │ XXe\Xd\Xdp │ │ │ │ XXe\Xd\Xd │ │ │ │ 0_[\\ddjWWt │ │ │ │ unseen predecessor ~S in ~S │ │ │ │ bad predecessor link ~S in ~S │ │ │ │ @@ -27806,14 +27771,54 @@ │ │ │ │ The definition has no ~A, but the ~A did. │ │ │ │ _W^rcg[R │ │ │ │ Don't inquire FILE-INFO-TRUENAME │ │ │ │ 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. │ │ │ │ dumping anonymous layout: ~S │ │ │ │ attempt to dump reference to obsolete class: ~S │ │ │ │ +SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ +SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ +SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ +Control whether the compiler should check for constant │ │ │ │ +modification. Defaults to SAFETY. │ │ │ │ +Control the way to perform runtime type checking: │ │ │ │ +0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ +2: fast checks are performed: declared types are weakened to │ │ │ │ + FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ +3: declared types are fully checked (several exceptions exist; │ │ │ │ + see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ + Implementation Limitations for details). │ │ │ │ +Control inline-substitution of used-once local functions. │ │ │ │ +Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ +more reliable bactracing across foreign calls. │ │ │ │ +Enables possibility of returning from stack frames with the debugger. │ │ │ │ +The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ +When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ +FOO ...) is considered to be the reference to the function being │ │ │ │ +defined. Calls to FOO are compiled as local. This allows better │ │ │ │ +optimization and type checking, but TRACE will not show recursive │ │ │ │ +calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ +bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ +recursive. │ │ │ │ +When disabled, internal references to a function FOO will be │ │ │ │ +considered ti be a call of a function, bound to the symbol at │ │ │ │ +run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ +case of renaming described above, calls to FOO will not be recursive │ │ │ │ +and will refer to the new function, bound to FOO. │ │ │ │ +Control instrumentation of code, enabling single-stepping through │ │ │ │ +it in the debugger. │ │ │ │ +This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ +When disabled, LET variable, which is never set and is referenced │ │ │ │ +exactly once, is eliminated and the reference is substituted with the │ │ │ │ +initial value. This allows better type inference and some algebraic │ │ │ │ +optimizations. │ │ │ │ +When enabled, the variable is preserved and can be seen in the │ │ │ │ +debugger. │ │ │ │ +SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;VM.LISP │ │ │ │ $$4rm0% │ │ │ │ Redefining modular version ~S of ~S for ~:[un~;~]signed width ~S. │ │ │ │ Control │ │ │ │ IR2Tran │ │ │ │ Disassembly of code for ~S │ │ │ │ ^Nxad\QrU │ │ │ │ Lambda list keyword ~S is not supported for modular function lambda lists. │ │ │ │ @@ -27844,34 +27849,32 @@ │ │ │ │ Element alignment is unknown. │ │ │ │ Element size is unknown. │ │ │ │ incorrect number of indices │ │ │ │ ~S not either a pointer or array type. │ │ │ │ +Kc%Y7cN │ │ │ │ Repeated OPTIMIZE qualit~@P. Using ~{~S~^ and ~} │ │ │ │ nYYXY~nYY │ │ │ │ +optimize │ │ │ │ %PRIMITIVE was used with a conditional template. │ │ │ │ Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ -optimize │ │ │ │ +WITHOUT-GCING-BODY- │ │ │ │ Unexpected fixup │ │ │ │ 0((((4"& │ │ │ │ ~S is not in ~S. │ │ │ │ bad PREV for ~S, should be ~S │ │ │ │ wrong TAIL for DFO, ~S in ~S │ │ │ │ ~S is malformed. │ │ │ │ strange FREE-VARS entry: ~S │ │ │ │ strange CONSTANTS entry: ~S │ │ │ │ strange FREE-FUNS entry: ~S │ │ │ │ TNs: ~W local, ~W temps, ~W constant, ~W env, ~W comp, ~W global. │ │ │ │ Wired: ~W, Unused: ~W. ~W block~:P, ~W global conflict~:P. │ │ │ │ The slot ~S does not have a suitable default, and no value was provided for it. │ │ │ │ The slot ~S default form ~s doesn't match :type ~s │ │ │ │ -SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;VM.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ Compiling ~A: │ │ │ │ cannot specify :LOAD-IF in a :MORE operand │ │ │ │ cannot specify :TARGET in a :MORE operand │ │ │ │ can only specify :TO in an argument: ~S │ │ │ │ can only specify :FROM in a result: ~S │ │ │ │ unknown keyword in operand specifier: ~S │ │ │ │ The MORE operand isn't the last operand: ~S │ │ │ │ @@ -27895,35 +27898,37 @@ │ │ │ │ DEST for ~S should be ~S. │ │ │ │ Node ~S using ~S is in an unknown block. │ │ │ │ unseen function ~S in ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ concatenate │ │ │ │ Can't ~a ~s into ~s │ │ │ │ +Lisp error during constant folding:~%~A │ │ │ │ +Incompatible array element types: ~a and ~a │ │ │ │ +The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ ihYhhmUPt │ │ │ │ multiple store variables for ~S │ │ │ │ no &REST context │ │ │ │ \hq`n[eKXdhQXvra │ │ │ │ dh d │ │ │ │ LEndzsn^}k │ │ │ │ PA-BITS-EA- │ │ │ │ -Lisp error during constant folding:~%~A │ │ │ │ -Incompatible array element types: ~a and ~a │ │ │ │ -The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ !>]hdda[ │ │ │ │ )daghLRa^ │ │ │ │ doing ~A (cost ~W)~@[ from ~S~]~@[ to ~S~] │ │ │ │ couldn't find op? bug! │ │ │ │ doing ~A (cost ~W)~:[~2*~; ~:[to~;from~] ~S~], for: │ │ │ │ ~6Tthe ~:R ~:[result~;argument~] of ~A │ │ │ │ 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: │ │ │ │ The ~:R argument is a ~S, not a ~S. │ │ │ │ The ~:R argument never returns a value. │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ Jg|~Y{XX │ │ │ │ unknown option specifier: ~S │ │ │ │ malformed option specification: ~S │ │ │ │ {~{~S~^ ~}} │ │ │ │ ~a is not a subtype of ARRAY. │ │ │ │ #7%% >7X } h │ │ │ │ shouldn't happen! (defined-fun) │ │ │ │ @@ -27943,30 +27948,28 @@ │ │ │ │ ~&; compiling file ~S (written ~A): │ │ │ │ ~:[A possible~;The~] binding of ~S │ │ │ │ Inconsistent :initial-contents rank. │ │ │ │ Inconsistent :initial-contents dimensions. │ │ │ │ Default expression ~S does not match ~S in ~S │ │ │ │ Implement │ │ │ │ Too many result values from c-call. │ │ │ │ -SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ * + │ │ │ │ ( 52 │ │ │ │ stub %SET-CONTEXT-FLOAT-REGISTER │ │ │ │ ~S and ~S don't have the same dimensions. │ │ │ │ unknown float trap kind: ~S │ │ │ │ return-pc not on stack in standard save location? │ │ │ │ ocfp not on stack in standard save location? │ │ │ │ ~S is not a known slot of thread │ │ │ │ Unknown object type #x~x addr=~x │ │ │ │ usage is: │ │ │ │ bytes overhead) │ │ │ │ Control and binding stack usage is for the current thread only. │ │ │ │ Garbage collection is currently │ │ │ │ DISABLED │ │ │ │ -There are ~W elements in the :INITIAL-CONTENTS, but the vector length is ~W. │ │ │ │ Summary of space │ │ │ │ bytes, │ │ │ │ Summary total: │ │ │ │ objects. │ │ │ │ Wrong number of subscripts, ~W, for array of rank 1. │ │ │ │ Wrong number of subscripts, ~W, for array of rank ~W. │ │ │ │ Breakdown for │ │ │ │ @@ -27988,58 +27991,57 @@ │ │ │ │ ~x: ~v,'0x~:[~; = ~@?~] │ │ │ │ X_aeX_a\k │ │ │ │ ga]gdX_dnf │ │ │ │ YbUZbQZdgyU`TZ^ │ │ │ │ WY[^QZ[y[[U │ │ │ │ ^[UZUZUT │ │ │ │ DO-REFERENCED-OBJECT usage error │ │ │ │ -PPRINT-EXIT-IF-LIST-EXHAUSTED must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ -PkakYk`L[OU │ │ │ │ -Don't know how to ~S ~A. │ │ │ │ -~@ │ │ │ │ page_table │ │ │ │ SYS:SRC;COMPILER;GENERIC;PARMS.LISP │ │ │ │ SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ TEXT_SPACE_START │ │ │ │ next_free_page │ │ │ │ READ_ONLY_SPACE_START │ │ │ │ text_space_highwatermark │ │ │ │ DYNAMIC_SPACE_START │ │ │ │ static_space_free_pointer │ │ │ │ read_only_space_free_pointer │ │ │ │ -SYS:SRC;CODE;EARLY-CONSTANTS.LISP │ │ │ │ +Don't know how to ~S ~A. │ │ │ │ +~@ │ │ │ │ bad place for a wild pathname │ │ │ │ Can't create directory ~A~:[~;,~%a file with ~ │ │ │ │ the same name already exists.~] │ │ │ │ ~&creating directory: ~A │ │ │ │ Retry directory creation. │ │ │ │ sz7o]HJj │ │ │ │ :q4w&*s@x& │ │ │ │ BBBBBBBBBBBBEEE[! │ │ │ │ SUB-CHAR must not be a decimal digit: ~S │ │ │ │ 2.5.10.debian │ │ │ │ -Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ (yes or no) │ │ │ │ Can not USE-PACKAGE ~S │ │ │ │ ~S can't use packages │ │ │ │ using package~P ~{~A~^, ~} │ │ │ │ can't adjust vector ~S to a size (~S) smaller than its current fill pointer (~S) │ │ │ │ Expected ~D new dimension~:P for array, but received ~D. │ │ │ │ unusing package~P ~{~A~^, ~} │ │ │ │ renaming as ~A~@[ with nickname~*~P ~1@*~{~A~^, ~}~] │ │ │ │ Another package is already accessible via name ~S │ │ │ │ +SYS:SRC;CODE;EARLY-CONSTANTS.LISP │ │ │ │ Undefined type: ~S │ │ │ │ nothing to unread │ │ │ │ (y or n) │ │ │ │ ~S is not accessible in the ~A package. │ │ │ │ unexporting symbol~P ~{~A~^, ~} │ │ │ │ /proc/sys/kernel/osrelease │ │ │ │ ~@ │ │ │ │ ~@<~S as EOF-ERROR-P argument to ~S: probable error. Two optional arguments must be provided before the first keyword argument.~:@> │ │ │ │ +PPRINT-EXIT-IF-LIST-EXHAUSTED must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ +PkakYk`L[OU │ │ │ │ access-function │ │ │ │ y"*"#"#"*"#"2(" │ │ │ │ uVVVl\VVi\Vq │ │ │ │ :SIZE is not a positive integer: ~S │ │ │ │ bogus DEFPACKAGE option: ~S │ │ │ │ ~S expects a single argument. Got ~S │ │ │ │ can't specify ~S more than once. │ │ │ │ @@ -28073,19 +28075,28 @@ │ │ │ │ X^drex[^bVaaU[g │ │ │ │ ]lTuuK^LrTm}U[Yhm[gnhs │ │ │ │ DEFSTRUCT: ~S is not a symbol. │ │ │ │ Malformed slot entry: ~s, should be (variable-name accessor-name) │ │ │ │ Malformed slot entry: ~s, should be either a symbol or (variable-name slot-name) │ │ │ │ U_^d^aP[Xacyy │ │ │ │ XIV}\UJlNh │ │ │ │ +array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ +YbY_fnYYwglbVbV_bb^R\VXepddp │ │ │ │ +KV-VECTOR- │ │ │ │ +TRUw^UP[Xc │ │ │ │ +SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ +ROYYhYXp │ │ │ │ +FORM-FUN- │ │ │ │ +normal-return │ │ │ │ +error-return │ │ │ │ +Malformed HANDLER-CASE lambda-list. Should be either () or (symbol), not ~s. │ │ │ │ Bogus slot-cell in SLOT-MAKUNBOUND: ~S │ │ │ │ ~S these symbols into the ~A package. │ │ │ │ ~@ │ │ │ │ exporting symbol~P ~{~A~^, ~} │ │ │ │ -SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ ~@ │ │ │ │ ~S can't be created. │ │ │ │ no translation for ~S │ │ │ │ (''!'k#\OD │ │ │ │ Return T │ │ │ │ Syscall ~A failed: ~A │ │ │ │ ~a is not a proper list │ │ │ │ @@ -28102,32 +28113,14 @@ │ │ │ │ -D2CJD53@JJ) │ │ │ │ not currently dribbling │ │ │ │ ~S is not a valid type-specifier │ │ │ │ ~S is not a recognized type specifier │ │ │ │ Return the existing package. │ │ │ │ A package named ~S already exists │ │ │ │ Don't know how to ~S ~A │ │ │ │ -Can't open ~S for output: is a directory │ │ │ │ -Can't find ~S │ │ │ │ -OPEN :IF-DOES-NOT-EXIST ~s ~ │ │ │ │ - :IF-EXISTS ~s will always signal an error. │ │ │ │ -OPEN :IF-EXISTS :NEW-VERSION is not supported ~ │ │ │ │ - when a new version must be created. │ │ │ │ -Undefined external-format: ~S │ │ │ │ -137?@R^LL │ │ │ │ -~S doesn't match ~S. │ │ │ │ -array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ -YbY_fnYYwglbVbV_bb^R\VXepddp │ │ │ │ -KV-VECTOR- │ │ │ │ -TRUw^UP[Xc │ │ │ │ -ROYYhYXp │ │ │ │ -FORM-FUN- │ │ │ │ -normal-return │ │ │ │ -error-return │ │ │ │ -Malformed HANDLER-CASE lambda-list. Should be either () or (symbol), not ~s. │ │ │ │ UlXi\XddQ\XXda` │ │ │ │ xV^[`t[PPRkW^todjj │ │ │ │ a DEFSETF lambda list │ │ │ │ Ill-formed DEFSETF for ~S │ │ │ │ a DEFINE-MODIFY-MACRO lambda list │ │ │ │ UOi__cddgX │ │ │ │ `T= ]D! │ │ │ │ @@ -28137,17 +28130,39 @@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ k [ X\ W │ │ │ │ Y_fnYbIn_btaV_qdXeWRbWpc[J\`W^OWd │ │ │ │ T[EYUTkmd\k │ │ │ │ PPRINT-POP must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ bb n} n| │ │ │ │ +j\ │ │ │ │ +_eUGsXV[iV\XX │ │ │ │ +unknown option: ~S │ │ │ │ +bad option: │ │ │ │ +slot :DOCUMENTATION argument is not a string: ~S │ │ │ │ +more than one :DOCUMENTATION in ~S │ │ │ │ +more than one :INITFORM in ~S │ │ │ │ +unknown slot option: │ │ │ │ +malformed condition slot spec: │ │ │ │ +Keyword slot name indicates probable syntax error: │ │ │ │ +UU]HPhN[[UPSnL[dNy[mqj\dH~EIJiQi │ │ │ │ +Dotted list ~S in DOLIST. │ │ │ │ +[a{[aaZa │ │ │ │ +ill-formed ~S clause, no lambda-list: │ │ │ │ +UP_QP\_pYNRVWp` │ │ │ │ +Can't open ~S for output: is a directory │ │ │ │ +Can't find ~S │ │ │ │ +OPEN :IF-DOES-NOT-EXIST ~s ~ │ │ │ │ + :IF-EXISTS ~s will always signal an error. │ │ │ │ +OPEN :IF-EXISTS :NEW-VERSION is not supported ~ │ │ │ │ + when a new version must be created. │ │ │ │ +Undefined external-format: ~S │ │ │ │ +137?@R^LL │ │ │ │ +~S doesn't match ~S. │ │ │ │ rE)-.@[XY8W │ │ │ │ -globaldb │ │ │ │ -Objects of type ~// can't be dumped into fasl files. │ │ │ │ SYS:SRC;CODE;IRRAT.LISP │ │ │ │ SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ There is nothing left to pop. │ │ │ │ Invalid argument to SLEEP: ~S, should be a non-negative real. │ │ │ │ ~S isn't forced to memory. Something went wrong. │ │ │ │ [aaRJSaaR │ │ │ │ unrecognized alien type: ~A │ │ │ │ @@ -28184,62 +28199,50 @@ │ │ │ │ Error creating pipe │ │ │ │ Could not delete directory ~S │ │ │ │ Input is not a proper list of weak pointers. │ │ │ │ Could not stop all threads │ │ │ │ objects, │ │ │ │ candidates, │ │ │ │ Unknown object type #x~x ~s │ │ │ │ -j\ │ │ │ │ -_eUGsXV[iV\XX │ │ │ │ -unknown option: ~S │ │ │ │ -bad option: │ │ │ │ -slot :DOCUMENTATION argument is not a string: ~S │ │ │ │ -more than one :DOCUMENTATION in ~S │ │ │ │ -more than one :INITFORM in ~S │ │ │ │ -unknown slot option: │ │ │ │ -malformed condition slot spec: │ │ │ │ -Keyword slot name indicates probable syntax error: │ │ │ │ -UU]HPhN[[UPSnL[dNy[mqj\dH~EIJiQi │ │ │ │ -Dotted list ~S in DOLIST. │ │ │ │ -[a{[aaZa │ │ │ │ -ill-formed ~S clause, no lambda-list: │ │ │ │ -UP_QP\_pYNRVWp` │ │ │ │ U\aRVMPddpd │ │ │ │ Something is wrong; local-alien-info not found: ~S │ │ │ │ [kVhUUPgkdXXddX │ │ │ │ [kVcnXgez │ │ │ │ [RRO\Yk|gbV[^{UUl │ │ │ │ PXYqcdW_Wa │ │ │ │ UNLOCKED-PACKAGES- │ │ │ │ aZbV[^{UUl │ │ │ │ [m_aUGjge[eq │ │ │ │ Malformed HASH-FUNCTION: ~S │ │ │ │ Cannot redefine standard hash table test ~S. │ │ │ │ aYLhXWpX │ │ │ │ RhgY_XXe_XXdN │ │ │ │ +SUPPLIED-P-P │ │ │ │ +DESCRIPTOR-IDX │ │ │ │ +SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ +SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ +SYS:SRC;COMPILER;LTN.LISP │ │ │ │ +SYS:SRC;CODE;STEP.LISP │ │ │ │ +globaldb │ │ │ │ +Objects of type ~// can't be dumped into fasl files. │ │ │ │ +bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ oCMIIHGkUd_hapva^UY[WjTdk]QY[LaUVdY_klkdp|^ │ │ │ │ BIM\Y[Y │ │ │ │ malformed NAMED-LET variable spec: ~S │ │ │ │ INFO-NUMBER- │ │ │ │ VVY_qadkWmp │ │ │ │ N-HASH-TABLE- │ │ │ │ gWmyU^f^ │ │ │ │ bYYVbVk_YV_kkm^iPGkddgbdY │ │ │ │ Not a parser state: ~S │ │ │ │ \kbVrtwbnVemX │ │ │ │ LUULV^`aYt │ │ │ │ aXa]LI[Lut │ │ │ │ X[d^gmXYtX^ru │ │ │ │ odd^gpwajd │ │ │ │ -SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ -SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ -SYS:SRC;COMPILER;LTN.LISP │ │ │ │ -SYS:SRC;CODE;STEP.LISP │ │ │ │ -WITHOUT-GCING-BODY- │ │ │ │ -SUPPLIED-P-P │ │ │ │ Abort ~A file ~S. │ │ │ │ Ignore error and continue ~A file ~S. │ │ │ │ Retry EVAL of current toplevel form. │ │ │ │ ~&While evaluating the form starting at line ~D, column ~D │ │ │ │ of ~S: │ │ │ │ ~{~S~^, ~} │ │ │ │ ~& ~@[type ~D~]~@[~{~S ~S~}~] = │ │ │ │ @@ -28335,18 +28338,15 @@ │ │ │ │ TIME-LEFT- │ │ │ │ Bad size for ~S type specifier: ~S. │ │ │ │ malformed ONCE-ONLY binding spec: ~S │ │ │ │ ^k ^ wkq │ │ │ │ bY_VYw^tgwh │ │ │ │ ~S is valid only inside ~S. │ │ │ │ Uz[OY^RPe[\Xnhhw^^ldd │ │ │ │ -SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ WITH-PINNED-OBJECTS-THUNK │ │ │ │ -vQJJUgZgm │ │ │ │ -FF]Xte[Ydd │ │ │ │ ~&Enter a form evaluating to a value of type ~a: │ │ │ │ ~s is not of type ~s │ │ │ │ File descriptor must be opened either for input or output. │ │ │ │ descriptor ~W │ │ │ │ Cannot resolve foreign symbol: lost *runtime-dlhandle* │ │ │ │ /proc/cpuinfo │ │ │ │ model name │ │ │ │ @@ -28354,24 +28354,34 @@ │ │ │ │ │ │ │ │ Using ~s instead. │ │ │ │ with the current directory │ │ │ │ invalid external alien name: ~S │ │ │ │ Unix system call getrusage failed: ~A. │ │ │ │ Error opening ~:[runtime~;shared object ~:*~S~]: │ │ │ │ Invalid direction ~S, must be either :INPUT or :OUTPUT │ │ │ │ +SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ Cancel the deadline and continue. │ │ │ │ By how many seconds shall the deadline ~ │ │ │ │ be deferred?: │ │ │ │ Defer the deadline for SECONDS more. │ │ │ │ Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ Cannot compare-and-swap slot ~S on: ~S │ │ │ │ +vQJJUgZgm │ │ │ │ +FF]Xte[Ydd │ │ │ │ LLbUpTPXgTd │ │ │ │ [PrYrR\xTdd^[[UX[_ofgJXOXm │ │ │ │ OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ illegal instruction at #X~X │ │ │ │ +bus error at #X~X │ │ │ │ +automatically-generated makunbound method │ │ │ │ +automatically-generated boundp method │ │ │ │ +automatically-generated writer method │ │ │ │ +automatically-generated reader method │ │ │ │ +3ddm\iddX │ │ │ │ +wjTWh]gsv\eS │ │ │ │ SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ public: the MetaObject Protocol interface, as defined by │ │ │ │ The Art of the Metaobject Protocol, by Kiczales, des Rivieres and Bobrow: │ │ │ │ ISBN 0-262-61074-4, with exceptions as noted in the User Manual. │ │ │ │ ?&_rMQP │ │ │ │ L)33C$i:3 │ │ │ │ 1d1ghA]~ │ │ │ │ @@ -28562,25 +28572,24 @@ │ │ │ │ Convert the alien-type structure TYPE back into a list specification of │ │ │ │ the type. │ │ │ │ COMMON-LISP │ │ │ │ Return a list whose elements are the dimensions of the array │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ Return the number of entries in the given HASH-TABLE. │ │ │ │ -z;7COA-3 │ │ │ │ -"ScSib?3 │ │ │ │ Creates a new symbol interned in package PACKAGE with the given PREFIX. │ │ │ │ Creates a new uninterned symbol whose name is a prefix string (defaults │ │ │ │ to "G"), followed by a decimal number. Thing, when supplied, will │ │ │ │ alter the prefix if it is a string, or be used for the decimal number │ │ │ │ if it is a number, of this symbol. The default value of the number is │ │ │ │ the current value of *gensym-counter* which is incremented each time │ │ │ │ it is used. │ │ │ │ +z;7COA-3 │ │ │ │ +"ScSib?3 │ │ │ │ Return the intersection of LIST1 and LIST2. │ │ │ │ -DESCRIPTOR-IDX │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Return the tail of LIST beginning with first element satisfying EQLity, │ │ │ │ :TEST, or :TEST-NOT with the given ITEM. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ @@ -28591,15 +28600,16 @@ │ │ │ │ NOTE-NEXT-INSTRUCTION │ │ │ │ OPTIONAL-ARGS │ │ │ │ NOTE-NEXT-INSTRUCTION VOP Kind │ │ │ │ Similar to NOTE-THIS-LOCATION, except the use the location of the next │ │ │ │ instruction for the code location, wherever the scheduler decided to put │ │ │ │ 7*pO:XUU │ │ │ │ Set the name of a compiled function object. Return the function. │ │ │ │ -%PATHNAME- │ │ │ │ +COMMON-LISP │ │ │ │ + ALIGNMENT │ │ │ │ PSETQ {var value}* │ │ │ │ Set the variables to the values, like SETQ, except that assignments │ │ │ │ happen in parallel, i.e. no assignments take place until all the │ │ │ │ forms have been evaluated. │ │ │ │ This is to SETF as PSETQ is to SETQ. Args are alternating place │ │ │ │ expressions and values to go into those places. All of the subforms and │ │ │ │ values are determined, left to right, and only then are the locations │ │ │ │ @@ -28622,19 +28632,16 @@ │ │ │ │ argument of is the new value. Note that the system provides no automatic │ │ │ │ atomicity for CAS functions, nor can it verify that they are atomic: it is up │ │ │ │ to the implementor of a CAS function to ensure its atomicity. │ │ │ │ EXPERIMENTAL: Interface subject to change. │ │ │ │ COMMON-LISP │ │ │ │ Return the 1st object in a list or NIL if the list is empty. │ │ │ │ COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ - ALIGNMENT │ │ │ │ -bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ -COMMON-LISP │ │ │ │ DERIVE-FUN0 │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ Unlocks PACKAGE and returns T. Has no effect if PACKAGE was already │ │ │ │ unlocked. Signals an error if PACKAGE is not a valid package designator. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ Return the type of the elements of the array │ │ │ │ EXTERNAL-FORMAT0 │ │ │ │ @@ -28662,14 +28669,19 @@ │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ +INSTANCE8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -28709,14 +28721,16 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ bM/+`o:01 │ │ │ │ q./)4%.5& │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Return the 1st object in a list. │ │ │ │ +COMMON-LISP │ │ │ │ +Return the integer code of CHAR. │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ @@ -28750,77 +28764,65 @@ │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ -automatically-generated boundp method │ │ │ │ +INSTANCE8 │ │ │ │ +FDEFN SB-KERNEL8 │ │ │ │ automatically generated writer method │ │ │ │ automatically generated reader method │ │ │ │ +redefining DEFTYPE type to be a class: ~// │ │ │ │ +Cannot redefine standard type ~//. │ │ │ │ +bad modulus specified for MOD type specifier: ~// │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP │ │ │ │ SYS:SRC;COMPILER;X86;CHAR.LISP │ │ │ │ SYS:SRC;COMPILER;X86;PRED.LISP │ │ │ │ Used by FILE-POSITION. Returns or changes the current position within STREAM. │ │ │ │ Is STREAM an interactive stream? │ │ │ │ Return a type specifier for the kind of object returned by the │ │ │ │ STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method │ │ │ │ which returns CHARACTER. │ │ │ │ -automatically-generated reader method │ │ │ │ -automatically-generated writer method │ │ │ │ SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ ]{_f`Rb@d │ │ │ │ SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ INSTANCE8 │ │ │ │ INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ -FDEFN SB-KERNEL8 │ │ │ │ -INSTANCE8 │ │ │ │ -INSTANCE8 │ │ │ │ NEW-VALUE8 │ │ │ │ INSTANCE8 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP8# │ │ │ │ DIVISOR0 │ │ │ │ COMMON-LISP │ │ │ │ Return second result of FLOOR. │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -COMMON-LISP │ │ │ │ -Return the integer code of CHAR. │ │ │ │ -COMMON-LISP │ │ │ │ -Return all but the first object in a list. │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +Return all but the first object in a list. │ │ │ │ +Return T if its arguments are in strictly decreasing order, NIL otherwise. │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -Return T if its arguments are in strictly decreasing order, NIL otherwise. │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ DIMENSION │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -redefining DEFTYPE type to be a class: ~// │ │ │ │ -Cannot redefine standard type ~//. │ │ │ │ -bad modulus specified for MOD type specifier: ~// │ │ │ │ -The type declarations ~// and ~// for ~S conflict. │ │ │ │ -OPTIMIZE-DECL │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INDEX-TYPE │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -28829,14 +28831,15 @@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ +OPTIMIZE-DECL │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP │ │ │ │ @@ -28885,56 +28888,41 @@ │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Call FUNCTION with the given ARGUMENTS. │ │ │ │ fold division by 1 │ │ │ │ convert integer division to multiplication │ │ │ │ convert division by 2^k to shift │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ -REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +Given a string and a non-negative integer index less than the length of │ │ │ │ + the string, returns the character object representing the character at │ │ │ │ + that position in the string. │ │ │ │ +CATEGORY │ │ │ │ + NEW-VALUE │ │ │ │ inline float truncate │ │ │ │ SYS:SRC;CODE;TYPEP.LISP │ │ │ │ SYS:SRC;CODE;CMACROS.LISP │ │ │ │ SYS:SRC;CODE;STUBS.LISP │ │ │ │ S$VqY~]Z_ │ │ │ │ +The type declarations ~// and ~// for ~S conflict. │ │ │ │ BEFORE-USES │ │ │ │ }$c'0+[+ │ │ │ │ SYS:SRC;CODE;COERCE.LISP │ │ │ │ -bus error at #X~X │ │ │ │ -automatically-generated makunbound method │ │ │ │ -3ddm\iddX │ │ │ │ -wjTWh]gsv\eS │ │ │ │ SYS:SRC;CODE;TARGET-SXHASH.LISP │ │ │ │ SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ inline npx function │ │ │ │ SYS:SRC;COMPILER;ARRAY-TRAN.LISP │ │ │ │ -SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ bytes_allocated │ │ │ │ +SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ Form associated with the STEP-CONDITION. │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ Outputs a new line to the Stream if it is not positioned at the │ │ │ │ beginning of a line. Returns T if it output a new line, nil │ │ │ │ otherwise. Used by FRESH-LINE. The default method uses │ │ │ │ STREAM-START-LINE-P and STREAM-TERPRI. │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP0 │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP0 │ │ │ │ -DEFAULTS │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP │ │ │ │ ->(E_ R`C │ │ │ │ -58oCh-YFD2 │ │ │ │ -COMMON-LISP │ │ │ │ -Given a string and a non-negative integer index less than the length of │ │ │ │ - the string, returns the character object representing the character at │ │ │ │ - that position in the string. │ │ │ │ -CATEGORY │ │ │ │ - NEW-VALUE │ │ │ │ $)H:p$(U │ │ │ │ \0^0SsnD │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP8 │ │ │ │ ,*`o:pt` │ │ │ │ COMMON-LISP │ │ │ │ @@ -28983,23 +28971,88 @@ │ │ │ │ only supported subtype relationships are is that any pointer type is a │ │ │ │ subtype of (* t), and any array type first dimension will match │ │ │ │ (array nil ...). Otherwise, the two types have to be │ │ │ │ ALIEN-TYPE-=. │ │ │ │ COMMON-LISP │ │ │ │ AXIS-NUMBER │ │ │ │ Return the length of dimension AXIS-NUMBER of ARRAY. │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP0 │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP0 │ │ │ │ +DEFAULTS │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP │ │ │ │ +>(E_ R`C │ │ │ │ +58oCh-YFD2 │ │ │ │ COMMON-LISP │ │ │ │ 3lG LN@tr │ │ │ │ +Destructively sort SEQUENCE. PREDICATE should return non-NIL if │ │ │ │ + ARG1 is to precede ARG2. │ │ │ │ +Destructively modifies SEQUENCE1 by copying successive elements │ │ │ │ +into it from the SEQUENCE2. │ │ │ │ +Elements are copied to the subsequence bounded by START1 and END1, │ │ │ │ +from the subsequence bounded by START2 and END2. If these subsequences │ │ │ │ +are not of the same length, then the shorter length determines how │ │ │ │ +many elements are copied. │ │ │ │ +CONTENT-LENGTH │ │ │ │ +COMMON-LISP │ │ │ │ +Create and return a new hash table. The keywords are as follows: │ │ │ │ + Determines how keys are compared. Must a designator for one of the │ │ │ │ + standard hash table tests, or a hash table test defined using │ │ │ │ + SB-EXT:DEFINE-HASH-TABLE-TEST. Additionally, when an explicit │ │ │ │ + HASH-FUNCTION is provided (see below), any two argument equivalence │ │ │ │ + predicate can be used as the TEST. │ │ │ │ + A hint as to how many elements will be put in this hash table. │ │ │ │ + :REHASH-SIZE │ │ │ │ + Indicates how to expand the table when it fills up. If an integer, add │ │ │ │ + space for that many elements. If a floating point number (which must be │ │ │ │ + greater than 1.0), multiply the size by that amount. │ │ │ │ + :REHASH-THRESHOLD │ │ │ │ + Indicates how dense the table can become before forcing a rehash. Can be │ │ │ │ + any positive number <=1, with density approaching zero as the threshold │ │ │ │ + approaches 0. Density 1 means an average of one entry per bucket. │ │ │ │ + :HASH-FUNCTION │ │ │ │ + If unsupplied, a hash function based on the TEST argument is used, │ │ │ │ + which then must be one of the standardized hash table test functions, or │ │ │ │ + one for which a default hash function has been defined using │ │ │ │ + SB-EXT:DEFINE-HASH-TABLE-TEST. If HASH-FUNCTION is specified, the TEST │ │ │ │ + argument can be any two argument predicate consistent with it. The │ │ │ │ + HASH-FUNCTION is expected to return a non-negative fixnum hash code. │ │ │ │ + If TEST is neither standard nor defined by DEFINE-HASH-TABLE-TEST, │ │ │ │ + then the HASH-FUNCTION must be specified. │ │ │ │ + :WEAKNESS │ │ │ │ + When :WEAKNESS is not NIL, garbage collection may remove entries from the │ │ │ │ + hash table. The value of :WEAKNESS specifies how the presence of a key or │ │ │ │ + value in the hash table preserves their entries from garbage collection. │ │ │ │ + Valid values are: │ │ │ │ + :KEY means that the key of an entry must be live to guarantee that the │ │ │ │ + entry is preserved. │ │ │ │ + :VALUE means that the value of an entry must be live to guarantee that │ │ │ │ + the entry is preserved. │ │ │ │ + :KEY-AND-VALUE means that both the key and the value must be live to │ │ │ │ + guarantee that the entry is preserved. │ │ │ │ + :KEY-OR-VALUE means that either the key or the value must be live to │ │ │ │ + guarantee that the entry is preserved. │ │ │ │ + NIL (the default) means that entries are always preserved. │ │ │ │ + :SYNCHRONIZED │ │ │ │ + If NIL (the default), the hash-table may have multiple concurrent readers, │ │ │ │ + but results are undefined if a thread writes to the hash-table │ │ │ │ + concurrently with another reader or writer. If T, all concurrent accesses │ │ │ │ + are safe, but note that CLHS 3.6 (Traversal Rules and Side Effects) │ │ │ │ + remains in force. See also: SB-EXT:WITH-LOCKED-HASH-TABLE. │ │ │ │ +Return a copy of sequence with elements not satisfying PREDICATE removed. │ │ │ │ COMMON-LISP08 │ │ │ │ Count the number of 1 bits if INTEGER is non-negative, │ │ │ │ and the number of 0 bits if INTEGER is negative. │ │ │ │ OPTIONAL-ARGS │ │ │ │ Emit LABEL at this location in the current section. │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP8 │ │ │ │ X^,R62h │ │ │ │ bTk&i4=N │ │ │ │ Load the file given by FILESPEC into the Lisp environment, returning T on │ │ │ │ success. The file type (a.k.a extension) is defaulted if missing. These │ │ │ │ options are defined: │ │ │ │ :IF-DOES-NOT-EXIST │ │ │ │ If :ERROR (the default), signal an error if the file can't be located. │ │ │ │ @@ -29012,16 +29065,16 @@ │ │ │ │ :EXTERNAL-FORMAT │ │ │ │ The external-format to use when opening the FILENAME. The default is │ │ │ │ :DEFAULT which uses the SB-EXT:*DEFAULT-SOURCE-EXTERNAL-FORMAT*. │ │ │ │ POSITION │ │ │ │ COMMON-LISP9 │ │ │ │ Return a byte specifier which may be used by other byte functions │ │ │ │ (e.g. LDB). │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ L*(pO:XU^q │ │ │ │ Make SYMBOL unbound, removing any value it may currently have. │ │ │ │ Make NAME have no global function definition. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ For use with ~/: Write SYMBOL to STREAM as if it is not accessible from │ │ │ │ the current package. │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -29030,54 +29083,46 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ CE#$z-RJ - │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ DEBUG-FUN8 │ │ │ │ DEBUG-FUN │ │ │ │ DEBUG-FUN │ │ │ │ DEBUG-FUN8 │ │ │ │ +SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ +Oversized code component? │ │ │ │ +attempt to multiply define ~A ~S │ │ │ │ +Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ +Repeated labels in ASSEMBLE body │ │ │ │ +Wnvm]t|p$j| │ │ │ │ +~:@(ARG-FOR-~S-~) │ │ │ │ +The byte spec ~S either overlaps another byte spec, or extends past the end. │ │ │ │ +There are holes. │ │ │ │ +~W isn't an even multiple of ~W. │ │ │ │ +Undefined instruction: ~s in │ │ │ │ +Undefined instruction: ~s in~% ~s │ │ │ │ +WITH-PRETTY-STREAM │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/package.lisp │ │ │ │ +Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ +Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ +:TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ + (alien (* (array (signed 8) 10))) │ │ │ │ - (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ - (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ ALIEN-NAME │ │ │ │ LISP-NAME │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +P<-Pu:03 │ │ │ │ +]d[$?DEWn │ │ │ │ +&wZA#K8o │ │ │ │ +FUN-TYPE │ │ │ │ +RESULT-TYPE │ │ │ │ +TYPED-LAMBDA-LIST │ │ │ │ +Return the size of the alien type TYPE. UNITS specifies the units to │ │ │ │ + use and can be either :BITS, :BYTES, or :WORDS. │ │ │ │ +Define the alien type NAME to be equivalent to TYPE. Name may be NIL for │ │ │ │ + STRUCT and UNION types, in which case the name is taken from the type │ │ │ │ + specifier. │ │ │ │ O3)pO:|W │ │ │ │ -~// is a built-in alien type. │ │ │ │ -Input type (~//) and output type (~//) are unrelated? │ │ │ │ -could not find any input routine for ~// │ │ │ │ -package nicknames │ │ │ │ -~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ -~@:_Lambda-list: ~// │ │ │ │ -~@:_Declared type: ~// │ │ │ │ -~@:_Derived type: ~// │ │ │ │ -~@:_(~A ~{~S ~}~//) │ │ │ │ -~@:_~:(~A~) type: ~// │ │ │ │ -~@:_A ~(~a~) for ~// │ │ │ │ -~@:_An accessor for ~// │ │ │ │ -~@:_Argument precedence order: ~// │ │ │ │ ALIEN-NAME │ │ │ │ LISP-NAME │ │ │ │ Initialize the alien symbol named by NAME with its alien callable │ │ │ │ function value. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP81 │ │ │ │ ,#V$b9gG │ │ │ │ @@ -29428,14 +29388,106 @@ │ │ │ │ (return-from pop-data nil))) │ │ │ │ (pop *data*))) │ │ │ │ ;; Producer │ │ │ │ (defun push-data (data) │ │ │ │ (with-mutex (*lock*) │ │ │ │ (push data *data*) │ │ │ │ (condition-notify *queue*))) │ │ │ │ +Name of the thread. Can be assigned to using SETF. A thread name must be │ │ │ │ +a simple-string (not necessarily unique) or NIL. │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +Returns the current count of the semaphore INSTANCE. │ │ │ │ +Returns the main thread of the process. │ │ │ │ +Create a waitqueue. │ │ │ │ +Create a new thread of NAME that runs FUNCTION with the argument │ │ │ │ +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. │ │ │ │ +nrK)SJ)3 │ │ │ │ +(define-alien-callable NAME RESULT-TYPE {(ARG-NAME ARG-TYPE)}* │ │ │ │ + {doc-string} {decls}* {FORM}*) │ │ │ │ +Define an alien function which can be called by alien code. The alien │ │ │ │ +function returned by (alien-callable-function NAME) expects alien │ │ │ │ +arguments of the specified ARG-TYPEs and returns an alien of type │ │ │ │ +RESULT-TYPE. │ │ │ │ +If (alien-callable-function NAME) already exists, its value is not │ │ │ │ +changed (though it is arranged that an updated version of the Lisp │ │ │ │ +callable function will be called, provided that the new type and the │ │ │ │ +existing type are compatible). This feature allows for incremental │ │ │ │ +redefinition of callable functions. │ │ │ │ +DEFINE-ALIEN-ROUTINE Name Result-Type {(Arg-Name Arg-Type [Style])}* │ │ │ │ +Define a foreign interface function for the routine with the specified NAME. │ │ │ │ +Also automatically DECLAIM the FTYPE of the defined function. │ │ │ │ +NAME may be either a string, a symbol, or a list of the form (string symbol). │ │ │ │ +RETURN-TYPE is the alien type for the function return value. VOID may be │ │ │ │ +used to specify a function with no result. │ │ │ │ +The remaining forms specify individual arguments that are passed to the │ │ │ │ +routine. ARG-NAME is a symbol that names the argument, primarily for │ │ │ │ +documentation. ARG-TYPE is the C type of the argument. STYLE specifies the │ │ │ │ +way that the argument is passed. │ │ │ │ + An :IN argument is simply passed by value. The value to be passed is │ │ │ │ + obtained from argument(s) to the interface function. No values are │ │ │ │ + returned for :In arguments. This is the default mode. │ │ │ │ + The specified argument type must be a pointer to a fixed sized object. │ │ │ │ + A pointer to a preallocated object is passed to the routine, and the │ │ │ │ + the object is accessed on return, with the value being returned from │ │ │ │ + the interface function. :OUT and :IN-OUT cannot be used with pointers │ │ │ │ + to arrays, records or functions. │ │ │ │ + This is similar to :IN, except that the argument values are stored │ │ │ │ + on the stack, and a pointer to the object is passed instead of │ │ │ │ + the value itself. │ │ │ │ + This is a combination of :OUT and :COPY. A pointer to the argument is │ │ │ │ + passed, with the object being initialized from the supplied argument │ │ │ │ + and the return value being determined by accessing the object on │ │ │ │ + return. │ │ │ │ +Define NAME as an external alien variable of type TYPE. NAME should │ │ │ │ +be a list of a string holding the alien name and a symbol to use as │ │ │ │ +the Lisp name. If NAME is just a symbol or string, then the other name │ │ │ │ +is guessed from the one supplied. │ │ │ │ +Access the alien variable named NAME, assuming it is of type TYPE. │ │ │ │ +This is SETFable. │ │ │ │ +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. │ │ │ │ +Convert the system area pointer SAP to an ALIEN of the specified TYPE (not │ │ │ │ + evaluated.) TYPE must be pointer-like. │ │ │ │ +Establish some local alien functions. Each DEFINITION is of the form: │ │ │ │ + NAME RESULT-TYPE {(ARG-NAME ARG-TYPE)}* │ │ │ │ + {doc-string} {decls}* {FORM}* │ │ │ │ + The resulting alien callable value has dynamic extent. │ │ │ │ +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))) │ │ │ │ Insert a barrier in the code stream, preventing some sort of │ │ │ │ reordering. │ │ │ │ KIND should be one of: │ │ │ │ :COMPILER │ │ │ │ Prevent the compiler from reordering memory access across the │ │ │ │ barrier. │ │ │ │ :MEMORY │ │ │ │ @@ -29459,41 +29511,33 @@ │ │ │ │ VALUES-FORM as the results visible to JOIN-THREAD. │ │ │ │ If current thread is the main thread of the process (see │ │ │ │ MAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as │ │ │ │ terminating the main thread would terminate the entire process. If │ │ │ │ ALLOW-EXIT is true, returning from the main thread is equivalent to │ │ │ │ calling SB-EXT:EXIT with :CODE 0 and :ABORT NIL. │ │ │ │ See also: ABORT-THREAD and SB-EXT:EXIT. │ │ │ │ -Name of the thread. Can be assigned to using SETF. A thread name must be │ │ │ │ -a simple-string (not necessarily unique) or NIL. │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -Returns the current count of the semaphore INSTANCE. │ │ │ │ -Returns the main thread of the process. │ │ │ │ -Create a waitqueue. │ │ │ │ -Create a new thread of NAME that runs FUNCTION with the argument │ │ │ │ -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. │ │ │ │ -nrK)SJ)3 │ │ │ │ #iznyg'r │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ 1*`o:00|= │ │ │ │ fmt$6VMOY9 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Signals a timeout condition while inhibiting further timeouts due to │ │ │ │ deadlines while the condition is being handled. │ │ │ │ ^h]h]h]h] │ │ │ │ @@ -29517,23 +29561,35 @@ │ │ │ │ COMMON-LISP │ │ │ │ 95_ry.Jpb │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ COMMON-LISP │ │ │ │ Removes NAME's encapsulation of the specified TYPE if such exists. │ │ │ │ 1*`o:0015=gOl │ │ │ │ -public: algorithms for Unicode data │ │ │ │ -PACKED-INFO- │ │ │ │ -BITMAP-ALL-TAGGEDP │ │ │ │ -POSSIBLY-RATIONAL │ │ │ │ DEYPl B{ER │ │ │ │ 7-[ZM^[Z5 │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ +PACKED-INFO- │ │ │ │ +BITMAP-ALL-TAGGEDP │ │ │ │ +POSSIBLY-RATIONAL │ │ │ │ COMMON-LISP0 │ │ │ │ STRING-DESIGNATORS │ │ │ │ REPLACEMENT-SPEC │ │ │ │ COMMON-LISP │ │ │ │ Return any available status information on child process with PID. │ │ │ │ fmt$8H3QYS │ │ │ │ /':}PZSZwG │ │ │ │ @@ -29748,14 +29803,16 @@ │ │ │ │ YwV%=Jng │ │ │ │ fmt$22UEYP │ │ │ │ fmt$4BWG1A │ │ │ │ fmt$4BEGTI │ │ │ │ fmt$1IK7FR │ │ │ │ fmt$7F1XBG │ │ │ │ COMMON-LISP │ │ │ │ + PREDICATE │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ Q>+Pu:0s │ │ │ │ L #a2ZXi │ │ │ │ ARGUMENT-LIST │ │ │ │ COMMON-LISP │ │ │ │ vYZ7Pos0 │ │ │ │ @@ -29790,55 +29847,46 @@ │ │ │ │ |2U&KI,5 │ │ │ │ UNIX-TIME0 │ │ │ │ %;d's-DCr" │ │ │ │ fmt$7S4X4M │ │ │ │ fmt$5ZBLT2 │ │ │ │ fmt$8OGHUT │ │ │ │ fmt$31D577 │ │ │ │ - PREDICATE │ │ │ │ -COMMON-LISP │ │ │ │ +g[[[[[[[[[ │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP8 │ │ │ │ ))pO:|R\U │ │ │ │ -close_current_thread_tlab │ │ │ │ -close_code_region │ │ │ │ -sb_get_os_thread_id │ │ │ │ -wifcontinued │ │ │ │ -wifstopped │ │ │ │ -unlockpt │ │ │ │ -wait_for_exec │ │ │ │ -gc_pathfind │ │ │ │ -gc_and_save │ │ │ │ -~&Evaluation took: │ │ │ │ -~@< ~@;~// of real time │ │ │ │ -~// of total run time (~@// user, ~@// system) │ │ │ │ -~[[ Real times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ -~;~2*~]~[[ Run times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ -~;~2*~]~,2F% CPU │ │ │ │ -~@[~:D form~:P interpreted │ │ │ │ -~]~@[~:D lambda~:P converted │ │ │ │ -~]~@[~:D processor cycles │ │ │ │ -~]~@[~:D page fault~:P │ │ │ │ -~]~:D bytes consed │ │ │ │ -before it was aborted by a non-local transfer of control. │ │ │ │ - NEW-VALUE │ │ │ │ - NEW-VALUE │ │ │ │ -g[[[[[[[[[ │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ 95_ry.Jpb │ │ │ │ 1!C0I9so │ │ │ │ COMPILER-P │ │ │ │ 1*`o:00~]~} │ │ │ │ +~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ +Not a function type: ~// │ │ │ │ Returns number of complete years since March 1st 2000, and remainder in seconds │ │ │ │ 95_ry.Jpb │ │ │ │ COMMON-LISP │ │ │ │ SUB-CHAR │ │ │ │ #_;alfWgT │ │ │ │ OPERATION │ │ │ │ COMMON-LISP │ │ │ │ @@ -29857,14 +29905,15 @@ │ │ │ │ +r[r{Ppk │ │ │ │ HASH-FUN-STATE │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ 158E/*5KNy │ │ │ │ ENVIRONMENT │ │ │ │ SUB-CHAR │ │ │ │ +DEFINITION-SOURCE-LOCATION- │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ FK/xy H%8 │ │ │ │ PRIORITY-QUEUE │ │ │ │ Remove and return the item in PRIORITY-QUEUE with the largest key. │ │ │ │ @@ -29884,15 +29933,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REPLACEMENT │ │ │ │ iQO$(d>+" │ │ │ │ COMMON-LISP │ │ │ │ REPLACEMENT │ │ │ │ -DEFINITION-SOURCE-LOCATION- │ │ │ │ Wm4JmRL)1O │ │ │ │ `pMp0>fX │ │ │ │ db89(`$ │ │ │ │ bt%+(`$ u │ │ │ │ 8\3K/';x │ │ │ │ COMMON-LISP │ │ │ │ s_UU+,: │ │ │ │ @@ -29907,33 +29955,29 @@ │ │ │ │ COMMON-LISP │ │ │ │ fmt$19F7UE │ │ │ │ fmt$3EAFX │ │ │ │ EXTERNAL-FORMAT │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ 9/ce\B>@ │ │ │ │ -~#[~;Use ~// instead.~;Use ~// or ~// instead.~:;Use~@{~#[~; or~] ~//~^,~} instead.~] │ │ │ │ -~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ -~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ -Not a function type: ~// │ │ │ │ ^h]h]h]h] │ │ │ │ OPTIONAL-ARGS │ │ │ │ K-Bi@gx> │ │ │ │ 3{Z+2DLH$Dw │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP │ │ │ │ 5?9Llk<( │ │ │ │ fmt$ILOT5 │ │ │ │ fmt$2Z388B │ │ │ │ N-BUCKETS │ │ │ │ ?-Pu:03W │ │ │ │ COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ BN0(Pu:P4J │ │ │ │ CAPACITY │ │ │ │ +REST-ARG │ │ │ │ YJXZ&#ay │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ 8XJB_`6w^ │ │ │ │ comma-dot │ │ │ │ comma-at │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -29960,17 +30004,17 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ HVssssss │ │ │ │ HASHSET0 │ │ │ │ 95_ry.Jpb │ │ │ │ -"O4+Pu:03 │ │ │ │ AUX-SYMBOL │ │ │ │ p'(`"rNw │ │ │ │ +"O4+Pu:03 │ │ │ │ PRIORITY-QUEUE0, │ │ │ │ Return the item in PRIORITY-QUEUE with the largest key. │ │ │ │ 7)`W:00 │ │ │ │ EF-ENTRY │ │ │ │ ^h]h]h]h │ │ │ │ fmt$684M8X │ │ │ │ fmt$4WCP71 │ │ │ │ @@ -30011,24 +30055,19 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ DEFINITION8 │ │ │ │ COMMON-LISP0" │ │ │ │ COMMON-LISP0 │ │ │ │ $9ru~^rt │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -HYe&-?=P% │ │ │ │ -Q=,Pu:pf │ │ │ │ -Gr'XhN3% │ │ │ │ -!\uTfQIA │ │ │ │ - P!fYQi9 │ │ │ │ -yI*gfdjb^ │ │ │ │ -#nO'"dSt │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP │ │ │ │ ORIGINAL │ │ │ │ +HYe&-?=P% │ │ │ │ +Q=,Pu:pf │ │ │ │ "* { W-W │ │ │ │ EOF-VAL- │ │ │ │ COMMON-LISP │ │ │ │ READTABLE │ │ │ │ COMMON-LISP │ │ │ │ READTABLE │ │ │ │ COMMON-LISP │ │ │ │ @@ -30046,20 +30085,24 @@ │ │ │ │ eightieth │ │ │ │ ninetieth │ │ │ │ thirteen │ │ │ │ fourteen │ │ │ │ seventeen │ │ │ │ eighteen │ │ │ │ nineteen │ │ │ │ + P!fYQi9 │ │ │ │ +yI*gfdjb^ │ │ │ │ +Gr'XhN3% │ │ │ │ E!TS)N)=jO │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ U1$}TW-u │ │ │ │ COMMON-LISP │ │ │ │ SYMBOLS8 │ │ │ │ +!\uTfQIA │ │ │ │ thousand │ │ │ │ million │ │ │ │ billion │ │ │ │ trillion │ │ │ │ quadrillion │ │ │ │ quintillion │ │ │ │ sextillion │ │ │ │ @@ -30079,14 +30122,15 @@ │ │ │ │ vigintillion │ │ │ │ COMMON-LISP │ │ │ │ evec#K3pqz │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ JU*b2Vk) │ │ │ │ +QUbJq'%}(I │ │ │ │ +#nO'"dSt │ │ │ │ COMMON-LISP │ │ │ │ CONTROL-STRING │ │ │ │ 1; 9nwCv~ │ │ │ │ COMMON-LISP0: │ │ │ │ f3,yLYQ. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ @@ -30129,41 +30173,50 @@ │ │ │ │ If given, internal data structures are dumped to the specified │ │ │ │ file, or if a value of T is given, to a file of *.trace type │ │ │ │ derived from the input file name. (non-standard) │ │ │ │ :EMIT-CFASL │ │ │ │ (Experimental). If true, outputs the toplevel compile-time effects │ │ │ │ of this file into a separate .cfasl file. │ │ │ │ SOURCE-LOC │ │ │ │ -Define a function at top level. │ │ │ │ -LAMBDA-LIST │ │ │ │ -NEXT-VAR │ │ │ │ -Move SRC into DST unless they are location=. │ │ │ │ - ARGUMENTS │ │ │ │ -GENERIC-FUNCTION │ │ │ │ -COMMON-LISP │ │ │ │ +~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ +violating package lock on ~// │ │ │ │ +using the lexical binding of the symbol ~//, not the │ │ │ │ +dynamic binding │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ NOTE-THIS-LOCATION VOP Kind │ │ │ │ Note that the current code location is an interesting (to the debugger) │ │ │ │ location of the specified Kind. VOP is the VOP responsible for this code. │ │ │ │ This VOP must specify some non-null :SAVE-P value (perhaps :COMPUTE-ONLY) so │ │ │ │ that the live set is computed. │ │ │ │ FALL-THRU-P │ │ │ │ START-LABEL │ │ │ │ TRAMPOLINE-LABEL │ │ │ │ SC-NUMBER │ │ │ │ +Define a function at top level. │ │ │ │ +LAMBDA-LIST │ │ │ │ +NEXT-VAR │ │ │ │ +Move SRC into DST unless they are location=. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ ztN53tV)x │ │ │ │ SB-ALIEN │ │ │ │ WRITE-P8/ │ │ │ │ OPTIONAL-ARGS │ │ │ │ DEPRECATED-NAMES8 │ │ │ │ SITUATIONS │ │ │ │ SC+OFFSET │ │ │ │ OPTIONAL-ARGS │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP8 │ │ │ │ 6ikdlXPJ │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @@ -30189,57 +30242,47 @@ │ │ │ │ SB-ALIEN0 │ │ │ │ f,'_iPRn' │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP0 │ │ │ │ CONTEXT0 │ │ │ │ (llACB+Z │ │ │ │ }&(@D`,y │ │ │ │ -~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ -violating package lock on ~// │ │ │ │ -using the lexical binding of the symbol ~//, not the │ │ │ │ -dynamic binding │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -It allows an unknown number of values, consider using │ │ │ │ -Type assertion too complex to check efficiently: │ │ │ │ -It allows a variable number of values, consider using │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -undefined ~(~A~): ~// │ │ │ │ -SAW-LAST │ │ │ │ -LVAR-SINGLE-VALUE-P │ │ │ │ -FUNCTIONAL-LETLIKE-P │ │ │ │ -ELEMENT-CTYPE │ │ │ │ C6xDkZaqx~H │ │ │ │ 8c\9qJD$ul │ │ │ │ tHpVAan[ │ │ │ │ REST-ARG │ │ │ │ fQ<*Pu:0Ef& │ │ │ │ oqGV##^M │ │ │ │ COMPONENT │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +REST-ARG │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +REST-ARG │ │ │ │ +(pHPk< U │ │ │ │ +REST-ARG │ │ │ │ +SYS:SRC;COMPILER;LTV.LISP │ │ │ │ fixnum untagging │ │ │ │ constant load │ │ │ │ integer to untagged word coercion │ │ │ │ fixnum tagging │ │ │ │ signed word to integer coercion │ │ │ │ unsigned word to integer coercion │ │ │ │ word integer move │ │ │ │ @@ -30260,22 +30303,14 @@ │ │ │ │ SAP argument move │ │ │ │ character untagging │ │ │ │ character tagging │ │ │ │ character move │ │ │ │ character arg move │ │ │ │ inline (unsigned-byte 32) logcount │ │ │ │ more-arg-context │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -REST-ARG │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -REST-ARG │ │ │ │ -(pHPk< U │ │ │ │ -REST-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ m#N_b63(sod │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Pii4DHhS"2 │ │ │ │ @@ -30319,26 +30354,27 @@ │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ {iYQIA91qx │ │ │ │ 5xpFuPO7 │ │ │ │ +Automagically generated boolean attribute creation function. │ │ │ │ + See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ bL,(`o:02 │ │ │ │ CONDITION │ │ │ │ COMMON-LISP8 │ │ │ │ SPECIFIER │ │ │ │ REST-ARG │ │ │ │ -SYS:SRC;COMPILER;LTV.LISP │ │ │ │ L+&`o:010 │ │ │ │ COMMON-LISP │ │ │ │ DS-LAMBDA-LIST0 │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -30363,16 +30399,14 @@ │ │ │ │ *&`o:0Lp │ │ │ │ SRZB46@8 │ │ │ │ >73333l_ │ │ │ │ o;0[m │ │ │ │ ENTRY-POINTS0 │ │ │ │ @@ -30398,28 +30432,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ %yUk{45Ki │ │ │ │ _\M3,8wB │ │ │ │ Pf5>:\Yp( │ │ │ │ CLOSURE SB-KERNEL0 │ │ │ │ RETURN-PC-PASS8) │ │ │ │ @yr%or&_r' │ │ │ │ -setting the symbol-function of ~A │ │ │ │ -setting the compiler-macro-function of ~A │ │ │ │ -can't SETF COMPILER-MACRO-FUNCTION when ENV is non-NIL │ │ │ │ -Using ~A as the class-name argument in ~ │ │ │ │ - (SETF FIND-CLASS) │ │ │ │ -encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ -4E4i4<4`4 │ │ │ │ -*9@9d979[9. │ │ │ │ -Syscall poll(2) failed: ~A │ │ │ │ -~S is not an early-method. │ │ │ │ -No slot called ~S in ~S. │ │ │ │ -Cannot look up slot-definition for ~S in ~S (too early to finalize.) │ │ │ │ -~@ │ │ │ │ -JMi ? 7 -$ │ │ │ │ COMMON-LISP0 │ │ │ │ COMPONENT │ │ │ │ REST-ARG │ │ │ │ DS-LAMBDA-LIST │ │ │ │ $*|uf,GC │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -30452,22 +30472,43 @@ │ │ │ │ e+J(~e{:! │ │ │ │ 9)`o:0L │ │ │ │ DISPATCHER │ │ │ │ EXPLICIT-CHECK │ │ │ │ SB-INT0( │ │ │ │ FASL-OUTPUT │ │ │ │ COMMON-LISP │ │ │ │ +It allows an unknown number of values, consider using │ │ │ │ +Type assertion too complex to check efficiently: │ │ │ │ +It allows a variable number of values, consider using │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +undefined ~(~A~): ~// │ │ │ │ +The result type from ~A: │ │ │ │ +conflicts with the definition's result type: │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~:[This~;~:*~A~] is not a ~< │ │ │ │ +~9T~:;~//:~> │ │ │ │ +~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ +~9T~:;not a ~//.~> │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~S can't be used to initialize an array of type ~//. │ │ │ │ '%Il/>NX │ │ │ │ COMPONENT │ │ │ │ Vt.Rf#QL │ │ │ │ uhm3D*hoR │ │ │ │ REST-ARG │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ EGt`7^wR │ │ │ │ +~a{.>iB/ │ │ │ │ COMMON-LISP0 │ │ │ │ JOIN-TYPES-P │ │ │ │ Y"32G)10Dy:>1 │ │ │ │ BDjmg9:[ │ │ │ │ /"(`$ hF │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -30485,22 +30526,23 @@ │ │ │ │ SB-ALIEN │ │ │ │ f*Af%sf6 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INTERVAL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ (@F`lu@; │ │ │ │ +ORIGINAL-FUN │ │ │ │ +LVAR-KIND │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ NEW-BLOCK │ │ │ │ SB-ALIEN │ │ │ │ NAME-KEY83 │ │ │ │ R/l90)jK │ │ │ │ -~a{.>iB/ │ │ │ │ REST-ARG │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ mz(i&$BB │ │ │ │ @@ -30519,17 +30561,14 @@ │ │ │ │ ZxA2>&]f │ │ │ │ ITEM-TYPE0 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ COMPONENT │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -degraded │ │ │ │ -ORIGINAL-FUN │ │ │ │ -LVAR-KIND │ │ │ │ REST-ARG │ │ │ │ B,PW:0333S │ │ │ │ Q`k#,/vY │ │ │ │ 1\oV3Ndf) │ │ │ │ COMMON-LISP8O │ │ │ │ REST-ARG │ │ │ │ .k5UUU->::: │ │ │ │ @@ -30539,29 +30578,31 @@ │ │ │ │ COMMON-LISP │ │ │ │ NEW-INLINEP │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ [qxh)j)xh │ │ │ │ *EUN R\M │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -TARGET-ENV │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ H[(tPD@LU │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ 9+`W:0Lm │ │ │ │ J#7do(V4 │ │ │ │ teC!6C~0 │ │ │ │ CONSTRAINT │ │ │ │ +TARGET-ENV │ │ │ │ +degraded │ │ │ │ +without-hashing │ │ │ │ REST-ARG │ │ │ │ INDICES8 │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP0( │ │ │ │ Sl'$/pxJ │ │ │ │ O4(Pu:pff │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ @@ -30607,52 +30648,39 @@ │ │ │ │ A:"RTP(m │ │ │ │ \^}Sde9xu%cV │ │ │ │ M1)Pu: W │ │ │ │ REST-ARG │ │ │ │ 'Gl`QMQ.qd │ │ │ │ BRANCH-IF0 │ │ │ │ COMMON-LISP0 │ │ │ │ -The result type from ~A: │ │ │ │ -conflicts with the definition's result type: │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~:[This~;~:*~A~] is not a ~< │ │ │ │ -~9T~:;~//:~> │ │ │ │ -~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ -~9T~:;not a ~//.~> │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~S can't be used to initialize an array of type ~//. │ │ │ │ - ~V@<~//~> │ │ │ │ -The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ CURRENT-FP SB-KERNEL │ │ │ │ REST-ARG │ │ │ │ ??FQ(Uh# │ │ │ │ })o'}V,* │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ SLzAkfqZ~ │ │ │ │ y\Rh]vA- │ │ │ │ +SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;CELL.LISP │ │ │ │ PRIMITIVE-TYPE0" │ │ │ │ e/afzbr" │ │ │ │ -without-hashing │ │ │ │ -COMPONENT-LAMBDA │ │ │ │ -COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ -N-SIMPLE-FUNS │ │ │ │ REST-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ -SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;CELL.LISP │ │ │ │ REST-ARG │ │ │ │ +COMPONENT-LAMBDA │ │ │ │ +COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ +N-SIMPLE-FUNS │ │ │ │ +PREV-KIND │ │ │ │ COMMON-LISP8/ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ >-Pu:0W# │ │ │ │ ?L1FMDDhI │ │ │ │ SB-ALIEN │ │ │ │ LTN-POLICY02 │ │ │ │ @@ -30666,24 +30694,24 @@ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ &M(}xc;p │ │ │ │ MORE-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ +CODE-OBJ │ │ │ │ Automagically generated boolean attribute setter. See │ │ │ │ !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ Automagically generated boolean attribute test function. │ │ │ │ See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ ELIDE-IF │ │ │ │ SB-ASSEM0 │ │ │ │ PA-BITS-EA │ │ │ │ -CODE-OBJ │ │ │ │ MNPX&+Au │ │ │ │ .O8`2100 │ │ │ │ REST-ARG │ │ │ │ AGe2ZgWh[ │ │ │ │ FOR-VALUE │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ @@ -30695,31 +30723,61 @@ │ │ │ │ ,/z-3?tY* │ │ │ │ Rlx!gc*tF │ │ │ │ REST-ARG │ │ │ │ TUUGQCpi │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ +setting the symbol-function of ~A │ │ │ │ +setting the compiler-macro-function of ~A │ │ │ │ +can't SETF COMPILER-MACRO-FUNCTION when ENV is non-NIL │ │ │ │ +Using ~A as the class-name argument in ~ │ │ │ │ + (SETF FIND-CLASS) │ │ │ │ +encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ +4E4i4<4`4 │ │ │ │ +*9@9d979[9. │ │ │ │ +Syscall poll(2) failed: ~A │ │ │ │ +~S is not an early-method. │ │ │ │ +No slot called ~S in ~S. │ │ │ │ +Cannot look up slot-definition for ~S in ~S (too early to finalize.) │ │ │ │ +~@ │ │ │ │ +JMi ? 7 -$ │ │ │ │ +Backtrace for: ~S │ │ │ │ +Skip printing frame ~S │ │ │ │ +while printing frame ~S. The partial output is: ~S │ │ │ │ +non-FIXNUM non-NULL location in cell: ~S │ │ │ │ +updating obsolete instance │ │ │ │ +~S cannot handle the second argument ~S. │ │ │ │ +failed to resolve home directory for Unix uid=~S │ │ │ │ +select(2) │ │ │ │ +Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ +4E4i4<4`4 │ │ │ │ +*9@9d979[9. │ │ │ │ +Error calling tmpfile(): ~a │ │ │ │ R)D|gT$M. │ │ │ │ 0a{[xCD; │ │ │ │ FUN-NAME │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -PREV-KIND │ │ │ │ 03((T:HS │ │ │ │ ENVIRONMENT0 │ │ │ │ ~CsAzm6Dw\ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ SOURCE-INFO │ │ │ │ \(p$(s7y │ │ │ │ YxDA<"]xd │ │ │ │ COMMON-LISP │ │ │ │ N-BITS-SHIFT1 │ │ │ │ + ARGUMENTS │ │ │ │ +GENERIC-FUNCTION │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ + NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ Generate-Error-Code Error-code Value* │ │ │ │ Emit code for an error with the specified Error-Code and context Values. │ │ │ │ 6CDDHtK2% │ │ │ │ 0mo|iCjG │ │ │ │ [:d:IBLk │ │ │ │ COMMON-LISP │ │ │ │ @@ -30744,16 +30802,14 @@ │ │ │ │ NUM-RESULTS │ │ │ │ SB-ALIEN0 │ │ │ │ COMMON-LISP │ │ │ │ BYTES-PER-ELEMENT │ │ │ │ DATA-OFFSET │ │ │ │ ELEMENT-SIZE │ │ │ │ WD3""""" │ │ │ │ -CONTENT-LENGTH │ │ │ │ -COMMON-LISP │ │ │ │ 7 &9 │ │ │ │ +The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN0# │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN0" │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP0# │ │ │ │ @@ -30778,29 +30836,56 @@ │ │ │ │ Adds a new module name to *MODULES* indicating that it has been loaded. │ │ │ │ Module-name is a string designator │ │ │ │ gO&b2j2G$ │ │ │ │ Performs a bit-wise logical NOT on the elements of BIT-ARRAY, │ │ │ │ putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, │ │ │ │ BIT-ARRAY is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is │ │ │ │ created. Both arrays must have the same rank and dimensions. │ │ │ │ -Return a symbol in PACKAGE having the specified NAME, creating it │ │ │ │ - if necessary. │ │ │ │ -Return T if arguments are in strictly non-increasing order, NIL otherwise. │ │ │ │ Define a parameter that is not normally changed by the program, │ │ │ │ but that may be changed without causing an error. Declare the │ │ │ │ variable special and sets its value to VAL, overwriting any │ │ │ │ previous value. The third argument is an optional documentation │ │ │ │ string for the parameter. │ │ │ │ -DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}* │ │ │ │ - Executes the FORMs once for each symbol in every package with VAR bound │ │ │ │ - to the current symbol. │ │ │ │ -Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return │ │ │ │ - if its list argument is exhausted. Can only be used inside │ │ │ │ - PPRINT-LOGICAL-BLOCK, and only when the LIST argument to │ │ │ │ - PPRINT-LOGICAL-BLOCK is supplied. │ │ │ │ +Return a symbol in PACKAGE having the specified NAME, creating it │ │ │ │ + if necessary. │ │ │ │ +Return T if arguments are in strictly non-increasing order, NIL otherwise. │ │ │ │ +UNWIND-PROTECT protected cleanup* │ │ │ │ +Evaluate the form PROTECTED, returning its values. The CLEANUP forms are │ │ │ │ +evaluated whenever the dynamic scope of the PROTECTED form is exited (either │ │ │ │ +due to normal completion or a non-local exit such as THROW). │ │ │ │ +Arrange for FORM to be evaluated at load-time and use the value produced as │ │ │ │ +if it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is │ │ │ │ +guaranteed to never be modified, so it can be put in read-only storage. │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +MULTIPLE-VALUE-CALL function values-form* │ │ │ │ +Call FUNCTION, passing all the values of each VALUES-FORM as arguments, │ │ │ │ +values from the first VALUES-FORM making up the first argument, etc. │ │ │ │ +Specifies that the values returned by FORM conform to the VALUE-TYPE. │ │ │ │ +CLHS specifies that the consequences are undefined if any result is │ │ │ │ +not of the declared type, but SBCL treats declarations as assertions │ │ │ │ +as long as SAFETY is at least 2, in which case incorrect type │ │ │ │ +information will result in a runtime type-error instead of leading to │ │ │ │ +eg. heap corruption. This is however expressly non-portable: use │ │ │ │ +CHECK-TYPE instead of THE to catch type-errors at runtime. THE is best │ │ │ │ +considered an optimization tool to inform the compiler about types it │ │ │ │ +is unable to derive from other declared types. │ │ │ │ +LET* ({(var [value]) | var}*) declaration* form* │ │ │ │ +Similar to LET, but the variables are bound sequentially, allowing each VALUE │ │ │ │ +form to reference any of the previous VARS. │ │ │ │ +CATCH tag form* │ │ │ │ +Evaluate TAG and instantiate it as a catcher while the body forms are │ │ │ │ +evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic │ │ │ │ +scope of the body, then control will be transferred to the end of the body and │ │ │ │ +the thrown values will be returned. │ │ │ │ Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise. │ │ │ │ Return a sequence formed by destructively removing the elements not │ │ │ │ satisfying the specified PREDICATE from the given SEQUENCE. │ │ │ │ COMMON-LISP0 │ │ │ │ Return the element of array corresponding to the row-major index. This is │ │ │ │ SETFable. │ │ │ │ Loads a module, unless it already has been loaded. PATHNAMES, if supplied, │ │ │ │ @@ -30892,105 +30977,21 @@ │ │ │ │ Return true if OBJECT is an ATOM, and NIL otherwise. │ │ │ │ Return the first restart identified by IDENTIFIER. If IDENTIFIER is a symbol, │ │ │ │ then the innermost applicable restart with that name is returned. If IDENTIFIER │ │ │ │ is a restart, it is returned if it is currently active. Otherwise NIL is │ │ │ │ returned. If CONDITION is specified and not NIL, then only restarts associated │ │ │ │ with that condition (or with no condition) will be returned. │ │ │ │ SLOT-NAME │ │ │ │ -Destructively modifies SEQUENCE1 by copying successive elements │ │ │ │ -into it from the SEQUENCE2. │ │ │ │ -Elements are copied to the subsequence bounded by START1 and END1, │ │ │ │ -from the subsequence bounded by START2 and END2. If these subsequences │ │ │ │ -are not of the same length, then the shorter length determines how │ │ │ │ -many elements are copied. │ │ │ │ M1%?\KD6_ │ │ │ │ Return a copy of STRUCTURE with the same (EQL) slot values. │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the cdr of the cddar of a list. │ │ │ │ -Create and return a new hash table. The keywords are as follows: │ │ │ │ - Determines how keys are compared. Must a designator for one of the │ │ │ │ - standard hash table tests, or a hash table test defined using │ │ │ │ - SB-EXT:DEFINE-HASH-TABLE-TEST. Additionally, when an explicit │ │ │ │ - HASH-FUNCTION is provided (see below), any two argument equivalence │ │ │ │ - predicate can be used as the TEST. │ │ │ │ - A hint as to how many elements will be put in this hash table. │ │ │ │ - :REHASH-SIZE │ │ │ │ - Indicates how to expand the table when it fills up. If an integer, add │ │ │ │ - space for that many elements. If a floating point number (which must be │ │ │ │ - greater than 1.0), multiply the size by that amount. │ │ │ │ - :REHASH-THRESHOLD │ │ │ │ - Indicates how dense the table can become before forcing a rehash. Can be │ │ │ │ - any positive number <=1, with density approaching zero as the threshold │ │ │ │ - approaches 0. Density 1 means an average of one entry per bucket. │ │ │ │ - :HASH-FUNCTION │ │ │ │ - If unsupplied, a hash function based on the TEST argument is used, │ │ │ │ - which then must be one of the standardized hash table test functions, or │ │ │ │ - one for which a default hash function has been defined using │ │ │ │ - SB-EXT:DEFINE-HASH-TABLE-TEST. If HASH-FUNCTION is specified, the TEST │ │ │ │ - argument can be any two argument predicate consistent with it. The │ │ │ │ - HASH-FUNCTION is expected to return a non-negative fixnum hash code. │ │ │ │ - If TEST is neither standard nor defined by DEFINE-HASH-TABLE-TEST, │ │ │ │ - then the HASH-FUNCTION must be specified. │ │ │ │ - :WEAKNESS │ │ │ │ - When :WEAKNESS is not NIL, garbage collection may remove entries from the │ │ │ │ - hash table. The value of :WEAKNESS specifies how the presence of a key or │ │ │ │ - value in the hash table preserves their entries from garbage collection. │ │ │ │ - Valid values are: │ │ │ │ - :KEY means that the key of an entry must be live to guarantee that the │ │ │ │ - entry is preserved. │ │ │ │ - :VALUE means that the value of an entry must be live to guarantee that │ │ │ │ - the entry is preserved. │ │ │ │ - :KEY-AND-VALUE means that both the key and the value must be live to │ │ │ │ - guarantee that the entry is preserved. │ │ │ │ - :KEY-OR-VALUE means that either the key or the value must be live to │ │ │ │ - guarantee that the entry is preserved. │ │ │ │ - NIL (the default) means that entries are always preserved. │ │ │ │ - :SYNCHRONIZED │ │ │ │ - If NIL (the default), the hash-table may have multiple concurrent readers, │ │ │ │ - but results are undefined if a thread writes to the hash-table │ │ │ │ - concurrently with another reader or writer. If T, all concurrent accesses │ │ │ │ - are safe, but note that CLHS 3.6 (Traversal Rules and Side Effects) │ │ │ │ - remains in force. See also: SB-EXT:WITH-LOCKED-HASH-TABLE. │ │ │ │ If NUMBER is zero, return NUMBER, else return (/ NUMBER (ABS NUMBER)). │ │ │ │ COMMON-LISP0 │ │ │ │ Return the cdr of the 1st sublist. │ │ │ │ -UNWIND-PROTECT protected cleanup* │ │ │ │ -Evaluate the form PROTECTED, returning its values. The CLEANUP forms are │ │ │ │ -evaluated whenever the dynamic scope of the PROTECTED form is exited (either │ │ │ │ -due to normal completion or a non-local exit such as THROW). │ │ │ │ -Arrange for FORM to be evaluated at load-time and use the value produced as │ │ │ │ -if it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is │ │ │ │ -guaranteed to never be modified, so it can be put in read-only storage. │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -MULTIPLE-VALUE-CALL function values-form* │ │ │ │ -Call FUNCTION, passing all the values of each VALUES-FORM as arguments, │ │ │ │ -values from the first VALUES-FORM making up the first argument, etc. │ │ │ │ -Specifies that the values returned by FORM conform to the VALUE-TYPE. │ │ │ │ -CLHS specifies that the consequences are undefined if any result is │ │ │ │ -not of the declared type, but SBCL treats declarations as assertions │ │ │ │ -as long as SAFETY is at least 2, in which case incorrect type │ │ │ │ -information will result in a runtime type-error instead of leading to │ │ │ │ -eg. heap corruption. This is however expressly non-portable: use │ │ │ │ -CHECK-TYPE instead of THE to catch type-errors at runtime. THE is best │ │ │ │ -considered an optimization tool to inform the compiler about types it │ │ │ │ -is unable to derive from other declared types. │ │ │ │ -LET* ({(var [value]) | var}*) declaration* form* │ │ │ │ -Similar to LET, but the variables are bound sequentially, allowing each VALUE │ │ │ │ -form to reference any of the previous VARS. │ │ │ │ -CATCH tag form* │ │ │ │ -Evaluate TAG and instantiate it as a catcher while the body forms are │ │ │ │ -evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic │ │ │ │ -scope of the body, then control will be transferred to the end of the body and │ │ │ │ -the thrown values will be returned. │ │ │ │ v50ZM(Q;W │ │ │ │ Return a list of all the currently active restarts ordered from most recently │ │ │ │ established to less recently established. If CONDITION is specified, then only │ │ │ │ restarts associated with CONDITION (or with no condition) will be returned. │ │ │ │ YES-OR-NO-P is similar to Y-OR-N-P, except that it clears the │ │ │ │ input buffer, beeps, and uses READ-LINE to get the strings │ │ │ │ YES or NO. │ │ │ │ @@ -31004,16 +31005,14 @@ │ │ │ │ new string COUNT long filled with the fill character. │ │ │ │ Subtract the second and all subsequent arguments from the first; │ │ │ │ or with one argument, negate the first argument. │ │ │ │ Predicate which returns T if logand of integer1 and integer2 is not zero. │ │ │ │ ORIGINAL-EXP │ │ │ │ Evaluate the argument in a null lexical environment, returning the │ │ │ │ result or results. │ │ │ │ -Destructively sort SEQUENCE. PREDICATE should return non-NIL if │ │ │ │ - ARG1 is to precede ARG2. │ │ │ │ *&rt:;*kDAT │ │ │ │ Add all the PACKAGES-TO-USE to the use list for PACKAGE so that the │ │ │ │ external symbols of the used packages are accessible as internal symbols in │ │ │ │ PACKAGE. │ │ │ │ Change the CDR of CONS to X and return the CONS. │ │ │ │ BYTESPEC8 │ │ │ │ Return the size part of the byte specifier bytespec. │ │ │ │ @@ -31273,22 +31272,21 @@ │ │ │ │ whitespace characters and then tries to parse an integer. The │ │ │ │ radix parameter must be between 2 and 36. │ │ │ │ COMMON-LISP1 │ │ │ │ Given a character-object argument, ALPHANUMERICP returns T if the argument │ │ │ │ is either numeric or alphabetic. │ │ │ │ COMMON-LISP │ │ │ │ Is this number zero? │ │ │ │ -Apply PREDICATE to the 0-indexed elements of the sequences, then │ │ │ │ - possibly to those with index 1, and so on. Return the first │ │ │ │ - non-NIL value encountered, or NIL if the end of any sequence is reached. │ │ │ │ -Substitute NEW for subtrees matching OLD. │ │ │ │ -Make and return a new uninterned symbol with the same print name │ │ │ │ - as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound │ │ │ │ - nor fbound and has no properties, else it has a copy of SYMBOL's │ │ │ │ - function, value and property list. │ │ │ │ +DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}* │ │ │ │ + Executes the FORMs once for each symbol in every package with VAR bound │ │ │ │ + to the current symbol. │ │ │ │ +Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return │ │ │ │ + if its list argument is exhausted. Can only be used inside │ │ │ │ + PPRINT-LOGICAL-BLOCK, and only when the LIST argument to │ │ │ │ + PPRINT-LOGICAL-BLOCK is supplied. │ │ │ │ ACCESS-FN │ │ │ │ Syntax like DEFMACRO, but creates a setf expander function. The body │ │ │ │ of the definition must be a form that returns five appropriate values. │ │ │ │ Defines a new package called PACKAGE. Each of OPTIONS should be one of the │ │ │ │ following: │ │ │ │ (USE {package-name}*) │ │ │ │ (EXPORT {symbol-name}*) │ │ │ │ @@ -31321,15 +31319,14 @@ │ │ │ │ of :INHERITED :EXTERNAL :INTERNAL. │ │ │ │ Group some output into a logical block. STREAM-SYMBOL should be either a │ │ │ │ stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer │ │ │ │ control variable *PRINT-LEVEL* is automatically handled. │ │ │ │ CONTEXT0 │ │ │ │ COMMON-LISP │ │ │ │ Pr&nF20ss │ │ │ │ -defining ~A as a method combination │ │ │ │ (RESTART-BIND ({(case-name function {keyword value}*)}*) forms) │ │ │ │ Executes forms in a dynamic context where the given bindings are in │ │ │ │ effect. Users probably want to use RESTART-CASE. A case-name of NIL │ │ │ │ indicates an anonymous restart. When bindings contain the same │ │ │ │ restart name, FIND-RESTART will find the first such binding. │ │ │ │ TYPECASE Keyform {(Type Form*)}* │ │ │ │ Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ @@ -31521,29 +31518,58 @@ │ │ │ │ The first argument is some location holding a number. This number is │ │ │ │ decremented by the second argument, DELTA, which defaults to 1. │ │ │ │ The first argument is some location holding a number. This number is │ │ │ │ incremented by the second argument, DELTA, which defaults to 1. │ │ │ │ The first argument is a byte specifier. The second is any place form │ │ │ │ acceptable to SETF. Replace the specified byte of the number in this │ │ │ │ place with bits from the low-order end of the new value. │ │ │ │ +defining ~A as a method combination │ │ │ │ The form is evaluated with single stepping enabled. Function calls │ │ │ │ outside the lexical scope of the form can be stepped into only if the │ │ │ │ functions in question have been compiled with sufficient DEBUG policy │ │ │ │ to be at least partially steppable. │ │ │ │ Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ -Return the 5th object in a list or NIL if there is no 5th object. │ │ │ │ -COMMON-LISP │ │ │ │ -Return SYMBOL's current bound value. │ │ │ │ -AP`mlxh]x │ │ │ │ -Substitute NEW for subtrees of TREE for which TEST is false. │ │ │ │ -COMMON-LISP │ │ │ │ -Return new integer with newbyte in specified position, newbyte is right justified. │ │ │ │ -CHAR-BAG │ │ │ │ -COMMON-LISP │ │ │ │ +Define a special variable at top level. Declare the variable │ │ │ │ + SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ + value, the old value is not clobbered. The third argument is an optional │ │ │ │ + documentation string for the variable. │ │ │ │ +Cause the iteration to terminate "normally", the same as implicit │ │ │ │ +termination by an iteration driving clause, or by use of WHILE or │ │ │ │ +UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ +collected result will be returned as the value of the LOOP. │ │ │ │ +CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If none of the keys matches then a correctable error is │ │ │ │ + signalled. │ │ │ │ +Bind the reader and printer control variables to values that enable READ │ │ │ │ + to reliably read the results of PRINT. These values are: │ │ │ │ + *PACKAGE* the COMMON-LISP-USER package │ │ │ │ + *PRINT-ARRAY* T │ │ │ │ + *PRINT-BASE* 10 │ │ │ │ + *PRINT-CASE* :UPCASE │ │ │ │ + *PRINT-CIRCLE* NIL │ │ │ │ + *PRINT-ESCAPE* T │ │ │ │ + *PRINT-GENSYM* T │ │ │ │ + *PRINT-LENGTH* NIL │ │ │ │ + *PRINT-LEVEL* NIL │ │ │ │ + *PRINT-LINES* NIL │ │ │ │ + *PRINT-MISER-WIDTH* NIL │ │ │ │ + *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ + *PRINT-PRETTY* NIL │ │ │ │ + *PRINT-RADIX* NIL │ │ │ │ + *PRINT-READABLY* T │ │ │ │ + *PRINT-RIGHT-MARGIN* NIL │ │ │ │ + *READ-BASE* 10 │ │ │ │ + *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ + *READ-EVAL* T │ │ │ │ + *READ-SUPPRESS* NIL │ │ │ │ + *READTABLE* the standard readtable │ │ │ │ + SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ + SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ MACROLET ({(name lambda-list form*)}*) body-form* │ │ │ │ Evaluate the BODY-FORMS in an environment with the specified local macros │ │ │ │ defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style │ │ │ │ destructuring lambda list, and the FORMS evaluate to the expansion. │ │ │ │ RETURN-FROM name value │ │ │ │ Evaluate the VALUE, returning its values from the lexically enclosing │ │ │ │ block NAME. This is constrained to be used only within the dynamic │ │ │ │ @@ -31568,14 +31594,57 @@ │ │ │ │ TAGS, and NIL is returned. If a statement contains a GO to a defined TAG │ │ │ │ within the lexical scope of the form, then control is transferred to the next │ │ │ │ statement following that tag. A TAG must be an integer or a symbol. A │ │ │ │ STATEMENT must be a list. Other objects are illegal within the body. │ │ │ │ EVAL-WHEN (situation*) form* │ │ │ │ Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, │ │ │ │ :LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL). │ │ │ │ +Can STREAM perform input operations? │ │ │ │ +Return true if STREAM is not closed. A default method is provided │ │ │ │ + by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ + called on the stream. │ │ │ │ +VECTOR-SYM │ │ │ │ +DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* │ │ │ │ + Executes the FORMs once for each external symbol in the given PACKAGE with │ │ │ │ + VAR bound to the current symbol. │ │ │ │ +(HANDLER-CASE form { (type ([var]) body) }* ) │ │ │ │ +Execute FORM in a context with handlers established for the condition types. A │ │ │ │ +peculiar property allows type to be :NO-ERROR. If such a clause occurs, and │ │ │ │ +form returns normally, all its values are passed to this clause as if by │ │ │ │ +MULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var │ │ │ │ +specification. │ │ │ │ +Signals an error if the value of TEST-FORM is NIL. Returns NIL. │ │ │ │ + Optional DATUM and ARGUMENTS can be used to change the signaled │ │ │ │ + error condition and are interpreted as in (APPLY #'ERROR DATUM │ │ │ │ + ARGUMENTS). │ │ │ │ + Continuing from the signaled error using the CONTINUE restart will │ │ │ │ + allow the user to alter the values of the SETFable locations │ │ │ │ + specified in PLACES and then start over with TEST-FORM. │ │ │ │ + If TEST-FORM is of the form │ │ │ │ + (FUNCTION ARG*) │ │ │ │ + where FUNCTION is a function (but not a special operator like │ │ │ │ + CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be │ │ │ │ + included in the error report if the assertion fails. │ │ │ │ +Apply PREDICATE to the 0-indexed elements of the sequences, then │ │ │ │ + possibly to those with index 1, and so on. Return the first │ │ │ │ + non-NIL value encountered, or NIL if the end of any sequence is reached. │ │ │ │ +Substitute NEW for subtrees matching OLD. │ │ │ │ +Make and return a new uninterned symbol with the same print name │ │ │ │ + as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound │ │ │ │ + nor fbound and has no properties, else it has a copy of SYMBOL's │ │ │ │ + function, value and property list. │ │ │ │ +Return the 5th object in a list or NIL if there is no 5th object. │ │ │ │ +COMMON-LISP │ │ │ │ +Return SYMBOL's current bound value. │ │ │ │ +AP`mlxh]x │ │ │ │ +Substitute NEW for subtrees of TREE for which TEST is false. │ │ │ │ +COMMON-LISP │ │ │ │ +Return new integer with newbyte in specified position, newbyte is right justified. │ │ │ │ +CHAR-BAG │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the car of the caadr of a list. │ │ │ │ Return a new sequence of all the argument sequences concatenated together │ │ │ │ which shares no structure with the original argument sequences of the │ │ │ │ specified RESULT-TYPE. │ │ │ │ ] ld01nV │ │ │ │ Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, │ │ │ │ @@ -31603,18 +31672,14 @@ │ │ │ │ Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ Coerce the Object to an object of type Output-Type-Spec. │ │ │ │ Exports SYMBOLS from PACKAGE, checking that no name conflicts result. │ │ │ │ Return the cons in ALIST whose car is equal (by a given test or EQL) to │ │ │ │ the ITEM. │ │ │ │ COMMON-LISP0 │ │ │ │ Return SYMBOL's current function definition. Settable with SETF. │ │ │ │ -Can STREAM perform input operations? │ │ │ │ -Return true if STREAM is not closed. A default method is provided │ │ │ │ - by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ - called on the stream. │ │ │ │ COMMON-LISP │ │ │ │ Return T if and only if calling ADJUST-ARRAY on ARRAY will return │ │ │ │ the identical object. │ │ │ │ Destructively return a list with elements which appear but once in LIST1 │ │ │ │ and LIST2. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -31764,15 +31829,14 @@ │ │ │ │ can be used with the ~/.../ format directive. │ │ │ │ Return a floating-point number that has the same sign as │ │ │ │ FLOAT1 and, if FLOAT2 is given, has the same absolute value │ │ │ │ as FLOAT2. │ │ │ │ Like APROPOS, except that it returns a list of the symbols found instead │ │ │ │ of describing them. │ │ │ │ Return a list of all symbols in the system having the specified name. │ │ │ │ -Return a copy of sequence with elements not satisfying PREDICATE removed. │ │ │ │ COMMON-LISP0/ │ │ │ │ Return the car of the caaar of a list. │ │ │ │ Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, │ │ │ │ putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, │ │ │ │ BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is │ │ │ │ created. All the arrays must have the same rank and dimensions. │ │ │ │ PACKAGE-DESIGNATOR SB-KERNEL0 │ │ │ │ @@ -31967,87 +32031,14 @@ │ │ │ │ of the current section, not the start of the line. │ │ │ │ Given two strings, if the first string is lexicographically less than │ │ │ │ the second string, returns the longest common prefix (using char=) │ │ │ │ of the two strings. Otherwise, returns (). │ │ │ │ Return T if the arguments are in strictly non-decreasing alphabetic order. │ │ │ │ Case is ignored. │ │ │ │ Return the denominator of NUMBER, which must be rational. │ │ │ │ -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 CHARACTER │ │ │ │ - :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, │ │ │ │ - :OVERWRITE, :APPEND, :SUPERSEDE or NIL │ │ │ │ - :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL │ │ │ │ - See the manual for details. │ │ │ │ -Attempt to set the element of ARRAY designated by its fill pointer │ │ │ │ - to NEW-ELEMENT, and increment the fill pointer by one. If the fill pointer is │ │ │ │ - too large, NIL is returned, otherwise the index of the pushed element is │ │ │ │ - returned. │ │ │ │ -Use the source pathname to translate the from-wildname's wild and │ │ │ │ -unspecified elements into a completed to-pathname based on the to-wildname. │ │ │ │ -Define a special variable at top level. Declare the variable │ │ │ │ - SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ - value, the old value is not clobbered. The third argument is an optional │ │ │ │ - documentation string for the variable. │ │ │ │ -Cause the iteration to terminate "normally", the same as implicit │ │ │ │ -termination by an iteration driving clause, or by use of WHILE or │ │ │ │ -UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ -collected result will be returned as the value of the LOOP. │ │ │ │ -CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If none of the keys matches then a correctable error is │ │ │ │ - signalled. │ │ │ │ -Bind the reader and printer control variables to values that enable READ │ │ │ │ - to reliably read the results of PRINT. These values are: │ │ │ │ - *PACKAGE* the COMMON-LISP-USER package │ │ │ │ - *PRINT-ARRAY* T │ │ │ │ - *PRINT-BASE* 10 │ │ │ │ - *PRINT-CASE* :UPCASE │ │ │ │ - *PRINT-CIRCLE* NIL │ │ │ │ - *PRINT-ESCAPE* T │ │ │ │ - *PRINT-GENSYM* T │ │ │ │ - *PRINT-LENGTH* NIL │ │ │ │ - *PRINT-LEVEL* NIL │ │ │ │ - *PRINT-LINES* NIL │ │ │ │ - *PRINT-MISER-WIDTH* NIL │ │ │ │ - *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ - *PRINT-PRETTY* NIL │ │ │ │ - *PRINT-RADIX* NIL │ │ │ │ - *PRINT-READABLY* T │ │ │ │ - *PRINT-RIGHT-MARGIN* NIL │ │ │ │ - *READ-BASE* 10 │ │ │ │ - *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ - *READ-EVAL* T │ │ │ │ - *READ-SUPPRESS* NIL │ │ │ │ - *READTABLE* the standard readtable │ │ │ │ - SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ - SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ -VECTOR-SYM │ │ │ │ -DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* │ │ │ │ - Executes the FORMs once for each external symbol in the given PACKAGE with │ │ │ │ - VAR bound to the current symbol. │ │ │ │ -(HANDLER-CASE form { (type ([var]) body) }* ) │ │ │ │ -Execute FORM in a context with handlers established for the condition types. A │ │ │ │ -peculiar property allows type to be :NO-ERROR. If such a clause occurs, and │ │ │ │ -form returns normally, all its values are passed to this clause as if by │ │ │ │ -MULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var │ │ │ │ -specification. │ │ │ │ -Signals an error if the value of TEST-FORM is NIL. Returns NIL. │ │ │ │ - Optional DATUM and ARGUMENTS can be used to change the signaled │ │ │ │ - error condition and are interpreted as in (APPLY #'ERROR DATUM │ │ │ │ - ARGUMENTS). │ │ │ │ - Continuing from the signaled error using the CONTINUE restart will │ │ │ │ - allow the user to alter the values of the SETFable locations │ │ │ │ - specified in PLACES and then start over with TEST-FORM. │ │ │ │ - If TEST-FORM is of the form │ │ │ │ - (FUNCTION ARG*) │ │ │ │ - where FUNCTION is a function (but not a special operator like │ │ │ │ - CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be │ │ │ │ - included in the error report if the assertion fails. │ │ │ │ Define a new type, with syntax like DEFMACRO. │ │ │ │ Execute FORMS handling ERROR conditions, returning the result of the last │ │ │ │ form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled. │ │ │ │ Evaluates the BODY in a dynamic environment where the restarts in the list │ │ │ │ RESTARTS-FORM are associated with the condition returned by CONDITION-FORM. │ │ │ │ This allows FIND-RESTART, etc., to recognize restarts that are not related │ │ │ │ to the error currently being debugged. See also RESTART-CASE. │ │ │ │ @@ -32058,18 +32049,14 @@ │ │ │ │ Associates a SETF update function or macro with the specified access │ │ │ │ function or macro. The format is complex. See the manual for details. │ │ │ │ Creates a new read-modify-write macro like PUSH or INCF. │ │ │ │ MORE-ARG │ │ │ │ The first argument is a byte specifier. The second is any place form │ │ │ │ acceptable to SETF. Replaces the specified byte of the number in this place │ │ │ │ with bits from the corresponding position in the new value. │ │ │ │ -:INITIAL-ELEMENT ~S is not of type ~//. │ │ │ │ -Static arrays of type ~// not supported. │ │ │ │ -:INITIAL-CONTENTS contains elements not of type ~//. │ │ │ │ -The ~(~A~) ~// has been deprecated as of ~@[~A ~]version ~A.~@[ │ │ │ │ DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ Iteration construct. Each Var is initialized sequentially (like LET*) to the │ │ │ │ value of the specified Init form. On subsequent iterations, the Vars are │ │ │ │ sequentially assigned the value of the Step form (if any). The Test is │ │ │ │ evaluated before each evaluation of the body Forms. When the Test is true, │ │ │ │ the Exit-Forms are evaluated as a PROGN, with the result being the value │ │ │ │ of the DO. A block named NIL is established around the entire expansion, │ │ │ │ @@ -32098,14 +32085,79 @@ │ │ │ │ Return the next element from LIST argument to the closest enclosing │ │ │ │ use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH* │ │ │ │ and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK. │ │ │ │ If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing │ │ │ │ is popped, but the *PRINT-LENGTH* testing still happens. │ │ │ │ LAMBDA-LIST8 │ │ │ │ QUALIFIERS │ │ │ │ +ETYPECASE Keyform {(Type Form*)}* │ │ │ │ + Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ + is true. If no form is satisfied then an error is signalled. │ │ │ │ +qlC'XUV4I │ │ │ │ +Execute FORM and print timing information on *TRACE-OUTPUT*. │ │ │ │ +On some hardware platforms estimated processor cycle counts are │ │ │ │ +included in this output; this number is slightly inflated, since it │ │ │ │ +includes the pipeline involved in reading the cycle counter -- │ │ │ │ +executing (TIME NIL) a few times will give you an idea of the │ │ │ │ +overhead, and its variance. The cycle counters are also per processor, │ │ │ │ +not per thread: if multiple threads are running on the same processor, │ │ │ │ +the reported counts will include cycles taken up by all threads │ │ │ │ +running on the processor where TIME was executed. Furthermore, if the │ │ │ │ +operating system migrates the thread to another processor between │ │ │ │ +reads of the cycle counter, the results will be completely bogus. │ │ │ │ +Finally, the counter is cycle counter, incremented by the hardware │ │ │ │ +even when the process is halted -- which is to say that cycles pass │ │ │ │ +normally during operations like SLEEP. │ │ │ │ +ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If none of the keys matches then an error is signalled. │ │ │ │ +(WITH-SIMPLE-RESTART (restart-name format-string format-arguments) │ │ │ │ + body) │ │ │ │ + If restart-name is not invoked, then all values returned by forms are │ │ │ │ + returned. If control is transferred to this restart, it immediately │ │ │ │ + returns the values NIL and T. │ │ │ │ +DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* │ │ │ │ + Define NAME as a condition type. This new type inherits slots and its │ │ │ │ + report function from the specified PARENT-TYPEs. A slot spec is a list of: │ │ │ │ + (slot-name :reader :initarg {Option Value}* │ │ │ │ + The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION │ │ │ │ + and :TYPE and the overall options :DEFAULT-INITARGS and │ │ │ │ + [type] :DOCUMENTATION are also allowed. │ │ │ │ + The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either │ │ │ │ + a string or a two-argument lambda or function name. If a function, the │ │ │ │ + function is called with the condition and stream to report the condition. │ │ │ │ + If a string, the string is printed. │ │ │ │ + Condition types are classes, but (as allowed by ANSI and not as described in │ │ │ │ + CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and │ │ │ │ + SLOT-VALUE may not be used on condition objects. │ │ │ │ +DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* │ │ │ │ + Executes the FORMs at least once for each symbol accessible in the given │ │ │ │ + PACKAGE with VAR bound to the current symbol. │ │ │ │ +(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*) │ │ │ │ + The form is evaluated in a dynamic context where the clauses have │ │ │ │ + special meanings as points to which control may be transferred (see │ │ │ │ + INVOKE-RESTART). When clauses contain the same case-name, │ │ │ │ + FIND-RESTART will find the first such clause. If form is a call to │ │ │ │ + SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the │ │ │ │ + signalled condition will be associated with the new restarts. │ │ │ │ +>)PW:`5w │ │ │ │ +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 CHARACTER │ │ │ │ + :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, │ │ │ │ + :OVERWRITE, :APPEND, :SUPERSEDE or NIL │ │ │ │ + :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL │ │ │ │ + See the manual for details. │ │ │ │ +Attempt to set the element of ARRAY designated by its fill pointer │ │ │ │ + to NEW-ELEMENT, and increment the fill pointer by one. If the fill pointer is │ │ │ │ + too large, NIL is returned, otherwise the index of the pushed element is │ │ │ │ + returned. │ │ │ │ +Use the source pathname to translate the from-wildname's wild and │ │ │ │ +unspecified elements into a completed to-pathname based on the to-wildname. │ │ │ │ Return a stream which takes its input from each of the streams in turn, │ │ │ │ going on to the next at EOF. │ │ │ │ Given two strings (string1 and string2), and optional integers start1, │ │ │ │ start2, end1 and end2, compares characters in string1 to characters in │ │ │ │ string2 (using char-equal). │ │ │ │ COMMON-LISP │ │ │ │ Return the number of dimensions of ARRAY. │ │ │ │ @@ -32122,75 +32174,31 @@ │ │ │ │ Rounds number (or number/divisor) to nearest integer. │ │ │ │ The second returned value is the remainder. │ │ │ │ Return T if all of the arguments are the same character. │ │ │ │ Case is ignored. │ │ │ │ Bitwise OR (LOGNOT INTEGER1) with INTEGER2. │ │ │ │ Return T if the arguments are in strictly decreasing alphabetic order. │ │ │ │ Case is ignored. │ │ │ │ -Backtrace for: ~S │ │ │ │ -Skip printing frame ~S │ │ │ │ -while printing frame ~S. The partial output is: ~S │ │ │ │ -non-FIXNUM non-NULL location in cell: ~S │ │ │ │ -updating obsolete instance │ │ │ │ -~S cannot handle the second argument ~S. │ │ │ │ -failed to resolve home directory for Unix uid=~S │ │ │ │ -select(2) │ │ │ │ -Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ -4E4i4<4`4 │ │ │ │ -*9@9d979[9. │ │ │ │ -Error calling tmpfile(): ~a │ │ │ │ -found no match for Unix uid=~S │ │ │ │ -~S~:[~;~:*~S~] │ │ │ │ -~S at ~S │ │ │ │ -~@[~S ~]~[free~;taken~;contested~:;err~] owner=~X │ │ │ │ -waiting on: │ │ │ │ -~@[tid=~D ~]~@[~S ~]~:[~{~I~A~^~2I~_ ~}~_~;~A~:[ no values~; values: ~:*~{~S~^, ~}~]~] │ │ │ │ -waiting on a mutex with a timeout │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -Cannot allocate an instance of ~S. │ │ │ │ -The object file ~A is~@ │ │ │ │ - older than the presumed source:~% ~A. │ │ │ │ -load object file │ │ │ │ -load source file │ │ │ │ -attempt to load an empty FASL file: │ │ │ │ - ^'!65 W │ │ │ │ ->5 Q/F │ │ │ │ -$@ 5 \!#6 5 n@ │ │ │ │ -$; 5 [ │ │ │ │ -Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ -or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ +Close the given STREAM. No more I/O may be performed, but │ │ │ │ + inquiries may still be made. If :ABORT is true, an attempt is made │ │ │ │ + to clean up the side effects of having created the stream. │ │ │ │ +Can STREAM perform output operations? │ │ │ │ +Return the stream line length or NIL. │ │ │ │ +SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ LOCALLY declaration* form* │ │ │ │ Sequentially evaluate the FORMS in a lexical environment where the │ │ │ │ DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are │ │ │ │ also processed as top level forms. │ │ │ │ Specifies that the values returned by FORM conform to the │ │ │ │ VALUE-TYPE, and causes the compiler to trust this information │ │ │ │ unconditionally. │ │ │ │ Consequences are undefined if any result is not of the declared type │ │ │ │ -- typical symptoms including memory corruptions. Use with great │ │ │ │ -SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ -Close the given STREAM. No more I/O may be performed, but │ │ │ │ - inquiries may still be made. If :ABORT is true, an attempt is made │ │ │ │ - to clean up the side effects of having created the stream. │ │ │ │ -Can STREAM perform output operations? │ │ │ │ -Return the stream line length or NIL. │ │ │ │ -This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ - optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ - The string argument is returned. The default method provided by │ │ │ │ - FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ - STREAM-WRITE-CHAR. │ │ │ │ -Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ - method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ -Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ - returns the integer as the result. │ │ │ │ -This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ - STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ - define their own method since it will usually be trivial and will │ │ │ │ - always be more efficient than the default method. │ │ │ │ +Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ +or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ Same as TRUNCATE, but returns first value as a float. │ │ │ │ Return the arc sine of NUMBER. │ │ │ │ If form is a macro (or symbol macro), expand it once. Return two values, │ │ │ │ the expanded form and a T-or-NIL flag indicating whether the form was, in │ │ │ │ fact, a macro. ENV is the lexical environment to expand in, which defaults │ │ │ │ to the null environment. │ │ │ │ COMMON-LISP │ │ │ │ @@ -32882,14 +32890,28 @@ │ │ │ │ :VALUE, :KEY-AND-VALUE, :KEY-OR-VALUE. │ │ │ │ Number of bytes that can be allocated to GENERATION before that │ │ │ │ generation is considered for garbage collection. This value is meaningless for │ │ │ │ generation 0 (the nursery): see BYTES-CONSED-BETWEEN-GCS instead. Default is │ │ │ │ 5% of the dynamic space size divided by the number of non-nursery generations. │ │ │ │ Can be assigned to using SETF. Available on GENCGC platforms only. │ │ │ │ Experimental: interface subject to change. │ │ │ │ +:INITIAL-ELEMENT ~S is not of type ~//. │ │ │ │ +Static arrays of type ~// not supported. │ │ │ │ +:INITIAL-CONTENTS contains elements not of type ~//. │ │ │ │ +The ~(~A~) ~// has been deprecated as of ~@[~A ~]version ~A.~@[ │ │ │ │ +~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ + ~// │ │ │ │ +illegal dotted lambda list: ~// │ │ │ │ +&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ +expected lambda list keyword at ~S in: ~// │ │ │ │ +~S and ~S are mutually exclusive: ~// │ │ │ │ +repeated ~S in lambda list: ~// │ │ │ │ +~A is not allowed in ~A: ~// │ │ │ │ +suspicious ~A ~S in lambda list: ~//. │ │ │ │ +expecting variable after ~A in: ~// │ │ │ │ Return the name of TIMER. │ │ │ │ Close all streams connected to PROCESS, stop maintaining the │ │ │ │ status slot. After PROCESS-CLOSE, PROCESS-ALIVE-P and │ │ │ │ PROCESS-EXIT-CODE can return stale information about a process, so │ │ │ │ should not be used. │ │ │ │ COMMON-LISP │ │ │ │ Locks PACKAGE and returns T. Has no effect if PACKAGE was already │ │ │ │ @@ -32967,65 +32989,14 @@ │ │ │ │ Returns T if READTABLE normalizes symbols to NFKC, and NIL otherwise. │ │ │ │ The READTABLE-NORMALIZATION of the standard readtable is T. │ │ │ │ Cancel TIMER. Once this function returns it is guaranteed that │ │ │ │ TIMER shall not be triggered again and there are no unfinished │ │ │ │ triggers. │ │ │ │ UYPO&*1G │ │ │ │ q#E}=Lp~=f │ │ │ │ -ETYPECASE Keyform {(Type Form*)}* │ │ │ │ - Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ - is true. If no form is satisfied then an error is signalled. │ │ │ │ -qlC'XUV4I │ │ │ │ -Execute FORM and print timing information on *TRACE-OUTPUT*. │ │ │ │ -On some hardware platforms estimated processor cycle counts are │ │ │ │ -included in this output; this number is slightly inflated, since it │ │ │ │ -includes the pipeline involved in reading the cycle counter -- │ │ │ │ -executing (TIME NIL) a few times will give you an idea of the │ │ │ │ -overhead, and its variance. The cycle counters are also per processor, │ │ │ │ -not per thread: if multiple threads are running on the same processor, │ │ │ │ -the reported counts will include cycles taken up by all threads │ │ │ │ -running on the processor where TIME was executed. Furthermore, if the │ │ │ │ -operating system migrates the thread to another processor between │ │ │ │ -reads of the cycle counter, the results will be completely bogus. │ │ │ │ -Finally, the counter is cycle counter, incremented by the hardware │ │ │ │ -even when the process is halted -- which is to say that cycles pass │ │ │ │ -normally during operations like SLEEP. │ │ │ │ -ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If none of the keys matches then an error is signalled. │ │ │ │ -(WITH-SIMPLE-RESTART (restart-name format-string format-arguments) │ │ │ │ - body) │ │ │ │ - If restart-name is not invoked, then all values returned by forms are │ │ │ │ - returned. If control is transferred to this restart, it immediately │ │ │ │ - returns the values NIL and T. │ │ │ │ -DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* │ │ │ │ - Define NAME as a condition type. This new type inherits slots and its │ │ │ │ - report function from the specified PARENT-TYPEs. A slot spec is a list of: │ │ │ │ - (slot-name :reader :initarg {Option Value}* │ │ │ │ - The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION │ │ │ │ - and :TYPE and the overall options :DEFAULT-INITARGS and │ │ │ │ - [type] :DOCUMENTATION are also allowed. │ │ │ │ - The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either │ │ │ │ - a string or a two-argument lambda or function name. If a function, the │ │ │ │ - function is called with the condition and stream to report the condition. │ │ │ │ - If a string, the string is printed. │ │ │ │ - Condition types are classes, but (as allowed by ANSI and not as described in │ │ │ │ - CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and │ │ │ │ - SLOT-VALUE may not be used on condition objects. │ │ │ │ -DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* │ │ │ │ - Executes the FORMs at least once for each symbol accessible in the given │ │ │ │ - PACKAGE with VAR bound to the current symbol. │ │ │ │ -(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*) │ │ │ │ - The form is evaluated in a dynamic context where the clauses have │ │ │ │ - special meanings as points to which control may be transferred (see │ │ │ │ - INVOKE-RESTART). When clauses contain the same case-name, │ │ │ │ - FIND-RESTART will find the first such clause. If form is a call to │ │ │ │ - SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the │ │ │ │ - signalled condition will be associated with the new restarts. │ │ │ │ ->)PW:`5w │ │ │ │ Atomically decrements PLACE by DIFF, and returns the value of PLACE before │ │ │ │ the decrement. │ │ │ │ PLACE must access one of the following: │ │ │ │ - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 32) │ │ │ │ or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) │ │ │ │ The type SB-EXT:WORD can be used for these purposes. │ │ │ │ - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ @@ -33209,25 +33180,27 @@ │ │ │ │ specificity, with the most specific form first. This allows the │ │ │ │ compiler to try and obtain a source path using subsequent elements of │ │ │ │ FORMS if it fails for the first one. │ │ │ │ Indicating the processing of sub-forms lets the compiler report │ │ │ │ precise source locations in case conditions are signaled during the │ │ │ │ execution of BODY. │ │ │ │ NOTE: This interface is experimental and subject to change. │ │ │ │ -SPLICE8^ │ │ │ │ -(lBUY1$9 │ │ │ │ -Define function names of the form of a list headed by SYMBOL to be │ │ │ │ -a legal function name, subject to restrictions imposed by BODY. BODY │ │ │ │ -is evaluated with VAR bound to the form required to check, and should │ │ │ │ -return two values: the first value is a generalized boolean indicating │ │ │ │ -legality, and the second a symbol for use as a BLOCK name or similar │ │ │ │ -situations. │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -{DH(Rj~H │ │ │ │ +This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ + optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ + The string argument is returned. The default method provided by │ │ │ │ + FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ + STREAM-WRITE-CHAR. │ │ │ │ +Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ + method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ +Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ + returns the integer as the result. │ │ │ │ +This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ + STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ + define their own method since it will usually be trivial and will │ │ │ │ + always be more efficient than the default method. │ │ │ │ This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. │ │ │ │ It returns either a character or :EOF. The default method calls │ │ │ │ STREAM-READ-CHAR and STREAM-UNREAD-CHAR. │ │ │ │ This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ Is STREAM known to be positioned at the beginning of a line? │ │ │ │ It is permissible for an implementation to always return │ │ │ │ NIL. This is used in the implementation of FRESH-LINE. Note that │ │ │ │ @@ -33262,15 +33235,14 @@ │ │ │ │ This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. │ │ │ │ The default method does nothing. │ │ │ │ This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ Read one character from the stream. Return either a │ │ │ │ character object, or the symbol :EOF if the stream is at end-of-file. │ │ │ │ Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a │ │ │ │ method for this function. │ │ │ │ -NEW-INFO │ │ │ │ This is used to implement READ-CHAR-NO-HANG. It returns either a │ │ │ │ character, or NIL if no input is currently available, or :EOF if │ │ │ │ end-of-file is reached. The default method provided by │ │ │ │ FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this │ │ │ │ is sufficient for file streams, but interactive streams should define │ │ │ │ their own method. │ │ │ │ Attempts to ensure that all output sent to the Stream has reached │ │ │ │ @@ -33279,20 +33251,32 @@ │ │ │ │ Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ if the stream is at end-of-file. │ │ │ │ Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. │ │ │ │ Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM │ │ │ │ must define a method for this function. │ │ │ │ Attempts to force any buffered output to be sent. Implements │ │ │ │ FORCE-OUTPUT. The default method does nothing. │ │ │ │ +SPLICE8^ │ │ │ │ +(lBUY1$9 │ │ │ │ +Define function names of the form of a list headed by SYMBOL to be │ │ │ │ +a legal function name, subject to restrictions imposed by BODY. BODY │ │ │ │ +is evaluated with VAR bound to the form required to check, and should │ │ │ │ +return two values: the first value is a generalized boolean indicating │ │ │ │ +legality, and the second a symbol for use as a BLOCK name or similar │ │ │ │ +situations. │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +{DH(Rj~H │ │ │ │ c8Pos03iG# │ │ │ │ Allocate vector of LENGTH elements in static space. Only allocation │ │ │ │ of specialized arrays is supported. │ │ │ │ Returns the value of the constant FORM in ENVIRONMENT. Behaviour │ │ │ │ is undefined unless CONSTANTP has been first used to determine the │ │ │ │ constantness of the FORM in ENVIRONMENT. │ │ │ │ +NEW-INFO │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP0 │ │ │ │ l|2f{<=id │ │ │ │ 7WIGzrg? │ │ │ │ This function returns a list representing the state of the floating │ │ │ │ point modes. The list is in the same format as the &KEY arguments to │ │ │ │ SET-FLOATING-POINT-MODES, i.e. │ │ │ │ @@ -33360,24 +33344,14 @@ │ │ │ │ 8FF^FA^"3u │ │ │ │ COMMON-LISP │ │ │ │ POSSIBLY-LOGICAL-PATHNAME0% │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP03 │ │ │ │ -~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ - ~// │ │ │ │ -illegal dotted lambda list: ~// │ │ │ │ -&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ -expected lambda list keyword at ~S in: ~// │ │ │ │ -~S and ~S are mutually exclusive: ~// │ │ │ │ -repeated ~S in lambda list: ~// │ │ │ │ -~A is not allowed in ~A: ~// │ │ │ │ -suspicious ~A ~S in lambda list: ~//. │ │ │ │ -expecting variable after ~A in: ~// │ │ │ │ OPTIONAL-ARGS │ │ │ │ MORE-ARG │ │ │ │ PROMISE0 │ │ │ │ MAYBE-PACKAGE │ │ │ │ If CAR is eq to the car of OLD-CONS and CDR is eq to the CDR, return │ │ │ │ OLD-CONS, otherwise return (cons CAR CDR). │ │ │ │ a macro lambda list │ │ │ │ @@ -33437,33 +33411,14 @@ │ │ │ │ Unless OVERRIDE is true, existing deadlines can only be restricted, │ │ │ │ not extended. Deadlines are per thread: children are unaffected by │ │ │ │ their parent's deadlines. │ │ │ │ Experimental. │ │ │ │ Arrange with the garbage collector that OBJECTS will not be moved in memory │ │ │ │ for the duration of BODY. Useful for e.g. foreign calls where another thread │ │ │ │ may trigger garbage collection. │ │ │ │ -WITHOUT-GCING-BODY │ │ │ │ -Executes the forms in the body without doing a garbage collection. It │ │ │ │ -inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ -upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ -Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ -enabled in this thread. │ │ │ │ -Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ -SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ -Should be used with great care, and not at all in multithreaded application │ │ │ │ -code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ -held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ -stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ -system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ -locks, application code can never be certain that this invariant is │ │ │ │ -maintained. │ │ │ │ -Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ -Establish a handler with SB-SYS:ADD-FD-HANDLER for the duration of BODY. │ │ │ │ - DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to │ │ │ │ - use, and FUNCTION is the function to call whenever FD is usable. │ │ │ │ COMMON-LISP │ │ │ │ Return the position of the first element EQ to ITEM. │ │ │ │ COMMON-LISP │ │ │ │ EXTERNAL-FORMAT │ │ │ │ Returns the address of the foreign symbol NAME, or NIL. Does not enter the │ │ │ │ symbol in the linkage table, and never returns an address in the linkage-table. │ │ │ │ SB-ALIEN │ │ │ │ @@ -33496,14 +33451,33 @@ │ │ │ │ invoke it with SECONDS as argument (deferring the deadline by that many │ │ │ │ seconds.) Otherwise return NIL if the restart is not found. │ │ │ │ Remove any handlers referring to FD. This should only be used when attempting │ │ │ │ to recover from a detected inconsistency. │ │ │ │ HANDLER0 │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ +WITHOUT-GCING-BODY │ │ │ │ +Executes the forms in the body without doing a garbage collection. It │ │ │ │ +inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ +upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ +Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ +enabled in this thread. │ │ │ │ +Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ +SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ +Should be used with great care, and not at all in multithreaded application │ │ │ │ +code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ +held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ +stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ +system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ +locks, application code can never be certain that this invariant is │ │ │ │ +maintained. │ │ │ │ +Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ +Establish a handler with SB-SYS:ADD-FD-HANDLER for the duration of BODY. │ │ │ │ + DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to │ │ │ │ + use, and FUNCTION is the function to call whenever FD is usable. │ │ │ │ Executes BODY with deferrable interrupts conditionally enabled. If there │ │ │ │ are pending interrupts they take effect prior to executing BODY. │ │ │ │ As interrupts are normally allowed WITH-INTERRUPTS only makes sense if there │ │ │ │ is an outer WITHOUT-INTERRUPTS with a corresponding ALLOW-WITH-INTERRUPTS: │ │ │ │ interrupts are not enabled if any outer WITHOUT-INTERRUPTS is not accompanied │ │ │ │ by ALLOW-WITH-INTERRUPTS. │ │ │ │ OUTER-ALLOW-WITH-INRUPTS │ │ │ │ @@ -33530,16 +33504,14 @@ │ │ │ │ ;; The body of the lambda would be executed with WITH-INTERRUPTS allowed │ │ │ │ ;; regardless of the interrupt policy in effect when it is called. │ │ │ │ (lambda () (allow-with-interrupts ...))) │ │ │ │ (without-interrupts │ │ │ │ ;; The body of the lambda would be executed with interrupts enabled │ │ │ │ ;; regardless of the interrupt policy in effect when it is called. │ │ │ │ (lambda () (with-local-interrupts ...))) │ │ │ │ -COMMON-LISP0 │ │ │ │ -8(PW:0uUc │ │ │ │ optimize away possible call to FDEFINITION at runtime │ │ │ │ COMMON-LISP │ │ │ │ METHOD-CELL │ │ │ │ MORE-ARG │ │ │ │ f&j"$l$SJ2; │ │ │ │ COMMON-LISP │ │ │ │ SLOT-NAME │ │ │ │ @@ -33547,23 +33519,65 @@ │ │ │ │ SLOT-NAME │ │ │ │ SLOT-NAME │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ @,$Gq[rNPSg │ │ │ │ .ANONYMOUS. │ │ │ │ +COMMON-LISP │ │ │ │ +Tests if STRING is normalized to FORM │ │ │ │ + NODE-HASH │ │ │ │ + NODE-HASH │ │ │ │ + NODE-HASH │ │ │ │ +SO-DATA0 │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ +0)pO:VUU │ │ │ │ +SIGNED-IMM-BYTE.PREFILTER │ │ │ │ +SIGNED-IMM-DATA.PREFILTER │ │ │ │ +ACCUM.PRINTER │ │ │ │ +COMMON-LISP │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +NUMBER-MATCHABLE-P8 │ │ │ │ +ONLY-INITIAL-ENTRIES0 │ │ │ │ +COMMON-LISP │ │ │ │ +MNEMONIC0 │ │ │ │ +OPERANDS │ │ │ │ SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ 5y5C9b:8;?< │ │ │ │ AJBDC8DnE{FXG │ │ │ │ SYS:SRC;PCL;WRAPPER.LISP │ │ │ │ +WRAPPER3 │ │ │ │ SYS:SRC;PCL;DLISP3.LISP │ │ │ │ SYS:SRC;CODE;SETF.LISP │ │ │ │ -WRAPPER3 │ │ │ │ NpPRQ/X Y%Z │ │ │ │ 1.0.56.55 │ │ │ │ +found no match for Unix uid=~S │ │ │ │ +~S~:[~;~:*~S~] │ │ │ │ +~S at ~S │ │ │ │ +~@[~S ~]~[free~;taken~;contested~:;err~] owner=~X │ │ │ │ +waiting on: │ │ │ │ +~@[tid=~D ~]~@[~S ~]~:[~{~I~A~^~2I~_ ~}~_~;~A~:[ no values~; values: ~:*~{~S~^, ~}~]~] │ │ │ │ +waiting on a mutex with a timeout │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +Cannot allocate an instance of ~S. │ │ │ │ +Got to T branch in ~S │ │ │ │ +The object file ~A is~@ │ │ │ │ + older than the presumed source:~% ~A. │ │ │ │ +load object file │ │ │ │ +load source file │ │ │ │ +attempt to load an empty FASL file: │ │ │ │ + ^'!65 W │ │ │ │ +>5 Q/F │ │ │ │ +$@ 5 \!#6 5 n@ │ │ │ │ +$; 5 [ │ │ │ │ +3:@@0E&}X3 │ │ │ │ +3:@@0V"&}X3 │ │ │ │ +3:@@0E&}["& │ │ │ │ SYS:SRC;PCL;ENV.LISP │ │ │ │ Return a type specifier for SPECIALIZER, a non-parsed specializer │ │ │ │ form or a SPECIALIZER instance. │ │ │ │ More specifically, SPECIALIZER can be │ │ │ │ * a non-parsed specializer form such as │ │ │ │ * a symbol naming a class │ │ │ │ * a list of the form (eql OBJECT) │ │ │ │ @@ -33591,63 +33605,59 @@ │ │ │ │ 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. │ │ │ │ Replaces the element at position INDEX of SEQUENCE with NEW-VALUE │ │ │ │ and returns NEW-VALUE or signals a PROTOCOL-UNIMPLEMENTED error if │ │ │ │ the sequence protocol is not implemented for the class of │ │ │ │ SEQUENCE. │ │ │ │ -3:@@0E&}X3 │ │ │ │ -3:@@0V"&}X3 │ │ │ │ -3:@@0E&}["& │ │ │ │ -UbQgg`mZ │ │ │ │ -result type unsuitable │ │ │ │ -RESULT-TYPE argument not constant │ │ │ │ -can't analyze sequence type relationship │ │ │ │ -/ X(&/&a6 │ │ │ │ Returns a freshly allocated sequence of length LENGTH and of the │ │ │ │ same class as SEQUENCE. Elements of the new sequence are │ │ │ │ initialized to INITIAL-ELEMENT, if supplied, initialized to │ │ │ │ INITIAL-CONTENTS if supplied, or undefined if neither is supplied. │ │ │ │ Signals a PROTOCOL-UNIMPLEMENTED error if the sequence protocol is │ │ │ │ not implemented for the class of SEQUENCE. │ │ │ │ -COMMON-LISP │ │ │ │ -Tests if STRING is normalized to FORM │ │ │ │ - NODE-HASH │ │ │ │ - NODE-HASH │ │ │ │ - NODE-HASH │ │ │ │ -SO-DATA0 │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ +UbQgg`mZ │ │ │ │ +result type unsuitable │ │ │ │ +RESULT-TYPE argument not constant │ │ │ │ +can't analyze sequence type relationship │ │ │ │ +/ X(&/&a6 │ │ │ │ .++...."G │ │ │ │ +(((+++" │ │ │ │ gc_card_mark │ │ │ │ , 5s(&T"# │ │ │ │ -0)pO:VUU │ │ │ │ -SIGNED-IMM-BYTE.PREFILTER │ │ │ │ -SIGNED-IMM-DATA.PREFILTER │ │ │ │ -ACCUM.PRINTER │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -NUMBER-MATCHABLE-P8 │ │ │ │ -ONLY-INITIAL-ENTRIES0 │ │ │ │ -COMMON-LISP │ │ │ │ -MNEMONIC0 │ │ │ │ -OPERANDS │ │ │ │ +WR^Wgh|\ │ │ │ │ +non-trivial :KEY or :TEST │ │ │ │ +5%,.($(> │ │ │ │ + 1`%&T"# │ │ │ │ + 5[%&U"# │ │ │ │ ++(((+++" │ │ │ │ +0 c++++" │ │ │ │ + 5c%&T"# │ │ │ │ +second argument type too vague │ │ │ │ +cerror trap │ │ │ │ +function end breakpoint trap │ │ │ │ +halt trap │ │ │ │ +pending interrupt trap │ │ │ │ +breakpoint trap │ │ │ │ +SYS:SRC;COMPILER;X86;MOVE.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;TYPE-VOPS.LISP │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/dumper-PTGsyz2X.lisp │ │ │ │ +ARGS-MINIMAL │ │ │ │ (p"dD<07 │ │ │ │ -kyHSeSKj │ │ │ │ +"{BD/7\, │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -"{BD/7\, │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NODE-DATA8 │ │ │ │ NODE-KEY │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Convert a LIST into hash-table that has the same elements when viewed as a set, │ │ │ │ up to the given equality TEST │ │ │ │ +kyHSeSKj │ │ │ │ REST-ARG │ │ │ │ pathname TYPE for lisp FASt Loading files │ │ │ │ MACRO-ENVIRONMENT8 │ │ │ │ SOURCE-CODE │ │ │ │ UNIVERSE0 │ │ │ │ GENERATOR8 │ │ │ │ GENERATOR-LAMBDA0 │ │ │ │ @@ -33669,59 +33679,28 @@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ Emit an alignment restriction to the current segment. │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ Do any final processing of SEGMENT and return the total number of bytes │ │ │ │ covered by this segment. │ │ │ │ -WR^Wgh|\ │ │ │ │ -non-trivial :KEY or :TEST │ │ │ │ -5%,.($(> │ │ │ │ - 1`%&T"# │ │ │ │ - 5[%&U"# │ │ │ │ -+(((+++" │ │ │ │ -0 c++++" │ │ │ │ - 5c%&T"# │ │ │ │ -second argument type too vague │ │ │ │ -cerror trap │ │ │ │ -function end breakpoint trap │ │ │ │ -halt trap │ │ │ │ -pending interrupt trap │ │ │ │ -breakpoint trap │ │ │ │ -(~:[~;*~]~S ~S) │ │ │ │ -*7 e8B │ │ │ │ -&7 e8B ) │ │ │ │ -You can't change the class of ~S to ~S │ │ │ │ -because it isn't already an instance with metaclass ~S. │ │ │ │ -#X~X..~X[~W]~:[ (#X~X)~;~*~]~@[ in ~S~] │ │ │ │ -&7 e8E )Sm │ │ │ │ - │ │ │ │ -emitter=~S │ │ │ │ -, depth=~W │ │ │ │ -*7 e8E │ │ │ │ -(deleted) │ │ │ │ -~A:~A ~W │ │ │ │ -&7 e8B 4 │ │ │ │ -Store and return a value as the slot-value. │ │ │ │ -Return a value as the slot-value. │ │ │ │ -&7 e8B 8 │ │ │ │ -hash-table │ │ │ │ -!T#O-K$D;N#G(? │ │ │ │ -+4+G("%7 │ │ │ │ -displaced │ │ │ │ -(VECTOR │ │ │ │ -) of length │ │ │ │ -length mismatch in ~S │ │ │ │ -supplied both ~S and ~S to ~S │ │ │ │ -~@[(ID=~d) ~]for ~S~@[, INVALID=~S~] │ │ │ │ -SYS:SRC;COMPILER;X86;MOVE.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;TYPE-VOPS.LISP │ │ │ │ -SYS:SRC;COMPILER;VMDEF.LISP │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/dumper-PTGsyz2X.lisp │ │ │ │ -ARGS-MINIMAL │ │ │ │ +COMMON-LISP │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP0 │ │ │ │ +CODE-OBJ │ │ │ │ + DEBUG-FUN │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +BREAKPOINT8 │ │ │ │ +Execute BODY (as a progn) with DEST as the current section or segment. │ │ │ │ +Execute BODY (as a PROGN) without scheduling any of the instructions │ │ │ │ + generated inside it. This is not protected by UNWIND-PROTECT, so │ │ │ │ + DO NOT use THROW or RETURN-FROM to escape from it. │ │ │ │ +Emit the specified instruction to the current segment. │ │ │ │ + SEMAPHORE82 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ SYS:SRC;CODE;SOLIST.LISP │ │ │ │ The debug prompt is square brackets, with number(s) indicating the current │ │ │ │ control stack level and, if you've entered the debugger recursively, how │ │ │ │ deeply recursed you are. │ │ │ │ Any command -- including the name of a restart -- may be uniquely abbreviated. │ │ │ │ The debugger rebinds various special variables for controlling i/o, sometimes │ │ │ │ to defaults (much like WITH-STANDARD-IO-SYNTAX does) and sometimes to │ │ │ │ @@ -33781,94 +33760,58 @@ │ │ │ │ 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.) │ │ │ │ -SYS:SRC;PCL;FSC.LISP │ │ │ │ -COMMON-LISP │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP0 │ │ │ │ -CODE-OBJ │ │ │ │ - DEBUG-FUN │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -BREAKPOINT8 │ │ │ │ - SEMAPHORE82 │ │ │ │ -Execute BODY (as a progn) with DEST as the current section or segment. │ │ │ │ -Execute BODY (as a PROGN) without scheduling any of the instructions │ │ │ │ - generated inside it. This is not protected by UNWIND-PROTECT, so │ │ │ │ - DO NOT use THROW or RETURN-FROM to escape from it. │ │ │ │ -Emit the specified instruction to the current segment. │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -1)Fpl]ai │ │ │ │ - NEW-VALUE0 │ │ │ │ -Takes an object and a location holding a list. Conses the object onto │ │ │ │ - the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ -The argument is a location holding a list. Pops one item off the front │ │ │ │ - of the list and returns it. │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ -COMMON-LISP8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP8 │ │ │ │ - NEW-VALUE │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ -VALUE SB-KERNEL │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-ALIST │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -SB-IMPL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -d%d@==w,DE6) │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ -SYS:SRC;CODE;C-CALL.LISP │ │ │ │ -SYS:SRC;CODE;BARRIER.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ -3J6+8k8}A │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-MAC.LISP │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UTF.LISP │ │ │ │ -4M4P:S@w@ │ │ │ │ -XXX/cfc~e │ │ │ │ -SYS:SRC;CODE;FILESYS.LISP │ │ │ │ +(~:[~;*~]~S ~S) │ │ │ │ +*7 e8B │ │ │ │ +&7 e8B ) │ │ │ │ +You can't change the class of ~S to ~S │ │ │ │ +because it isn't already an instance with metaclass ~S. │ │ │ │ +#X~X..~X[~W]~:[ (#X~X)~;~*~]~@[ in ~S~] │ │ │ │ +&7 e8E )Sm │ │ │ │ + │ │ │ │ +emitter=~S │ │ │ │ +, depth=~W │ │ │ │ +*7 e8E │ │ │ │ +(deleted) │ │ │ │ +~A:~A ~W │ │ │ │ +&7 e8B 4 │ │ │ │ +Store and return a value as the slot-value. │ │ │ │ +Return a value as the slot-value. │ │ │ │ +&7 e8B 8 │ │ │ │ +hash-table │ │ │ │ +!T#O-K$D;N#G(? │ │ │ │ ++4+G("%7 │ │ │ │ +displaced │ │ │ │ +(VECTOR │ │ │ │ +) of length │ │ │ │ +length mismatch in ~S │ │ │ │ +supplied both ~S and ~S to ~S │ │ │ │ +~@[(ID=~d) ~]for ~S~@[, INVALID=~S~] │ │ │ │ Component │ │ │ │ :STREAMS ~S │ │ │ │ discarding unsupported DOCUMENTATION: doc-type ~S for object of type ~S │ │ │ │ _+,K%$>5Mf4"n : │ │ │ │ ~S~:[~;, interrupted~] │ │ │ │ :INPUT-STREAM ~S :OUTPUT-STREAM ~S │ │ │ │ ~@ │ │ │ │ ~@[~S ~]Ct=~D │ │ │ │ ~d keys, ~d bins │ │ │ │ &7 e8B │ │ │ │ +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. │ │ │ │ +SYS:SRC;PCL;FSC.LISP │ │ │ │ +SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ ~S structure class ~A │ │ │ │ (~D+~D)/~D [~@[~,3f words/sym,~]load=~,1f%] │ │ │ │ structure-object │ │ │ │ compiling │ │ │ │ *7 e8B │ │ │ │ *7 e8B 3 │ │ │ │ #)0&0&0&0=& │ │ │ │ @@ -34055,77 +33998,132 @@ │ │ │ │ +~W~@[ in ~S~] │ │ │ │ :SYMBOL ~S │ │ │ │ *7 e8B │ │ │ │ + ! ! % (Y │ │ │ │ Starting a ~A without a timeout while interrupts are disabled. │ │ │ │ ~&=== Starting a ~A without a timeout while interrupts are disabled. === │ │ │ │ a method lambda list │ │ │ │ -because │ │ │ │ ~S is a set, not a map │ │ │ │ _jga[a\SPh^X[hvshXIQ │ │ │ │ +address ~X not in the code component ~S │ │ │ │ +; Jump table (~d entries) @ ~X │ │ │ │ +; ~vt~v,'02x = ~a │ │ │ │ + Z%&l(# │ │ │ │ +SYS:SRC;CODE;C-CALL.LISP │ │ │ │ +SYS:SRC;CODE;BARRIER.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ +3J6+8k8}A │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-MAC.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UTF.LISP │ │ │ │ +4M4P:S@w@ │ │ │ │ +XXX/cfc~e │ │ │ │ +1)Fpl]ai │ │ │ │ + NEW-VALUE0 │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP8 │ │ │ │ + NEW-VALUE │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ +VALUE SB-KERNEL │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ + NEW-ALIST │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +d%d@==w,DE6) │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +K%'#)V%= │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +qVN' 2I)S │ │ │ │ +Takes an object and a location holding a list. Conses the object onto │ │ │ │ + the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ +The argument is a location holding a list. Pops one item off the front │ │ │ │ + of the list and returns it. │ │ │ │ +SYS:SRC;CODE;FILESYS.LISP │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-EBCDIC.LISP │ │ │ │ +SYS:SRC;CODE;QUERY.LISP │ │ │ │ KV-VECTOR-REHASHING │ │ │ │ REHASHING-STAMP │ │ │ │ OLD-KV-VECTOR │ │ │ │ NEW-KV-VECTOR │ │ │ │ HASH-TABLE-PAIRS-CAPACITY │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-EBCDIC.LISP │ │ │ │ -SYS:SRC;CODE;QUERY.LISP │ │ │ │ SYS:SRC;CODE;FORMAT-TIME.LISP │ │ │ │ SYS:SRC;CODE;TARGET-STREAM.LISP │ │ │ │ NEW-CELLS │ │ │ │ HAS-TRUNCATED-FLAG │ │ │ │ CLEANUP-FUN-1 │ │ │ │ -lisp_init_function │ │ │ │ -tot_gc_nsec │ │ │ │ -gc_coalesce_string_literals │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ -SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ lisp_package_vector │ │ │ │ -address ~X not in the code component ~S │ │ │ │ -; Jump table (~d entries) @ ~X │ │ │ │ -; ~vt~v,'02x = ~a │ │ │ │ -~S is wired to location ~D in SC ~A of kind ~S that it conflicts with. │ │ │ │ -~S is wired to a location that is out of bounds. │ │ │ │ -failed to pack after growing SC? │ │ │ │ -$Bf^(!5u │ │ │ │ - Z%&l(# │ │ │ │ +SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ +SYS:SRC;COMPILER;VMDEF.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;LATE-NLX.LISP │ │ │ │ $&%B%X%m& │ │ │ │ E/ETEyE,G │ │ │ │ SYS:SRC;ASSEMBLY;X86;SUPPORT.LISP │ │ │ │ -SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ SYS:SRC;COMPILER;X86;NLX.LISP │ │ │ │ SYS:SRC;COMPILER;ENVANAL.LISP │ │ │ │ +FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ +ORIGINAL-KIND │ │ │ │ SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ SYS:SRC;COMPILER;DFO.LISP │ │ │ │ -FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ -ORIGINAL-KIND │ │ │ │ +SYS:SRC;COMPILER;STACK.LISP │ │ │ │ +SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ LAST-POP │ │ │ │ BLOCK-DELETE-P │ │ │ │ USE-HOME │ │ │ │ -SYS:SRC;COMPILER;STACK.LISP │ │ │ │ -SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ ) '& ',R │ │ │ │ &5`%&/&8&]"# │ │ │ │ &5`%&/&I"&a0 │ │ │ │ , 5c(&T"# │ │ │ │ (333_$+." │ │ │ │ j(&/&]"# │ │ │ │ " x(&b"# │ │ │ │ " W0&]"# │ │ │ │ 7$ (?$ (- │ │ │ │ 3j%&/&A │ │ │ │ + 9 *&]"# │ │ │ │ -SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ -SYS:SRC;COMPILER;GTN.LISP │ │ │ │ -SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ &@"&I"&I"&a0 │ │ │ │ &@"&I"&I"&I"&a0 │ │ │ │ +SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ ** tail-call old-fp in reg not S0 │ │ │ │ ** tail-call old-fp not S0 │ │ │ │ $ {%&T%# │ │ │ │ nvalues is 1 │ │ │ │ 1X(&X0 │ │ │ │ 1++...."F │ │ │ │ +(((+++$ │ │ │ │ @@ -34136,34 +34134,58 @@ │ │ │ │ _oXONwax │ │ │ │ gUvrgUlETE │ │ │ │ WRRNgqCcT │ │ │ │ encountered the non-standard lambda list keyword ~S │ │ │ │ {FN[e]d\hc │ │ │ │ 31#[d[Xds\ │ │ │ │ [d[Xdsbdd │ │ │ │ +~S is wired to location ~D in SC ~A of kind ~S that it conflicts with. │ │ │ │ +~S is wired to a location that is out of bounds. │ │ │ │ +failed to pack after growing SC? │ │ │ │ jit-code.txt │ │ │ │ ~&; Logging code allocation to ~S │ │ │ │ ~&New code(~Db,~A): ~A │ │ │ │ +because │ │ │ │ +$Bf^(!5u │ │ │ │ Replace the function binding │ │ │ │ a generic function lambda list │ │ │ │ Multiple ~S options in DEFCLASS ~S. │ │ │ │ ~S is not a legal :documentation value │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~S is not a legal defclass option. │ │ │ │ t]R]oN{XbxQ │ │ │ │ ~S structure class │ │ │ │ ~Aconstructor │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ +SYS:SRC;COMPILER;GTN.LISP │ │ │ │ +SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ +SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ +SYS:SRC;COMPILER;PACK.LISP │ │ │ │ LAST-LOSE │ │ │ │ COALESCED │ │ │ │ Argument and/or result bit arrays are not the same length:~ │ │ │ │ ~% ~S~% ~S ~% ~S │ │ │ │ -SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ +load TN allocated, but no move function?~@ │ │ │ │ + VM definition is inconsistent, recompile and try again. │ │ │ │ +JUMPTABLE-WORD │ │ │ │ +Dynamic space │ │ │ │ +Text space │ │ │ │ +Read-only space │ │ │ │ +Static space │ │ │ │ +Control stack │ │ │ │ +Binding stack │ │ │ │ +L%g#-V%= │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +COMMON-LISP8 │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP8 │ │ │ │ X|!bMXg) │ │ │ │ }T*4p]1>< │ │ │ │ n>S7Auh7 │ │ │ │ T*4p]1>< │ │ │ │ }T*4p*W │ │ │ │ 4"YsOpG6 │ │ │ │ Rrvcgvg w │ │ │ │ @@ -34759,32 +34781,14 @@ │ │ │ │ qRr,'KHY │ │ │ │ tr`^m"R6 │ │ │ │ r|t."@rSU │ │ │ │ ^,=(Q,gD │ │ │ │ h]m2_]rxc] │ │ │ │ |8wfyQS8 │ │ │ │ H>p|[by6 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -K%'#)V%= │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -qVN' 2I)S │ │ │ │ -L%g#-V%= │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -COMMON-LISP8 │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP8 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ MORE-ARG │ │ │ │ @@ -34824,67 +34828,92 @@ │ │ │ │ three system timers (:real :virtual or :profile). On success, │ │ │ │ unix-getitimer returns 5 values, │ │ │ │ T, it-interval-secs, it-interval-usec, it-value-secs, it-value-usec. │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ -load TN allocated, but no move function?~@ │ │ │ │ - VM definition is inconsistent, recompile and try again. │ │ │ │ -SYS:SRC;COMPILER;PACK.LISP │ │ │ │ +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 │ │ │ │ +is :DEBUGGER-FRAME. │ │ │ │ + :CURRENT-FRAME │ │ │ │ + specifies the caller of PRINT-BACKTRACE. │ │ │ │ + :INTERRUPTED-FRAME │ │ │ │ + specifies the first interrupted frame on the stack (typically the frame │ │ │ │ + where the error occured, 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. │ │ │ │ +If PRINT-THREAD is true (default), backtrace is preceded by printing the │ │ │ │ +thread object the backtrace is from. │ │ │ │ +If PRINT-FRAME-SOURCE is true (default is false), each frame is followed by │ │ │ │ +printing the currently executing source form in the function responsible for │ │ │ │ +that frame, when available. Requires the function to have been compiled at │ │ │ │ +DEBUG 2 or higher. If PRINT-FRAME-SOURCE is :ALWAYS, it also reports "no │ │ │ │ +source available" for frames for which were compiled at lower debug settings. │ │ │ │ +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 EMERGENCY-BEST-EFFORT is true then try to print as much information as │ │ │ │ +possible while navigating and ignoring possible errors. │ │ │ │ +OPERANDS │ │ │ │ +MNEMONIC │ │ │ │ +OPERANDS │ │ │ │ +COMMON-LISP │ │ │ │ +OBJECT SB-KERNEL0 │ │ │ │ +FUNCTION │ │ │ │ +COMMON-LISP0 │ │ │ │ +Unix-lseek accepts a file descriptor and moves the file pointer by │ │ │ │ + OFFSET octets. Whence can be any of the following: │ │ │ │ + L_SET Set the file pointer. │ │ │ │ + L_INCR Increment the file pointer. │ │ │ │ + L_XTND Extend the file size. │ │ │ │ +SB-ALIEN │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP8 │ │ │ │ SYS:SRC;CODE;ICF.LISP │ │ │ │ SYS:SRC;COMPILER;X86;ALLOC.LISP │ │ │ │ SYS:SRC;COMPILER;X86;ARRAY.LISP │ │ │ │ SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ SYS:SRC;COMPILER;X86;SAP.LISP │ │ │ │ +WRAPPER4 │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ tKS[^\tKR[[oQd │ │ │ │ unknown TRACE option: ~S │ │ │ │ U`m< │ │ │ │ WS7Auh7v │ │ │ │ }U~A+%vg) │ │ │ │ '((.4O │ │ │ │ +Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ loading ~S │ │ │ │ loading stuff from ~S │ │ │ │ ;;;;;;;;;;;;;;;; │ │ │ │ can't understand something in the arglist ~S │ │ │ │ dummy macro │ │ │ │ -Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ -Got to T branch in ~S │ │ │ │ +Output-partial-line called when nothing can be output. │ │ │ │ cannot use optimized accessor in safe code │ │ │ │ Cannot make slot ~S in ~S unbound. │ │ │ │ slot name is not an interned symbol │ │ │ │ -Output-partial-line called when nothing can be output. │ │ │ │ -~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ -attempt to emit ~S a second time │ │ │ │ -Alignment ~S needs more space now? It was ~W, and is ~W now. │ │ │ │ -~S shrunk by ~W bytes, but claimed that it preserves ~W bits of alignment. │ │ │ │ -~S emitted ~W bytes, but claimed its max was ~W. │ │ │ │ -Chooser ~S passed, but not before emitting ~W bytes. │ │ │ │ -~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -:GENERIC-FUNCTION-CLASS argument │ │ │ │ -:METHOD-CLASS argument │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -JUMPTABLE-WORD │ │ │ │ -Dynamic space │ │ │ │ -Text space │ │ │ │ -Read-only space │ │ │ │ -Static space │ │ │ │ -Control stack │ │ │ │ -Binding stack │ │ │ │ -WRAPPER4 │ │ │ │ SYS:SRC;CODE;MISC.LISP │ │ │ │ SYS:SRC;CODE;LINUX-OS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ -SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ ~S outside of a effective method form │ │ │ │ +SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ +KV-VECTOR-SUPPLEMENT │ │ │ │ Character-Tabulation-With-Justification │ │ │ │ Start-Selected-Area │ │ │ │ Start-Guarded-Area │ │ │ │ Line-Tabulation-Set │ │ │ │ Message-Waiting │ │ │ │ Single-Shift-Three │ │ │ │ Single-Character-Introducer │ │ │ │ @@ -34907,136 +34936,103 @@ │ │ │ │ Single-Shift-Two │ │ │ │ Next-Line │ │ │ │ Partial-Line-Forward │ │ │ │ Reverse-Linefeed │ │ │ │ Set-Transmit-State │ │ │ │ Partial-Line-Backward │ │ │ │ String-Terminator │ │ │ │ -KV-VECTOR-SUPPLEMENT │ │ │ │ -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 │ │ │ │ -is :DEBUGGER-FRAME. │ │ │ │ - :CURRENT-FRAME │ │ │ │ - specifies the caller of PRINT-BACKTRACE. │ │ │ │ - :INTERRUPTED-FRAME │ │ │ │ - specifies the first interrupted frame on the stack (typically the frame │ │ │ │ - where the error occured, 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. │ │ │ │ -If PRINT-THREAD is true (default), backtrace is preceded by printing the │ │ │ │ -thread object the backtrace is from. │ │ │ │ -If PRINT-FRAME-SOURCE is true (default is false), each frame is followed by │ │ │ │ -printing the currently executing source form in the function responsible for │ │ │ │ -that frame, when available. Requires the function to have been compiled at │ │ │ │ -DEBUG 2 or higher. If PRINT-FRAME-SOURCE is :ALWAYS, it also reports "no │ │ │ │ -source available" for frames for which were compiled at lower debug settings. │ │ │ │ -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 EMERGENCY-BEST-EFFORT is true then try to print as much information as │ │ │ │ -possible while navigating and ignoring possible errors. │ │ │ │ -OPERANDS │ │ │ │ -MNEMONIC │ │ │ │ -OPERANDS │ │ │ │ -COMMON-LISP │ │ │ │ -OBJECT SB-KERNEL0 │ │ │ │ -FUNCTION │ │ │ │ -COMMON-LISP0 │ │ │ │ -Unix-lseek accepts a file descriptor and moves the file pointer by │ │ │ │ - OFFSET octets. Whence can be any of the following: │ │ │ │ - L_SET Set the file pointer. │ │ │ │ - L_INCR Increment the file pointer. │ │ │ │ - L_XTND Extend the file size. │ │ │ │ -SB-ALIEN │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP8 │ │ │ │ -SB-ALIEN │ │ │ │ -SB-ALIEN │ │ │ │ -L,(`o:0(` │ │ │ │ -SB-ALIEN │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -AC 4@A#C │ │ │ │ dynamic_space_size │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP0 │ │ │ │ -REST-ARG │ │ │ │ -SPECIALIZER │ │ │ │ -SB-MOP0 │ │ │ │ -! U$'19z │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP │ │ │ │ -OPERATION-CLASS │ │ │ │ -This function creates and memoizes an instance of OPERATION-CLASS. │ │ │ │ -All operation instances MUST be created through this function. │ │ │ │ -Use of INITARGS is not supported at this time. │ │ │ │ -COMMON-LISP │ │ │ │ - NEW-VALUE │ │ │ │ -COMMON-LISP │ │ │ │ -i=6xm+O!Y │ │ │ │ SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ SYS:SRC;CODE;WEAK.LISP │ │ │ │ SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ Superclass of all Gray output streams whose element-type │ │ │ │ is a subtype of character. │ │ │ │ Superclass of all Gray output streams whose element-type │ │ │ │ is a subtype of unsigned-byte or signed-byte. │ │ │ │ +SYS:SRC;CODE;SHOW.LISP │ │ │ │ SYS:SRC;CODE;UNCROSS.LISP │ │ │ │ SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ SYS:SRC;PCL;WALK.LISP │ │ │ │ SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ SYS:SRC;PCL;SLOT-NAME.LISP │ │ │ │ +SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ +SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ +SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ +/build/reproducible-path/sbcl-2.5.10/contrib/asdf/asdf.lisp │ │ │ │ the current number of recursive LOADs │ │ │ │ Specializer lock │ │ │ │ pv table index lock │ │ │ │ -~S ~S #X~8,'0X ~S ~// │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ SBCL specific extensions to MOP: if this value is read from an │ │ │ │ instance using STANDARD-INSTANCE-ACCESS, the slot is unbound. │ │ │ │ Similarly, an :INSTANCE allocated slot can be made unbound by │ │ │ │ assigning this to it using (SETF STANDARD-INSTANCE-ACCESS). │ │ │ │ Value of +SLOT-UNBOUND+ is unspecified, and should not be relied to be │ │ │ │ of any particular type, but it is guaranteed to be suitable for EQ │ │ │ │ comparison. │ │ │ │ -SYS:SRC;CODE;SHOW.LISP │ │ │ │ +SB-ALIEN │ │ │ │ +SB-ALIEN │ │ │ │ +L,(`o:0(` │ │ │ │ +SB-ALIEN │ │ │ │ +COMMON-LISP │ │ │ │ +! U$'19z │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +AC 4@A#C │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP0 │ │ │ │ +REST-ARG │ │ │ │ +SPECIALIZER │ │ │ │ +SB-MOP0 │ │ │ │ uv`}n*?n │ │ │ │ 8&PW:*ff │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP │ │ │ │ +OPERATION-CLASS │ │ │ │ +This function creates and memoizes an instance of OPERATION-CLASS. │ │ │ │ +All operation instances MUST be created through this function. │ │ │ │ +Use of INITARGS is not supported at this time. │ │ │ │ +COMMON-LISP │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +i=6xm+O!Y │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +VALUE SB-KERNEL0) │ │ │ │ FHp~gA|l │ │ │ │ inline non-SIMPLE-vector-handling logic │ │ │ │ open code │ │ │ │ DIMENSION │ │ │ │ -SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ strength reduce large variable right shift │ │ │ │ Convert %ASH/RIGHT by constant back to ASH │ │ │ │ COMMON-LISP0 │ │ │ │ -SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ -SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ -/build/reproducible-path/sbcl-2.5.10/contrib/asdf/asdf.lisp │ │ │ │ &!#4/.yRKO │ │ │ │ expand inline │ │ │ │ convert to inline logical operations │ │ │ │ rmTM)_F, │ │ │ │ Bl&MICN: │ │ │ │ ]a;X|TTi │ │ │ │ -ZZZZ#2k{') │ │ │ │ ]a;X|TTi │ │ │ │ +7)`W:0 │ │ │ │ -~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ Moves ITERATOR one position forward or backward in SEQUENCE │ │ │ │ depending on the iteration direction encoded in FROM-END. │ │ │ │ Returns non-NIL when ITERATOR has reached LIMIT (which may │ │ │ │ correspond to the end of SEQUENCE) with respect to the iteration │ │ │ │ direction encoded in FROM-END. │ │ │ │ Returns the element of SEQUENCE associated to the position of │ │ │ │ ITERATOR. │ │ │ │ @@ -35127,14 +35085,44 @@ │ │ │ │ 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-CLASS argument │ │ │ │ +:METHOD-CLASS argument │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ +attempt to emit ~S a second time │ │ │ │ +Alignment ~S needs more space now? It was ~W, and is ~W now. │ │ │ │ +~S shrunk by ~W bytes, but claimed that it preserves ~W bits of alignment. │ │ │ │ +~S emitted ~W bytes, but claimed its max was ~W. │ │ │ │ +Chooser ~S passed, but not before emitting ~W bytes. │ │ │ │ +~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ +IN-WITHOUT-SCHEDULING │ │ │ │ +No encoder for ~S │ │ │ │ +~&Your command, ~S, is ambiguous: │ │ │ │ +~&error flushed (because ~S is set) │ │ │ │ +~@ │ │ │ │ +No applicable method found for ~S │ │ │ │ +No primary method found for ~S among applicable methods: ~S │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +2K#"&%6- │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ +V\^jbebp │ │ │ │ +wrong number of arguments; expected ~W, got ~W │ │ │ │ +can't tell function type at compile time │ │ │ │ +FUNCTION doc-type is not supported. │ │ │ │ +Non-list or improper list spliced in ~ │ │ │ │ + the middle of a backquoted list. │ │ │ │ The width of instruction bytes. │ │ │ │ The column in which end-of-line comments for notes are started. │ │ │ │ Unpacked a TN to satisfy operand SC restriction. │ │ │ │ Repacked a block due to TN unpacking. │ │ │ │ Unpacked some operand TN. │ │ │ │ When set (the default), evaluations in the debugger's command loop occur │ │ │ │ relative to the current frame's environment without the need of debugger │ │ │ │ @@ -35162,49 +35150,39 @@ │ │ │ │ ((sb-pcl:slow-method [*] (*)) ...args...) │ │ │ │ In the this case arguments may include values internal to SBCL's method │ │ │ │ dispatch machinery. │ │ │ │ If the trace indentation exceeds this value, then indentation restarts at │ │ │ │ the increase in trace indentation at each call level │ │ │ │ Default number of frames to backtrace. Defaults to 1000. │ │ │ │ This is T while in the debugger. │ │ │ │ -~&Your command, ~S, is ambiguous: │ │ │ │ -~&error flushed (because ~S is set) │ │ │ │ -~@ │ │ │ │ -IN-WITHOUT-SCHEDULING │ │ │ │ -No encoder for ~S │ │ │ │ -FUNCTION doc-type is not supported. │ │ │ │ -No applicable method found for ~S │ │ │ │ -No primary method found for ~S among applicable methods: ~S │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -2K#"&%6- │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ -V\^jbebp │ │ │ │ -wrong number of arguments; expected ~W, got ~W │ │ │ │ -can't tell function type at compile time │ │ │ │ -Non-list or improper list spliced in ~ │ │ │ │ - the middle of a backquoted list. │ │ │ │ -Parse SPECIALIZER-NAME into a specializer object suitable for GENERIC-FUNCTION. │ │ │ │ -If SPECIALIZER-NAME is not well-formed with respect to the specializer │ │ │ │ -syntax of GENERIC-FUNCTION, an error of type │ │ │ │ -SB-PCL:SPECIALIZER-NAME-SYNTAX-ERROR is signaled. │ │ │ │ -If GENERIC-FUNCTION is a STANDARD-GENERIC-FUNCTION and │ │ │ │ -SPECIALIZER-NAME is a symbol that does not name an existing class, an │ │ │ │ -error of type SB-PCL:CLASS-NOT-FOUND-ERROR is signaled. │ │ │ │ -Other errors may be signaled for generic function classes other than │ │ │ │ -STANDARD-GENERIC-FUNCTION. │ │ │ │ -If GENERIC-FUNCTION is a STANDARD-GENERIC-FUNCTION and │ │ │ │ -SPECIALIZER-NAME is of the form (eql OBJECT), OBJECT is not │ │ │ │ -evaluated (in contrast to DEFMETHOD's behavior). │ │ │ │ -NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ -protocol. Interface subject to change. │ │ │ │ -It has a slot ~//, while ~// is requested. │ │ │ │ -~//, slot:~S, ~:S │ │ │ │ +~S ~S #X~8,'0X ~S ~// │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ +~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ + NEW-CLASS │ │ │ │ +REST-ARG │ │ │ │ + COMPONENT0 │ │ │ │ +COMMON-LISP │ │ │ │ + COMPONENT0 │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +8%(pH@(U │ │ │ │ + READTABLE │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP │ │ │ │ +fmt$GX3J2 │ │ │ │ +Awch9:"@ │ │ │ │ +}WVf"b~Qf │ │ │ │ +=:7mY"qH │ │ │ │ +>]2Dk[ y │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ SLOT-NAME0 │ │ │ │ +N2+pm:VU │ │ │ │ COMMON-LISP │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP8 │ │ │ │ - NEW-VALUE │ │ │ │ -GENERIC-FUNCTION │ │ │ │ -COMMON-LISP0 │ │ │ │ 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. │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ -~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ +BL)%`Os0 │ │ │ │ +fP:*PW:P │ │ │ │ +SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ REHASH-STAMP-ELT │ │ │ │ NEW-STAMP │ │ │ │ PKGNICK-INDEX-BITS │ │ │ │ -Normalize STRING to the Unicode normalization form FORM. │ │ │ │ -Acceptable values for form are :NFD, :NFC, :NFKD, and :NFKC. │ │ │ │ -If FILTER is a function it is called on each decomposed character and │ │ │ │ -only characters for which it returns T are collected. │ │ │ │ +~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ MISS-FN- │ │ │ │ ELEMENT-TYPE is not constant. │ │ │ │ +can't compile TYPEP of anonymous or undefined class: │ │ │ │ Could not insert ~S:~S to supposedly empty ~S. │ │ │ │ ~@ │ │ │ │ ~S with non-constant EMF ~S │ │ │ │ -Function is not TRACEd: ~S │ │ │ │ Invalid designator for initial backtrace frame: ~S │ │ │ │ - [~{~(~A~)~^,~}] │ │ │ │ - source: ~S │ │ │ │ -~& no source available for frame │ │ │ │ -~& error printing frame source: ~A │ │ │ │ -~& error finding frame source: ~A │ │ │ │ -~S is neither a type nor a specializer. │ │ │ │ -~S is not a legal specializer type. │ │ │ │ -~S cannot handle the second argument ~S │ │ │ │ -bad argument to TYPE-CLASS │ │ │ │ -can't compile TYPEP of anonymous or undefined class: │ │ │ │ -CLEANUP-FUN-19 │ │ │ │ -WITHOUT-INTERRUPTS-BODY-1 │ │ │ │ -CLEANUP-FUN-10 │ │ │ │ -CLEANUP-FUN-2 │ │ │ │ -BL)%`Os0 │ │ │ │ -fP:*PW:P │ │ │ │ d3M:'T,D │ │ │ │ d3M:'T,D │ │ │ │ -~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ 2=Ya1q)! │ │ │ │ 2=Ya1q)! │ │ │ │ 2=Ya1q)! │ │ │ │ h^T`Rz~,,. │ │ │ │ WSO&&#k'+c] │ │ │ │ +CLEANUP-FUN-19 │ │ │ │ +WITHOUT-INTERRUPTS-BODY-1 │ │ │ │ +CLEANUP-FUN-10 │ │ │ │ +CLEANUP-FUN-2 │ │ │ │ +START-LVAR │ │ │ │ /(`o:00$ │ │ │ │ %doI$eJ) │ │ │ │ \f\lKI|@ │ │ │ │ -RMYANCB_V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ O3%PW:.ff │ │ │ │ 4CoAbA_z │ │ │ │ 4CoAbA_z │ │ │ │ 2(`o:0LYk │ │ │ │ E' >U_O[ │ │ │ │ cquUU}UWu_ │ │ │ │ :::VWUUx\U │ │ │ │ +0Zz*X%kyI │ │ │ │ 8%PW:*ff │ │ │ │ a3;!S h` │ │ │ │ -N2+pm:VU │ │ │ │ >_/+JtkJV │ │ │ │ uT4a.]V& │ │ │ │ ]M}i!(p$0x │ │ │ │ %(p$@I*PW:03uY │ │ │ │ 0o,qfL%}0?bQ │ │ │ │ START-LAB │ │ │ │ hjtt\yDskl │ │ │ │ TEMP-VAR │ │ │ │ +GENERIC-FUNCTION │ │ │ │ +COMMON-LISP0 │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP8 │ │ │ │ + NEW-VALUE │ │ │ │ CONSTANT SB-KERNEL0& │ │ │ │ Backspace │ │ │ │ COMMON-LISP │ │ │ │ FUN-NAME │ │ │ │ bf6nkkkk │ │ │ │ -SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ SYS:SRC;PCL;ECD.LISP │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP │ │ │ │ OPERATION │ │ │ │ PPRINT-DISPATCH │ │ │ │ COMMON-LISP │ │ │ │ .+pO:t-T\ │ │ │ │ _3P=PJ?p │ │ │ │ -START-LVAR │ │ │ │ -WRAPPER6 │ │ │ │ + METATYPES │ │ │ │ + METATYPES │ │ │ │ NODE-BLOCK │ │ │ │ +WRAPPER6 │ │ │ │ +CLEANUP-FUN-11 │ │ │ │ +WITHOUT-GCING-BODY-10 │ │ │ │ +WITHOUT-GCING-BODY-0 │ │ │ │ + [~{~(~A~)~^,~}] │ │ │ │ + source: ~S │ │ │ │ +~& no source available for frame │ │ │ │ +~& error printing frame source: ~A │ │ │ │ +~& error finding frame source: ~A │ │ │ │ +~S is neither a type nor a specializer. │ │ │ │ +~S is not a legal specializer type. │ │ │ │ +~S cannot handle the second argument ~S │ │ │ │ +bad argument to TYPE-CLASS │ │ │ │ +Function is not TRACEd: ~S │ │ │ │ U3/adXXad │ │ │ │ Unexpectedly small N-RANDOM-CHUNK-BITS │ │ │ │ ~S doesn't have a precise float representation. │ │ │ │ The RATIONAL value isn't known at compile time. │ │ │ │ e#(+-** ) 8j │ │ │ │ W[dt5]Y\XeXXs@YXX │ │ │ │ ZZZZwdi`\ │ │ │ │ UB~D-BASH-COPY │ │ │ │ -CLEANUP-FUN-11 │ │ │ │ -WITHOUT-GCING-BODY-10 │ │ │ │ -WITHOUT-GCING-BODY-0 │ │ │ │ - METATYPES │ │ │ │ - METATYPES │ │ │ │ METATYPES │ │ │ │ STREAM-WE-ARE-LOADING-FROM │ │ │ │ COMMON-LISP │ │ │ │ mZt9q@v= │ │ │ │ Oa_s"(PH0 │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ LOCATION0 │ │ │ │ METHOD-ARGS │ │ │ │ PV-TABLE0 │ │ │ │ -al.v}#|~= │ │ │ │ L&P PP$( │ │ │ │ -SPECIALIZER │ │ │ │ -SB-MOP0 │ │ │ │ COMMON-LISP1 │ │ │ │ ENVIRONMENT │ │ │ │ KEYWORDS-AND-FORMS │ │ │ │ UNIVERSE │ │ │ │ -nqf4m{mw │ │ │ │ +al.v}#|~= │ │ │ │ +SPECIALIZER │ │ │ │ +SB-MOP0 │ │ │ │ METHOD-LAMBDA │ │ │ │ PROTO-GF │ │ │ │ PROTO-METHOD │ │ │ │ PROTO-GENERIC-FUNCTION │ │ │ │ SPECIALIZER-NAME0 │ │ │ │ SPECIALIZER-NAME0 │ │ │ │ SPECIALIZER │ │ │ │ @@ -35635,55 +35628,46 @@ │ │ │ │ N%,~ l | │ │ │ │ l_ nbkbb nU │ │ │ │ ohnbkbkn^bh_dd`Xuagt │ │ │ │ ~@ │ │ │ │ rZsOmmsj\ │ │ │ │ :FROM-END is not constant. │ │ │ │ U[tr`n`p\ │ │ │ │ -SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ IJJn\eedgZ │ │ │ │ Uknown upgraded array element type of the result │ │ │ │ The function doesn't have a fixed argument count. │ │ │ │ -bogus arguments to MOV: ~S ~S │ │ │ │ -bogus args to XCHG: ~S ~S │ │ │ │ -bogus operands for TEST: ~S and ~S │ │ │ │ -can't scan bytes: ~S │ │ │ │ -don't know what to do with ~A │ │ │ │ -can't bounds-test bytes: ~S │ │ │ │ -["2N++ *H │ │ │ │ -~&~6x : [~D,~D] ~2,'0x~v@{ ~x~} │ │ │ │ - ~35t~(~a~) │ │ │ │ -corrupt fasl file: FOP code #x~x │ │ │ │ -CLEANUP-FUN-43 │ │ │ │ -CLEANUP-FUN-31 │ │ │ │ -CLEANUP-FUN-16 │ │ │ │ auxiliary │ │ │ │ -SYS:SRC;PCL;DLISP.LISP │ │ │ │ ~S is an unknown vector type │ │ │ │ ~S ~S is not a ~S │ │ │ │ This shouldn't happen. │ │ │ │ The type is not constant at compile time; can't open code. │ │ │ │ Aliens of type ~S cannot be represented immediately. │ │ │ │ The alien type is not constant, so access cannot be open coded. │ │ │ │ [X^TX[XXXR^ │ │ │ │ [X^TX[XXXR^ │ │ │ │ +CLEANUP-FUN-43 │ │ │ │ +CLEANUP-FUN-31 │ │ │ │ +CLEANUP-FUN-16 │ │ │ │ ~2&Assembler input: │ │ │ │ ~:@(~A~) ~{~A~^, ~}~A │ │ │ │ # Unused labels: │ │ │ │ # end of input │ │ │ │ # postit ~S~A │ │ │ │ # ~{~@[~A~^, ~]~} │ │ │ │ (notused) │ │ │ │ ~A~{~A: ~}~A │ │ │ │ ZM0%#tXK! │ │ │ │ 1.0.11.18 │ │ │ │ Load the fasl file anyway │ │ │ │ FOP stack underflow │ │ │ │ ~&; While loading ~S: │ │ │ │ xRUUtRTT │ │ │ │ +~&~6x : [~D,~D] ~2,'0x~v@{ ~x~} │ │ │ │ + ~35t~(~a~) │ │ │ │ +corrupt fasl file: FOP code #x~x │ │ │ │ cannot load assembler code except at cold load │ │ │ │ fasl stack not empty when it should be │ │ │ │ fasl table of improper size │ │ │ │ ~S loaded │ │ │ │ tNQQnNNN │ │ │ │ Not a property list: ~S │ │ │ │ WRAPPER- │ │ │ │ @@ -35716,24 +35700,24 @@ │ │ │ │ ~@<~S, in ~S ~S, is not a ~S.~@:> │ │ │ │ ~@<~S of ~S is an improper list.~@:> │ │ │ │ ~@ │ │ │ │ c#%)=EAN │ │ │ │ @> 54,"$2Am2$47'). │ │ │ │ pTLL~ga^pv^ │ │ │ │ Weird location in ~S │ │ │ │ +SYS:SRC;PCL;DLISP.LISP │ │ │ │ / │ │ │ │ ~@ │ │ │ │ Cannot make structure slots unbound │ │ │ │ ~@<~S, in ~S ~S, is not a non-~S atom.~@:> │ │ │ │ i^YPP`Ri^YPP`NdP │ │ │ │ oUVQO^Zm │ │ │ │ UVQik^Z[^ │ │ │ │ -kqbkwhuXRae^[X][U │ │ │ │ The key for the last case arg to mcase was not T │ │ │ │ ~@<~S of ~S is neither ~S nor a ~S.~@:> │ │ │ │ Something strange where symbol or class expected. │ │ │ │ e(P" " │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ @@ -35776,14 +35760,21 @@ │ │ │ │ the method and generic function differ in whether they accept~_~ │ │ │ │ &REST or &KEY arguments. │ │ │ │ the method has ~A optional arguments than the generic function. │ │ │ │ the method does not accept each of the &KEY arguments~2I~_~ │ │ │ │ ~S. │ │ │ │ ~@ │ │ │ │ While computing the class precedence list of the class ~A. │ │ │ │ +kqbkwhuXRae^[X][U │ │ │ │ +^b^UhgPY[PnWd[ps │ │ │ │ +illegal kind argument to ~S: ~S │ │ │ │ +[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ +^b^UhgXXPY[XXPLShWj │ │ │ │ +The RESTP argument is not constant. │ │ │ │ +nY\[Y[YSknX │ │ │ │ ]YikNXp^ggd^ │ │ │ │ ~@ │ │ │ │ The class │ │ │ │ follows the class │ │ │ │ in the supers of the class │ │ │ │ @@ -35793,63 +35784,83 @@ │ │ │ │ PATHNAME-INITARG- │ │ │ │ BIT-VECTOR-INITARG- │ │ │ │ STRING-INITARG- │ │ │ │ Tuple ~S not found │ │ │ │ ~@ │ │ │ │ No SLOT-INFO for ~S in ~S │ │ │ │ ~@ │ │ │ │ -^b^UhgPY[PnWd[ps │ │ │ │ -illegal kind argument to ~S: ~S │ │ │ │ -[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ -^b^UhgXXPY[XXPLShWj │ │ │ │ -The RESTP argument is not constant. │ │ │ │ -nY\[Y[YSknX │ │ │ │ -^b^UhnW\YbW\LShWj │ │ │ │ -Invalid eq-p argument: ~S │ │ │ │ __d\ t X t │ │ │ │ early method with no method-function │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ # │ │ │ │ XYedR_tcdPll\U_k^ddP │ │ │ │ ^aaf[d^] │ │ │ │ No ~S methods. │ │ │ │ ANY-KEYP │ │ │ │ :8++p.M;b │ │ │ │ Remove all methods. │ │ │ │ ~S is not a STANDARD-CLASS. │ │ │ │ EFFECTIVE-METHOD-GENSYM- │ │ │ │ +^b^UhnW\YbW\LShWj │ │ │ │ +Invalid eq-p argument: ~S │ │ │ │ +a_dgRVaX │ │ │ │ +WaWR\fmj │ │ │ │ d?J;z\D │ │ │ │ f?E !CB != │ │ │ │ +SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ +["2N++ *H │ │ │ │ ~:<~W~^ ~3I~:_~W~^~1I~@{~:@_~:<~^~W~^ ~:I~@_~@{~W~^ ~_~}~:>~}~:> │ │ │ │ -a_dgRVaX │ │ │ │ -WaWR\fmj │ │ │ │ -C,'6(&&ffu8((,2"6 │ │ │ │ 1AO]j"&p( │ │ │ │ :TYPE must be one of ~S │ │ │ │ Must not specify :SORT or :TEST with :KEY-TYPE │ │ │ │ Must specify both :SORT and :TEST │ │ │ │ +\E\YXkaSRPXXjkZyd │ │ │ │ .~A ~S~:[~:A~;~] │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ +nqf4m{mw │ │ │ │ +RES^ac(P(6 │ │ │ │ + NEW-VALUE0 │ │ │ │ +Etq'XX9< │ │ │ │ +APPLICABLE-METHODS0 │ │ │ │ +TLA9Q!+\% │ │ │ │ + NEW-VALUE │ │ │ │ +COMMON-LISP │ │ │ │ +{R]O) Rw │ │ │ │ +~= oDwe_CN │ │ │ │ +juZ=2[U-e7 │ │ │ │ +COMMON-LISP │ │ │ │ +INITARGS │ │ │ │ +COMMON-LISP │ │ │ │ +sG@,/KCk │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +SB-DISASSEM0 │ │ │ │ +SB-DISASSEM │ │ │ │ +SPECIALIZER-COUNT │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +LAMBDA-LIST │ │ │ │ +LAMBDA-LIST0 │ │ │ │ +^t#sFZuj= │ │ │ │ +MORE-ARG │ │ │ │ +MORE-ARG │ │ │ │ bF:'eH*E │ │ │ │ -\E\YXkaSRPXXjkZyd │ │ │ │ multiple specializing masters: ~S │ │ │ │ ~@ │ │ │ │ ;;; [~W] │ │ │ │ .SKIP ~D │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ #X~2,'0x │ │ │ │ #x~8,'0x: ~a~@[ +~d~] │ │ │ │ ~&; Size: ~a bytes. Origin: #x~x~@[ (segment 1 of ~D)~] │ │ │ │ ~&; Origin #x~x (segment ~D of ~D) │ │ │ │ (&MORE ~s) │ │ │ │ (&OPTIONAL ~s) │ │ │ │ (XEP ~s) │ │ │ │ bogus operands to ~A │ │ │ │ Double shifts can only be used with words. │ │ │ │ +can't scan bytes: ~S │ │ │ │ can't index off of ESP │ │ │ │ size mismatch: ~S is a ~S and ~S is a ~S. │ │ │ │ can't tell the size of either ~S or ~S │ │ │ │ can't tell the size of ~S ~S │ │ │ │ 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 │ │ │ │ @@ -35952,14 +35963,16 @@ │ │ │ │ frame number: │ │ │ │ The ~A of the stack was encountered. │ │ │ │ can't figure out the function for this frame │ │ │ │ return: │ │ │ │ ~@ │ │ │ │ ~@<~S ~_= ~:[; No values~;~:*~{~S~^, ~}~]~:> │ │ │ │ ; No values │ │ │ │ +RVN\jNZ[m │ │ │ │ +SU\mXxV\HhmX │ │ │ │ The argument specification ~S is out of range. │ │ │ │ invalid &REST argument before n'th argument │ │ │ │ unused &REST argument before n'th argument │ │ │ │ DMs*+;!'!'!= ' │ │ │ │ ::FUN-START │ │ │ │ ~&::FUN-END *Active* │ │ │ │ *Continue here* │ │ │ │ @@ -35977,16 +35990,14 @@ │ │ │ │ error printing ~a {~x} │ │ │ │ error printing object │ │ │ │ Index ~a out of bounds for ~a supplied argument~:p. │ │ │ │ more unavailable arguments │ │ │ │ ~&~S: FUN-END in ~S │ │ │ │ ~&~S: FUN-START in ~S │ │ │ │ ~&~S: ~S in ~S │ │ │ │ -RVN\jNZ[m │ │ │ │ -SU\mXxV\HhmX │ │ │ │ invalid argument value │ │ │ │ Unused arguments have no values. │ │ │ │ No argument values are available. │ │ │ │ Specify variable ID to disambiguate ~S. Use one of ~S. │ │ │ │ invalid variable ID, ~W: should have been one of ~S │ │ │ │ specification ambiguous: │ │ │ │ No known valid variables match ~S. │ │ │ │ @@ -36010,14 +36021,19 @@ │ │ │ │ ~:[as the value of the LOOP~;~:*INTO ~S~]: ~S and ~S │ │ │ │ unequal datatypes specified in different LOOP value accumulations~@ │ │ │ │ into ~S: ~S and ~S │ │ │ │ in INTO clause │ │ │ │ The value accumulation recipient name, ~S, is not a symbol. │ │ │ │ LOOP couldn't verify that ~S is a subtype of the required type ~S. │ │ │ │ The specified data type ~S is not a subtype of ~S. │ │ │ │ +RESTART-FRAME │ │ │ │ +LIST-BREAKPOINTS │ │ │ │ +LIST-LOCATIONS │ │ │ │ +LIST-LOCALS │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ GEN-LOOP-BODY called with non-synched before- and after-loop lists │ │ │ │ You may only use one NAMED clause in your loop: NAMED ~S ... NAMED ~S. │ │ │ │ The NAMED ~S clause occurs too late. │ │ │ │ ~S is an invalid name for your LOOP │ │ │ │ don't know where to start stepping │ │ │ │ missing OF or IN phrase in sequence path │ │ │ │ conflicting stepping directions in LOOP sequencing path │ │ │ │ @@ -36025,43 +36041,14 @@ │ │ │ │ maybe invalid prepositions were specified in iteration path descriptor? │ │ │ │ Arithmetic index must be an atom. │ │ │ │ The variable substitution for ~S occurs twice in a USING phrase,~@ │ │ │ │ with ~S and ~S. │ │ │ │ Preposition ~S was used when some other preposition has subsumed it. │ │ │ │ A ~S prepositional phrase occurs multiply for some LOOP clause. │ │ │ │ A compound form was expected, but ~S found. │ │ │ │ -RESTART-FRAME │ │ │ │ -LIST-BREAKPOINTS │ │ │ │ -LIST-LOCATIONS │ │ │ │ -LIST-LOCALS │ │ │ │ -SPECIALIZER-COUNT │ │ │ │ - NEW-VALUE0 │ │ │ │ -RES^ac(P(6 │ │ │ │ -COMMON-LISP │ │ │ │ -INITARGS │ │ │ │ -COMMON-LISP │ │ │ │ -sG@,/KCk │ │ │ │ -Etq'XX9< │ │ │ │ -APPLICABLE-METHODS0 │ │ │ │ -TLA9Q!+\% │ │ │ │ - NEW-VALUE │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -{R]O) Rw │ │ │ │ -~= oDwe_CN │ │ │ │ -juZ=2[U-e7 │ │ │ │ -COMMON-LISP │ │ │ │ -SB-DISASSEM0 │ │ │ │ -SB-DISASSEM │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -LAMBDA-LIST │ │ │ │ -LAMBDA-LIST0 │ │ │ │ -^t#sFZuj= │ │ │ │ -H(`$(Cc| │ │ │ │ -MORE-ARG │ │ │ │ -MORE-ARG │ │ │ │ 3'{xU_pUU^mv │ │ │ │ 4 .$ d_%Xa │ │ │ │ This LOOP clause is not permitted with anonymous collectors. │ │ │ │ current LOOP context:~{ ~S~}. │ │ │ │ MINMAXTMP │ │ │ │ secondary clause misplaced at top level in LOOP macro: ~S ~S ~S ... │ │ │ │ unknown LOOP keyword: ~S │ │ │ │ @@ -36096,57 +36083,61 @@ │ │ │ │ 4O0A"%5i │ │ │ │ ~@ │ │ │ │ ignoring unknown optimization quality ~S in ~S │ │ │ │ ~@ │ │ │ │ Tried to set a symbol-macrolet! │ │ │ │ VU\Y\eem │ │ │ │ [PM^hN[P │ │ │ │ +C,'6(&&ffu8((,2"6 │ │ │ │ operation. │ │ │ │ operation │ │ │ │ resetting │ │ │ │ configuration. │ │ │ │ _.=6__X2$8 │ │ │ │ .A%" 0#> │ │ │ │ ;%G%Zi03 (#),* │ │ │ │ ,#3;((P"_ │ │ │ │ unexpected special form ~S │ │ │ │ +autom4te.cache │ │ │ │ +cover_db │ │ │ │ Invalid Huffman-code: ~S │ │ │ │ Not a variable declaration the walker cares about: ~S │ │ │ │ Ignoring doc-type ~a for ~a. │ │ │ │ -autom4te.cache │ │ │ │ -cover_db │ │ │ │ -,h2E │ │ │ │ +R7z+1F@*b │ │ │ │ +:555?<<1F7F │ │ │ │ +XV │ │ │ │ +YVl\VVVVi_YYoX │ │ │ │ +C'#K54i(W8@ │ │ │ │ +Continue using :external-format :default │ │ │ │ +~@ │ │ │ │ ~@ │ │ │ │ named ~// │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~//~:[~:; ~:S~] │ │ │ │ New lambda-list ~// is incompatible with existing methods of ~S. │ │ │ │ Old lambda-list ~// │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ -HASH-KEYS │ │ │ │ -HASH-VALUES │ │ │ │ -EXTERNAL-SYMBOL │ │ │ │ -PRESENT-SYMBOL │ │ │ │ -PRESENT-SYMBOLS │ │ │ │ ARG-NAMES │ │ │ │ +H(`$(Cc| │ │ │ │ 21e_Z3g'6 │ │ │ │ LINE-SIZE │ │ │ │ VECTOR-LENGTH │ │ │ │ +Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ +fold identity operation │ │ │ │ +recode as leas, shifts and adds │ │ │ │ ,$v:"e 9 │ │ │ │ ARG-INFO │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ V#@Nu:`kj │ │ │ │ COMMON-LISP │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP0 │ │ │ │ -&}/]4AD#o │ │ │ │ -UUuUU]WW │ │ │ │ Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ Returns the last value returned by FUNCTION. │ │ │ │ COUNT is the number of frames to backtrace, defaulting to │ │ │ │ *BACKTRACE-FRAME-COUNT*. │ │ │ │ START is the number of the frame the backtrace should start from. │ │ │ │ FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ values are an explicit SB-DI:FRAME object, and the │ │ │ │ @@ -36157,38 +36148,38 @@ │ │ │ │ :INTERRUPTED-FRAME │ │ │ │ specifies the first interrupted frame on the stack (typically the frame │ │ │ │ where the error occurred, as opposed to error handling frames) if any, │ │ │ │ otherwise behaving as :CURRENT-FRAME. │ │ │ │ :DEBUGGER-FRAME │ │ │ │ specifies the currently debugged frame when inside the debugger, and │ │ │ │ behaves as :INTERRUPTED-FRAME outside the debugger. │ │ │ │ -8ymdXBjP │ │ │ │ -Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ -fold identity operation │ │ │ │ SYS:SRC;COMPILER;X86;MEMORY.LISP │ │ │ │ SYS:SRC;ASSEMBLY;X86;ASSEM-RTNS.LISP │ │ │ │ SYS:SRC;ASSEMBLY;X86;ARITH.LISP │ │ │ │ SYS:SRC;COMPILER;X86;VALUES.LISP │ │ │ │ SYS:SRC;COMPILER;X86;SUBPRIM.LISP │ │ │ │ SYS:SRC;COMPILER;X86;SHOW.LISP │ │ │ │ SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ -recode as leas, shifts and adds │ │ │ │ +,h2E │ │ │ │ +RMYANCB_ │ │ │ │ +V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ +8ymdXBjP │ │ │ │ +&}/]4AD#o │ │ │ │ +UUuUU]WW │ │ │ │ MORE-ARG │ │ │ │ DISPLACEMENT.USE-LABEL │ │ │ │ DISPLACEMENT.PRINTER │ │ │ │ COMMON-LISP │ │ │ │ optimize to inlined RANDOM-CHUNK operations │ │ │ │ Use inline float operations. │ │ │ │ open-code INTEGER to RATIO comparison │ │ │ │ open-code RATIONAL to FLOAT comparison │ │ │ │ invert or open code │ │ │ │ open-code FLOAT to RATIONAL comparison │ │ │ │ convert to simpler equality predicate │ │ │ │ -RMYANCB_ │ │ │ │ -V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ associate LOGIOR/(LOGIOR) of constants │ │ │ │ FORM SB-KERNEL │ │ │ │ associate +/(+ -) of constants │ │ │ │ check for iteration variable reoptimization │ │ │ │ convert (- 0 x) to negate │ │ │ │ associate -/(+ -) of constants │ │ │ │ associate LOGTEST/(LOGAND) of constants │ │ │ │ @@ -36201,134 +36192,21 @@ │ │ │ │ SB-ALIEN0 │ │ │ │ SB-ALIEN0 │ │ │ │ constant-fold INTEGER to RATIO comparison │ │ │ │ RM/,pm:F@U │ │ │ │ convert NTHCDR to CAxxR │ │ │ │ SEQS-NAMES │ │ │ │ SUB-ACCESSOR2 │ │ │ │ -SRC-SIZE │ │ │ │ convert to EQ test │ │ │ │ ARRAY-TYPE SB-KERNEL0 │ │ │ │ recode as an ODDP check │ │ │ │ recode as multiplication or sqrt │ │ │ │ -7jUDIQ&| │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -SEGMENT0 │ │ │ │ -Rp │ │ │ │ +SI-AROUND │ │ │ │ g.pgy(^{ │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ SLOT-NAME0 │ │ │ │ SPECIALIZER │ │ │ │ METHOD-LAMBDA │ │ │ │ @@ -36491,117 +36379,81 @@ │ │ │ │ CLASS-OR-NAME0 │ │ │ │ SPECIALIZERS │ │ │ │ CLASS-SLOT-P │ │ │ │ METATYPES │ │ │ │ QUALIFIER8 │ │ │ │ TYPE-NAME │ │ │ │ COMMON-LISP │ │ │ │ -&P:,`W:00 │ │ │ │ -METHOD-CALL │ │ │ │ ARG-NUMBER │ │ │ │ -~@ │ │ │ │ -SI-AROUND │ │ │ │ -DUMMY-NODE-P │ │ │ │ LAMBDA-LIST │ │ │ │ fmt$2J775S │ │ │ │ TUuUuU}UW_]uu │ │ │ │ KEYWORDS │ │ │ │ LAMBDA-LIST │ │ │ │ MORE-ARG │ │ │ │ y['8MSZ3J6 │ │ │ │ SLOT-NAME │ │ │ │ MORE-ARG │ │ │ │ ARG-INFO0 │ │ │ │ METATYPES │ │ │ │ +METHOD-CALL │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ D(]VYU^- │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +DUMMY-NODE-P │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ NODE-HASH │ │ │ │ +Coerce CLASS to a class that is subclass of SUPER if specified, │ │ │ │ +or invoke ERROR handler as per CALL-FUNCTION. │ │ │ │ +A keyword designates the name a symbol, which when found in either PACKAGE, designates a class. │ │ │ │ +-- for backward compatibility, *PACKAGE* is also accepted for now, but this may go in the future. │ │ │ │ +A string is read as a symbol while in PACKAGE, the symbol designates a class. │ │ │ │ +A class object designates itself. │ │ │ │ +NIL designates itself (no class). │ │ │ │ +A symbol otherwise designates a class by name. │ │ │ │ +Lookup the TABLE for a KEY as by GETHASH, but if not present, │ │ │ │ +call the (possibly constant) function designated by DEFAULT as per CALL-FUNCTION, │ │ │ │ +set the corresponding entry to the result in the table. │ │ │ │ +Return two values: the entry after its optional computation, and whether it was found │ │ │ │ +SB-DISASSEM │ │ │ │ +SB-DISASSEM │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ -SB-DISASSEM │ │ │ │ -SB-DISASSEM │ │ │ │ - COMPONENT │ │ │ │ - OPERATION0 │ │ │ │ -ASDF/COMPONENT0 │ │ │ │ -Given a designator for a component NAME, return the name as a string. │ │ │ │ -The designator can be a COMPONENT (designing its name; note that a SYSTEM is a component), │ │ │ │ -a SYMBOL (designing its name, downcased), or a STRING (designing itself). │ │ │ │ -Read from STRING using a safe syntax, as per WITH-SAFE-IO-SYNTAX │ │ │ │ -Open FILE for input with given recognizes options, call THUNK with the resulting stream. │ │ │ │ -Other keys are accepted but discarded. │ │ │ │ -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. │ │ │ │ -Return a path from a root system to the COMPONENT. │ │ │ │ -The return value is a list of component NAMES; a list of strings. │ │ │ │ -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. │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP │ │ │ │ -Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME, │ │ │ │ -and NIL NAME, TYPE and VERSION components │ │ │ │ -MERGE-PATHNAMES* is like MERGE-PATHNAMES except that │ │ │ │ -if the SPECIFIED pathname does not have an absolute directory, │ │ │ │ -then the HOST and DEVICE both come from the DEFAULTS, whereas │ │ │ │ -if the SPECIFIED pathname does have an absolute directory, │ │ │ │ -then the HOST and DEVICE both come from the SPECIFIED pathname. │ │ │ │ -This is what users want on a modern Unix or Windows operating system, │ │ │ │ -unlike the MERGE-PATHNAMES behavior. │ │ │ │ -Also, if either argument is NIL, then the other argument is returned unmodified; │ │ │ │ -this is unlike MERGE-PATHNAMES which always merges with a pathname, │ │ │ │ -by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL. │ │ │ │ -4Ic`QY)8b$LP │ │ │ │ -PATHSPEC8 │ │ │ │ -If PATHSPEC is a pathname or namestring object that parses as a pathname │ │ │ │ -possessing an :ABSOLUTE directory component, return the (parsed) pathname. │ │ │ │ -Otherwise return NIL │ │ │ │ -Detect circular dependencies │ │ │ │ -Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ - ARGUMENTS │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ SO-KEY8% │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ +4Ic`QY)8b$LP │ │ │ │ +LABEL.PREFILTER │ │ │ │ 0337#23BA │ │ │ │ COMMON-LISP0 │ │ │ │ -SEGMENT0 │ │ │ │ -ERRNUM0+ │ │ │ │ -COMMON-LISP │ │ │ │ -BYTE-OFFSET2 │ │ │ │ +OTHER-SPECIALIZERS │ │ │ │ Overwriting already existing readtable ~S. │ │ │ │ &OPTIONAL and &KEY found in the same lambda list: ~S │ │ │ │ No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function. │ │ │ │ Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ ~// is undefined, not tracing. │ │ │ │ -asdf-output-translations │ │ │ │ -source-registry │ │ │ │ +SEGMENT0 │ │ │ │ +ERRNUM0+ │ │ │ │ +COMMON-LISP │ │ │ │ +BYTE-OFFSET2 │ │ │ │ SC+OFFSET │ │ │ │ SEGMENT0 │ │ │ │ DSTATE0% │ │ │ │ FQ<*Pu:0 │ │ │ │ COMMON-LISP │ │ │ │ ob^Mk";5 │ │ │ │ COMMON-LISP │ │ │ │ @@ -36610,43 +36462,43 @@ │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ MORE-ARG │ │ │ │ COMMON-LISP │ │ │ │ -6mvpEnE │ │ │ │ -R7z+1F@*b │ │ │ │ -:555?<<1F7F │ │ │ │ -XV │ │ │ │ -YVl\VVVVi_YYoX │ │ │ │ -C'#K54i(W8@ │ │ │ │ -Continue using :external-format :default │ │ │ │ -~@ │ │ │ │ -These functions were not called: │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ INTEGER1 │ │ │ │ COMMON-LISP0 │ │ │ │ NEIGHBOR │ │ │ │ FFvVtYXh|@ │ │ │ │ 9H%*BJEFL@T │ │ │ │ b*]hhFh$I │ │ │ │ |&N28_J'7 │ │ │ │ N2*`o:02e │ │ │ │ p;ZFc;T?# │ │ │ │ DzGNY/]O │ │ │ │ COMMON-LISP │ │ │ │ -common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ -OTHER-SPECIALIZERS │ │ │ │ DEFAULT0 │ │ │ │ VQ<+`o:0 │ │ │ │ COMMON-LISP │ │ │ │ .tyiETt+ │ │ │ │ LOCATION │ │ │ │ ,'/z<(@F0 │ │ │ │ +FORM SB-KERNEL │ │ │ │ +STEP implements a debugging paradigm wherein the programmer is allowed │ │ │ │ + to step through the evaluation of a form. We use the debugger's stepping │ │ │ │ + facility to step through an anonymous function containing only form. │ │ │ │ + Currently the stepping facility only supports stepping compiled code, │ │ │ │ + so step will try to compile the resultant anonymous function. If this │ │ │ │ + fails, e.g. because it closes over a non-null lexical environment, an │ │ │ │ + error is signalled. │ │ │ │ +o9MS Liy[9 │ │ │ │ +)Cetj+$%A │ │ │ │ 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 │ │ │ │ @@ -36660,26 +36512,14 @@ │ │ │ │ ARG-COUNT │ │ │ │ ESCAPED0 │ │ │ │ DEBUG-FUN0 │ │ │ │ DEFINITION │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP0 │ │ │ │ OPTIONAL-ARGS │ │ │ │ -FORM SB-KERNEL │ │ │ │ -STEP implements a debugging paradigm wherein the programmer is allowed │ │ │ │ - to step through the evaluation of a form. We use the debugger's stepping │ │ │ │ - facility to step through an anonymous function containing only form. │ │ │ │ - Currently the stepping facility only supports stepping compiled code, │ │ │ │ - so step will try to compile the resultant anonymous function. If this │ │ │ │ - fails, e.g. because it closes over a non-null lexical environment, an │ │ │ │ - error is signalled. │ │ │ │ -o9MS Liy[9 │ │ │ │ -)Cetj+$%A │ │ │ │ -LABEL.PREFILTER │ │ │ │ -IMM-WORD.PREFILTER │ │ │ │ Return the N'th argument's value if possible. Argument zero is the first │ │ │ │ argument in a frame's default printed representation. Count keyword/value │ │ │ │ pairs as separate arguments. │ │ │ │ Returns a list describing the call stack. Each frame is represented │ │ │ │ by a sublist: │ │ │ │ ( ...args...) │ │ │ │ where the name describes the function responsible for the frame. The name │ │ │ │ @@ -36720,19 +36560,22 @@ │ │ │ │ unspecified, then this returns no values after displaying the distinguishing │ │ │ │ id values. │ │ │ │ The result of this function is limited to the availability of variable │ │ │ │ information. This is SETF'able. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ LOOP-TOKEN │ │ │ │ -FORM SB-KERNEL0 │ │ │ │ -FORM SB-KERNEL8" │ │ │ │ +asdf-output-translations │ │ │ │ +source-registry │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ +common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ +FORM SB-KERNEL0 │ │ │ │ +FORM SB-KERNEL8" │ │ │ │ FORMAT-ARGS │ │ │ │ FORMAT-STRING │ │ │ │ REST-ARG │ │ │ │ OPTIONAL-ARGS │ │ │ │ NEGATE SB-KERNEL │ │ │ │ DATA-TYPE │ │ │ │ FORM SB-KERNEL │ │ │ │ @@ -36874,16 +36717,58 @@ │ │ │ │ a list for each collection, in order. │ │ │ │ E.g., │ │ │ │ (while-collecting (foo bar) │ │ │ │ (dolist (x '((a 1) (b 2) (c 3))) │ │ │ │ (foo (first x)) │ │ │ │ (bar (second x)))) │ │ │ │ Returns two values: (A B C) and (1 2 3). │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ - NEW-VALUE │ │ │ │ + COMPONENT │ │ │ │ + OPERATION0 │ │ │ │ +ASDF/COMPONENT0 │ │ │ │ +Given a designator for a component NAME, return the name as a string. │ │ │ │ +The designator can be a COMPONENT (designing its name; note that a SYSTEM is a component), │ │ │ │ +a SYMBOL (designing its name, downcased), or a STRING (designing itself). │ │ │ │ +Read from STRING using a safe syntax, as per WITH-SAFE-IO-SYNTAX │ │ │ │ +Open FILE for input with given recognizes options, call THUNK with the resulting stream. │ │ │ │ +Other keys are accepted but discarded. │ │ │ │ +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. │ │ │ │ +Return a path from a root system to the COMPONENT. │ │ │ │ +The return value is a list of component NAMES; a list of strings. │ │ │ │ +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. │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP │ │ │ │ +Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME, │ │ │ │ +and NIL NAME, TYPE and VERSION components │ │ │ │ +MERGE-PATHNAMES* is like MERGE-PATHNAMES except that │ │ │ │ +if the SPECIFIED pathname does not have an absolute directory, │ │ │ │ +then the HOST and DEVICE both come from the DEFAULTS, whereas │ │ │ │ +if the SPECIFIED pathname does have an absolute directory, │ │ │ │ +then the HOST and DEVICE both come from the SPECIFIED pathname. │ │ │ │ +This is what users want on a modern Unix or Windows operating system, │ │ │ │ +unlike the MERGE-PATHNAMES behavior. │ │ │ │ +Also, if either argument is NIL, then the other argument is returned unmodified; │ │ │ │ +this is unlike MERGE-PATHNAMES which always merges with a pathname, │ │ │ │ +by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL. │ │ │ │ +PATHSPEC8 │ │ │ │ +If PATHSPEC is a pathname or namestring object that parses as a pathname │ │ │ │ +possessing an :ABSOLUTE directory component, return the (parsed) pathname. │ │ │ │ +Otherwise return NIL │ │ │ │ +Detect circular dependencies │ │ │ │ +Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ + ARGUMENTS │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ ASDF/COMPONENT │ │ │ │ Coerce a system designator NAME into a string suitable as a filename component. │ │ │ │ The (current) transformation is to replace characters /:\ each by --, │ │ │ │ the former being forbidden in a filename component. │ │ │ │ NB: The onus is unhappily on the user to avoid clashes. │ │ │ │ fmt$TDSP4 │ │ │ │ fmt$26JOW8 │ │ │ │ @@ -36952,14 +36837,15 @@ │ │ │ │ with those keys, removing TYPE DEFAULTS and DOT-DOT. │ │ │ │ When you're manipulating pathnames that are supposed to make sense portably │ │ │ │ even though the OS may not be Unixish, we recommend you use :WANT-RELATIVE T │ │ │ │ to throw an error if the pathname is absolute │ │ │ │ :,Pu:pe'f │ │ │ │ Perform the loading of a FASL associated to specified action (O . C), │ │ │ │ an OPERATION and a COMPONENT. │ │ │ │ +uUr]H0mJ │ │ │ │ The unique output file of performing OPERATION on COMPONENT │ │ │ │ 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. │ │ │ │ Variant of PRINC that also calls TERPRI afterwards │ │ │ │ $Ks,=c0W │ │ │ │ z'zuu i, │ │ │ │ Call FUN on all the valid dependencies of the given action in the given plan │ │ │ │ @@ -37009,15 +36895,14 @@ │ │ │ │ actually-existing directory. │ │ │ │ when given a pathname P (designated by a string as per PARSE-NAMESTRING), │ │ │ │ probes the filesystem for a file or directory with given pathname. │ │ │ │ If it exists, return its truename if TRUENAME is true, │ │ │ │ or the original (parsed) pathname if it is false (the default). │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ -uUr]H0mJ │ │ │ │ The type of Lisp implementation used, as a short UIOP-standardized keyword │ │ │ │ Calls FUN with a staging pathname, and atomically │ │ │ │ renames the staging pathname to the PATHNAME in the end. │ │ │ │ NB: this protects only against failure of the program, not against concurrent attempts. │ │ │ │ For the latter case, we ought pick a random suffix and atomically open it. │ │ │ │ OUTPUT0 │ │ │ │ Combine a list of FASLs INPUTS into a single FASL OUTPUT │ │ │ │ @@ -37039,16 +36924,14 @@ │ │ │ │ by letting you supply a symbol or keyword for the name; │ │ │ │ also works well when the package is not present. │ │ │ │ If optional ERROR argument is NIL, return NIL instead of an error │ │ │ │ when the symbol is not found. │ │ │ │ Compute the transitive sub-components of given COMPONENT that are of given TYPE │ │ │ │ Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE? │ │ │ │ If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead. │ │ │ │ -CLEANUP-FUN-42 │ │ │ │ -CLEANUP-FUN-141 │ │ │ │ DEPRECATED: all subclasses of OPERATION used in ASDF should inherit from one of │ │ │ │ DOWNWARD-OPERATION UPWARD-OPERATION SIDEWAY-OPERATION SELFWARD-OPERATION NON-PROPAGATING-OPERATION. │ │ │ │ The function BACKWARD-COMPATIBLE-DEPENDS-ON temporarily provides ASDF2 behaviour for those that │ │ │ │ don't. In the future this functionality will be removed, and the default will be no propagation. │ │ │ │ Convert a list of directives to a list of pathnames. No two │ │ │ │ pathnames in th eresult have the same pathname-name. A directive │ │ │ │ should be a list of a symbol and a pathname. The directive can be │ │ │ │ @@ -37057,54 +36940,48 @@ │ │ │ │ A new empty file with said temporary pathname is created, to ensure there is no │ │ │ │ clash with any concurrent process attempting the same thing. │ │ │ │ create a new OUTPUT file the contents of which a the concatenate of the INPUTS files. │ │ │ │ Rename a file, overwriting any previous file with the TARGET name, │ │ │ │ in an atomic way if the implementation allows. │ │ │ │ Enforce that OPERATION instances must be created with MAKE-OPERATION. │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ + NEW-VALUE │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ LOCATION0 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ NEW-VALUE │ │ │ │ REST-ARG │ │ │ │ +CLEANUP-FUN-42 │ │ │ │ +CLEANUP-FUN-141 │ │ │ │ +sbcl-source │ │ │ │ +These functions were not called: │ │ │ │ +STANDARD method combination accepts no options. │ │ │ │ +COMMON-LISP0 │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP0 │ │ │ │ Returns the canonical combining class (CCC) of CHARACTER │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ -COMMON-LISP0 │ │ │ │ DECLARATION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ NEW-VALUE │ │ │ │ SB-DISASSEM │ │ │ │ COMMON-LISP0 │ │ │ │ +IMM-WORD.PREFILTER │ │ │ │ FP-REG.PRINTER │ │ │ │ COMMON-LISP │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ DOC-TYPE │ │ │ │ NEW-VALUE │ │ │ │ ^L:MW-Z9 │ │ │ │ ^P:MW-Z9 │ │ │ │ IMM-ADDR.PREFILTER │ │ │ │ IMM-BYTE.PREFILTER │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ TZ+yuOZ3 │ │ │ │ -sbcl-source │ │ │ │ -CLEANUP-FUN-5 │ │ │ │ -surplus arguments: ~S │ │ │ │ -V-8QXZ()7695JUITGPFK │ │ │ │ -OHED21430WSL │ │ │ │ -STANDARD method combination accepts no options. │ │ │ │ - uD 3BV,# $! │ │ │ │ -The :DISPLACED-TO array is too small │ │ │ │ -The number of dimensions is not equal to the rank of the array │ │ │ │ -Can't displace an array of type ~S to another of type ~S │ │ │ │ -SYS:SRC;PCL;DLISP2.LISP │ │ │ │ -WRAPPER10 │ │ │ │ -/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ -SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST │ │ │ │ n!gO[Z2% │ │ │ │ CvuPk.CDz[ │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ COMMON-LISP │ │ │ │ Call a function associated with symbol of given name in given package, │ │ │ │ with given ARGS. Useful when the call is read before the package is loaded, │ │ │ │ @@ -37114,28 +36991,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ 4,PW:033S │ │ │ │ 2T~^x3#F │ │ │ │ EicOII>$ │ │ │ │ COMMON-LISP0 │ │ │ │ PACKAGE-DESIGNATOR │ │ │ │ -*ASDF-VERSION* │ │ │ │ -*ASDF-REVISION* │ │ │ │ - #: :U j( │ │ │ │ -/7&!"@#"@ │ │ │ │ -;; loading file │ │ │ │ -;; loading system │ │ │ │ - /%/(%+" │ │ │ │ - NvNii3$( │ │ │ │ -<*9Q 7 & │ │ │ │ -UY]RYck`` │ │ │ │ -+z 4z 4z 4+ │ │ │ │ -&(1,g o │ │ │ │ -") )g │ │ │ │ -Illegal function call in method body: │ │ │ │ COMMON-LISP │ │ │ │ Changes the home package of a symbol, also leaving it present in its old home if any │ │ │ │ SYSTEM0 │ │ │ │ COMMON-LISP │ │ │ │ DEFINE-PACKAGE takes a PACKAGE and a number of CLAUSES, of the form │ │ │ │ (KEYWORD . ARGS). │ │ │ │ DEFINE-PACKAGE supports the following keywords: │ │ │ │ @@ -37170,59 +37033,66 @@ │ │ │ │ nickname and package name pairs. Using this option will cause an error if the │ │ │ │ host CL implementation does not support it. │ │ │ │ USE-REEXPORT, MIX-REEXPORT -- Use or mix the specified packages as per the USE or │ │ │ │ MIX directives, and reexport their contents as per the REEXPORT directive. │ │ │ │ L-)Pu:03 │ │ │ │ ffffff6nkkk │ │ │ │ @y$2QARR7 │ │ │ │ -The function to call if there are errors in the command-line │ │ │ │ -buildapp application. │ │ │ │ ENCODING │ │ │ │ Default, ignorant, function to transform a character ENCODING as a │ │ │ │ portable keyword to an implementation-dependent EXTERNAL-FORMAT specification. │ │ │ │ Load system ASDF-ENCODINGS to hook in a better one. │ │ │ │ Trivial function to use as *encoding-detection-hook*, │ │ │ │ always 'detects' the *default-encoding* │ │ │ │ -DISPATCH-ENTRY │ │ │ │ - DIRECTORY │ │ │ │ -COMMON-LISP │ │ │ │ -Convert the DIRECTORY component from a format usable by the underlying │ │ │ │ -implementation's MAKE-PATHNAME and other primitives to a CLHS-standard format │ │ │ │ -that is a list and not a string. │ │ │ │ -Helper for MERGE-PATHNAMES* that handles directory components │ │ │ │ -Make a pathname component suitable for use in a logical-pathname │ │ │ │ -Given a SYSTEM on which operate is called and the specified FORCE argument, │ │ │ │ -extract a hash-set of systems that are forced, or a predicate on system names, │ │ │ │ -or NIL if none are forced, or :ALL if all are. │ │ │ │ -Given a SYSTEM on which operate is called, the specified FORCE-NOT argument, │ │ │ │ -and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not, │ │ │ │ -or predicate on system names, or NIL if none are forced, or :ALL if all are. │ │ │ │ -Report results from profiling. The results are approximately │ │ │ │ -adjusted for profiling overhead. The compensation may be rather │ │ │ │ -inaccurate when bignums are involved in runtime calculation, as in a │ │ │ │ -very-long-running Lisp process. │ │ │ │ -If LIMIT is set to an integer, only the top LIMIT results are │ │ │ │ -reported. If PRINT-NO-CALL-LIST is T (the default) then a list of │ │ │ │ -uncalled profiled functions are listed. │ │ │ │ -Reset the counters for all profiled functions. │ │ │ │ -If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK │ │ │ │ -and save those warnings to the given file for latter use, │ │ │ │ -possibly in a different process. Otherwise just call THUNK. │ │ │ │ -SETTINGS81 │ │ │ │ -Proclaim the optimization settings in *OPTIMIZATION-SETTINGS* │ │ │ │ -Detect SB-GROVEL unknown-constant conditions on older versions of SBCL │ │ │ │ -Get current compiler optimization settings, ready to PROCLAIM again │ │ │ │ -contrib/debug.lisp │ │ │ │ +surplus arguments: ~S │ │ │ │ +V-8QXZ()7695JUITGPFK │ │ │ │ +OHED21430WSL │ │ │ │ +CLEANUP-FUN-5 │ │ │ │ +sb-aclrepl │ │ │ │ +sb-bsd-sockets │ │ │ │ +sb-capstone │ │ │ │ +sb-cltl2 │ │ │ │ +sb-concurrency │ │ │ │ +sb-cover │ │ │ │ +sb-executable │ │ │ │ +sb-grovel │ │ │ │ +sb-introspect │ │ │ │ +sb-posix │ │ │ │ +sb-queue │ │ │ │ +sb-rotate-byte │ │ │ │ +sb-simple-streams │ │ │ │ +sb-sprof │ │ │ │ +fiveam-asdf │ │ │ │ +asdf-tools │ │ │ │ +asdf-driver │ │ │ │ +The :DISPLACED-TO array is too small │ │ │ │ +The number of dimensions is not equal to the rank of the array │ │ │ │ +Can't displace an array of type ~S to another of type ~S │ │ │ │ +SYS:SRC;PCL;DLISP2.LISP │ │ │ │ +WRAPPER10 │ │ │ │ +/usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ CLEANUP-FUN-14 │ │ │ │ -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. │ │ │ │ +SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST │ │ │ │ + uD 3BV,# $! │ │ │ │ +*ASDF-VERSION* │ │ │ │ +*ASDF-REVISION* │ │ │ │ + #: :U j( │ │ │ │ +/7&!"@#"@ │ │ │ │ +;; loading file │ │ │ │ +;; loading system │ │ │ │ + /%/(%+" │ │ │ │ + NvNii3$( │ │ │ │ +<*9Q 7 & │ │ │ │ +UY]RYck`` │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ ++z 4z 4z 4+ │ │ │ │ +&(1,g o │ │ │ │ +") )g │ │ │ │ +Illegal function call in method body: │ │ │ │ w(,,(%$"l V │ │ │ │ measuring PROFILE overhead.. │ │ │ │ ignoring undefined function ~S │ │ │ │ ~S is already profiled, so unprofiling it first. │ │ │ │ QNNNV"""" │ │ │ │ :'*''*$'*%g │ │ │ │ :KHKHKHKEKKxf │ │ │ │ @@ -37234,39 +37104,46 @@ │ │ │ │ estimated total profiling overhead: │ │ │ │ seconds │ │ │ │ overhead estimation parameters: │ │ │ │ s/call, │ │ │ │ s total profiling, │ │ │ │ s internal profiling │ │ │ │ ~&~@{ ~v:@<~A~>~^|~} │ │ │ │ -FROM-END- │ │ │ │ -Hn[RJfQ\mUPFkWp| │ │ │ │ +contrib/debug.lisp │ │ │ │ +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-115 │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ CLEANUP-FUN-240 │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ -SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ +The function to call if there are errors in the command-line │ │ │ │ +buildapp application. │ │ │ │ wwwwwwwwwww │ │ │ │ +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. │ │ │ │ +Reset the counters for all profiled functions. │ │ │ │ convert (* x 0) to 0 │ │ │ │ -associate */(* /) of constants │ │ │ │ -convert x*2^k to shift │ │ │ │ -optimize multiplication by one │ │ │ │ while handling code walker REPEAT: │ │ │ │ │ │ │ │ ran into STOP while still in REPEAT template │ │ │ │ NTR(* ! │ │ │ │ n+y\LC* │ │ │ │ -SzKzffioo │ │ │ │ -V-8QXZ()7695JUI │ │ │ │ -D21430WSL │ │ │ │ -Argument and result bit arrays are not the same length:~ │ │ │ │ - ~% ~S~% ~S │ │ │ │ +associate */(* /) of constants │ │ │ │ +convert x*2^k to shift │ │ │ │ +optimize multiplication by one │ │ │ │ +OPTIONS0 │ │ │ │ #(p$Hh; Wk │ │ │ │ lVCOSg'/ │ │ │ │ -OPTIONS0 │ │ │ │ Unwrap any profiling code around the named functions, or if no names │ │ │ │ are given, unprofile all profiled functions. A symbol names │ │ │ │ a function. A string names all the functions named by symbols in the │ │ │ │ named package. NAMES defaults to the list of names of all currently │ │ │ │ profiled functions. │ │ │ │ PROFILE Name* │ │ │ │ If no names are supplied, return the list of profiled functions. │ │ │ │ @@ -37274,20 +37151,57 @@ │ │ │ │ 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. │ │ │ │ Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS │ │ │ │ +SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ +V-8QXZ()7695JUI │ │ │ │ +D21430WSL │ │ │ │ +Argument and result bit arrays are not the same length:~ │ │ │ │ + ~% ~S~% ~S │ │ │ │ +/usr/lib/sbcl/contrib/sb-aclrepl.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-bsd-sockets.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-capstone.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-cltl2.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-concurrency.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-cover.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-executable.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-gmp.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-grovel.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-introspect.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-md5.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-mpfr.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-perf.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-posix.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-queue.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-rotate-byte.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-rt.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-simple-streams.asd │ │ │ │ +/usr/lib/sbcl/contrib/sb-sprof.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/contrib/fiveam-asdf/fiveam-asdf.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/tools/asdf-tools.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/uiop/asdf-driver.asd │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/uiop/uiop.asd │ │ │ │ +common-lisp │ │ │ │ +sbcl-2.5.10.debian-linux-x86-s │ │ │ │ Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS │ │ │ │ OMd@ t@% │ │ │ │ L/-`o:01 │ │ │ │ A wrapper macro for code that should only be run when upgrading a │ │ │ │ previously-loaded version of ASDF. │ │ │ │ +If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK │ │ │ │ +and save those warnings to the given file for latter use, │ │ │ │ +possibly in a different process. Otherwise just call THUNK. │ │ │ │ +SETTINGS81 │ │ │ │ +Proclaim the optimization settings in *OPTIMIZATION-SETTINGS* │ │ │ │ +Detect SB-GROVEL unknown-constant conditions on older versions of SBCL │ │ │ │ +Get current compiler optimization settings, ready to PROCLAIM again │ │ │ │ return a portable S-expression, portably readable and writeable in any Common Lisp implementation │ │ │ │ using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by │ │ │ │ WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF. │ │ │ │ This function provides a portable wrapper around COMPILE-FILE. │ │ │ │ It ensures that the OUTPUT-FILE value is only returned and │ │ │ │ the file only actually created if the compilation was successful, │ │ │ │ even though your implementation may not do that. It also checks an optional │ │ │ │ @@ -37304,22 +37218,14 @@ │ │ │ │ If WARNINGS-FILE is defined, deferred warnings are saved to that file. │ │ │ │ On ECL or MKCL, it creates both the linkable object and loadable fasl files. │ │ │ │ On implementations that erroneously do not recognize standard keyword arguments, │ │ │ │ it will filter them appropriately. │ │ │ │ Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled │ │ │ │ Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents │ │ │ │ Given the results of COMPILE-FILE, raise an error or warning as appropriate │ │ │ │ -CLEANUP-FUN-3 │ │ │ │ -CLEANUP-FUN-0 │ │ │ │ -CLEANUP-FUN-47 │ │ │ │ -VERTEX-SC │ │ │ │ -common-lisp │ │ │ │ -sbcl-2.5.10.debian-linux-x86-s │ │ │ │ -asdf-output-translations.conf.d │ │ │ │ -source-registry.conf.d │ │ │ │ L2mX^UY)mS │ │ │ │ Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT. │ │ │ │ One of three functions required for deferred-warnings support in ASDF. │ │ │ │ INPUT-FILE │ │ │ │ From a INPUT-FILE pathname, return a corresponding .lisp source pathname │ │ │ │ COMMON-LISP │ │ │ │ Portably read and evaluate forms from a STRING. │ │ │ │ @@ -37481,14 +37387,21 @@ │ │ │ │ also "Configuration DSL") in the ASDF manual. │ │ │ │ Given a designator X for an relative location, resolve it to a pathname. │ │ │ │ Semi-portable implementation of a subset of LispWorks' sys:get-folder-path, │ │ │ │ this function tries to locate the Windows FOLDER for one of │ │ │ │ :LOCAL-APPDATA, :APPDATA or :COMMON-APPDATA. │ │ │ │ Returns NIL when the folder is not defined (e.g., not on Windows). │ │ │ │ Try to locate the UIOP source directory at runtime │ │ │ │ +CLEANUP-FUN-3 │ │ │ │ +CLEANUP-FUN-4 │ │ │ │ +CLEANUP-FUN-0 │ │ │ │ +CLEANUP-FUN-47 │ │ │ │ +CLEANUP-FUN-226 │ │ │ │ +CLEANUP-FUN-53 │ │ │ │ +VERTEX-SC │ │ │ │ Given a designator X for an absolute location, resolve it to a pathname │ │ │ │ REST-ARG │ │ │ │ The base directory relative to which user specific non-essential data files should be stored. │ │ │ │ Returns an absolute directory pathname. │ │ │ │ MORE may contain specifications for a subpath relative to this directory: a │ │ │ │ subpathname specification and keyword arguments as per RESOLVE-LOCATION (see │ │ │ │ also "Configuration DSL") in the ASDF manual. │ │ │ │ @@ -37575,14 +37488,15 @@ │ │ │ │ Traverses the tree in order, collecting non-null leaves into a list. │ │ │ │ fmt$QFKN1 │ │ │ │ The function to call if there are errors when loading the dump file. │ │ │ │ Return a list of forms to be saved to a dumpfile. │ │ │ │ fmt$1LIRVR │ │ │ │ Search for FILE in *LOAD-SEARCH-PATHS* and, if found, load │ │ │ │ it. If an exact filename is not found, file.lisp is also tried. │ │ │ │ +DISPATCH-ENTRY │ │ │ │ Return a random string with LENGTH characters. │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP0 │ │ │ │ Return a list of forms to implement DUMPER's actions, i.e. the │ │ │ │ --load, --load-system, --require, and --eval arguments. │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -37613,14 +37527,29 @@ │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP0 │ │ │ │ DIRECTORY │ │ │ │ COMMON-LISP │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ ASDF/SYSTEM │ │ │ │ + DIRECTORY │ │ │ │ +COMMON-LISP │ │ │ │ +Convert the DIRECTORY component from a format usable by the underlying │ │ │ │ +implementation's MAKE-PATHNAME and other primitives to a CLHS-standard format │ │ │ │ +that is a list and not a string. │ │ │ │ +Helper for MERGE-PATHNAMES* that handles directory components │ │ │ │ +Make a pathname component suitable for use in a logical-pathname │ │ │ │ +Given a SYSTEM on which operate is called and the specified FORCE argument, │ │ │ │ +extract a hash-set of systems that are forced, or a predicate on system names, │ │ │ │ +or NIL if none are forced, or :ALL if all are. │ │ │ │ +Given a SYSTEM on which operate is called, the specified FORCE-NOT argument, │ │ │ │ +and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not, │ │ │ │ +or predicate on system names, or NIL if none are forced, or :ALL if all are. │ │ │ │ +asdf-output-translations.conf.d │ │ │ │ +source-registry.conf.d │ │ │ │ Coerces its argument into a PATHNAME, │ │ │ │ optionally doing some transformations and checking specified constraints. │ │ │ │ If the argument is NIL, then NIL is returned unless the WANT-PATHNAME constraint is specified. │ │ │ │ If the argument is a STRING, it is first converted to a pathname via │ │ │ │ PARSE-UNIX-NAMESTRING, PARSE-NAMESTRING or PARSE-NATIVE-NAMESTRING respectively │ │ │ │ depending on the NAMESTRING argument being :UNIX, :LISP or :NATIVE respectively, │ │ │ │ or else by using CALL-FUNCTION on the NAMESTRING argument; │ │ │ │ @@ -37705,19 +37634,14 @@ │ │ │ │ We assume filename has no directory component. │ │ │ │ The last . if any separates name and type from from type, │ │ │ │ except that if there is only one . and it is in first position, │ │ │ │ the whole filename is the NAME with an empty type. │ │ │ │ NAME is always a string. │ │ │ │ For an empty type, *UNSPECIFIC-PATHNAME-TYPE* is returned. │ │ │ │ What character does the current OS conventionally uses to separate directories? │ │ │ │ -MORE-ARG │ │ │ │ -The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO). │ │ │ │ -It will build system FOO using the operation BUILD-OP, │ │ │ │ -the meaning of which is configurable by the system, and │ │ │ │ -defaults to LOAD-OP, to load it in current image. │ │ │ │ Is this action valid to include amongst dependencies? │ │ │ │ A partial test of the values of a component. │ │ │ │ COMPONENT │ │ │ │ ASDF/COMPONENT0 │ │ │ │ COMMON-LISP │ │ │ │ Is the PATHNAME under the current installation of the CL implementation? │ │ │ │ Parse the dependency defs in DD-LIST into canonical form by translating all │ │ │ │ @@ -37758,45 +37682,19 @@ │ │ │ │ your reader will not have magically used the KEYWORD package, so you need specify │ │ │ │ keywords explicitly. │ │ │ │ Given a VERSION string, and the starting versions for notifying the programmer of │ │ │ │ various levels of deprecation, return the current level of deprecation as per WITH-DEPRECATION │ │ │ │ that is the highest level that has a declared version older than the specified version. │ │ │ │ Each start version for a level of deprecation can be specified by a keyword argument, or │ │ │ │ if left unspecified, will be the NEXT-VERSION of the immediate lower level of deprecation. │ │ │ │ -SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ -Read the contents of the INPUT stream as a list of forms, │ │ │ │ -then return the ACCESS-AT of these forms following the AT. │ │ │ │ -AT defaults to 0, i.e. return the first form. │ │ │ │ -AT is typically a list of integers. │ │ │ │ -If AT is NIL, it will return all the forms in the file. │ │ │ │ -The stream will not be read beyond the Nth form, │ │ │ │ -where N is the index specified by path, │ │ │ │ -if path is either an integer or a list that starts with an integer. │ │ │ │ -BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ -Read the contents of the INPUT stream as a list of forms, │ │ │ │ -and return those forms. │ │ │ │ -If COUNT is null, read to the end of the stream; │ │ │ │ -if COUNT is an integer, stop after COUNT forms were read. │ │ │ │ -BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ -Read the contents of the INPUT stream as a list of lines, │ │ │ │ -then return the ACCESS-AT of that list of lines using the AT specifier. │ │ │ │ -PATH defaults to 0, i.e. return the first line. │ │ │ │ -PATH is typically an integer, or a list of an integer and a function. │ │ │ │ -If PATH is NIL, it will return all the lines in the file. │ │ │ │ -The stream will not be read beyond the Nth lines, │ │ │ │ -where N is the index specified by path │ │ │ │ -if path is either an integer or a list that starts with an integer. │ │ │ │ -Read the contents of the INPUT stream as a list of lines, return those lines. │ │ │ │ -Note: relies on the Lisp's READ-LINE, but additionally removes any remaining CR │ │ │ │ -from the line-ending if the file or stream had CR+LF but Lisp only removed LF. │ │ │ │ -Read no more than COUNT lines. │ │ │ │ -Read the contents of the INPUT stream as a string │ │ │ │ -CLEANUP-FUN-4 │ │ │ │ -CLEANUP-FUN-226 │ │ │ │ -Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ +MORE-ARG │ │ │ │ +The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO). │ │ │ │ +It will build system FOO using the operation BUILD-OP, │ │ │ │ +the meaning of which is configurable by the system, and │ │ │ │ +defaults to LOAD-OP, to load it in current image. │ │ │ │ return the hostname of the current host │ │ │ │ 70G';|.; │ │ │ │ Shorthand for `(asdf:operate 'asdf:test-op system)`. See OPERATE for details. │ │ │ │ Apply FN to each defined system. │ │ │ │ FN should be a function of one argument. It will be │ │ │ │ called with an object of type asdf:system. │ │ │ │ SYSTEM-NAME │ │ │ │ @@ -37846,14 +37744,15 @@ │ │ │ │ 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 │ │ │ │ +Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ 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? │ │ │ │ @@ -37922,45 +37821,58 @@ │ │ │ │ &ZE h%vo │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ A readable data structure that identifies the action. │ │ │ │ Reconstitute an action from its action-path │ │ │ │ FORMAT helper to display an action's action-description. │ │ │ │ Use it in FORMAT control strings as ~/asdf-action:format-action/ │ │ │ │ -CLEANUP-FUN-53 │ │ │ │ -Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ -where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ -on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ -?haeSzv] │ │ │ │ -VT*P2 D# │ │ │ │ -Executes BODY with the elements of VARS bound to the iteration │ │ │ │ - state returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ - ARGS. Elements of VARS may be NIL in which case the corresponding │ │ │ │ - value returned by MAKE-SEQUENCE-ITERATOR is ignored. │ │ │ │ -Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ -bound to local functions which execute the iteration state query and │ │ │ │ -mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ -ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ -name, no local functions are established for those names. The │ │ │ │ -functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ -dynamic extent. │ │ │ │ -Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ - SEQUENCE, then returns RETURN. │ │ │ │ -Evaluate BODY in a context when VAR is bound to an input stream that always returns end of file. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ -Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ P]D!`_eW │ │ │ │ ASDF/COMPONENT │ │ │ │ COMMON-LISP │ │ │ │ Is the provided version a compatible substitution for the required-version? │ │ │ │ If major versions differ, it's not compatible. │ │ │ │ If they are equal, then any later version is compatible, │ │ │ │ with later being determined by a lexicographical comparison of minor numbers. │ │ │ │ DEPRECATED. │ │ │ │ DEPRECATED. Please use UIOP:PARSE-UNIX-NAMESTRING instead. │ │ │ │ +Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ +where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ +on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ +?haeSzv] │ │ │ │ +Read the contents of the INPUT stream as a list of forms, │ │ │ │ +then return the ACCESS-AT of these forms following the AT. │ │ │ │ +AT defaults to 0, i.e. return the first form. │ │ │ │ +AT is typically a list of integers. │ │ │ │ +If AT is NIL, it will return all the forms in the file. │ │ │ │ +The stream will not be read beyond the Nth form, │ │ │ │ +where N is the index specified by path, │ │ │ │ +if path is either an integer or a list that starts with an integer. │ │ │ │ +BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ +Read the contents of the INPUT stream as a list of forms, │ │ │ │ +and return those forms. │ │ │ │ +If COUNT is null, read to the end of the stream; │ │ │ │ +if COUNT is an integer, stop after COUNT forms were read. │ │ │ │ +BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ +Read the contents of the INPUT stream as a list of lines, │ │ │ │ +then return the ACCESS-AT of that list of lines using the AT specifier. │ │ │ │ +PATH defaults to 0, i.e. return the first line. │ │ │ │ +PATH is typically an integer, or a list of an integer and a function. │ │ │ │ +If PATH is NIL, it will return all the lines in the file. │ │ │ │ +The stream will not be read beyond the Nth lines, │ │ │ │ +where N is the index specified by path │ │ │ │ +if path is either an integer or a list that starts with an integer. │ │ │ │ +Read the contents of the INPUT stream as a list of lines, return those lines. │ │ │ │ +Note: relies on the Lisp's READ-LINE, but additionally removes any remaining CR │ │ │ │ +from the line-ending if the file or stream had CR+LF but Lisp only removed LF. │ │ │ │ +Read no more than COUNT lines. │ │ │ │ +Read the contents of the INPUT stream as a string │ │ │ │ + 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. │ │ │ │ Return a list of the files in a directory according to the PATTERN. │ │ │ │ Subdirectories should NOT be returned. │ │ │ │ PATTERN defaults to a pattern carefully chosen based on the implementation; │ │ │ │ override the default at your own risk. │ │ │ │ DIRECTORY-FILES tries NOT to resolve symlinks if the implementation permits this, │ │ │ │ but the behavior in presence of symlinks is not portable. Use IOlib to handle such situations. │ │ │ │ Extract a list of pathname from a user-configured environment variable, as per native OS, │ │ │ │ @@ -38216,79 +38128,43 @@ │ │ │ │ Parse a VERSION-STRING as a series of natural numbers separated by dots. │ │ │ │ Return a (non-null) list of integers if the string is valid; │ │ │ │ otherwise return NIL. │ │ │ │ When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL, │ │ │ │ with format arguments explaining why the version is invalid. │ │ │ │ ON-ERROR is also called if the version is not canonical │ │ │ │ in that it doesn't print back to itself, but the list is returned anyway. │ │ │ │ -R1SU&f?% │ │ │ │ -Evaluate BODY where the symbols specified by keyword arguments │ │ │ │ -STREAM and PATHNAME (if respectively specified) are bound corresponding │ │ │ │ -to a newly created temporary file ready for I/O, as per CALL-WITH-TEMPORARY-FILE. │ │ │ │ -At least one of STREAM or PATHNAME must be specified. │ │ │ │ -If the STREAM is not specified, it will be closed before the BODY is evaluated. │ │ │ │ -If STREAM is specified, then the :CLOSE-STREAM label if it appears in the BODY, │ │ │ │ -separates forms run before and after the stream is closed. │ │ │ │ -The values of the last form of the BODY (not counting the separating :CLOSE-STREAM) are returned. │ │ │ │ -Upon success, the KEEP form is evaluated and the file is is deleted unless it evaluates to TRUE. │ │ │ │ -Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ -Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ -of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ -the scope of this binding. │ │ │ │ -Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR) │ │ │ │ -as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding. │ │ │ │ -Establish safe CL reader options around the evaluation of BODY │ │ │ │ -Call BODY while the POSIX current working directory is set to DIR │ │ │ │ -Evaluate BODY in a context when VAR is bound to an output stream that discards all output. │ │ │ │ -The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ -Given a deprecation LEVEL (a form to be EVAL'ed at macro-expansion time), instrument the │ │ │ │ -DEFUN and DEFMETHOD forms in DEFINITIONS to notify the programmer of the deprecation of the function │ │ │ │ -when it is compiled or called. │ │ │ │ -Increasing levels (as result from evaluating LEVEL) are: NIL (not deprecated yet), │ │ │ │ -:STYLE-WARNING (a style warning is issued when used), :WARNING (a full warning is issued when used), │ │ │ │ -:ERROR (a continuable error instead), and :DELETE (it's an error if the code is still there while │ │ │ │ -at that level). │ │ │ │ -Forms other than DEFUN and DEFMETHOD are not instrumented, and you can protect a DEFUN or DEFMETHOD │ │ │ │ -from instrumentation by enclosing it in a PROGN. │ │ │ │ -SB-DISASSEM │ │ │ │ -COMMON-LISP │ │ │ │ +SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ V-8QXZ()7695JU │ │ │ │ D21430WS │ │ │ │ -reproducible-path │ │ │ │ -buildapp-1.5.6 │ │ │ │ CLEANUP-FUN-34 │ │ │ │ CLEANUP-FUN-20 │ │ │ │ BEFORE77 │ │ │ │ +reproducible-path │ │ │ │ +buildapp-1.5.6 │ │ │ │ WRAPPER228 │ │ │ │ WRAPPER72 │ │ │ │ WRAPPER7 │ │ │ │ BEFORE199 │ │ │ │ -CLEANUP-FUN-242 │ │ │ │ V-8QXZ()7695J │ │ │ │ +CLEANUP-FUN-242 │ │ │ │ CLEANUP-FUN-188 │ │ │ │ CLEANUP-FUN-336 │ │ │ │ +CLEANUP-FUN-32 │ │ │ │ CLEANUP-FUN-100 │ │ │ │ CLEANUP-FUN-69 │ │ │ │ -CLEANUP-FUN-32 │ │ │ │ -bitmap describing the status of the action. │ │ │ │ -STAMP associated with the ACTION if it has been completed already in some │ │ │ │ -previous session or image, T if it was done and builtin the image, or NIL if it needs to be done. │ │ │ │ -the highest (operate-level) at which the action was needed │ │ │ │ -INDEX associated with the ACTION in the current session, │ │ │ │ -or NIL if no the status is considered outside of a specific plan. │ │ │ │ -Forcing parameters for the session │ │ │ │ CLEANUP-FUN-24 │ │ │ │ CLEANUP-FUN-57 │ │ │ │ +Forcing parameters for the session │ │ │ │ +8QXZ()7695J │ │ │ │ +Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ +sbcl-2.5.10.debian-linux-x86 │ │ │ │ Top level session that this is part of │ │ │ │ Memoize expensive computations │ │ │ │ Number of nested calls to operate we're under (for toplevel session only) │ │ │ │ Was ASDF already upgraded in this session - only valid for toplevel-asdf-session. │ │ │ │ -8QXZ()7695J │ │ │ │ -Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ -sbcl-2.5.10.debian-linux-x86 │ │ │ │ undefined_alien_address │ │ │ │ alien_linkage_table_n_prelinked │ │ │ │ lisp_init_time │ │ │ │ sbcl_runtime │ │ │ │ posix_argv │ │ │ │ core_string │ │ │ │ gc_card_table_nbits │ │ │ │ @@ -38441,32 +38317,32 @@ │ │ │ │ invoking │ │ │ │ Don't know how to infer package dependencies for non-standard option │ │ │ │ while trying to define package-inferred-system │ │ │ │ High bound is not * or a rational or list of one rational: ~S │ │ │ │ Low bound is not * or a rational or list of one rational: ~S │ │ │ │ ~@ │ │ │ │ funcallable-structure-instance allocation with slots unimplemented │ │ │ │ -sb-aclrepl │ │ │ │ -sb-bsd-sockets │ │ │ │ -sb-capstone │ │ │ │ -sb-cltl2 │ │ │ │ -sb-concurrency │ │ │ │ -sb-cover │ │ │ │ -sb-executable │ │ │ │ -sb-grovel │ │ │ │ -sb-introspect │ │ │ │ -sb-posix │ │ │ │ -sb-queue │ │ │ │ -sb-rotate-byte │ │ │ │ -sb-simple-streams │ │ │ │ -sb-sprof │ │ │ │ -fiveam-asdf │ │ │ │ -asdf-tools │ │ │ │ -asdf-driver │ │ │ │ +close_current_thread_tlab │ │ │ │ +close_code_region │ │ │ │ +sb_get_os_thread_id │ │ │ │ +wifcontinued │ │ │ │ +wifstopped │ │ │ │ +unlockpt │ │ │ │ +wait_for_exec │ │ │ │ +gc_pathfind │ │ │ │ +gc_and_save │ │ │ │ +HASH-KEYS │ │ │ │ +HASH-VALUES │ │ │ │ +EXTERNAL-SYMBOL │ │ │ │ +PRESENT-SYMBOL │ │ │ │ +PRESENT-SYMBOLS │ │ │ │ asdf-package-system │ │ │ │ +FROM-END- │ │ │ │ +Hn[RJfQ\mUPFkWp| │ │ │ │ +SzKzffioo │ │ │ │ searching │ │ │ │ evaluated │ │ │ │ absolute │ │ │ │ directory. │ │ │ │ replace │ │ │ │ continue. │ │ │ │ the value of the most recent top level EVAL │ │ │ │ @@ -38622,95 +38498,215 @@ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ +bogus arguments to MOV: ~S ~S │ │ │ │ +bogus args to XCHG: ~S ~S │ │ │ │ +bogus operands for TEST: ~S and ~S │ │ │ │ +don't know what to do with ~A │ │ │ │ +can't bounds-test bytes: ~S │ │ │ │ 0$%"%7$%" │ │ │ │ }(( =( │ │ │ │ FOB0v 2. │ │ │ │ ]c61S_;C │ │ │ │ P1V=Q6i │ │ │ │ +lisp_init_function │ │ │ │ +tot_gc_nsec │ │ │ │ +gc_coalesce_string_literals │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if │ │ │ │ none exists. │ │ │ │ ALLOW-EXIT │ │ │ │ COMMON-LISP │ │ │ │ Converts any REAL to a float. If OTHER is not provided, it returns a │ │ │ │ SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the │ │ │ │ result is the same float format as OTHER. │ │ │ │ SLOT-SPECS │ │ │ │ 2(`o:p`% │ │ │ │ >EC^+|WM │ │ │ │ -/usr/lib/sbcl/contrib/sb-aclrepl.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-bsd-sockets.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-capstone.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-cltl2.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-concurrency.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-cover.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-executable.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-gmp.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-grovel.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-introspect.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-md5.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-mpfr.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-perf.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-posix.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-queue.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-rotate-byte.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-rt.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-simple-streams.asd │ │ │ │ -/usr/lib/sbcl/contrib/sb-sprof.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/contrib/fiveam-asdf/fiveam-asdf.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/tools/asdf-tools.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/uiop/asdf-driver.asd │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/uiop/uiop.asd │ │ │ │ +VT*P2 D# │ │ │ │ +Executes BODY with the elements of VARS bound to the iteration │ │ │ │ + state returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ + ARGS. Elements of VARS may be NIL in which case the corresponding │ │ │ │ + value returned by MAKE-SEQUENCE-ITERATOR is ignored. │ │ │ │ +Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ +bound to local functions which execute the iteration state query and │ │ │ │ +mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ +ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ +name, no local functions are established for those names. The │ │ │ │ +functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ +dynamic extent. │ │ │ │ +Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ + SEQUENCE, then returns RETURN. │ │ │ │ +Evaluate BODY in a context when VAR is bound to an input stream that always returns end of file. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ +Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ +R1SU&f?% │ │ │ │ +Evaluate BODY where the symbols specified by keyword arguments │ │ │ │ +STREAM and PATHNAME (if respectively specified) are bound corresponding │ │ │ │ +to a newly created temporary file ready for I/O, as per CALL-WITH-TEMPORARY-FILE. │ │ │ │ +At least one of STREAM or PATHNAME must be specified. │ │ │ │ +If the STREAM is not specified, it will be closed before the BODY is evaluated. │ │ │ │ +If STREAM is specified, then the :CLOSE-STREAM label if it appears in the BODY, │ │ │ │ +separates forms run before and after the stream is closed. │ │ │ │ +The values of the last form of the BODY (not counting the separating :CLOSE-STREAM) are returned. │ │ │ │ +Upon success, the KEEP form is evaluated and the file is is deleted unless it evaluates to TRUE. │ │ │ │ +Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ +Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ +of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ +the scope of this binding. │ │ │ │ +Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR) │ │ │ │ +as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding. │ │ │ │ +Establish safe CL reader options around the evaluation of BODY │ │ │ │ +Call BODY while the POSIX current working directory is set to DIR │ │ │ │ +Evaluate BODY in a context when VAR is bound to an output stream that discards all output. │ │ │ │ +The keyword arguments are allowed for backward compatibility, but are ignored. │ │ │ │ +Given a deprecation LEVEL (a form to be EVAL'ed at macro-expansion time), instrument the │ │ │ │ +DEFUN and DEFMETHOD forms in DEFINITIONS to notify the programmer of the deprecation of the function │ │ │ │ +when it is compiled or called. │ │ │ │ +Increasing levels (as result from evaluating LEVEL) are: NIL (not deprecated yet), │ │ │ │ +:STYLE-WARNING (a style warning is issued when used), :WARNING (a full warning is issued when used), │ │ │ │ +:ERROR (a continuable error instead), and :DELETE (it's an error if the code is still there while │ │ │ │ +at that level). │ │ │ │ +Forms other than DEFUN and DEFMETHOD are not instrumented, and you can protect a DEFUN or DEFMETHOD │ │ │ │ +from instrumentation by enclosing it in a PROGN. │ │ │ │ +SB-DISASSEM │ │ │ │ +COMMON-LISP │ │ │ │ +ASDF/COMPONENT │ │ │ │ + SLOT-NAME │ │ │ │ + NEW-VALUE0 │ │ │ │ Erase any data from a SYSTEM except its basic identity, then reinitialize it │ │ │ │ based on supplied KEYS. │ │ │ │ Clear all currently registered defined systems. │ │ │ │ Preloaded systems (including immutable ones) will be reset, other systems will be de-registered. │ │ │ │ :-@u:CQQ │ │ │ │ +EaTm+FeD} │ │ │ │ +8L@#$r`& │ │ │ │ +The character ~S is a surrogate, which should not │ │ │ │ +appear in an SBCL string. The line-breaking behavior of surrogates is undefined. │ │ │ │ + $","("()@ │ │ │ │ fmt$2Q680T │ │ │ │ Mark a component as preloaded. │ │ │ │ Return a list containing every registered system (as a system object). │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP8 │ │ │ │ ASDF/COMPONENT │ │ │ │ - NEW-VALUE0 │ │ │ │ - SLOT-NAME │ │ │ │ -Return SYSTEM's virtual SLOT-NAME value. │ │ │ │ -If SYSTEM's SLOT-NAME value is NIL and SYSTEM is a secondary system, look in │ │ │ │ -the primary one. │ │ │ │ .A@cYH,f │ │ │ │ -ASDF/COMPONENT │ │ │ │ - SLOT-NAME │ │ │ │ -EaTm+FeD} │ │ │ │ -8L@#$r`& │ │ │ │ -The character ~S is a surrogate, which should not │ │ │ │ -appear in an SBCL string. The line-breaking behavior of surrogates is undefined. │ │ │ │ - $","("()@ │ │ │ │ Set an environment variable. │ │ │ │ -WORD-ACCUM.PRINTER │ │ │ │ -COMMON-LISP │ │ │ │ PACKED-INFO-EQUALP │ │ │ │ SPLIT-ORDERED-LIST-EQUALP │ │ │ │ LAYOUT-EQUALP │ │ │ │ CLASSOID-CELL-EQUALP │ │ │ │ NAMED-TYPE-EQUALP │ │ │ │ DEFINITION-SOURCE-LOCATION-EQUALP │ │ │ │ STRUCTURE-CLASSOID-EQUALP │ │ │ │ UNION-TYPE-EQUALP │ │ │ │ NUMERIC-UNION-TYPE-EQUALP │ │ │ │ CONS-TYPE-EQUALP │ │ │ │ ARRAY-TYPE-EQUALP │ │ │ │ DEFSTRUCT-DESCRIPTION-EQUALP │ │ │ │ -Takes SYSTEM-NAME and returns an initialized SYSTEM object, or NIL. Made to be added to │ │ │ │ -*SYSTEM-DEFINITION-SEARCH-FUNCTIONS*. │ │ │ │ +7jUDIQ&| │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SRC-SIZE │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +SEGMENT0 │ │ │ │ +Rp