--- /srv/reproducible-results/rbuild-debian/r-b-build.Tu203RYK/b1/buildapp_1.5.6-3_i386.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.Tu203RYK/b2/buildapp_1.5.6-3_i386.changes ├── Files │ @@ -1,2 +1,2 @@ │ │ - a9b7f242c88cfd583629eb4bc3ab4257 7522548 lisp optional buildapp_1.5.6-3_i386.deb │ + 39496c9be212fce819fb7958a08236ed 7546936 lisp optional buildapp_1.5.6-3_i386.deb ├── buildapp_1.5.6-3_i386.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2021-11-10 19:52:07.000000 debian-binary │ │ --rw-r--r-- 0 0 0 796 2021-11-10 19:52:07.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 7521560 2021-11-10 19:52:07.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 800 2021-11-10 19:52:07.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 7545944 2021-11-10 19:52:07.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./control │ │ │ │ @@ -1,12 +1,12 @@ │ │ │ │ Package: buildapp │ │ │ │ Version: 1.5.6-3 │ │ │ │ Architecture: i386 │ │ │ │ Maintainer: Debian Common Lisp Team │ │ │ │ -Installed-Size: 25787 │ │ │ │ +Installed-Size: 25807 │ │ │ │ Depends: libc6 (>= 2.38), libzstd1 (>= 1.5.5), sbcl │ │ │ │ Section: lisp │ │ │ │ Priority: optional │ │ │ │ Homepage: https://www.xach.com/lisp/buildapp/ │ │ │ │ Description: application to create common lisp images │ │ │ │ Buildapp is an application for SBCL that configures and saves an │ │ │ │ executable Common Lisp image. It is similar to cl-launch and │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/bin/ │ │ │ │ --rwxr-xr-x 0 root (0) root (0) 26368924 2021-11-10 19:52:07.000000 ./usr/bin/buildapp │ │ │ │ +-rwxr-xr-x 0 root (0) root (0) 26389432 2021-11-10 19:52:07.000000 ./usr/bin/buildapp │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/doc/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2021-11-10 19:52:07.000000 ./usr/share/doc/buildapp/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 875 2021-11-10 19:52:07.000000 ./usr/share/doc/buildapp/changelog.Debian.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1607 2021-11-10 19:45:23.000000 ./usr/share/doc/buildapp/copyright │ │ │ │ -rw-r--r-- 0 root (0) root (0) 19096 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1168 2015-11-08 00:29:26.000000 ./usr/share/doc/buildapp/style.css │ │ │ ├── ./usr/bin/buildapp │ │ │ │┄ File has been modified after NT_GNU_BUILD_ID has been applied. │ │ │ │ ├── strings --all --bytes=8 {} │ │ │ │ │ @@ -1729,22 +1729,33 @@ │ │ │ │ │ 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 │ │ │ │ │ -/a0I1)212a3 │ │ │ │ │ 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. │ │ │ │ │ +/90I1)212a3 │ │ │ │ │ This is a hash table whose keys are strings -- the names of systems -- │ │ │ │ │ and whose values are systems. │ │ │ │ │ A system is referred to as "registered" if it is present in this table. │ │ │ │ │ +The default class for sessions │ │ │ │ │ +A hash-set (equal hash-table mapping keys to T) of systems that are immutable, │ │ │ │ │ +i.e. already loaded in memory and not to be refreshed from the filesystem. │ │ │ │ │ +They will be treated specially by find-system, and passed as :force-not argument to make-plan. │ │ │ │ │ +For instance, to can deliver an image with many systems precompiled, that *will not* check the │ │ │ │ │ +filesystem for them every time a user loads an extension, what more risk a problematic upgrade │ │ │ │ │ + or catastrophic downgrade, before you dump an image, you may use: │ │ │ │ │ + (map () 'asdf:register-immutable-system (asdf:already-loaded-systems)) │ │ │ │ │ +Note that direct access to this variable from outside ASDF is not supported. │ │ │ │ │ +Please call REGISTER-IMMUTABLE-SYSTEM to add new immutable systems, and │ │ │ │ │ +contact maintainers if you need a stable API to do more than that. │ │ │ │ │ A specification as per RESOLVE-LOCATION of where the user keeps his FASL cache │ │ │ │ │ Hook for an extension (e.g. ASDF-ENCODINGS) to define a better mapping │ │ │ │ │ from non-default encodings to and implementation-defined external-format's │ │ │ │ │ List of default source registries │ │ │ │ │ Hook for an extension to define a function to automatically detect a file's encoding │ │ │ │ │ A list of 'system directory designators' ASDF uses to find systems. │ │ │ │ │ A 'system directory designator' is a pathname or an expression │ │ │ │ │ @@ -1766,15 +1777,14 @@ │ │ │ │ │ Defaults to T. │ │ │ │ │ Pathname type for warnings files, or NIL if disabled │ │ │ │ │ The type of Lisp implementation used, as a short UIOP-standardized keyword │ │ │ │ │ Have configuration forms been ignored while parsing the configuration? │ │ │ │ │ This special variable is bound to the currect directory during calls to │ │ │ │ │ PROCESS-SOURCE-REGISTRY in order that we be able to interpret the :here │ │ │ │ │ directive. │ │ │ │ │ -The default class for sessions │ │ │ │ │ Wild directory component for use with MAKE-PATHNAME │ │ │ │ │ Wild-inferiors directory component for use with MAKE-PATHNAME │ │ │ │ │ Unspecific type component to use with the underlying implementation's MAKE-PATHNAME │ │ │ │ │ A pathname object with wildcards for matching any subdirectory │ │ │ │ │ A pathname that is as neutral as possible for use as defaults │ │ │ │ │ when merging, making or parsing pathnames │ │ │ │ │ Wild component for use with MAKE-PATHNAME │ │ │ │ │ @@ -1787,57 +1797,48 @@ │ │ │ │ │ which will serve as the *DEFAULT-PATHNAME-DEFAULTS* around a COMPILE-FILE, │ │ │ │ │ what more while the input-file is shortened if possible to ENOUGH-PATHNAME relative to it. │ │ │ │ │ This can help you produce more deterministic output for FASLs. │ │ │ │ │ A hook for user-defined compile-time invariants │ │ │ │ │ Additional conditions that may be skipped while compiling Lisp code. │ │ │ │ │ Conditions that may be skipped while compiling or loading Lisp code. │ │ │ │ │ A suggested value to which to set or bind *uninteresting-conditions*. │ │ │ │ │ -A hash-set (equal hash-table mapping keys to T) of systems that are immutable, │ │ │ │ │ -i.e. already loaded in memory and not to be refreshed from the filesystem. │ │ │ │ │ -They will be treated specially by find-system, and passed as :force-not argument to make-plan. │ │ │ │ │ -For instance, to can deliver an image with many systems precompiled, that *will not* check the │ │ │ │ │ -filesystem for them every time a user loads an extension, what more risk a problematic upgrade │ │ │ │ │ - or catastrophic downgrade, before you dump an image, you may use: │ │ │ │ │ - (map () 'asdf:register-immutable-system (asdf:already-loaded-systems)) │ │ │ │ │ -Note that direct access to this variable from outside ASDF is not supported. │ │ │ │ │ -Please call REGISTER-IMMUTABLE-SYSTEM to add new immutable systems, and │ │ │ │ │ -contact maintainers if you need a stable API to do more than that. │ │ │ │ │ Name of the slot for FORMAT-CONTROL in simple-condition │ │ │ │ │ form that evaluates to the pathname to your favorite debugging utilities │ │ │ │ │ Either NIL (for uninitialized), or a list of one element, │ │ │ │ │ said element itself being a sorted list of mappings. │ │ │ │ │ Each mapping is a pair of a source pathname and destination pathname, │ │ │ │ │ and the order is by decreasing length of namestring of the source pathname. │ │ │ │ │ Either NIL (for uninitialized), or an equal hash-table, mapping │ │ │ │ │ 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. │ │ │ │ │ +3333%3333 │ │ │ │ │ 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 │ │ │ │ │ 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 │ │ │ │ │ when the image is restarted, but before the entry point is called. │ │ │ │ │ a form to evaluate, or string containing forms to read and evaluate │ │ │ │ │ before the image dump hooks are called and before the image is dumped. │ │ │ │ │ -3333%3333 │ │ │ │ │ -SYS:make-target-2-load.lisp │ │ │ │ │ +%H&z&k'C │ │ │ │ │ Registration table for preloaded systems. │ │ │ │ │ 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 │ │ │ │ │ -`,glh,hl │ │ │ │ │ -^{^[`;`{a │ │ │ │ │ +SYS:make-target-2-load.lisp │ │ │ │ │ +XgXgY'Xg │ │ │ │ │ +nPn0pPp0 │ │ │ │ │ '5(j)6*r │ │ │ │ │ r0r(sKt~u │ │ │ │ │ DUMPER131 │ │ │ │ │ MAYBE-MUFFLE │ │ │ │ │ Short for _operate on system_ and an alias for the OPERATE function. │ │ │ │ │ Operate does mainly four things for the user: │ │ │ │ │ 1. Resolves the OPERATION designator into an operation object. │ │ │ │ │ @@ -5588,17 +5589,16 @@ │ │ │ │ │ BASE-STRING │ │ │ │ │ INITIALIZING │ │ │ │ │ *BLOCKS-TO-TERMINATE* │ │ │ │ │ *CONSTRAINT-BLOCKS-P* │ │ │ │ │ SPECIALIZER-NAME │ │ │ │ │ SUPERCLASS │ │ │ │ │ INTERACTIVE-THREAD │ │ │ │ │ -CONTEXT-ARGUMENTS │ │ │ │ │ -REQUIRED-BY │ │ │ │ │ REQUIRES │ │ │ │ │ +PATHNAME │ │ │ │ │ LVAR-TYPE │ │ │ │ │ OK-LVAR-LAMBDA-VAR │ │ │ │ │ NUMERIC-CONTAGION-CONSTRAINT-BACK │ │ │ │ │ DIV-CONSTRAINTS │ │ │ │ │ INITIAL-DFUN-INFO │ │ │ │ │ SET-DFUN │ │ │ │ │ EARLY-GF-P │ │ │ │ │ @@ -5978,15 +5978,14 @@ │ │ │ │ │ INTERPRET-FORMAT-LOGICAL-BLOCK │ │ │ │ │ %COMPILER-WALK-FORMAT-STRING │ │ │ │ │ MACROLET │ │ │ │ │ SIGNED-BYTE │ │ │ │ │ MISSING-ARG │ │ │ │ │ HASH-TABLE │ │ │ │ │ MODIFIED │ │ │ │ │ -PATHNAME │ │ │ │ │ SIMPLE-STRING │ │ │ │ │ WEAK-POINTER │ │ │ │ │ DEFINITION-SOURCE-LOCATION │ │ │ │ │ OUTPUT-CHAR-ISO-8859-3/CR-NONE-BUFFERED │ │ │ │ │ BYTES-FOR-CHAR/CP437/CR │ │ │ │ │ OUTPUT-BYTES/ISO-8859-13/CR │ │ │ │ │ OUTPUT-CHAR-ISO-8859-10/CRLF-LINE-BUFFERED │ │ │ │ │ @@ -16879,14 +16878,15 @@ │ │ │ │ │ UNSPECIFIED │ │ │ │ │ SLOTD-INITIALIZATION-ERROR-INITARG │ │ │ │ │ SLOTD-INITIALIZATION-ERROR-KIND │ │ │ │ │ SLOTD-INITIALIZATION-ERROR-VALUE │ │ │ │ │ INITARG-ERROR-INITARGS │ │ │ │ │ EFFECTIVE-METHOD-CONDITION │ │ │ │ │ FUNCTIONALITY │ │ │ │ │ +CONTEXT-ARGUMENTS │ │ │ │ │ CONTEXT-FORMAT │ │ │ │ │ MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION │ │ │ │ │ CHECKING-SLOT-BOUNDP │ │ │ │ │ INITARG-ERROR-CLASS │ │ │ │ │ INVALID-SUPERCLASS-CLASS │ │ │ │ │ INVALID-SUPERCLASS-SUPERCLASS │ │ │ │ │ CPL-PROTOCOL-VIOLATION-CLASS │ │ │ │ │ @@ -16907,14 +16907,15 @@ │ │ │ │ │ ERROR-OPTION │ │ │ │ │ ERROR-ARGUMENTS │ │ │ │ │ ARGUMENT-ERROR-DESCRIPTION │ │ │ │ │ ARGUMENT-ERROR-FLAG │ │ │ │ │ ARGUMENT-ERROR-EXTRA-INFO │ │ │ │ │ SLOT-DEFINITION-ALWAYS-BOUND-P │ │ │ │ │ SLOT-DEFINITION-INTERNAL-READER-FUNCTION │ │ │ │ │ +REQUIRED-BY │ │ │ │ │ PRETTY-STREAM │ │ │ │ │ FUNCALLABLE-STANDARD-CLASS │ │ │ │ │ STANDARD-METHOD-COMBINATION │ │ │ │ │ %GENERIC-FUNCTIONS │ │ │ │ │ GF-INFO-C-A-M-EMF-STD-P │ │ │ │ │ ARG-INFO-KEYS │ │ │ │ │ ARG-INFO-KEY/REST-P │ │ │ │ │ @@ -17226,31 +17227,31 @@ │ │ │ │ │ SB-SOURCE-LOCATIONS │ │ │ │ │ SB-XREF-FOR-INTERNALS │ │ │ │ │ STACK-GROWS-DOWNWARD-NOT-UPWARD │ │ │ │ │ UNWIND-TO-FRAME-AND-CALL-VOP │ │ │ │ │ WALK-LET* │ │ │ │ │ WALK-MACROLET │ │ │ │ │ SYMBOLIC-ASM │ │ │ │ │ -NON-BASE-CHARS-EXIST-P │ │ │ │ │ -ASDF-UNICODE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -IEEE-FLOATING-POINT │ │ │ │ │ POST-ENV │ │ │ │ │ POST-REST │ │ │ │ │ POST-MORE │ │ │ │ │ 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 │ │ │ │ │ WALK-DEFUN │ │ │ │ │ WALK-LOAD-TIME-VALUE │ │ │ │ │ +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 │ │ │ │ │ @@ -17385,41 +17386,23 @@ │ │ │ │ │ *STANDARD-METHOD-COMBINATION* │ │ │ │ │ NEXT-METHOD-CALL │ │ │ │ │ SET-SLOT-VALUE │ │ │ │ │ STANDARD-INSTANCE │ │ │ │ │ PRINT-OBJECT-STREAM-SPECIALIZER │ │ │ │ │ DEFINE-PACKAGE-STYLE-WARNING │ │ │ │ │ DEPENDENCY-NOT-DONE │ │ │ │ │ +%SLOT-DEFINITION │ │ │ │ │ COMPUTE-SLOT-ACCESSOR-INFO │ │ │ │ │ SLOT-READER-NAME │ │ │ │ │ SLOT-BOUNDP-NAME │ │ │ │ │ SLOT-MAKUNBOUND-NAME │ │ │ │ │ SLOT-WRITER-NAME │ │ │ │ │ +*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ │ CLASS-DEFSTRUCT-FORM │ │ │ │ │ CLASS-DEFSTRUCT-CONSTRUCTOR │ │ │ │ │ -RELATIVE-TO │ │ │ │ │ -%SLOT-DEFINITION │ │ │ │ │ -INTERNAL-WRITER-FUNCTION │ │ │ │ │ -DEFSTRUCT-ACCESSOR-SYMBOL │ │ │ │ │ -ALWAYS-BOUND-P │ │ │ │ │ -IDENTITY-WITH-ONE-ARGUMENT │ │ │ │ │ -BUILD-OPERATION │ │ │ │ │ -ADDITIONAL-INPUT-FILES │ │ │ │ │ -WEAKLY-DEPENDS-ON │ │ │ │ │ -DEPENDS-ON │ │ │ │ │ -PARAMETERS │ │ │ │ │ -REG-REG/MEM-DIR │ │ │ │ │ -REG/MEM-IMM │ │ │ │ │ -ACCUM-IMM │ │ │ │ │ -*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ │ -REMAINING │ │ │ │ │ -SECTION-RELATIVE │ │ │ │ │ -DOWNCASE │ │ │ │ │ -CAPITALIZE-FIRST │ │ │ │ │ -CAPITALIZE │ │ │ │ │ EMIT-BYTES │ │ │ │ │ SEGMENT-WRITERS │ │ │ │ │ IF-AFTER │ │ │ │ │ MAKE-FILLER │ │ │ │ │ TEXT-ORIGIN-LABEL │ │ │ │ │ PROCESS-BACK-PATCHES │ │ │ │ │ SEGMENT-FIXUP-NOTES │ │ │ │ │ @@ -17563,15 +17546,14 @@ │ │ │ │ │ DATA-SECTION │ │ │ │ │ INDIRECTION-TABLE │ │ │ │ │ EXTRACT-PREFIX-KEYWORDS │ │ │ │ │ READ-DEPENDENCIES │ │ │ │ │ %ASSEMBLE │ │ │ │ │ %EMIT-ALIGNMENT │ │ │ │ │ SEGMENT-DELAYED │ │ │ │ │ -PER-LINE-PREFIX │ │ │ │ │ FOP-EMPTY-LIST │ │ │ │ │ CHECK-FASL-HEADER │ │ │ │ │ FOP-COMPLEX │ │ │ │ │ FOP-COPY-SYMBOL-SAVE │ │ │ │ │ READ-WORD-ARG │ │ │ │ │ FASL-GROUP-FUN-NAMES │ │ │ │ │ MAKE-FASL-INPUT │ │ │ │ │ @@ -17747,21 +17729,46 @@ │ │ │ │ │ RUN-HANDLER │ │ │ │ │ SYSCALL* │ │ │ │ │ TYPE-SYSCALL │ │ │ │ │ SIGINFO-CODE │ │ │ │ │ VAL-SECS │ │ │ │ │ EXCEPTION-FDS │ │ │ │ │ ITIMERVAL │ │ │ │ │ +RELATIVE-TO │ │ │ │ │ +INTERNAL-WRITER-FUNCTION │ │ │ │ │ +DEFSTRUCT-ACCESSOR-SYMBOL │ │ │ │ │ +ALWAYS-BOUND-P │ │ │ │ │ +IDENTITY-WITH-ONE-ARGUMENT │ │ │ │ │ +BUILD-OPERATION │ │ │ │ │ +ANCESTOR │ │ │ │ │ +ADDITIONAL-INPUT-FILES │ │ │ │ │ +DEPENDS-ON │ │ │ │ │ +PARAMETERS │ │ │ │ │ +WEAKLY-DEPENDS-ON │ │ │ │ │ +REG-REG/MEM-DIR │ │ │ │ │ +REG/MEM-IMM │ │ │ │ │ +ACCUM-IMM │ │ │ │ │ +REMAINING │ │ │ │ │ +SECTION-RELATIVE │ │ │ │ │ +DOWNCASE │ │ │ │ │ +CAPITALIZE-FIRST │ │ │ │ │ +CAPITALIZE │ │ │ │ │ +PER-LINE-PREFIX │ │ │ │ │ ISO-8859-8 │ │ │ │ │ ISO-8859-6 │ │ │ │ │ EXISTENCE │ │ │ │ │ SIGNALED │ │ │ │ │ ABSOLUTE │ │ │ │ │ RELATIVE │ │ │ │ │ WILD-INFERIORS │ │ │ │ │ +ASSUMED-TYPE │ │ │ │ │ +WIRED-TLS │ │ │ │ │ +WALKER-TEMPLATE │ │ │ │ │ +MACRO-EXPANSION │ │ │ │ │ +TRANSLATOR │ │ │ │ │ SHIFT_JIS │ │ │ │ │ ISO-8859-7 │ │ │ │ │ EBCDIC-US │ │ │ │ │ ISO-8859-3 │ │ │ │ │ MAC-ROMAN │ │ │ │ │ MAKE-CACHE │ │ │ │ │ %STRUCT-TYPECASE-MISS │ │ │ │ │ @@ -17772,19 +17779,14 @@ │ │ │ │ │ ISO-8859-14 │ │ │ │ │ ISO-8859-9 │ │ │ │ │ UTF-32LE │ │ │ │ │ BIVALENT │ │ │ │ │ ISO-8859-4 │ │ │ │ │ PRESERVE │ │ │ │ │ ISO-8859-5 │ │ │ │ │ -ASSUMED-TYPE │ │ │ │ │ -WIRED-TLS │ │ │ │ │ -WALKER-TEMPLATE │ │ │ │ │ -MACRO-EXPANSION │ │ │ │ │ -TRANSLATOR │ │ │ │ │ PREDICATE-FOR │ │ │ │ │ PREDICATE-TRUTH-CONSTRAINT │ │ │ │ │ FORWARD-REFERENCES │ │ │ │ │ ALIEN-INFO │ │ │ │ │ TYPED-STRUCTURE │ │ │ │ │ RANDOM-DOCUMENTATION │ │ │ │ │ SYMBOL-MACRO │ │ │ │ │ @@ -17906,65 +17908,65 @@ │ │ │ │ │ CMPXCHG8B │ │ │ │ │ PREFETCH │ │ │ │ │ PREFETCHNTA │ │ │ │ │ IMMOBILE-FIXED │ │ │ │ │ IMMOBILE-VARIABLE │ │ │ │ │ IMPORT-FROM │ │ │ │ │ SHADOWING-IMPORT-FROM │ │ │ │ │ -PARTIAL-MACROEXPANDER │ │ │ │ │ -INITIALIZATION │ │ │ │ │ -MAKE-SLOT-INFO │ │ │ │ │ -*COMPILING-OPTIMIZED-CONSTRUCTOR* │ │ │ │ │ *INITIAL-PPRINT-DISPATCH-TABLE* │ │ │ │ │ +*COMPILING-OPTIMIZED-CONSTRUCTOR* │ │ │ │ │ SLOT-INFO-TYPECHECK │ │ │ │ │ SLOT-INFO-ALLOCATION │ │ │ │ │ SLOT-INFO-LOCATION │ │ │ │ │ SLOT-INFO-READER │ │ │ │ │ SLOT-INFO-WRITER │ │ │ │ │ SLOT-INFO-BOUNDP │ │ │ │ │ SLOT-INFO-MAKUNBOUND │ │ │ │ │ ARGUMENT-PRECEDENCE-ORDER │ │ │ │ │ COMPILE-OR-LOAD-DEFGENERIC │ │ │ │ │ LOAD-DEFGENERIC │ │ │ │ │ SET-INITIAL-METHODS │ │ │ │ │ +PARTIAL-MACROEXPANDER │ │ │ │ │ +INITIALIZATION │ │ │ │ │ +MAKE-SLOT-INFO │ │ │ │ │ PPRINT-LENGTH-CHECK* │ │ │ │ │ *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 │ │ │ │ │ NO-CONSTRUCTOR-DEFUN │ │ │ │ │ -UNSUPPLIED │ │ │ │ │ USE-LABELS │ │ │ │ │ +UNSUPPLIED │ │ │ │ │ NO-ERROR │ │ │ │ │ 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* │ │ │ │ │ +%DEFMETHOD-EXPANDER │ │ │ │ │ *OLD-DEBUGGER-HOOK* │ │ │ │ │ PSEUDO-STATIC │ │ │ │ │ DENORMALIZED-OPERAND │ │ │ │ │ UNDERFLOW │ │ │ │ │ ENCAPSULATED │ │ │ │ │ TRACE-CALL │ │ │ │ │ ABBREVIATED │ │ │ │ │ EXIT-IF-NULL │ │ │ │ │ -INVALID-KEYS │ │ │ │ │ COPY-ENV │ │ │ │ │ NATIVE-LEXENV │ │ │ │ │ OBSOLETE │ │ │ │ │ METACLASS │ │ │ │ │ +INVALID-KEYS │ │ │ │ │ COPY-LINKED-LIST │ │ │ │ │ LINKED-LIST-P │ │ │ │ │ INEQUALITY │ │ │ │ │ SO-NODE-P │ │ │ │ │ NODE-HASH │ │ │ │ │ SO-KEY-NODE-P │ │ │ │ │ SO-DATA-NODE-P │ │ │ │ │ @@ -18073,15 +18075,14 @@ │ │ │ │ │ METHOD-COMBINATION-INFO-P │ │ │ │ │ COUNTER-P │ │ │ │ │ PROFILE-INFO-P │ │ │ │ │ READ-STATS-FUN │ │ │ │ │ OVERHEAD-P │ │ │ │ │ TIME-INFO-P │ │ │ │ │ GC-RUN-TIME │ │ │ │ │ -.NOT-THERE. │ │ │ │ │ INITIAL-OFFSET │ │ │ │ │ EQL-SPECIALIZER-P │ │ │ │ │ CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P │ │ │ │ │ %FORCE-CACHE-FLUSHES │ │ │ │ │ ENSURE-CLASS-FINALIZED │ │ │ │ │ MAKE-SEQUENCE-ITERATOR │ │ │ │ │ DEFINITION-SOURCE │ │ │ │ │ @@ -18098,14 +18099,32 @@ │ │ │ │ │ FILL-CACHE │ │ │ │ │ N-N-DFUN-INFO │ │ │ │ │ GET-DFUN-CONSTRUCTOR │ │ │ │ │ ACCESSOR-MISS-FUNCTION │ │ │ │ │ TWO-CLASS-DFUN-INFO │ │ │ │ │ ONE-CLASS-DFUN-INFO │ │ │ │ │ GET-GENERIC-FUN-INFO │ │ │ │ │ +NON-LOCAL-EXIT │ │ │ │ │ +CALL-SITE │ │ │ │ │ +EMIT-N-N-MAKUNBOUNDS │ │ │ │ │ +EMIT-N-N-READERS │ │ │ │ │ +EMIT-N-N-WRITERS │ │ │ │ │ +EMIT-N-N-BOUNDPS │ │ │ │ │ +EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ │ +EMIT-ONE-INDEX-READERS │ │ │ │ │ +EMIT-ONE-INDEX-WRITERS │ │ │ │ │ +EMIT-ONE-INDEX-BOUNDPS │ │ │ │ │ +EMIT-TWO-CLASS-MAKUNBOUND │ │ │ │ │ +EMIT-TWO-CLASS-READER │ │ │ │ │ +EMIT-TWO-CLASS-WRITER │ │ │ │ │ +EMIT-TWO-CLASS-BOUNDP │ │ │ │ │ +EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ │ +EMIT-ONE-CLASS-READER │ │ │ │ │ +EMIT-ONE-CLASS-WRITER │ │ │ │ │ +EMIT-ONE-CLASS-BOUNDP │ │ │ │ │ CACHE-MISS-VALUES-INTERNAL │ │ │ │ │ ERROR-NEED-AT-LEAST-N-ARGS │ │ │ │ │ SLOT-UNBOUND-INTERNAL │ │ │ │ │ METHOD-PLIST-VALUE │ │ │ │ │ CACHING-DFUN-INFO │ │ │ │ │ USE-CONSTANT-VALUE-DFUN-P │ │ │ │ │ USE-DISPATCH-DFUN-P │ │ │ │ │ @@ -18118,47 +18137,21 @@ │ │ │ │ │ CHECKING-DFUN-INFO │ │ │ │ │ CHECKING-MISS │ │ │ │ │ SAFE-METHOD-SPECIALIZERS │ │ │ │ │ SPECIALIZER-APPLICABLE-USING-TYPE-P │ │ │ │ │ SORT-APPLICABLE-METHODS │ │ │ │ │ SAFE-GENERIC-FUNCTION-METHODS │ │ │ │ │ PRINT-BACKTRACE │ │ │ │ │ -CALL-SITE │ │ │ │ │ -NON-LOCAL-EXIT │ │ │ │ │ -EMIT-N-N-MAKUNBOUNDS │ │ │ │ │ -EMIT-N-N-READERS │ │ │ │ │ -EMIT-N-N-WRITERS │ │ │ │ │ -EMIT-N-N-BOUNDPS │ │ │ │ │ -EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ │ -EMIT-ONE-INDEX-READERS │ │ │ │ │ -EMIT-ONE-INDEX-WRITERS │ │ │ │ │ -EMIT-ONE-INDEX-BOUNDPS │ │ │ │ │ -EMIT-TWO-CLASS-MAKUNBOUND │ │ │ │ │ -EMIT-TWO-CLASS-READER │ │ │ │ │ -EMIT-TWO-CLASS-WRITER │ │ │ │ │ -EMIT-TWO-CLASS-BOUNDP │ │ │ │ │ -EMIT-ONE-CLASS-MAKUNBOUND │ │ │ │ │ -EMIT-ONE-CLASS-READER │ │ │ │ │ -EMIT-ONE-CLASS-WRITER │ │ │ │ │ -EMIT-ONE-CLASS-BOUNDP │ │ │ │ │ -INITIAL-CACHE │ │ │ │ │ DFUN-INFO-CACHE │ │ │ │ │ +INITIAL-CACHE │ │ │ │ │ +.NOT-THERE. │ │ │ │ │ +ELSEWHERE │ │ │ │ │ LOAD-TOPLEVEL │ │ │ │ │ COMPILER │ │ │ │ │ DATA-DEPENDENCY │ │ │ │ │ -ACCESSOR-MISS │ │ │ │ │ -%MAKE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ │ -MAKE-NEWLINE │ │ │ │ │ -MAYBE-OUTPUT │ │ │ │ │ -PRETTY-SOUT │ │ │ │ │ -MAKE-LOGICAL-BLOCK │ │ │ │ │ -EXPAND-TABS │ │ │ │ │ -MAKE-BLOCK-START │ │ │ │ │ -MAKE-BLOCK-END │ │ │ │ │ -MAKE-INDENTATION │ │ │ │ │ SETF-SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ │ PRETTY-STREAM-IN-BUFFER │ │ │ │ │ PRETTY-STREAM-CIN-BUFFER │ │ │ │ │ PRETTY-STREAM-CSIZE-BUFFER │ │ │ │ │ PRETTY-STREAM-IN-INDEX │ │ │ │ │ PRETTY-STREAM-IN │ │ │ │ │ PRETTY-STREAM-BIN │ │ │ │ │ @@ -18181,25 +18174,21 @@ │ │ │ │ │ PRETTY-STREAM-BLOCKS │ │ │ │ │ PRETTY-STREAM-PREFIX │ │ │ │ │ PRETTY-STREAM-SUFFIX │ │ │ │ │ PRETTY-STREAM-QUEUE-TAIL │ │ │ │ │ PRETTY-STREAM-QUEUE-HEAD │ │ │ │ │ PRETTY-STREAM-PENDING-BLOCKS │ │ │ │ │ PRETTY-STREAM-PENDING-BLOCKS-LENGTH │ │ │ │ │ -COMPUTE-APPLICABLE-METHODS-FUNCTION │ │ │ │ │ -ALLOCATE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ │ -SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ │ -SLOT-BOUNDP-USING-CLASS-DFUN │ │ │ │ │ MAKE-GF-HASHSET │ │ │ │ │ METHOD-CELL │ │ │ │ │ +MAKE-FAST-METHOD-CALL │ │ │ │ │ FAST-METHOD-CALL-FUNCTION │ │ │ │ │ FAST-METHOD-CALL-PV │ │ │ │ │ FAST-METHOD-CALL-NEXT-METHOD-CALL │ │ │ │ │ FAST-METHOD-CALL-ARG-INFO │ │ │ │ │ -MAKE-FAST-METHOD-CALL │ │ │ │ │ MAKE-METHOD-INITARGS-FORM-INTERNAL1 │ │ │ │ │ CTOR-ARGS │ │ │ │ │ WRITER-FN │ │ │ │ │ INITFORM/INITFN │ │ │ │ │ *SIMPLE-STREAM-ROOT-CLASSOID* │ │ │ │ │ MEMF-TEST-CONVERTER │ │ │ │ │ GENERATING-LISP │ │ │ │ │ @@ -18251,14 +18240,15 @@ │ │ │ │ │ EXTRA-DATA │ │ │ │ │ .PV-OFFSET. │ │ │ │ │ NOTE-GF-SIGNATURE │ │ │ │ │ QUALIFIER-CHECK-RUNTIME │ │ │ │ │ *STRUCTURE-SLOT-MAKUNBOUND-USING-CLASS-METHOD* │ │ │ │ │ SPECIALIZER-TYPE │ │ │ │ │ *INTERNAL-PCL-GENERALIZED-FUN-NAME-SYMBOLS* │ │ │ │ │ +SLOT-VALUE-USING-CLASS-DFUN │ │ │ │ │ METHOD-ALIST-P │ │ │ │ │ DEFAULT-CONSTANTP │ │ │ │ │ *SLOT-NAME-LISTS* │ │ │ │ │ SBUC-SLOTS │ │ │ │ │ NON-STANDARD │ │ │ │ │ SAUT-PROTOTYPE │ │ │ │ │ .CALL-METHOD-LIST. │ │ │ │ │ @@ -18468,14 +18458,15 @@ │ │ │ │ │ TYPE-FROM-SPECIALIZER │ │ │ │ │ REAL-GET-METHOD │ │ │ │ │ SAFE-SET-SLOT-VALUE │ │ │ │ │ MAYBE-CALL-CTOR │ │ │ │ │ REAL-SPECIALIZER-TYPE-SPECIFIER/CLASS │ │ │ │ │ EFFECTIVE-METHOD-GENSYM-4 │ │ │ │ │ NEW-INSTANCE-SLOTDS │ │ │ │ │ +SLOT-BOUNDP-USING-CLASS-DFUN │ │ │ │ │ CHECK-SPECIALIZERS │ │ │ │ │ ALLOCATE-INSTANCE->CONSTRUCTOR-CALL │ │ │ │ │ LMF-PARAMS │ │ │ │ │ SETF-FIND-CLASS │ │ │ │ │ BOOTSTRAP │ │ │ │ │ GET-FUN-GENERATOR │ │ │ │ │ NEW-TYPE │ │ │ │ │ @@ -18509,14 +18500,15 @@ │ │ │ │ │ PV-TABLE-FORM │ │ │ │ │ CONSTANT-CLASS-ARG-P │ │ │ │ │ STRUCTURE-CLASS-P │ │ │ │ │ MAKE-DEFSTRUCT-ALLOCATION-FUNCTION │ │ │ │ │ %PARAMETER-BINDING-MODIFIED │ │ │ │ │ CPD-COUNT │ │ │ │ │ DIRECT-DEFAULT-INITARGS-P │ │ │ │ │ +ACCESSOR-MISS │ │ │ │ │ MAKE-STD-READER-METHOD-FUNCTION │ │ │ │ │ WRAPPER-SLOT-LIST │ │ │ │ │ ARG-INFO-NUMBER-REQUIRED │ │ │ │ │ MUTATE-SLOTS │ │ │ │ │ .PV-TABLE. │ │ │ │ │ MAKE-A-METHOD │ │ │ │ │ GENERATE-SLOTD-TYPECHECK │ │ │ │ │ @@ -18579,14 +18571,15 @@ │ │ │ │ │ .DUMMY0. │ │ │ │ │ STANDARD-SLOT-VALUE/GF │ │ │ │ │ MAKE-DIRECT-SLOTD │ │ │ │ │ METHOD-GROUP-SPECIFIERS │ │ │ │ │ OPTIMIZING-ALLOCATOR-GENERATOR │ │ │ │ │ ONE-INDEX-INDEX │ │ │ │ │ MAYBE-ENCAPSULATE-DISCRIMINATING-FUNCTION │ │ │ │ │ +%MAKE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ │ SIMPLE-NEXT-METHOD-CALL-P │ │ │ │ │ CALL-METHOD-LIST │ │ │ │ │ .CALL-METHOD. │ │ │ │ │ CREATE-GF-LAMBDA-LIST │ │ │ │ │ .QUALIFIERS. │ │ │ │ │ METATYPES │ │ │ │ │ *STANDARD-SLOT-MAKUNBOUND-USING-CLASS-METHOD* │ │ │ │ │ @@ -18628,14 +18621,15 @@ │ │ │ │ │ ALLOCATE-STANDARD-INSTANCE │ │ │ │ │ SIMPLE-LEXICAL-METHOD-FUNCTIONS │ │ │ │ │ .VALID-KEYS. │ │ │ │ │ PCL-SYMBOLICATE │ │ │ │ │ TWO-CLASS-INDEX │ │ │ │ │ PV-OFFSET │ │ │ │ │ .CM-ARGS. │ │ │ │ │ +ALLOCATE-STANDARD-FUNCALLABLE-INSTANCE │ │ │ │ │ ADDED-SLOTS │ │ │ │ │ METHOD-COMBINATION-P │ │ │ │ │ ALLOCATIONP │ │ │ │ │ MEMF-CONSTANT-CONVERTER │ │ │ │ │ METHOD-EM-CACHE │ │ │ │ │ ACCESSES-STANDARD-CLASS-SLOT-P │ │ │ │ │ PROPERLY-NAMED-P │ │ │ │ │ @@ -18993,14 +18987,15 @@ │ │ │ │ │ *THE-CLASS-SLOT-CLASS* │ │ │ │ │ UPDATE-CLASS │ │ │ │ │ REAL-SPECIALIZER-TYPE-SPECIFIER/SYMBOL │ │ │ │ │ INSTANCE-BOUNDP-STANDARD │ │ │ │ │ PV-BINDING1 │ │ │ │ │ FAST-CALL-NEXT-METHOD-BODY │ │ │ │ │ STANDARD-CLASS-P │ │ │ │ │ +COMPUTE-APPLICABLE-METHODS-FUNCTION │ │ │ │ │ STRUCTURE-TYPE-P │ │ │ │ │ TRACE-EMF-CALL-INTERNAL │ │ │ │ │ GENERATE-FAST-CLASS-SLOT-ACCESS-P │ │ │ │ │ MAKE-METHOD-COMBINATION-INFO │ │ │ │ │ METATYPE │ │ │ │ │ .REST-ARG. │ │ │ │ │ SLOT-INIT-FORMS │ │ │ │ │ @@ -19189,19 +19184,24 @@ │ │ │ │ │ +CTOR-TABLE-MAX-SIZE+ │ │ │ │ │ SPECIALIZER-TYPE-SPECIFIER │ │ │ │ │ +SLOT-UNBOUND+ │ │ │ │ │ NO-PRIMARY-METHOD │ │ │ │ │ +CTOR-LIST-MAX-SIZE+ │ │ │ │ │ PARSE-SPECIALIZER-USING-CLASS │ │ │ │ │ COMPUTE-CACHE-INDEX │ │ │ │ │ -ELSEWHERE │ │ │ │ │ -OBJ-SUPPLIED-P │ │ │ │ │ +MAKE-NEWLINE │ │ │ │ │ +MAYBE-OUTPUT │ │ │ │ │ +PRETTY-SOUT │ │ │ │ │ +MAKE-LOGICAL-BLOCK │ │ │ │ │ +EXPAND-TABS │ │ │ │ │ +MAKE-BLOCK-START │ │ │ │ │ +MAKE-BLOCK-END │ │ │ │ │ +MAKE-INDENTATION │ │ │ │ │ BODY-NAME- │ │ │ │ │ -ANCESTOR │ │ │ │ │ -*LOOP-ANSI-UNIVERSE* │ │ │ │ │ +OBJ-SUPPLIED-P │ │ │ │ │ ACTIONS-R │ │ │ │ │ SO-MAPLIST │ │ │ │ │ F-STREAM- │ │ │ │ │ US-ASCII │ │ │ │ │ ANSI_X3.4-1968 │ │ │ │ │ ISO-646-US │ │ │ │ │ ISO-8859-1 │ │ │ │ │ @@ -19238,83 +19238,93 @@ │ │ │ │ │ WINDOWS-1258 │ │ │ │ │ windows-1258 │ │ │ │ │ mac-roman │ │ │ │ │ MacRoman │ │ │ │ │ MACINTOSH │ │ │ │ │ macintosh │ │ │ │ │ Shift_JIS │ │ │ │ │ +*LOOP-ANSI-UNIVERSE* │ │ │ │ │ GET-FILE-POSITION │ │ │ │ │ INTERACTIVE-P │ │ │ │ │ RESET-UNICODE-P │ │ │ │ │ SO-INSERT │ │ │ │ │ MAKE-SO-MAP/ADDR │ │ │ │ │ NORMALIZE-STRING │ │ │ │ │ -TARGET-IF-DESIRABLE │ │ │ │ │ SAVE-ONCE │ │ │ │ │ ALIEN-CODE-LINKAGE-INDEX │ │ │ │ │ ALIEN-DATA-LINKAGE-INDEX │ │ │ │ │ IMMOBILE-SYMBOL │ │ │ │ │ +TARGET-IF-DESIRABLE │ │ │ │ │ FINISH-INCOMPLETE-DELETIONS │ │ │ │ │ SYMBOL-MACRO77 │ │ │ │ │ DISASSEMBLE-ASSEM-SEGMENT │ │ │ │ │ -MACROEXPAND-ALL │ │ │ │ │ -DISASSEMBLE-MEMORY │ │ │ │ │ -GET-COMPILED-FUNS │ │ │ │ │ -DISASSEMBLE-CODE-COMPONENT │ │ │ │ │ COVERAGE-MARKS │ │ │ │ │ RESULT-REFS │ │ │ │ │ VARIANT-COST │ │ │ │ │ ARG-REFS │ │ │ │ │ +MACROEXPAND-ALL │ │ │ │ │ +DISASSEMBLE-MEMORY │ │ │ │ │ +GET-COMPILED-FUNS │ │ │ │ │ +DISASSEMBLE-CODE-COMPONENT │ │ │ │ │ ALIGN-OF │ │ │ │ │ -MAKE-PPRINT-DISPATCH-TABLE │ │ │ │ │ DOUBLE-FLOAT-BITS │ │ │ │ │ -MISER-WIDTH │ │ │ │ │ READABLY │ │ │ │ │ +MISER-WIDTH │ │ │ │ │ RIGHT-MARGIN │ │ │ │ │ SUPPRESS-ERRORS │ │ │ │ │ KEY-OR-VALUE │ │ │ │ │ KEY-AND-VALUE │ │ │ │ │ -STREAM-SYMBOL │ │ │ │ │ -%LIST-TRACED-FUNS │ │ │ │ │ +MAKE-PPRINT-DISPATCH-TABLE │ │ │ │ │ UNICODE-CHAR->NAME │ │ │ │ │ MAYBE-RETRACE │ │ │ │ │ EXPAND-TRACE │ │ │ │ │ UNICODE-1-CHAR->NAME │ │ │ │ │ DISASSEMBLE-FUN │ │ │ │ │ ASSERT-NOT-STANDARD-PPRINT-DISPATCH-TABLE │ │ │ │ │ MAKE-PPRINT-DISPATCH-ENTRY │ │ │ │ │ PPRINT-DISPATCH-ENTRY-TYPE │ │ │ │ │ DEFER-TYPE-CHECKER │ │ │ │ │ COMPUTE-TEST-FN │ │ │ │ │ ENQUEUE-TAB │ │ │ │ │ SO-DELETE │ │ │ │ │ +STREAM-SYMBOL │ │ │ │ │ +%LIST-TRACED-FUNS │ │ │ │ │ MAYBE-RETRACE-FUNCTION │ │ │ │ │ MAYBE-RETRACE-COMPILER-MACRO │ │ │ │ │ +DEBUGGER-FRAME │ │ │ │ │ +*BACKTRACE-FRAME-COUNT* │ │ │ │ │ +*BACKTRACE-PRINT-PC* │ │ │ │ │ +*DEFAULT-ARGUMENT-LIMIT* │ │ │ │ │ +*METHOD-FRAME-STYLE* │ │ │ │ │ +*DEBUG-COMMAND-LEVEL* │ │ │ │ │ +SKIP-PRINTING-FRAME │ │ │ │ │ +PRINT-PC │ │ │ │ │ +ARGUMENT-LIMIT │ │ │ │ │ +METHOD-FRAME-STYLE │ │ │ │ │ +PRINT-FRAME-SOURCE │ │ │ │ │ +DONT-KNOW │ │ │ │ │ END-LOOP │ │ │ │ │ UNTRACE-ALL │ │ │ │ │ MAKE-DSTATE │ │ │ │ │ MAKE-TRACE-INFO │ │ │ │ │ COMPILE-FUNOBJ-ENCAPSULATION │ │ │ │ │ SET-TRACING-BIT │ │ │ │ │ OUTPUT-PRETTY-OBJECT │ │ │ │ │ EVAL-IN-NATIVE-ENVIRONMENT │ │ │ │ │ FIND-PACKAGE* │ │ │ │ │ -WALKER-ENVIRONMENT-BIND-1 │ │ │ │ │ -WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ │ -WALK-ARGLIST │ │ │ │ │ -WALK-REPEAT-EVAL │ │ │ │ │ -WALK-DECLARATIONS │ │ │ │ │ -CONVERT-MACRO-TO-LAMBDA │ │ │ │ │ POSITIVE-INFINITY │ │ │ │ │ NEGATIVE-INFINITY │ │ │ │ │ -TRACED-FUN │ │ │ │ │ -KEY-INDEX- │ │ │ │ │ SYMBOL-EXPANSIONS │ │ │ │ │ EXPANDERS │ │ │ │ │ +TRACED-FUN │ │ │ │ │ +KEY-INDEX- │ │ │ │ │ INSERTER │ │ │ │ │ +WALKER-ENVIRONMENT-BIND-1 │ │ │ │ │ +WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ │ +WALK-ARGLIST │ │ │ │ │ CONS-ENTRIES │ │ │ │ │ NUMBER-MATCHABLE-P │ │ │ │ │ ONLY-INITIAL-ENTRIES │ │ │ │ │ USE-LABEL │ │ │ │ │ DEFAULT-PRINTER │ │ │ │ │ VIRTUAL-LOCATION │ │ │ │ │ SCRATCH-BUF │ │ │ │ │ @@ -19354,40 +19364,32 @@ │ │ │ │ │ EMITTED-BODY │ │ │ │ │ FINAL-VALUE-CULPRIT │ │ │ │ │ NEVER-STEPPED-VAR │ │ │ │ │ INCLUSIVE-PERMITTED │ │ │ │ │ PREPOSITION-GROUPS │ │ │ │ │ START-BREAKPOINT │ │ │ │ │ BREAK-AFTER │ │ │ │ │ -ENSURE-SPACE-IN-BUFFER │ │ │ │ │ +WALK-REPEAT-EVAL │ │ │ │ │ +WALK-DECLARATIONS │ │ │ │ │ +CONVERT-MACRO-TO-LAMBDA │ │ │ │ │ ENCAPSULATION-FUN │ │ │ │ │ CLEAR-STATS-FUN │ │ │ │ │ ENCAPSULATED-FUN │ │ │ │ │ -PRETTY-OUT │ │ │ │ │ -PRETTY-MISC │ │ │ │ │ ERROR-OUTPUT-STREAM │ │ │ │ │ BIDIR-STREAM │ │ │ │ │ SIGNAL-CODE │ │ │ │ │ KEEP-OPERATION │ │ │ │ │ KEEP-COMPONENT │ │ │ │ │ DEP-COMPONENT │ │ │ │ │ -DEBUGGER-FRAME │ │ │ │ │ -*BACKTRACE-FRAME-COUNT* │ │ │ │ │ -*BACKTRACE-PRINT-PC* │ │ │ │ │ -*DEFAULT-ARGUMENT-LIMIT* │ │ │ │ │ -*METHOD-FRAME-STYLE* │ │ │ │ │ -*DEBUG-COMMAND-LEVEL* │ │ │ │ │ -SKIP-PRINTING-FRAME │ │ │ │ │ -PRINT-PC │ │ │ │ │ -ARGUMENT-LIMIT │ │ │ │ │ -METHOD-FRAME-STYLE │ │ │ │ │ -PRINT-FRAME-SOURCE │ │ │ │ │ -DONT-KNOW │ │ │ │ │ -FINISHED │ │ │ │ │ -*DEPRECATED-FUNCTION-STYLE-WARNING-REQUIRE-SYSTEM-NOTIFIED-P* │ │ │ │ │ +CONDITION-FORMAT │ │ │ │ │ +CONDITION-LOCATION │ │ │ │ │ +CONDITION-ARGUMENTS │ │ │ │ │ +CONDITION-OPERATION │ │ │ │ │ +CONDITION-COMPONENT │ │ │ │ │ +CONDITION-ACTION │ │ │ │ │ PREVIOUS-HOOK │ │ │ │ │ ALL-THREADS │ │ │ │ │ PUSH-FUN │ │ │ │ │ EVAL-FLET │ │ │ │ │ EVAL-BLOCK │ │ │ │ │ MAKE-ENV-FROM-NATIVE-ENVIRONMENT │ │ │ │ │ PARSE-LAMBDA-HEADERS │ │ │ │ │ @@ -19617,14 +19619,15 @@ │ │ │ │ │ PLAN-CLASS │ │ │ │ │ FILE-TYPES │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ │ INCLUDE-PER-USER-INFORMATION │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-DEFINITION-PATHNAME-NOTIFIED-P* │ │ │ │ │ OPERATION-CLASS │ │ │ │ │ SOURCE-TO-TARGET-MAPPINGS │ │ │ │ │ +*DEPRECATED-FUNCTION-STYLE-WARNING-REQUIRE-SYSTEM-NOTIFIED-P* │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-PROPERTY-NOTIFIED-P* │ │ │ │ │ CENTRALIZE-LISP-BINARIES │ │ │ │ │ DESTINATION-DIRECTORY │ │ │ │ │ PRIMARY-SYSTEM │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-REGISTERED-P-NOTIFIED-P* │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-EXPLAIN-NOTIFIED-P* │ │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-TRAVERSE-NOTIFIED-P* │ │ │ │ │ @@ -19755,37 +19758,34 @@ │ │ │ │ │ LOAD-SYSTEM │ │ │ │ │ NEEDS-ASDF-P │ │ │ │ │ *ASDF-SYSTEMS-TABLE* │ │ │ │ │ *ALPHABET* │ │ │ │ │ LOAD-PATHS │ │ │ │ │ COMMAND-LINE-DUMPER │ │ │ │ │ BUILD-BUILDAPP │ │ │ │ │ +PRETTY-OUT │ │ │ │ │ +PRETTY-MISC │ │ │ │ │ INITIAL-BUFFER-SIZE │ │ │ │ │ -CONDITION-FORMAT │ │ │ │ │ -CONDITION-LOCATION │ │ │ │ │ -CONDITION-ARGUMENTS │ │ │ │ │ -CONDITION-OPERATION │ │ │ │ │ -CONDITION-COMPONENT │ │ │ │ │ -CONDITION-ACTION │ │ │ │ │ +ENSURE-SPACE-IN-BUFFER │ │ │ │ │ PRINT-REG │ │ │ │ │ PRINT-REG/MEM │ │ │ │ │ PRINT-SIZED-REG/MEM │ │ │ │ │ -LOOP-STANDARD-EXPANSION │ │ │ │ │ -GBK->STRING-AREF │ │ │ │ │ -EUC-JP->STRING-AREF │ │ │ │ │ -SHIFT_JIS->STRING-AREF │ │ │ │ │ +FINISHED │ │ │ │ │ +COLLECT-DEPENDENCIES │ │ │ │ │ +ASDF/INTERFACE │ │ │ │ │ +OTHER-SYSTEMS │ │ │ │ │ +FORCE-NOT │ │ │ │ │ VAR-SPECIAL-P │ │ │ │ │ DEFINE-WALKER-TEMPLATE │ │ │ │ │ VAR-GLOBALLY-SPECIAL-P │ │ │ │ │ WALK-FORM │ │ │ │ │ VAR-LEXICAL-P │ │ │ │ │ *WALK-FORM-EXPAND-MACROS-P* │ │ │ │ │ VAR-DECLARATION │ │ │ │ │ ARMENIAN │ │ │ │ │ -OTHER-SYSTEMS │ │ │ │ │ PATTERN-WHITE-SPACE │ │ │ │ │ ENSURE-SUBPATH │ │ │ │ │ WANT-PHYSICAL │ │ │ │ │ LATIN-EXTENDED-ADDITIONAL │ │ │ │ │ ADAPTIVE │ │ │ │ │ OTHER-DEFAULT-IGNORABLE-CODE-POINT │ │ │ │ │ MSWINDOWS │ │ │ │ │ @@ -19820,14 +19820,15 @@ │ │ │ │ │ INSCRIPTIONAL-PAHLAVI │ │ │ │ │ OPTICAL-CHARACTER-RECOGNITION │ │ │ │ │ MATHEMATICAL-OPERATORS │ │ │ │ │ CUNEIFORM-NUMBERS-AND-PUNCTUATION │ │ │ │ │ SHIFT_JIS->STRING-SAP-REF-8 │ │ │ │ │ CJK-COMPATIBILITY-IDEOGRAPHS-SUPPLEMENT │ │ │ │ │ %TO-BE-DELETED │ │ │ │ │ +SHIFT_JIS->STRING-AREF │ │ │ │ │ ENABLE-USER-CACHE │ │ │ │ │ ORIGINAL-SOURCE │ │ │ │ │ OS-WINDOWS │ │ │ │ │ SOURCE-FILE │ │ │ │ │ OPERATE-LEVEL │ │ │ │ │ OTHER-UPPERCASE │ │ │ │ │ WANT-ABSOLUTE │ │ │ │ │ @@ -20123,21 +20124,23 @@ │ │ │ │ │ BUILD-PATHNAME │ │ │ │ │ AEGEAN-NUMBERS │ │ │ │ │ SOURCE-REGISTRY │ │ │ │ │ ENCLOSED-CJK-LETTERS-AND-MONTHS │ │ │ │ │ PPC32-TARGET │ │ │ │ │ DUMP-HOOK │ │ │ │ │ UIOP/VERSION │ │ │ │ │ +GBK->STRING-AREF │ │ │ │ │ HIGH-SURROGATES │ │ │ │ │ BASIC-LATIN │ │ │ │ │ MYANMAR-EXTENDED-A │ │ │ │ │ EMOJI-COMPONENT │ │ │ │ │ WANT-FILE │ │ │ │ │ UIOP/LISP-BUILD │ │ │ │ │ NOTIFIED-P │ │ │ │ │ +EUC-JP->STRING-AREF │ │ │ │ │ VERTICAL-FORMS │ │ │ │ │ PHONETIC-EXTENSIONS-SUPPLEMENT │ │ │ │ │ IMPORT-UNINTERNED │ │ │ │ │ CORMANLISP │ │ │ │ │ SUTTON-SIGNWRITING │ │ │ │ │ OUTPUT-NAME │ │ │ │ │ MIDLETTER │ │ │ │ │ @@ -20165,15 +20168,14 @@ │ │ │ │ │ INVALID-FORM-REPORTER │ │ │ │ │ OUTPUT-FILES │ │ │ │ │ VITHKUQI │ │ │ │ │ SORA-SOMPENG │ │ │ │ │ BHAIKSUKI │ │ │ │ │ ASDF-ACTION │ │ │ │ │ OLD-PERSIAN │ │ │ │ │ -ASDF/INTERFACE │ │ │ │ │ MONGOLIAN-SUPPLEMENT │ │ │ │ │ JAVANESE │ │ │ │ │ LATIN-EXTENDED-C │ │ │ │ │ EPILOGUE-CODE │ │ │ │ │ TANGUT-SUPPLEMENT │ │ │ │ │ GLAGOLITIC │ │ │ │ │ QUOTATION-MARK │ │ │ │ │ @@ -20253,15 +20255,14 @@ │ │ │ │ │ UNIFIED-CANADIAN-ABORIGINAL-SYLLABICS-EXTENDED-A │ │ │ │ │ LOCAL-APPDATA │ │ │ │ │ MATHEMATICAL-ALPHANUMERIC-SYMBOLS │ │ │ │ │ PPC64-TARGET │ │ │ │ │ ASDF/OPERATE │ │ │ │ │ DOUBLE-QUOTE │ │ │ │ │ PROPERTIES │ │ │ │ │ -FORCE-NOT │ │ │ │ │ IN-PROGRESS │ │ │ │ │ MISCELLANEOUS-SYMBOLS │ │ │ │ │ SHARED-LIBRARY │ │ │ │ │ ASDF/BACKWARD-INTERNALS │ │ │ │ │ NICKNAME │ │ │ │ │ ALLOW-UNBOUNDED-SC │ │ │ │ │ CJK-COMPATIBILITY-IDEOGRAPHS │ │ │ │ │ @@ -20340,51 +20341,59 @@ │ │ │ │ │ ASDF/SYSTEM │ │ │ │ │ WSEGSPACE │ │ │ │ │ MODIFIER-TONE-LETTERS │ │ │ │ │ ARABIC-EXTENDED-B │ │ │ │ │ MAXIMIZE │ │ │ │ │ LISU-SUPPLEMENT │ │ │ │ │ KANA-EXTENDED-B │ │ │ │ │ -COLLECT-DEPENDENCIES │ │ │ │ │ ITERATOR-COPY │ │ │ │ │ ADJUST-SEQUENCE │ │ │ │ │ -+CHARACTER-MISC-DATABASE+ │ │ │ │ │ -NEAR-JUMP │ │ │ │ │ -REG-NO-WIDTH │ │ │ │ │ -SHORT-JUMP │ │ │ │ │ ITERATOR-ELEMENT │ │ │ │ │ ITERATOR-ENDP │ │ │ │ │ MAKE-SIMPLE-SEQUENCE-ITERATOR │ │ │ │ │ GATHER-TYPE │ │ │ │ │ ITERATOR-STEP │ │ │ │ │ *DEFAULT-OUTPUT-TRANSLATIONS* │ │ │ │ │ *MODULES-BEING-REQUIRED* │ │ │ │ │ -+GOOD-BITS+ │ │ │ │ │ ITERATOR-INDEX │ │ │ │ │ ++GOOD-BITS+ │ │ │ │ │ +DONE-BIT+ │ │ │ │ │ ++CHARACTER-MISC-DATABASE+ │ │ │ │ │ +LOOP-STANDARD-EXPANSION │ │ │ │ │ +NEAR-JUMP │ │ │ │ │ +REG-NO-WIDTH │ │ │ │ │ +SHORT-JUMP │ │ │ │ │ FADD-STI │ │ │ │ │ -%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ │ FSUB-STI │ │ │ │ │ FSUBR-STI │ │ │ │ │ FMUL-STI │ │ │ │ │ FSUBP-STI │ │ │ │ │ FADDP-STI │ │ │ │ │ STORE-COVERAGE-MARK │ │ │ │ │ SIMPLE-FUN-HEADER-WORD │ │ │ │ │ *LOOP-DESETQ-TEMPORARY* │ │ │ │ │ +WORD-IMM │ │ │ │ │ +BYTE-IMM │ │ │ │ │ +COND-SET │ │ │ │ │ +%QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ │ +DECOMPOSE-STRING │ │ │ │ │ +CANONICALLY-COMPOSE │ │ │ │ │ *PACK-ASSIGN-COSTS* │ │ │ │ │ *REGISTER-ALLOCATION-METHOD* │ │ │ │ │ *REPACK-BLOCKS* │ │ │ │ │ *PACK-OPTIMIZE-SAVES* │ │ │ │ │ *REPACK-BLOCK-EVENT-INFO* │ │ │ │ │ *TRACED-FUNS* │ │ │ │ │ -ASM-EXPRESSION │ │ │ │ │ -WORD-IMM │ │ │ │ │ -BYTE-IMM │ │ │ │ │ -COND-SET │ │ │ │ │ +*DEFAULT-DSTATE-HOOKS* │ │ │ │ │ +*DISASSEM-LOCATION-COLUMN-WIDTH* │ │ │ │ │ +*DISASSEM-INST-COLUMN-WIDTH* │ │ │ │ │ +*DISASSEM-OPCODE-COLUMN-WIDTH* │ │ │ │ │ +*TRACE-ENCAPSULATE-DEFAULT* │ │ │ │ │ +*TRACE-REPORT-DEFAULT* │ │ │ │ │ +*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ │ PPRINT-PROG2 │ │ │ │ │ PPRINT-DEFUN │ │ │ │ │ PPRINT-DO │ │ │ │ │ PPRINT-DEFMETHOD │ │ │ │ │ PPRINT-CASE │ │ │ │ │ PPRINT-PROGV │ │ │ │ │ PPRINT-PROGN │ │ │ │ │ @@ -20398,62 +20407,60 @@ │ │ │ │ │ PPRINT-LET │ │ │ │ │ PPRINT-DEFPACKAGE │ │ │ │ │ PPRINT-TAGBODY │ │ │ │ │ PPRINT-LOOP │ │ │ │ │ PPRINT-DECLARE │ │ │ │ │ PPRINT-LAMBDA │ │ │ │ │ PPRINT-IF │ │ │ │ │ -*DEFAULT-DSTATE-HOOKS* │ │ │ │ │ -*DISASSEM-LOCATION-COLUMN-WIDTH* │ │ │ │ │ -*DISASSEM-INST-COLUMN-WIDTH* │ │ │ │ │ -*DISASSEM-OPCODE-COLUMN-WIDTH* │ │ │ │ │ -*TRACE-ENCAPSULATE-DEFAULT* │ │ │ │ │ -*TRACE-REPORT-DEFAULT* │ │ │ │ │ -*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ │ +ASM-EXPRESSION │ │ │ │ │ +BACKTRACE-START-FRAME │ │ │ │ │ +FUNCALL-WITH-DEBUG-IO-SYNTAX │ │ │ │ │ +MAP-BACKTRACE │ │ │ │ │ +PRINT-FRAME-CALL │ │ │ │ │ +WALK-FORM-INTERNAL │ │ │ │ │ +WALK-BINDINGS-1 │ │ │ │ │ +REALLY-END-LOGICAL-BLOCK │ │ │ │ │ +FITS-ON-LINE-P │ │ │ │ │ +INDEX-COLUMN │ │ │ │ │ +REALLY-START-LOGICAL-BLOCK │ │ │ │ │ +MISERING-P │ │ │ │ │ +SET-INDENTATION │ │ │ │ │ +OUTPUT-LINE │ │ │ │ │ ONE-ITER- │ │ │ │ │ %MAKE-LFL │ │ │ │ │ %MAKE-SO-DUMMY-NODE │ │ │ │ │ %MAKE-SO-SET-NODE │ │ │ │ │ %MAKE-SO-MAP-NODE │ │ │ │ │ MAKE-FINALIZER-NODE │ │ │ │ │ LIST-HEAD │ │ │ │ │ LIST-INSERTER │ │ │ │ │ LIST-DELETER │ │ │ │ │ LIST-FINDER │ │ │ │ │ LIST-INEQUALITY │ │ │ │ │ LIST-EQUALITY │ │ │ │ │ -WALK-DEFINITIONS │ │ │ │ │ %MAKE-ARG │ │ │ │ │ MAKE-INST-FORMAT │ │ │ │ │ -MAKE-STORAGE-INFO │ │ │ │ │ -%MAKE-SEGMENT │ │ │ │ │ -%MAKE-DSTATE │ │ │ │ │ -%MAKE-VERTEX │ │ │ │ │ -%MAKE-INTERFERENCE-GRAPH │ │ │ │ │ -MAKE-BINARY-NODE │ │ │ │ │ -MAKE-NODE │ │ │ │ │ -QUEUED-OP-POSN │ │ │ │ │ -SECTION-START-SECTION-END │ │ │ │ │ -SECTION-START-DEPTH │ │ │ │ │ -SECTION-START-POSN │ │ │ │ │ -MAKE-TAB │ │ │ │ │ PP-DISPATCH-ENTRIES │ │ │ │ │ PP-DISPATCH-CONS-ENTRIES │ │ │ │ │ PP-DISPATCH-NUMBER-MATCHABLE-P │ │ │ │ │ PP-DISPATCH-ONLY-INITIAL-ENTRIES │ │ │ │ │ ARG-NAME │ │ │ │ │ ARG-FIELDS │ │ │ │ │ ARG-VALUE │ │ │ │ │ ARG-SIGN-EXTEND-P │ │ │ │ │ ARG-PRINTER │ │ │ │ │ ARG-PREFILTER │ │ │ │ │ ARG-USE-LABEL │ │ │ │ │ DISASSEM-LENGTH │ │ │ │ │ FORMAT-LENGTH │ │ │ │ │ FORMAT-DEFAULT-PRINTER │ │ │ │ │ +MAKE-STORAGE-INFO │ │ │ │ │ +%MAKE-SEGMENT │ │ │ │ │ +%MAKE-DSTATE │ │ │ │ │ +%MAKE-VERTEX │ │ │ │ │ STORAGE-INFO-GROUPS │ │ │ │ │ STORAGE-INFO-DEBUG-VARS │ │ │ │ │ SEG-OBJECT │ │ │ │ │ SEG-SAP-MAKER │ │ │ │ │ SEG-LENGTH │ │ │ │ │ SEG-VIRTUAL-LOCATION │ │ │ │ │ SEG-STORAGE-INFO │ │ │ │ │ @@ -20510,14 +20517,31 @@ │ │ │ │ │ BINARY-NODE-%LEFT │ │ │ │ │ BINARY-NODE-%RIGHT │ │ │ │ │ TERNARY-NODE-LEFT │ │ │ │ │ TERNARY-NODE-KEY1 │ │ │ │ │ TERNARY-NODE-MIDDLE │ │ │ │ │ TERNARY-NODE-KEY2 │ │ │ │ │ TERNARY-NODE-RIGHT │ │ │ │ │ +%MAKE-INTERFERENCE-GRAPH │ │ │ │ │ +MAKE-BINARY-NODE │ │ │ │ │ +MAKE-NODE │ │ │ │ │ +QUEUED-OP-POSN │ │ │ │ │ +SECTION-START-SECTION-END │ │ │ │ │ +SECTION-START-DEPTH │ │ │ │ │ +SECTION-START-POSN │ │ │ │ │ +MAKE-TAB │ │ │ │ │ +MAKE-INST-SPACE │ │ │ │ │ +MAKE-INST-SPACE-CHOICE │ │ │ │ │ +MAKE-OFFS-HOOK │ │ │ │ │ +MAKE-SOURCE-FORM-CACHE │ │ │ │ │ +MAKE-LOCATION-GROUP │ │ │ │ │ +MAKE-LOOP-COLLECTOR │ │ │ │ │ +MAKE-LOOP-MINIMAX-INTERNAL │ │ │ │ │ +MAKE-LOOP-PATH │ │ │ │ │ +WALK-DEFINITIONS │ │ │ │ │ BLOCK-END-POSN │ │ │ │ │ BLOCK-END-SUFFIX │ │ │ │ │ NEWLINE-POSN │ │ │ │ │ NEWLINE-DEPTH │ │ │ │ │ NEWLINE-SECTION-END │ │ │ │ │ NEWLINE-KIND │ │ │ │ │ LOGICAL-BLOCK-START-COLUMN │ │ │ │ │ @@ -20539,32 +20563,14 @@ │ │ │ │ │ TAB-SECTIONP │ │ │ │ │ TAB-RELATIVEP │ │ │ │ │ TAB-COLNUM │ │ │ │ │ TAB-COLINC │ │ │ │ │ PPRINT-DISPATCH-ENTRY-TEST-FN │ │ │ │ │ PPRINT-DISPATCH-ENTRY-PRIORITY │ │ │ │ │ PPRINT-DISPATCH-ENTRY-FUN │ │ │ │ │ -PREFETCHT0 │ │ │ │ │ -PREFETCHT1 │ │ │ │ │ -PREFETCHT2 │ │ │ │ │ -FSUBRP-STI │ │ │ │ │ -XACQUIRE │ │ │ │ │ -XRELEASE │ │ │ │ │ -MAKE-INST-SPACE │ │ │ │ │ -MAKE-INST-SPACE-CHOICE │ │ │ │ │ -MAKE-OFFS-HOOK │ │ │ │ │ -MAKE-SOURCE-FORM-CACHE │ │ │ │ │ -MAKE-LOCATION-GROUP │ │ │ │ │ -MAKE-LOOP-COLLECTOR │ │ │ │ │ -MAKE-LOOP-MINIMAX-INTERNAL │ │ │ │ │ -MAKE-LOOP-PATH │ │ │ │ │ -MAKE-COUNTER │ │ │ │ │ -MAKE-PROFILE-INFO │ │ │ │ │ -MAKE-OVERHEAD │ │ │ │ │ -MAKE-TIME-INFO │ │ │ │ │ INST-NAME │ │ │ │ │ INST-FORMAT-NAME │ │ │ │ │ INST-MASK │ │ │ │ │ DCHUNK-ZERO │ │ │ │ │ INST-LENGTH │ │ │ │ │ INST-PRINT-NAME │ │ │ │ │ INST-PREFILTER │ │ │ │ │ @@ -20622,74 +20628,68 @@ │ │ │ │ │ TRACE-INFO-CONDITION-AFTER │ │ │ │ │ TRACE-INFO-BREAK-AFTER │ │ │ │ │ TRACE-INFO-PRINT-AFTER │ │ │ │ │ COUNTER-WORD │ │ │ │ │ COUNTER-OVERFLOW │ │ │ │ │ PROFILE-INFO-NAME │ │ │ │ │ PROFILE-INFO-ENCAPSULATED-FUN │ │ │ │ │ +MAKE-COUNTER │ │ │ │ │ +MAKE-PROFILE-INFO │ │ │ │ │ +MAKE-OVERHEAD │ │ │ │ │ +MAKE-TIME-INFO │ │ │ │ │ PROFILE-INFO-ENCAPSULATION-FUN │ │ │ │ │ PROFILE-INFO-READ-STATS-FUN │ │ │ │ │ PROFILE-INFO-CLEAR-STATS-FUN │ │ │ │ │ OVERHEAD-CALL │ │ │ │ │ OVERHEAD-INTERNAL │ │ │ │ │ OVERHEAD-TOTAL │ │ │ │ │ TIME-INFO-NAME │ │ │ │ │ TIME-INFO-CALLS │ │ │ │ │ TIME-INFO-SECONDS │ │ │ │ │ TIME-INFO-CONSING │ │ │ │ │ TIME-INFO-GC-RUN-TIME │ │ │ │ │ -DECOMPOSE-STRING │ │ │ │ │ -CANONICALLY-COMPOSE │ │ │ │ │ -BACKTRACE-START-FRAME │ │ │ │ │ -FUNCALL-WITH-DEBUG-IO-SYNTAX │ │ │ │ │ -MAP-BACKTRACE │ │ │ │ │ -PRINT-FRAME-CALL │ │ │ │ │ -WALK-FORM-INTERNAL │ │ │ │ │ -WALK-BINDINGS-1 │ │ │ │ │ -REALLY-END-LOGICAL-BLOCK │ │ │ │ │ -FITS-ON-LINE-P │ │ │ │ │ -INDEX-COLUMN │ │ │ │ │ -REALLY-START-LOGICAL-BLOCK │ │ │ │ │ -MISERING-P │ │ │ │ │ -SET-INDENTATION │ │ │ │ │ -OUTPUT-LINE │ │ │ │ │ -COMPUTE-TAB-SIZE │ │ │ │ │ -DSTATE-SETPROP │ │ │ │ │ -READ-SUFFIX │ │ │ │ │ -READ-SIGNED-SUFFIX │ │ │ │ │ -INST-OPERAND-SIZE │ │ │ │ │ -NOTIFY-DEPRECATED-FUNCTION │ │ │ │ │ -LET*-BINDINGS │ │ │ │ │ -NOTE-VAR-BINDING │ │ │ │ │ -WALKED-VAR-DECLARATION-P │ │ │ │ │ -NOTE-DECLARATION │ │ │ │ │ FLOATING-POINT │ │ │ │ │ FLOATING-POINT-FP │ │ │ │ │ -PREFILTER-WIDTH │ │ │ │ │ -PREFILTER-REG/MEM │ │ │ │ │ FAILURE-QUIT │ │ │ │ │ -SPECIAL75 │ │ │ │ │ -NOT-PRESENT78 │ │ │ │ │ *FLUSH-DEBUG-ERRORS* │ │ │ │ │ *DEBUG-BEGINNER-HELP-P* │ │ │ │ │ *DEBUG-READTABLE* │ │ │ │ │ *DEBUG-CONDITION* │ │ │ │ │ FRAME-HAS-DEBUG-TAG-P │ │ │ │ │ *DEBUG-HELP-STRING* │ │ │ │ │ INTERNAL-DEBUG │ │ │ │ │ *MAX-TRACE-INDENTATION* │ │ │ │ │ *TRACE-INDENTATION-STEP* │ │ │ │ │ LIST-BACKTRACE │ │ │ │ │ *IN-THE-DEBUGGER* │ │ │ │ │ UNPROFILE │ │ │ │ │ +SPECIAL75 │ │ │ │ │ +NOT-PRESENT78 │ │ │ │ │ +COMPUTE-TAB-SIZE │ │ │ │ │ +DSTATE-SETPROP │ │ │ │ │ +READ-SUFFIX │ │ │ │ │ +READ-SIGNED-SUFFIX │ │ │ │ │ +INST-OPERAND-SIZE │ │ │ │ │ +NOTIFY-DEPRECATED-FUNCTION │ │ │ │ │ +LET*-BINDINGS │ │ │ │ │ +NOTE-VAR-BINDING │ │ │ │ │ +WALKED-VAR-DECLARATION-P │ │ │ │ │ +NOTE-DECLARATION │ │ │ │ │ +ENV-WALK-FUNCTION │ │ │ │ │ +CANONIZE-KEY │ │ │ │ │ +INHERIT-OUTPUT-TRANSLATIONS │ │ │ │ │ +PREFILTER-WIDTH │ │ │ │ │ +PREFILTER-REG/MEM │ │ │ │ │ +PERFORM-LISP-WARNINGS-CHECK │ │ │ │ │ SIMPLE-DIR │ │ │ │ │ SHIFT-INST │ │ │ │ │ REG-REG/MEM │ │ │ │ │ NEAR-COND-JUMP │ │ │ │ │ SHORT-COND-JUMP │ │ │ │ │ +DCHUNK-EXTRACT │ │ │ │ │ PPRINT-FUN-CALL │ │ │ │ │ PPRINT-ARRAY │ │ │ │ │ PPRINT-UNQUOTING-COMMA │ │ │ │ │ PPRINT-MULTI-DIM-ARRAY │ │ │ │ │ PPRINT-EXTENDED-LOOP │ │ │ │ │ FORCE-NEWLINES-P │ │ │ │ │ MACRO-INDENTATION │ │ │ │ │ @@ -20699,37 +20699,35 @@ │ │ │ │ │ PPRINT-CALL-FORM-P │ │ │ │ │ DEFAULT-LINE-LENGTH │ │ │ │ │ OUTPUT-PARTIAL-LINE │ │ │ │ │ PPRINT-LAMBDA-LIST │ │ │ │ │ OUTPUT-GUTS │ │ │ │ │ PPRINT-ARRAY-P │ │ │ │ │ NOTE-SIGNIFICANT-SPACE │ │ │ │ │ -ENV-WALK-FUNCTION │ │ │ │ │ -CANONIZE-KEY │ │ │ │ │ -INHERIT-OUTPUT-TRANSLATIONS │ │ │ │ │ -PERFORM-LISP-WARNINGS-CHECK │ │ │ │ │ BUNDLE-OUTPUT-FILES │ │ │ │ │ -KEYWORDS-AND-FORMS │ │ │ │ │ PATHNAME-TYPE-EQUAL-FUNCTION │ │ │ │ │ PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ │ PROCESS-OUTPUT-TRANSLATIONS-DIRECTIVE │ │ │ │ │ SPACE-FOR-CRLF │ │ │ │ │ CANONIZE-TEST │ │ │ │ │ COLLECT-ACTION-DEPENDENCIES │ │ │ │ │ REQUIRED-MODULE │ │ │ │ │ MAKE-ACTION-STATUS │ │ │ │ │ ACTION-OVERRIDE-P │ │ │ │ │ MERGE-ACTION-STATUS │ │ │ │ │ STATUS-BITS │ │ │ │ │ STATUS-LEVEL │ │ │ │ │ -DCHUNK-EXTRACT │ │ │ │ │ -N-ARRAY23 │ │ │ │ │ PROCESS-SOURCE-REGISTRY-DIRECTIVE │ │ │ │ │ INITIALIZE-BIN │ │ │ │ │ SO-EXPAND-BINS │ │ │ │ │ +N-ARRAY23 │ │ │ │ │ +KEYWORDS-AND-FORMS │ │ │ │ │ +LOOP-DESETQ-TEMP │ │ │ │ │ +TYPE-FOR-DEFAULT-INIT │ │ │ │ │ +*TRACED-LOCALS* │ │ │ │ │ OLDEST-COMPATIBLE-VERSION │ │ │ │ │ REDEFINED-FUNCTIONS │ │ │ │ │ REDEFINED-CLASSES │ │ │ │ │ SUPERCLASSES │ │ │ │ │ *ASDF-UPGRADED-P* │ │ │ │ │ PREVIOUS-VERSION │ │ │ │ │ OLD-VERSION │ │ │ │ │ @@ -20794,19 +20792,21 @@ │ │ │ │ │ SUB-SPEC │ │ │ │ │ EMIT-SUBSTRING │ │ │ │ │ OPERAND1 │ │ │ │ │ EMIT-RANDOM-ARITH-INST │ │ │ │ │ MAYBE-PRINT-SEGMENT-OVERRIDE │ │ │ │ │ EMIT-ABSOLUTE-FIXUP │ │ │ │ │ TWO-BYTES │ │ │ │ │ +PREFETCHT2 │ │ │ │ │ EMIT-IMM-OPERAND │ │ │ │ │ PRINT-ADDR-REG │ │ │ │ │ EMIT-DOUBLE-SHIFT │ │ │ │ │ IMUL-3-OPERAND │ │ │ │ │ XCHG-REG-WITH-SOMETHING │ │ │ │ │ +PREFETCHT0 │ │ │ │ │ BYTE-DISP-P │ │ │ │ │ ACCUM-REG/MEM │ │ │ │ │ EXT-REG-REG/MEM-NO-WIDTH │ │ │ │ │ EMIT-BYTE-DISPLACEMENT-BACKPATCH │ │ │ │ │ FP-REG-TN-P │ │ │ │ │ MAYBE-EMIT-OPERAND-SIZE-PREFIX │ │ │ │ │ EXT-REG/MEM-NO-WIDTH+IMM8 │ │ │ │ │ @@ -20824,28 +20824,32 @@ │ │ │ │ │ EXT-REG-REG/MEM │ │ │ │ │ INST-WORD-OPERAND-SIZE │ │ │ │ │ PRINT-MEM-ACCESS │ │ │ │ │ OPERAND2 │ │ │ │ │ EMIT-HEADER-DATA │ │ │ │ │ REG-TN-ENCODING │ │ │ │ │ EMIT-PREFIX │ │ │ │ │ +FSUBRP-STI │ │ │ │ │ THREE-BYTES │ │ │ │ │ SIZE-NBYTE │ │ │ │ │ BYTE-IMM-CODE │ │ │ │ │ +XACQUIRE │ │ │ │ │ EMIT-BYTE+REG │ │ │ │ │ MATCHING-OPERAND-SIZE │ │ │ │ │ EMIT-DWORD │ │ │ │ │ PRINT-REG-WITH-WIDTH │ │ │ │ │ +XRELEASE │ │ │ │ │ EMIT-FP-OP │ │ │ │ │ EXT-REG/MEM-NO-WIDTH │ │ │ │ │ EMIT-SHIFT-INST │ │ │ │ │ COND-MOVE │ │ │ │ │ OPCODE+SIZE-BIT │ │ │ │ │ WORD-IMM-CODE │ │ │ │ │ MARK-INDEX │ │ │ │ │ +PREFETCHT1 │ │ │ │ │ EMIT-MOD-REG-R/M-BYTE │ │ │ │ │ PRINT-BYTE-REG │ │ │ │ │ EMIT-WORD │ │ │ │ │ EXT-REG-NO-WIDTH │ │ │ │ │ ENTER-FORMAT │ │ │ │ │ FLOATING-POINT-NO │ │ │ │ │ DWORD-REG-P │ │ │ │ │ @@ -20912,15 +20916,14 @@ │ │ │ │ │ *LOOP-INSIDE-CONDITIONAL* │ │ │ │ │ AFTER-LOOP │ │ │ │ │ LOOP-DO-REPEAT │ │ │ │ │ LOOP-DO-RETURN │ │ │ │ │ LOOP-DESTRUCTURING-BIND │ │ │ │ │ LOOP-SUM-COLLECTION │ │ │ │ │ LOOP-DISALLOW-ANONYMOUS-COLLECTORS │ │ │ │ │ -TYPE-FOR-DEFAULT-INIT │ │ │ │ │ LOOP-DO-DO │ │ │ │ │ LOOP-WARN │ │ │ │ │ MAKE-LOOP-MINIMAX │ │ │ │ │ LOOP-BIND-BLOCK │ │ │ │ │ LOOP-ITERATION-DRIVER │ │ │ │ │ LOOP-DISALLOW-CONDITIONAL │ │ │ │ │ WITH-MINIMAX-VALUE │ │ │ │ │ @@ -21099,32 +21102,30 @@ │ │ │ │ │ STOP-FORM │ │ │ │ │ BOGO-FUN-TO-WALKER-INFO │ │ │ │ │ WITH-SEQUENCE-ITERATOR │ │ │ │ │ WITH-SEQUENCE-ITERATOR-FUNCTIONS │ │ │ │ │ DOSEQUENCE │ │ │ │ │ %COMPUTE-OPERATIONS-VALUE │ │ │ │ │ *IN-MAKE-OPERATION* │ │ │ │ │ -LOOP-DESETQ-TEMP │ │ │ │ │ MAKE-VECTOR-SEGMENT │ │ │ │ │ LABEL-SEGMENTS │ │ │ │ │ DISASSEMBLE-SEGMENTS │ │ │ │ │ GET-CODE-SEGMENTS │ │ │ │ │ MAKE-MEMORY-SEGMENT │ │ │ │ │ HUFFMAN-DECODE │ │ │ │ │ RETRACE-LOCAL-FUNS │ │ │ │ │ PARSE-TRACE-OPTIONS │ │ │ │ │ GET-FUN-SEGMENTS │ │ │ │ │ -*TRACED-LOCALS* │ │ │ │ │ +*CURRENT-FRAME* │ │ │ │ │ *TRACED-ENTRIES* │ │ │ │ │ MAX-FILTERED-VALUE-INDEX │ │ │ │ │ -*CURRENT-FRAME* │ │ │ │ │ DEP-SPEC │ │ │ │ │ COMBINATOR │ │ │ │ │ -*IMAGE-RESTORED-P* │ │ │ │ │ NEW-STATUS │ │ │ │ │ +*IMAGE-RESTORED-P* │ │ │ │ │ ARG-INDEX │ │ │ │ │ COMPUTE-PREFILTER │ │ │ │ │ PERFORM-STATUS │ │ │ │ │ PRINT-BYTES │ │ │ │ │ PRINT-CURRENT-ADDRESS │ │ │ │ │ SAP-REF-INT │ │ │ │ │ SET-LOCATION-PRINTING-RANGE │ │ │ │ │ @@ -21308,14 +21309,15 @@ │ │ │ │ │ MAKE-SO-MAP/FIXNUM │ │ │ │ │ %SO-EQ-SET-PHASE2-INSERT │ │ │ │ │ MAKE-MARKED-REF │ │ │ │ │ MAKE-SO-MAP/STRING │ │ │ │ │ C-SO-FIND/ADDR │ │ │ │ │ LFL-DELETE*/T │ │ │ │ │ LFL-INSERT*/T │ │ │ │ │ +TRACE-FDEFINITION │ │ │ │ │ CALL-WITH-INPUT │ │ │ │ │ PATHNAME-VALUE │ │ │ │ │ OUTPUT-VAR │ │ │ │ │ INPUT-VAR │ │ │ │ │ CALL-WITH-OUTPUT │ │ │ │ │ GET-TEMPORARY-FILE │ │ │ │ │ REPORT-ERROR │ │ │ │ │ @@ -21407,15 +21409,14 @@ │ │ │ │ │ RESTART-FRAME-DEBUG-COMMAND │ │ │ │ │ SHOW-RESTARTS │ │ │ │ │ TRACE-START-BREAKPOINT-FUN │ │ │ │ │ DEBUG-LOOP-CATCHER │ │ │ │ │ COERCE-FORM │ │ │ │ │ FUNCTION-OR-NAME │ │ │ │ │ NEXT-DEBUG-COMMAND │ │ │ │ │ -TRACE-FDEFINITION │ │ │ │ │ DEBUG-LOOP-FUN │ │ │ │ │ FIND-BINDING-STACK-POINTER │ │ │ │ │ STEP-DEBUG-COMMAND │ │ │ │ │ PRINT-DEBUG-COMMAND │ │ │ │ │ FIND-ENCLOSING-CATCH-BLOCK │ │ │ │ │ FRAME-HAS-DEBUG-VARS-P │ │ │ │ │ MAYBE-BLOCK-START-LOCATION │ │ │ │ │ @@ -21487,21 +21488,21 @@ │ │ │ │ │ DEBUG-EVAL-PRINT │ │ │ │ │ BACKTRACE-DEBUG-COMMAND │ │ │ │ │ POSTLUDEP │ │ │ │ │ LISP-OBJECT-FILES │ │ │ │ │ PRELUDEP │ │ │ │ │ ENTRY-POINT-P │ │ │ │ │ RESULT-WIDTH-NAME- │ │ │ │ │ -LIST-INITARG-0 │ │ │ │ │ *!DELAYED-DEFMETHOD-ARGS* │ │ │ │ │ !DECODE-FOP │ │ │ │ │ -ARG-FOR-(BYTE 3 0)- │ │ │ │ │ -ARG-FOR-(BYTE 3 3)- │ │ │ │ │ ARG-FOR-(BYTE 2 6)- │ │ │ │ │ +ARG-FOR-(BYTE 3 3)- │ │ │ │ │ +ARG-FOR-(BYTE 3 0)- │ │ │ │ │ !HAIRY-DATA-VECTOR-REFFER-INIT │ │ │ │ │ +LIST-INITARG-0 │ │ │ │ │ EMF-N-59 │ │ │ │ │ EMF-N-63 │ │ │ │ │ EMF-N-69 │ │ │ │ │ EMF-N-95 │ │ │ │ │ EMF-N-107 │ │ │ │ │ .SLOTS.97 │ │ │ │ │ EMF-N-9598 │ │ │ │ │ @@ -22118,34 +22119,34 @@ │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ n8civ:&& │ │ │ │ │ + CONDITION │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + CONDITION │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ CLEANUP-FUN- │ │ │ │ │ WITHOUT-INTERRUPTS-BODY- │ │ │ │ │ ~@ │ │ │ │ │ ~@<~// is a macro, not a function.~@:> │ │ │ │ │ ~@ │ │ │ │ │ ~@<~S fell through ~S expression.~@[ ~:_Wanted one of (~//).~]~:> │ │ │ │ │ ~A elements in ~2I~_~:S ~I~_to satisfy lambda list ~2I~_~//: ~I~_ │ │ │ │ │ ~@<~S ~S causes name-conflicts in ~S between the following symbols: ~2I~@:_~{~//~^, ~}~:@> │ │ │ │ │ ~@ │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ - CONDITION │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - CONDITION │ │ │ │ │ -COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -22205,27 +22206,27 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ -~@ │ │ │ │ │ -~&Error during printing. │ │ │ │ │ -~@ │ │ │ │ │ SB-ASSEM │ │ │ │ │ private: the assembler, used by the compiler │ │ │ │ │ private: stuff related to fasload logic (and GENESIS) │ │ │ │ │ private: a wrapper layer for SBCL itself to use when talking with │ │ │ │ │ an underlying Unix-y operating system. This was a public package in │ │ │ │ │ CMU CL, but that was different. CMU CL's UNIX package tried to │ │ │ │ │ provide a comprehensive, stable Unix interface suitable for the end │ │ │ │ │ user. This package only tries to implement what happens to be needed │ │ │ │ │ by the current implementation of SBCL, and makes no guarantees of │ │ │ │ │ interface stability. │ │ │ │ │ +~@ │ │ │ │ │ +~&Error during printing. │ │ │ │ │ +~@ │ │ │ │ │ SYS:SRC;CODE;EARLY-EXTENSIONS.LISP │ │ │ │ │ complex float realpart │ │ │ │ │ complex float imagpart │ │ │ │ │ inline complex single-float creation │ │ │ │ │ inline complex double-float creation │ │ │ │ │ inline float coercion │ │ │ │ │ SYS:SRC;CODE;RESTART.LISP │ │ │ │ │ @@ -22504,15 +22505,14 @@ │ │ │ │ │ A list of function designators which are called in an unspecified │ │ │ │ │ order when SBCL process exits. │ │ │ │ │ Unused by SBCL itself: reserved for user and applications. │ │ │ │ │ Using (SB-EXT:EXIT :ABORT T), or calling exit(3) directly circumvents │ │ │ │ │ these hooks. │ │ │ │ │ SEMAPHORE- │ │ │ │ │ SESSION- │ │ │ │ │ -INTERVAL- │ │ │ │ │ ~S used on non-constant LVAR ~S │ │ │ │ │ * is not permitted as a type specifier~@[ in the context ~S~] │ │ │ │ │ * is not permitted as an argument to the ~S type specifier │ │ │ │ │ Should not be called: ~S │ │ │ │ │ ~2I~@[~:@_ ~:@_~:{~:(~A~): ~S~:^, ~:_~}~]~:@_ ~:@_Stream: ~S │ │ │ │ │ Bogus slot cell in SLOT-VALUE: ~S │ │ │ │ │ ~:[~*~;error in ~S: ~]~?~@[ │ │ │ │ │ @@ -22522,14 +22522,15 @@ │ │ │ │ │ High bound is not * or a double-float or list of one double-float: ~S │ │ │ │ │ Low bound is not * or a double-float or list of one double-float: ~S │ │ │ │ │ High bound is not * or a single-float or list of one single-float: ~S │ │ │ │ │ Low bound is not * or a single-float or list of one single-float: ~S │ │ │ │ │ forced to do runtime allocation of alien-value structure │ │ │ │ │ 0 2)"(/` │ │ │ │ │ COMPLEX-FLOAT-VALUE VOP failure │ │ │ │ │ +INTERVAL- │ │ │ │ │ Should the contents of arrays be printed? │ │ │ │ │ Should we use #n= and #n# notation to preserve uniqueness in general (and │ │ │ │ │ circularity in particular) when printing? │ │ │ │ │ VMXMZH^__6o │ │ │ │ │ @4L7[8E99< │ │ │ │ │ FUN-DESIGNATOR-TYPE- │ │ │ │ │ ALIEN-C-STRING-TYPE- │ │ │ │ │ @@ -22716,38 +22717,38 @@ │ │ │ │ │ The output base for RATIONALs (including integers). │ │ │ │ │ Should base be verified when printing RATIONALs? │ │ │ │ │ COMPONENT- │ │ │ │ │ COMBINATION- │ │ │ │ │ FD-STREAM- │ │ │ │ │ PRETTY-STREAM- │ │ │ │ │ BROADCAST-STREAM- │ │ │ │ │ -FORM-TRACKING-STREAM- │ │ │ │ │ After trying to die in EXIT. │ │ │ │ │ c-a"T<)7 │ │ │ │ │ )))))'"B: │ │ │ │ │ 'ks?>F"? │ │ │ │ │ $&,&(*0! │ │ │ │ │ _I): %.H │ │ │ │ │ ~&quitting because IR1-TRANSFORM result was NIL │ │ │ │ │ ~&trying transform ~s for ~s │ │ │ │ │ The return value of ~A should not be discarded. │ │ │ │ │ shouldn't happen? │ │ │ │ │ +FORM-TRACKING-STREAM- │ │ │ │ │ TWO-WAY-STREAM- │ │ │ │ │ CONCATENATED-STREAM- │ │ │ │ │ ECHO-STREAM- │ │ │ │ │ SYS:SRC;COMPILER;IR2TRAN.LISP │ │ │ │ │ SYS:SRC;COMPILER;CONSTRAINT.LISP │ │ │ │ │ SYS:SRC;PCL;CTOR.LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP │ │ │ │ │ SYS:SRC;PCL;PRE-WARM.LISP │ │ │ │ │ SYS:SRC;CODE;EARLY-FULL-EVAL.LISP │ │ │ │ │ -SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ │ SYS:SRC;CODE;EARLY-PPRINT.LISP │ │ │ │ │ SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP │ │ │ │ │ FAST-METHOD-CALL- │ │ │ │ │ +SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ │ /etc/sbclrc │ │ │ │ │ Setting *READ-SUPPRESS* to NIL to restore toplevel usability. │ │ │ │ │ The block name ~S is not a symbol. │ │ │ │ │ Place ~S in PSETQ is not a SYMBOL │ │ │ │ │ Odd number of args to ~S. │ │ │ │ │ ~S called with too few arguments: ~S │ │ │ │ │ ~@ │ │ │ │ │ @@ -22758,14 +22759,17 @@ │ │ │ │ │ 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 │ │ │ │ │ O)D-~-&W │ │ │ │ │ WR\W_dkv}bWWhjZs?eU │ │ │ │ │ VALUES type illegal in this context: │ │ │ │ │ +~S can't be converted to type ~//. │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ VALUE85g5 │ │ │ │ │ ALIEN-TYPE │ │ │ │ │ SB-ALIEN-INTERNALS0 │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ @@ -22841,28 +22845,23 @@ │ │ │ │ │ EXPANSION │ │ │ │ │ EXPANSION │ │ │ │ │ avBVuYw" │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ optimize away %SAP-ALIEN │ │ │ │ │ -~S can't be converted to type ~//. │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ thread interruptions lock │ │ │ │ │ -LAMBDA-VAR- │ │ │ │ │ -SSET-ELEMENT- │ │ │ │ │ List of available buffers. │ │ │ │ │ Package Table Lock │ │ │ │ │ finalizer │ │ │ │ │ Package Graph Lock │ │ │ │ │ Scheduler lock │ │ │ │ │ A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ │ -List of all the currently active handlers for file descriptors │ │ │ │ │ Around spawn(). │ │ │ │ │ +List of all the currently active handlers for file descriptors │ │ │ │ │ List of all available output routines. Each element is a list of the │ │ │ │ │ element-type output, the kind of buffering, the function name, and the number │ │ │ │ │ of bytes per element. │ │ │ │ │ List of process structures for all active processes. │ │ │ │ │ A function of no arguments returning a function of one argument NOPRINT │ │ │ │ │ that provides the REPL for the system. Assumes that *STANDARD-INPUT* and │ │ │ │ │ *STANDARD-OUTPUT* are set up. │ │ │ │ │ @@ -22900,23 +22899,23 @@ │ │ │ │ │ in a given lambda list. This is actually the limit on required and &OPTIONAL │ │ │ │ │ parameters. With &KEY and &AUX you can get more. │ │ │ │ │ Boole function op, makes BOOLE return logeqv of integer1 and integer2. │ │ │ │ │ a list of symbols that describe features provided by the │ │ │ │ │ implementation │ │ │ │ │ the form currently being evaluated │ │ │ │ │ interactive debugging stream │ │ │ │ │ +counter for generating unique GENSYM symbols │ │ │ │ │ +Boole function op, makes BOOLE return logorc2 of integer1 and integer2. │ │ │ │ │ bounding index designator │ │ │ │ │ SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ │ Metaobject Protocol │ │ │ │ │ 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. │ │ │ │ │ -counter for generating unique GENSYM symbols │ │ │ │ │ -Boole function op, makes BOOLE return logorc2 of integer1 and integer2. │ │ │ │ │ How many elements at any level should be printed before abbreviating │ │ │ │ │ with "..."? │ │ │ │ │ The default for the :VERBOSE argument to COMPILE-FILE. │ │ │ │ │ Boole function op, makes BOOLE return integer1. │ │ │ │ │ the previous value of * │ │ │ │ │ Boole function op, makes BOOLE return 0. │ │ │ │ │ Boole function op, makes BOOLE return logxor of integer1 and integer2. │ │ │ │ │ @@ -23133,22 +23132,22 @@ │ │ │ │ │ call: Return the next Lisp form to evaluate (possibly handling other magic -- │ │ │ │ │ like ACL-style keyword commands -- which precede the next Lisp form). The OUT │ │ │ │ │ stream is there to support magic which requires issuing new prompts. │ │ │ │ │ The source file types which LOAD looks for by default. │ │ │ │ │ A list of functions that (SETF COMPILER-MACRO-FUNCTION) invokes before │ │ │ │ │ storing the new value. The functions take the function name and the new │ │ │ │ │ value. │ │ │ │ │ +bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ │ The value of LONG-SITE-NAME. │ │ │ │ │ The value of SHORT-SITE-NAME. │ │ │ │ │ Signaled when an operation in the context of a deadline takes │ │ │ │ │ longer than permitted by the deadline. │ │ │ │ │ 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. │ │ │ │ │ -bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ │ 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. │ │ │ │ │ CONDITION-SLOT- │ │ │ │ │ SYS:SRC;COMPILER;MAIN.LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -23203,23 +23202,23 @@ │ │ │ │ │ CORE-DEBUG-SOURCE-EQUALP │ │ │ │ │ TRANSFORM-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ B SB-KERNEL0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ REST-ARG │ │ │ │ │ -~&~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ FORMAT-ARGUMENTS │ │ │ │ │ FORMAT-CONTROL SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -23258,18 +23257,20 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ 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, │ │ │ │ │ or when loading the package is optional. │ │ │ │ │ COMMON-LISP │ │ │ │ │ SYS:SRC;PCL;DOCUMENTATION.LISP │ │ │ │ │ +hash-table lock │ │ │ │ │ SYS:SRC;CODE;DESCRIBE.LISP │ │ │ │ │ SYS:SRC;CODE;INSPECT.LISP │ │ │ │ │ -hash-table lock │ │ │ │ │ ALIEN-SINGLE-FLOAT-TYPE- │ │ │ │ │ +SYS:SRC;CODE;CLASS.LISP │ │ │ │ │ +SYS:SRC;CODE;EARLY-RAW-SLOTS.LISP │ │ │ │ │ ~S is a bad :TYPE for DEFSTRUCT. │ │ │ │ │ ~S and ~S may not both be specified │ │ │ │ │ ~S does not define a constructor │ │ │ │ │ The DEFSTRUCT option :NAMED takes no arguments. │ │ │ │ │ unknown DEFSTRUCT option: │ │ │ │ │ Invalid syntax in DEFSTRUCT option ~S │ │ │ │ │ DEFSTRUCT option ~S ~[requires at least~;requires exactly~;accepts at most~] one argument │ │ │ │ │ @@ -23357,16 +23358,14 @@ │ │ │ │ │ Special Operator ~S │ │ │ │ │ Function ~S │ │ │ │ │ The SBCL Manual │ │ │ │ │ Variable ~S │ │ │ │ │ Initialization of ~:(~A~) Metaobjects │ │ │ │ │ Generic Function ~S │ │ │ │ │ x0<#G;*# │ │ │ │ │ -SYS:SRC;CODE;CLASS.LISP │ │ │ │ │ -SYS:SRC;CODE;EARLY-RAW-SLOTS.LISP │ │ │ │ │ inline fixnum arithmetic │ │ │ │ │ inline (unsigned-byte 32) arithmetic │ │ │ │ │ inline (signed-byte 32) arithmetic │ │ │ │ │ SYS:SRC;CODE;TARGET-RANDOM.LISP │ │ │ │ │ SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ │ SYS:SRC;CODE;XSET.LISP │ │ │ │ │ The current │ │ │ │ │ @@ -23530,35 +23529,37 @@ │ │ │ │ │ invalid number of arguments │ │ │ │ │ invalid number of arguments: 0 │ │ │ │ │ invalid number of arguments: 1 │ │ │ │ │ invalid number of arguments: 2 │ │ │ │ │ ? ")'8$ │ │ │ │ │ ~&Enter a form to be evaluated: │ │ │ │ │ Invalid function name: ~S │ │ │ │ │ -~&~@<~S: ~3i~:_~A~:> │ │ │ │ │ -~S does not designate a ~A class │ │ │ │ │ -Skip warning. │ │ │ │ │ -Recursive lock attempt ~S. │ │ │ │ │ SYS:SRC;COMPILER;X86;FLOAT.LISP │ │ │ │ │ SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ │ SYS:SRC;CODE;AVLTREE.LISP │ │ │ │ │ SYS:SRC;CODE;UNIX.LISP │ │ │ │ │ SYS:SRC;CODE;HASHSET.LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-FLOAT.LISP │ │ │ │ │ +LAMBDA-VAR- │ │ │ │ │ +SSET-ELEMENT- │ │ │ │ │ AVLNODE- │ │ │ │ │ WAITQUEUE- │ │ │ │ │ ALIEN-TYPE-TYPE- │ │ │ │ │ CONSTANT-TYPE- │ │ │ │ │ NEGATION-TYPE- │ │ │ │ │ HAIRY-TYPE- │ │ │ │ │ HASHSET- │ │ │ │ │ WRAPPER18 │ │ │ │ │ WRAPPER14 │ │ │ │ │ WRAPPER8 │ │ │ │ │ WRAPPER2 │ │ │ │ │ +~&~@<~S: ~3i~:_~A~:> │ │ │ │ │ +~S does not designate a ~A class │ │ │ │ │ +Skip warning. │ │ │ │ │ +Recursive lock attempt ~S. │ │ │ │ │ ~&~@ │ │ │ │ │ A nested error within --disable-debugger error handling prevents printing the backtrace. Sorry, exiting. │ │ │ │ │ A nested error within --disable-debugger error handling prevents displaying the original error. Attempting to print a backtrace. │ │ │ │ │ unhandled condition in --disable-debugger mode, quitting │ │ │ │ │ ~&Unhandled ~S~@[ in thread ~S~]: │ │ │ │ │ ~@ │ │ │ │ │ g<5u1$2( │ │ │ │ │ @@ -23617,32 +23618,35 @@ │ │ │ │ │ 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. │ │ │ │ │ %CONDITION-WAIT: invalid status on normal return: ~S │ │ │ │ │ The current thread is not holding ~s. │ │ │ │ │ Failed to release CAS lock! │ │ │ │ │ -The current thread is not at the foreground, │ │ │ │ │ -SB-THREAD:RELEASE-FOREGROUND has to be called in ~s │ │ │ │ │ -for this thread to enter the debugger. │ │ │ │ │ -session lock │ │ │ │ │ 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{ │ │ │ │ │ +1.0.53.11 │ │ │ │ │ +1.0.29.17 │ │ │ │ │ +1.0.37.33 │ │ │ │ │ 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 │ │ │ │ │ ~S is not a valid L-value. │ │ │ │ │ Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ │ +The current thread is not at the foreground, │ │ │ │ │ +SB-THREAD:RELEASE-FOREGROUND has to be called in ~s │ │ │ │ │ +for this thread to enter the debugger. │ │ │ │ │ +session lock │ │ │ │ │ pthread_kill() failed │ │ │ │ │ ~@ │ │ │ │ │ Clear notification status and continue. │ │ │ │ │ Could not create new OS thread. │ │ │ │ │ Exit Lock │ │ │ │ │ Allocator │ │ │ │ │ @@ -23653,18 +23657,15 @@ │ │ │ │ │ GET-MUTEX won't get a mutex on behalf of a different thread │ │ │ │ │ ~& 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%) │ │ │ │ │ Unknown barrier kind ~S │ │ │ │ │ %% >7X } h │ │ │ │ │ -1.0.53.11 │ │ │ │ │ -1.0.29.17 │ │ │ │ │ -ALIEN-DOUBLE-FLOAT-TYPE- │ │ │ │ │ -1.0.37.33 │ │ │ │ │ +note: ~A │ │ │ │ │ /build/reproducible-path/buildapp-1.5.6/package.lisp │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ Calls the function associated with the given restart, passing any given │ │ │ │ │ arguments. If the argument restart is not a restart or a currently active │ │ │ │ │ non-nil restart name, then a CONTROL-ERROR is signalled. │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ @@ -23732,31 +23733,14 @@ │ │ │ │ │ A SB-KERNEL │ │ │ │ │ FORM-TRACKING-STREAM-EQUALP │ │ │ │ │ TWO-WAY-STREAM-EQUALP │ │ │ │ │ CONCATENATED-STREAM-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ ECHO-STREAM-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ -Impossible: fixnum ASH should not be called with │ │ │ │ │ -constant shift greater than word length │ │ │ │ │ -note: ~A │ │ │ │ │ -~@ │ │ │ │ │ - !j+ H,R#(S& │ │ │ │ │ -xoH11 1 │ │ │ │ │ -The name ~S does not designate any package. │ │ │ │ │ -Specify a different package │ │ │ │ │ -Retry finding the package. │ │ │ │ │ -Use the current package, ~a. │ │ │ │ │ -~S is not defined for ~S │ │ │ │ │ -~S is not a ~S │ │ │ │ │ -~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ │ -Unimplemented │ │ │ │ │ -?*5""*(**% , │ │ │ │ │ -~W is too big for a fixnum. │ │ │ │ │ -~S is not a defined storage class. │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ FAST-METHOD-CALL-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ B SB-KERNEL0 │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ Return all of the elements of LIST, in order, as values. │ │ │ │ │ @@ -23805,30 +23789,47 @@ │ │ │ │ │ FUN-NAME │ │ │ │ │ NEW-RANGE │ │ │ │ │ CTYPE SB-KERNEL8 │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ PRED8Dg" │ │ │ │ │ Simple equality transform │ │ │ │ │ +ALIEN-DOUBLE-FLOAT-TYPE- │ │ │ │ │ +Impossible: fixnum ASH should not be called with │ │ │ │ │ +constant shift greater than word length │ │ │ │ │ Base class for all Gray streams. │ │ │ │ │ Superclass of all Gray input streams. │ │ │ │ │ SYS:SRC;PCL;LOW.LISP │ │ │ │ │ UNDEFINED-CLASSOID- │ │ │ │ │ -TYPE-CONTEXT- │ │ │ │ │ +~@ │ │ │ │ │ +bad thing to be a type specifier: ~// │ │ │ │ │ +~@ │ │ │ │ │ + !j+ H,R#(S& │ │ │ │ │ +xoH11 1 │ │ │ │ │ +The name ~S does not designate any package. │ │ │ │ │ +Specify a different package │ │ │ │ │ +Retry finding the package. │ │ │ │ │ +Use the current package, ~a. │ │ │ │ │ +~S is not defined for ~S │ │ │ │ │ +~S is not a ~S │ │ │ │ │ +~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ │ +Unimplemented │ │ │ │ │ +?*5""*(**% , │ │ │ │ │ +~W is too big for a fixnum. │ │ │ │ │ +~S is not a defined storage class. │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ -~@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -23838,32 +23839,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ LVAR-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ -REF-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -CSET-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -LAMBDA-VAR-EQUALP │ │ │ │ │ -CONSET-EQUALP │ │ │ │ │ -SSET-ELEMENT-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -B SB-KERNEL8 g │ │ │ │ │ - KV-VECTOR │ │ │ │ │ -TABLE8 g │ │ │ │ │ -EMPTY-KV-INDEX │ │ │ │ │ -HASH-TABLE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - KV-VECTOR0 │ │ │ │ │ -HASH-TABLE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - KV-VECTOR │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ .DEFAULTING-TEMP.0 │ │ │ │ │ Return true if OBJECT is a STRING, and NIL otherwise. │ │ │ │ │ COMMON-LISP │ │ │ │ │ N-RESULT │ │ │ │ │ @@ -23963,35 +23946,56 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ SQRT-Z+1 │ │ │ │ │ CHARACTERS │ │ │ │ │ CODE10g" │ │ │ │ │ DEFSTRUCT │ │ │ │ │ COMMON-LISP │ │ │ │ │ SLOT-TYPE │ │ │ │ │ +INSTANCE │ │ │ │ │ automatically generated writer method │ │ │ │ │ automatically generated reader method │ │ │ │ │ CONSTANT- │ │ │ │ │ INTERSECTION-TYPE- │ │ │ │ │ +TYPE-CONTEXT- │ │ │ │ │ +COMPOUND-TYPE- │ │ │ │ │ +UNKNOWN-TYPE- │ │ │ │ │ SYS:SRC;CODE;CL-SPECIALS.LISP │ │ │ │ │ SYS:SRC;CODE;DEFMACRO.LISP │ │ │ │ │ SYS:SRC;CODE;LATE-EXTENSIONS.LISP │ │ │ │ │ SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ │ &{("+~5<7\7 │ │ │ │ │ SYS:SRC;CODE;PPRINT.LISP │ │ │ │ │ SB-PRETTY │ │ │ │ │ private: implementation of pretty-printing │ │ │ │ │ SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ │ SYS:SRC;COMPILER;X86;ARITH.LISP │ │ │ │ │ -COMPOUND-TYPE- │ │ │ │ │ -UNKNOWN-TYPE- │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP │ │ │ │ │ +LVAR-DEPENDENT-ANNOTATION- │ │ │ │ │ +LVAR-FUNCTION-DESIGNATOR-ANNOTATION- │ │ │ │ │ LVAR-SEQUENCE-BOUNDS-ANNOTATION- │ │ │ │ │ LVAR-TYPE-ANNOTATION- │ │ │ │ │ LVAR-FUNCTION-ANNOTATION- │ │ │ │ │ LVAR-LAMBDA-VAR-ANNOTATION- │ │ │ │ │ +CLEANUP- │ │ │ │ │ +ALIEN-FUN-TYPE- │ │ │ │ │ +ALIEN-ARRAY-TYPE- │ │ │ │ │ +Return the documentation string of Doc-Type for X, or NIL if none │ │ │ │ │ +exists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T. │ │ │ │ │ +Function documentation is stored separately for function names and objects: │ │ │ │ │ +DEFUN, LAMBDA, &co create function objects with the specified documentation │ │ │ │ │ +strings. │ │ │ │ │ + (SETF (DOCUMENTATION NAME 'FUNCTION) STRING) │ │ │ │ │ +sets the documentation string stored under the specified name, and │ │ │ │ │ + (SETF (DOCUMENTATION FUNC T) STRING) │ │ │ │ │ +sets the documentation string stored in the function object. │ │ │ │ │ + (DOCUMENTATION NAME 'FUNCTION) │ │ │ │ │ +returns the documentation stored under the function name if any, and │ │ │ │ │ +falls back on the documentation in the function object if necessary. │ │ │ │ │ +SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ │ +SYS:SRC;CODE;FORMAT.LISP │ │ │ │ │ ~@ │ │ │ │ │ seconds │ │ │ │ │ ~8d ~:{~:[~2*~18@t~;~:* ~2d ~6,2f ~5,1,2f%~] |~} ~a │ │ │ │ │ Index ~W is out of bounds. It should have been between ~ │ │ │ │ │ 0 and ~W. │ │ │ │ │ can't reconstitute key of deleted finalizer node │ │ │ │ │ ~&Unhashed: │ │ │ │ │ @@ -24008,23 +24012,14 @@ │ │ │ │ │ Too many parameters, expected none │ │ │ │ │ No corresponding close parenthesis │ │ │ │ │ No package named ~S │ │ │ │ │ Malformed ~~/ directive │ │ │ │ │ Unknown directive ~@[(character: ~A)~] │ │ │ │ │ @ modifier not allowed in close directive of justification block (i.e. ~~<...~~@>. │ │ │ │ │ ~D illegal directive~:P found inside justification block │ │ │ │ │ -CLEANUP- │ │ │ │ │ -ENVIRONMENT- │ │ │ │ │ -TAIL-SET- │ │ │ │ │ -NLX-INFO- │ │ │ │ │ -BASIC-VAR- │ │ │ │ │ -GLOBAL-VAR- │ │ │ │ │ -DEFINED-FUN- │ │ │ │ │ -ALIEN-FUN-TYPE- │ │ │ │ │ -ALIEN-ARRAY-TYPE- │ │ │ │ │ No corresponding close brace │ │ │ │ │ No corresponding open parenthesis │ │ │ │ │ │ │ │ │ │ No corresponding open bracket │ │ │ │ │ 6W7eH3/* │ │ │ │ │ hundred │ │ │ │ │ Can only specify one section │ │ │ │ │ @@ -24062,33 +24057,14 @@ │ │ │ │ │ No parameters can be supplied with ~~<...~~:>. │ │ │ │ │ Cannot include format directives inside the ~:[suffix~;prefix~] segment of ~~<...~~:> │ │ │ │ │ ABCDEFGORSWX$/ │ │ │ │ │ IT%&|_();>~ │ │ │ │ │ A required &KEY or &OPTIONAL argument was not supplied. │ │ │ │ │ [.;^Z>dZ6[ │ │ │ │ │ RPXRTJXm │ │ │ │ │ -SYS:SRC;COMPILER;SSET.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: │ │ │ │ │ -DEFUN, LAMBDA, &co create function objects with the specified documentation │ │ │ │ │ -strings. │ │ │ │ │ - (SETF (DOCUMENTATION NAME 'FUNCTION) STRING) │ │ │ │ │ -sets the documentation string stored under the specified name, and │ │ │ │ │ - (SETF (DOCUMENTATION FUNC T) STRING) │ │ │ │ │ -sets the documentation string stored in the function object. │ │ │ │ │ - (DOCUMENTATION NAME 'FUNCTION) │ │ │ │ │ -returns the documentation stored under the function name if any, and │ │ │ │ │ -falls back on the documentation in the function object if necessary. │ │ │ │ │ -SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ │ -SYS:SRC;CODE;FORMAT.LISP │ │ │ │ │ -SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ │ -SYS:SRC;CODE;TARGET-PATHNAME.LISP │ │ │ │ │ -SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ │ -SYS:SRC;CODE;RUN-PROGRAM.LISP │ │ │ │ │ y[.;SW7YW/[ │ │ │ │ │ Invalid fill-pointer ~a │ │ │ │ │ Parameters ~S and ~S must be disjoint but have common elements │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ Replacement byte, bytes, character, or string (evaluated): │ │ │ │ │ ~@ │ │ │ │ │ @@ -24115,22 +24091,22 @@ │ │ │ │ │ ~S can not be encapsulated │ │ │ │ │ Invalid use of ~S after ~S. │ │ │ │ │ .YCOm*mKs*mC[ │ │ │ │ │ >&+,=KZ=g │ │ │ │ │ no non-whitespace characters in string ~S. │ │ │ │ │ no digits in string ~S │ │ │ │ │ junk in string ~S │ │ │ │ │ -~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 │ │ │ │ │ of the directory segment ~S. │ │ │ │ │ user homedir not known~@[ for ~S~]: ~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).~% │ │ │ │ │ >&+pKA=i │ │ │ │ │ ~@ │ │ │ │ │ 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%]%{ │ │ │ │ │ @@ -24140,24 +24116,29 @@ │ │ │ │ │ contrib/ │ │ │ │ │ standard input │ │ │ │ │ standard output │ │ │ │ │ standard error │ │ │ │ │ /dev/tty │ │ │ │ │ the terminal │ │ │ │ │ Globaldb rehash failure. Mutated key? │ │ │ │ │ +SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ │ +SYS:SRC;CODE;TARGET-PATHNAME.LISP │ │ │ │ │ +SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ │ +SYS:SRC;CODE;RUN-PROGRAM.LISP │ │ │ │ │ SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ │ SYS:SRC;COMPILER;INFO-VECTOR.LISP │ │ │ │ │ SYS:SRC;CODE;TIMER.LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-CHAR.LISP │ │ │ │ │ SYS:SRC;CODE;EARLY-STEP.LISP │ │ │ │ │ SYS:SRC;CODE;HASH-TABLE.LISP │ │ │ │ │ SYS:SRC;CODE;READER.LISP │ │ │ │ │ SYS:SRC;CODE;SOURCE-LOCATION.LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-HASH-TABLE.LISP │ │ │ │ │ SYS:SRC;CODE;SERVE-EVENT.LISP │ │ │ │ │ +SYS:SRC;CODE;TARGET-LFHASH.LISP │ │ │ │ │ mR\gUO[Xmf │ │ │ │ │ Can't SET-INFO-VALUE on PCL-internal function │ │ │ │ │ ~D is not a legal INFO name. │ │ │ │ │ >&+,=KJ=g │ │ │ │ │ Couldn't find home directory~@[ for ~S~]. │ │ │ │ │ #~WA axis ~W is not a sequence:~% ~S │ │ │ │ │ ~@ │ │ │ │ │ Supply a replacement string. │ │ │ │ │ ~S is not acceptable to ~S. │ │ │ │ │ initialization │ │ │ │ │ Impossible case reached in PEEK-CHAR │ │ │ │ │ -SYS:SRC;CODE;TARGET-LFHASH.LISP │ │ │ │ │ SYS:SRC;CODE;READTABLE.LISP │ │ │ │ │ SYS:SRC;CODE;SHARPM.LISP │ │ │ │ │ SYS:SRC;CODE;MODULE.LISP │ │ │ │ │ +SYS:SRC;CODE;PATHNAME.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GLOBALDB.LISP │ │ │ │ │ 2>}2>"x2> │ │ │ │ │ 2>}2>"6%69 │ │ │ │ │ 2>}2>"x2>6|,=" │ │ │ │ │ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ │ $$$$$$$ │ │ │ │ │ !"#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ │ │ │ │ │ logical host not yet defined: ~S │ │ │ │ │ @@ -24257,15 +24239,14 @@ │ │ │ │ │ defining ~s as a constant │ │ │ │ │ Go ahead and change the value. │ │ │ │ │ redefining a MAKUNBOUND constant: ~S │ │ │ │ │ redefining ~(~A~) ~S to be a constant │ │ │ │ │ Defining ~S as a constant │ │ │ │ │ The constant name is not a symbol: ~S │ │ │ │ │ Keep the old value. │ │ │ │ │ -YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ │ 02-9Vd&G │ │ │ │ │ 02-9Vd&G │ │ │ │ │ Jbj8bfYW │ │ │ │ │ invalid directory component: ~S │ │ │ │ │ no dispatch function defined for ~S │ │ │ │ │ ~S is not a dispatching macro character. │ │ │ │ │ power-vector too short │ │ │ │ │ @@ -24292,14 +24273,15 @@ │ │ │ │ │ Multiple expressions in --eval option: ~S │ │ │ │ │ Skip rest of --eval and --load options. │ │ │ │ │ Ignore runtime option --load ~S. │ │ │ │ │ Ignore runtime option --eval ~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" #!# │ │ │ │ │ +YV_Uh^khmRea^ajNUXXWpdjf │ │ │ │ │ after escape │ │ │ │ │ ~@ │ │ │ │ │ Error opening ~S │ │ │ │ │ Try opening a different file. │ │ │ │ │ Retry opening. │ │ │ │ │ Reopen with :if-exists :append │ │ │ │ │ Reopen with :if-exists :rename │ │ │ │ │ @@ -24331,25 +24313,17 @@ │ │ │ │ │ ~A names ~A: │ │ │ │ │ Can't find the ~A of wild pathname ~A (physicalized from ~A). │ │ │ │ │ Specify a different path. │ │ │ │ │ ~S is neither a symbol nor a list of symbols. │ │ │ │ │ ~S is not a symbol. │ │ │ │ │ #K% │ │ │ │ │ ~@ │ │ │ │ │ +STRING-DISPATCH-FUN │ │ │ │ │ The length requested (~S) does not match the type restriction in ~S. │ │ │ │ │ weird type in S-T-L-M-ERROR │ │ │ │ │ -STRING-DISPATCH-FUN │ │ │ │ │ -XLzZUzZZnzfgsny^btXYwwa │ │ │ │ │ -X\asW_ds │ │ │ │ │ -SYS:SRC;CODE;PATHNAME.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GLOBALDB.LISP │ │ │ │ │ -SB-PROFILE │ │ │ │ │ -public: the interface to the profiler │ │ │ │ │ -SB-X86-ASM │ │ │ │ │ -private: backend-specific assembler mnemonics │ │ │ │ │ --script │ │ │ │ │ --sysinit │ │ │ │ │ --no-sysinit │ │ │ │ │ --userinit │ │ │ │ │ --no-userinit │ │ │ │ │ --noprint │ │ │ │ │ --disable-debugger │ │ │ │ │ @@ -24392,14 +24366,16 @@ │ │ │ │ │ Will try to reset the IO streams and disable debugger hooks. │ │ │ │ │ Will try to THROW this thread to the toplevel. │ │ │ │ │ Will try to halt this thread as a last resort. │ │ │ │ │ Maximum error nesting depth exceeded │ │ │ │ │ Remove ~S │ │ │ │ │ IYP[YSkK[ekodi │ │ │ │ │ :BACK cannot be represented in namestrings. │ │ │ │ │ +XLzZUzZZnzfgsny^btXYwwa │ │ │ │ │ +X\asW_ds │ │ │ │ │ can't happen │ │ │ │ │ Missing obuf. │ │ │ │ │ Error opening directory ~S │ │ │ │ │ Enter a valid index ( │ │ │ │ │ Enter a valid index (~:[0-~W~;0~]). │ │ │ │ │ The object contains nothing to inspect. │ │ │ │ │ That slot is unbound. │ │ │ │ │ @@ -24438,14 +24414,30 @@ │ │ │ │ │ ~S is not a stream associated with a file. │ │ │ │ │ unrecognized character name: ~S │ │ │ │ │ after REPL │ │ │ │ │ ~@ │ │ │ │ │ string-output-stream maximum length exceeded │ │ │ │ │ ~S is not positionable │ │ │ │ │ │ │ │ │ │ +SB-PROFILE │ │ │ │ │ +public: the interface to the profiler │ │ │ │ │ +SB-X86-ASM │ │ │ │ │ +private: backend-specific assembler mnemonics │ │ │ │ │ +private: implementation details of LOOP │ │ │ │ │ +SB-BROTHERTREE │ │ │ │ │ +internal: 1-2-Brother tree │ │ │ │ │ +SB-REGALLOC │ │ │ │ │ +private: implementation of the compiler's register allocator │ │ │ │ │ +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;ERROR-ERROR.LISP │ │ │ │ │ +SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ │ X}HUUERt │ │ │ │ │ l!1/9> 6 │ │ │ │ │ Methods: │ │ │ │ │ No methods. │ │ │ │ │ Method-combination: │ │ │ │ │ Known attributes: │ │ │ │ │ Inline proclamation: │ │ │ │ │ @@ -24516,40 +24508,14 @@ │ │ │ │ │ Ea XYh d │ │ │ │ │ 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 │ │ │ │ │ failed to build float from ~a │ │ │ │ │ ~S cannot be represented relative to ~S. │ │ │ │ │ Bad fallthrough in ~S │ │ │ │ │ -private: implementation details of LOOP │ │ │ │ │ -SB-BROTHERTREE │ │ │ │ │ -internal: 1-2-Brother tree │ │ │ │ │ -SB-REGALLOC │ │ │ │ │ -private: implementation of the compiler's register allocator │ │ │ │ │ -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;ERROR-ERROR.LISP │ │ │ │ │ -SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ │ -SYS:SRC;CODE;SORT.LISP │ │ │ │ │ -SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ │ -SYS:SRC;CODE;BACKQ.LISP │ │ │ │ │ -SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ │ -SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ │ -SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ │ -SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ │ -SYS:SRC;COMPILER;DUMP.LISP │ │ │ │ │ -SYS:SRC;COMPILER;POLICY.LISP │ │ │ │ │ -SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ │ -SYS:SRC;COMPILER;EARLY-C.LISP │ │ │ │ │ -SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ │ -SYS:SRC;COMPILER;MODARITH.LISP │ │ │ │ │ `OWh%Wh8$$ │ │ │ │ │ 0)1+3$|5H │ │ │ │ │ >aj7afIW │ │ │ │ │ a standard │ │ │ │ │ ~A names ~A declaration. │ │ │ │ │ an SBCL-specific │ │ │ │ │ a user-defined │ │ │ │ │ @@ -24573,14 +24539,69 @@ │ │ │ │ │ Continue │ │ │ │ │ finite-base-string-out-misc needs an implementation │ │ │ │ │ ~@:_~A:~@<~;~{ ~A~^,~:_~}~;~:> │ │ │ │ │ ~@:_~A:~@<~;~{ ~S~^,~:_~}~;~:> │ │ │ │ │ setting fdefinition of ~A │ │ │ │ │ hT?rCkWm[^ │ │ │ │ │ Unhandled EVAL-ERROR │ │ │ │ │ +SYS:SRC;CODE;SORT.LISP │ │ │ │ │ +SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ │ +SYS:SRC;CODE;BACKQ.LISP │ │ │ │ │ +SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ │ +SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ │ +SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ │ +SYS:SRC;COMPILER;DUMP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;POLICY.LISP │ │ │ │ │ +SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ │ +SYS:SRC;COMPILER;EARLY-C.LISP │ │ │ │ │ +SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ │ +SYS:SRC;COMPILER;MODARITH.LISP │ │ │ │ │ +SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ │ +SYS:SRC;COMPILER;META-VMDEF.LISP │ │ │ │ │ +SYS:SRC;COMPILER;VOP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ │ +SYS:SRC;COMPILER;DEBUG-DUMP.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. │ │ │ │ │ Trailing ~A in backquoted expression. │ │ │ │ │ %$%,%4%<% │ │ │ │ │ W%X%Y%Z%[% │ │ │ │ │ ]%^%_%`%a% │ │ │ │ │ f%g%h%i%j% │ │ │ │ │ ~S contains a splicing comma after a dot │ │ │ │ │ Nothing appears before . in list. │ │ │ │ │ @@ -24801,66 +24822,26 @@ │ │ │ │ │ Cannot coerce ~s to ~s │ │ │ │ │ no unique move-arg-vop for moves in SC ~S │ │ │ │ │ Something is broken. │ │ │ │ │ constant is too large for inlining │ │ │ │ │ 9Jeeeeeeeeeeeeeeeeeeey │ │ │ │ │ eeeeeeeeeeeeeeeeeee │ │ │ │ │ Unknown vector type in IR2 conversion for ~S. │ │ │ │ │ -SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ │ -SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ │ -SYS:SRC;COMPILER;META-VMDEF.LISP │ │ │ │ │ -SYS:SRC;COMPILER;VOP.LISP │ │ │ │ │ -SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ │ -SYS:SRC;COMPILER;DEBUG-DUMP.LISP │ │ │ │ │ -Control whether the compiler should check for constant │ │ │ │ │ -modification. Defaults to SAFETY. │ │ │ │ │ -Control the way to perform runtime type checking: │ │ │ │ │ -0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ │ -2: fast checks are performed: declared types are weakened to │ │ │ │ │ - FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ │ -3: declared types are fully checked (several exceptions exist; │ │ │ │ │ - see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ │ - Implementation Limitations for details). │ │ │ │ │ -Control inline-substitution of used-once local functions. │ │ │ │ │ -Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ │ -more reliable bactracing across foreign calls. │ │ │ │ │ -Enables possibility of returning from stack frames with the debugger. │ │ │ │ │ -The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ │ -When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ │ -FOO ...) is considered to be the reference to the function being │ │ │ │ │ -defined. Calls to FOO are compiled as local. This allows better │ │ │ │ │ -optimization and type checking, but TRACE will not show recursive │ │ │ │ │ -calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ │ -bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ │ -recursive. │ │ │ │ │ -When disabled, internal references to a function FOO will be │ │ │ │ │ -considered ti be a call of a function, bound to the symbol at │ │ │ │ │ -run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ │ -case of renaming described above, calls to FOO will not be recursive │ │ │ │ │ -and will refer to the new function, bound to FOO. │ │ │ │ │ -Control instrumentation of code, enabling single-stepping through │ │ │ │ │ -it in the debugger. │ │ │ │ │ -This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ │ -When disabled, LET variable, which is never set and is referenced │ │ │ │ │ -exactly once, is eliminated and the reference is substituted with the │ │ │ │ │ -initial value. This allows better type inference and some algebraic │ │ │ │ │ -optimizations. │ │ │ │ │ -When enabled, the variable is preserved and can be seen in the │ │ │ │ │ -debugger. │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-MACS.LISP │ │ │ │ │ SYS:SRC;COMPILER;SEQTRAN.LISP │ │ │ │ │ SYS:SRC;COMPILER;XREF.LISP │ │ │ │ │ SYS:SRC;COMPILER;IR1REPORT.LISP │ │ │ │ │ SYS:SRC;COMPILER;CODEGEN.LISP │ │ │ │ │ SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ │ SYS:SRC;COMPILER;CTYPE.LISP │ │ │ │ │ SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ │ SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ │ SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ │ O*'$***N │ │ │ │ │ eTIlPZaejdX │ │ │ │ │ aNV[N_hg_aW │ │ │ │ │ [S[edXg[YUffRagR │ │ │ │ │ The lambda expression has a missing or non-list lambda list: │ │ │ │ │ ~S was expected but ~S was found: │ │ │ │ │ A ~S was found when expecting a lambda expression: │ │ │ │ │ @@ -24952,18 +24933,18 @@ │ │ │ │ │ wrong number of codegen info args in ~S │ │ │ │ │ BLOCK in ~S should be ~S. │ │ │ │ │ ~@<~{~S~^, ~} and ~S are not a known argument keywords.~:@> │ │ │ │ │ ~S is not a known argument keyword. │ │ │ │ │ The ~:R argument of type ~s cannot be used as a keyword. │ │ │ │ │ Jg|~Y{XX │ │ │ │ │ code-length=~W, n-written=~W │ │ │ │ │ -Item of type ~s can't be found using :key ~s which returns ~s. │ │ │ │ │ -Item of type ~s can't be found in a sequence of type ~s. │ │ │ │ │ ihYhhmUPt │ │ │ │ │ multiple store variables for ~S │ │ │ │ │ +Item of type ~s can't be found using :key ~s which returns ~s. │ │ │ │ │ +Item of type ~s can't be found in a sequence of type ~s. │ │ │ │ │ Incompatible array element types: ~a and ~a │ │ │ │ │ The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ │ What? No ir2 blocks have a non-nil number? │ │ │ │ │ ~:@ │ │ │ │ │ ~:@ │ │ │ │ │ ~:@ │ │ │ │ │ tKX^yKo[ │ │ │ │ │ @@ -25029,16 +25010,14 @@ │ │ │ │ │ forced to do ~A (cost ~W) │ │ │ │ │ ~{~?~^~&~6T~} │ │ │ │ │ forced to do full call │ │ │ │ │ Sa%_&93H' │ │ │ │ │ assembly code for ~S │ │ │ │ │ missing generator for ~S │ │ │ │ │ environment elsewhere start │ │ │ │ │ -Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ │ -Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ │ DEST-ENV │ │ │ │ │ The function ~S is called~@[ by ~S~] with ~R argument~:P, but wants at least ~R. │ │ │ │ │ The function ~s is called with odd number of keyword arguments. │ │ │ │ │ The function ~S called~@[ by ~S~] with ~R argument~:P, but wants at most ~R. │ │ │ │ │ The function ~S is called~@[ by ~S~] with ~R argument~:P, but wants exactly ~R. │ │ │ │ │ ~a is not a subtype of VECTOR. │ │ │ │ │ a hairy form │ │ │ │ │ @@ -25090,14 +25069,16 @@ │ │ │ │ │ ~&compilation unit ~:[finished~;aborted~] │ │ │ │ │ ~& Undefined ~(~A~)~p: │ │ │ │ │ ~{~< │ │ │ │ │ ~1:;~S~>~^ ~} │ │ │ │ │ ~[~:;~:*~& caught ~W fatal ERROR condition~:P~]~[~:;~:*~& caught ~W ERROR condition~:P~]~[~:;~:*~& caught ~W WARNING condition~:P~]~[~:;~:*~& caught ~W STYLE-WARNING condition~:P~]~[~:;~:*~& printed ~W note~:P~] │ │ │ │ │ ~@ │ │ │ │ │ CONSTANT-FORM-VALUE called with invalid expression ~S │ │ │ │ │ +Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ │ +Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ │ tRP^Y_[R{{ │ │ │ │ │ called with ~W operands, but was expecting ~W │ │ │ │ │ cannot use VOP with variable operand count templates │ │ │ │ │ FROM-END argument value not known at compile time │ │ │ │ │ sequence type not known at compile time │ │ │ │ │ '+'3*,';*,' │ │ │ │ │ 7Ca2$c0F\ │ │ │ │ │ @@ -25276,16 +25257,16 @@ │ │ │ │ │ Unknown label: ~S │ │ │ │ │ ZTXQ]ZTRU │ │ │ │ │ the-~A-formerly-known-as-~X │ │ │ │ │ circular references in creation form for ~S │ │ │ │ │ unknown option specifier: ~S │ │ │ │ │ malformed option specification: ~S │ │ │ │ │ ~@ │ │ │ │ │ -@"*"E%E' bei │ │ │ │ │ T_QYHOHO^dgg │ │ │ │ │ +@"*"E%E' bei │ │ │ │ │ $$4rm1% │ │ │ │ │ #H.&4!* │ │ │ │ │ !!c**]Kc │ │ │ │ │ │ │ │ │ │ unseen predecessor ~S in ~S │ │ │ │ │ bad predecessor link ~S in ~S │ │ │ │ │ The START of ~S has the wrong kind. │ │ │ │ │ @@ -25298,17 +25279,14 @@ │ │ │ │ │ ~S has exactly 1 use, but LVAR-USES is a list. │ │ │ │ │ ~S is not used by its LVAR ~S. │ │ │ │ │ ~S has strange NEXT. │ │ │ │ │ The ctran ~S is used. │ │ │ │ │ ~S has no LAST. │ │ │ │ │ ~S has no START. │ │ │ │ │ ~S form is too short: ~S │ │ │ │ │ -SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ │ -SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;CORE.LISP │ │ │ │ │ Function previously called with unknown argument keyword ~S. │ │ │ │ │ must specify :SC for all temporaries: ~S │ │ │ │ │ Temporary lifetime doesn't begin before it ends: ~S │ │ │ │ │ must specify exactly one SC for a temporary │ │ │ │ │ unknown temporary option: ~S │ │ │ │ │ bad temporary name: ~S │ │ │ │ │ temporary spec allocates no temps: │ │ │ │ │ @@ -25367,14 +25345,18 @@ │ │ │ │ │ ~@ │ │ │ │ │ SOURCE_DATE_EPOCH │ │ │ │ │ basic block │ │ │ │ │ attempt to dump invalid structure: │ │ │ │ │ How did this happen? │ │ │ │ │ c]'&fch'&i]8= │ │ │ │ │ 'y5g c:) │ │ │ │ │ +SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;CORE.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;CALL.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ │ ~S not found in REFS for ~S │ │ │ │ │ There should be at least ~W ~A in ~S, but there are only ~W. │ │ │ │ │ There should be ~W ~A in ~S, but are ~W. │ │ │ │ │ The target for ~S isn't in REFS for ~S. │ │ │ │ │ The target for ~S isn't complementary WRITE-P. │ │ │ │ │ ~S not found in reads/writes for its TN │ │ │ │ │ The WRITE-P in ~S isn't ~S. │ │ │ │ │ @@ -25450,14 +25432,29 @@ │ │ │ │ │ N-SEQUENCE- │ │ │ │ │ binding ~A as a local function │ │ │ │ │ The ~S definition spec ~S is malformed. │ │ │ │ │ concatenate │ │ │ │ │ Can't ~a ~s into ~s │ │ │ │ │ -% F53/ │ │ │ │ │ ~:[A possible~;The~] binding of ~S │ │ │ │ │ +`tPNkbcRL^[RU^K^rQ │ │ │ │ │ +T case is not last in SC-CASE. │ │ │ │ │ +illegal SC-CASE clause: ~S │ │ │ │ │ +mjYM[XRPbeNRV^dkhh │ │ │ │ │ +unknown kind ~S │ │ │ │ │ +malformed SCs spec: ~S │ │ │ │ │ +\\U[~[Pq │ │ │ │ │ +a source transform │ │ │ │ │ +XRX[[W`R │ │ │ │ │ +Xy[^c~X}T │ │ │ │ │ +-OPTIMIZER │ │ │ │ │ +kweXYXXdd\xfzfa │ │ │ │ │ +scX_hRkii[[ │ │ │ │ │ +lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ │ +function name │ │ │ │ │ ~S is not a legal go tag. │ │ │ │ │ The tag ~S appears more than once in a tagbody. │ │ │ │ │ vb an zn │ │ │ │ │ ekawzneql │ │ │ │ │ Unknown list item seek transform: name=~S, key-functions=~S variant=~S │ │ │ │ │ defining ~S as a function │ │ │ │ │ ~S is not a defined primitive type. │ │ │ │ │ @@ -25482,65 +25479,47 @@ │ │ │ │ │ ~&; Base: ~x Data: ~x │ │ │ │ │ Can't disassemble a special operator │ │ │ │ │ iY{Z N │ │ │ │ │ __msan_unpoison │ │ │ │ │ │ │ │ │ │ ~S and ~S don't have the same dimensions. │ │ │ │ │ Unknown object type #x~x addr=~x │ │ │ │ │ -`tPNkbcRL^[RU^K^rQ │ │ │ │ │ -T case is not last in SC-CASE. │ │ │ │ │ -illegal SC-CASE clause: ~S │ │ │ │ │ -mjYM[XRPbeNRV^dkhh │ │ │ │ │ -unknown kind ~S │ │ │ │ │ -malformed SCs spec: ~S │ │ │ │ │ -\\U[~[Pq │ │ │ │ │ -a source transform │ │ │ │ │ -XRX[[W`R │ │ │ │ │ -Xy[^c~X}T │ │ │ │ │ --OPTIMIZER │ │ │ │ │ -kweXYXXdd\xfzfa │ │ │ │ │ -scX_hRkii[[ │ │ │ │ │ -lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ │ -function name │ │ │ │ │ ^abe\kwdguX^[| │ │ │ │ │ yesm\np[TRfX │ │ │ │ │ eSgzpWZTT^` │ │ │ │ │ UPzRVUgX │ │ │ │ │ +SYS:SRC;COMPILER;TN.LISP │ │ │ │ │ +SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;PARMS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;VM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ │ +SYS:SRC;CODE;ROOM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ │ dSwsY[Y` │ │ │ │ │ [[Xa[_X[dbhm[bhsT[ │ │ │ │ │ IR1-CONVERT- │ │ │ │ │ beYbfp^UaXUP[wd │ │ │ │ │ UiUPkmd` │ │ │ │ │ Wrong number of subscripts, ~W, for array of rank ~W. │ │ │ │ │ Wrong number of subscripts, ~W, for array of rank 1. │ │ │ │ │ Summary of space │ │ │ │ │ bytes, │ │ │ │ │ Summary total: │ │ │ │ │ objects. │ │ │ │ │ Too many result values from c-call. │ │ │ │ │ -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;X86;VM.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-OBJDEF.LISP │ │ │ │ │ -globaldb │ │ │ │ │ -SYS:SRC;CODE;ROOM.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ │ -SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ │ Breakdown for │ │ │ │ │ space total │ │ │ │ │ bytes for │ │ │ │ │ ~V:D bytes for ~V:D ~(~A~) object~2:*~P~*~:[~; ~:*(~A)~] │ │ │ │ │ return-pc not on stack in standard save location? │ │ │ │ │ ocfp not on stack in standard save location? │ │ │ │ │ unknown float trap kind: ~S │ │ │ │ │ * + │ │ │ │ │ ( <0 │ │ │ │ │ +globaldb │ │ │ │ │ ~S is not a known slot of thread │ │ │ │ │ immediate structure-object ~S │ │ │ │ │ usage is: │ │ │ │ │ bytes overhead) │ │ │ │ │ Control and binding stack usage is for the current thread only. │ │ │ │ │ Garbage collection is currently │ │ │ │ │ DISABLED │ │ │ │ │ @@ -25562,15 +25541,14 @@ │ │ │ │ │ ~@ │ │ │ │ │ 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. │ │ │ │ │ -&X@:R1:$[P │ │ │ │ │ dh d │ │ │ │ │ LEndzsn^}k │ │ │ │ │ PA-BITS-EA- │ │ │ │ │ ga]gdX_dnf │ │ │ │ │ X_aeX_a\k │ │ │ │ │ YbUZbQZdgyU`TZ^ │ │ │ │ │ WY[^QZ[y[[U │ │ │ │ │ @@ -25581,45 +25559,38 @@ │ │ │ │ │ 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. │ │ │ │ │ -SETF of APPLY is only defined for function args like #'SYMBOL. │ │ │ │ │ +&X@:R1:$[P │ │ │ │ │ +BBBBBBBBBBBBEEE[! │ │ │ │ │ +shadowing symbol~P ~{~A~^, ~} │ │ │ │ │ +SUB-CHAR must not be a decimal digit: ~S │ │ │ │ │ +2.5.2.debian │ │ │ │ │ +~@ │ │ │ │ │ +Can't LOAD a directory: ~s. │ │ │ │ │ +Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ │ +(yes or no) │ │ │ │ │ +SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;PARMS.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;UTILS.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;TYPE-ERROR.LISP │ │ │ │ │ page_table │ │ │ │ │ SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ │ TEXT_SPACE_START │ │ │ │ │ next_free_page │ │ │ │ │ READ_ONLY_SPACE_START │ │ │ │ │ text_space_highwatermark │ │ │ │ │ DYNAMIC_SPACE_START │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;LATE-OBJDEF.LISP │ │ │ │ │ static_space_free_pointer │ │ │ │ │ read_only_space_free_pointer │ │ │ │ │ SYS:SRC;CODE;EARLY-CONSTANTS.LISP │ │ │ │ │ -Idiosyncrasies │ │ │ │ │ -standard readtable │ │ │ │ │ -standard pprint dispatch table │ │ │ │ │ -Package Locks │ │ │ │ │ -parameter specializer name │ │ │ │ │ -Extensible Sequences │ │ │ │ │ -Vars is not a list of symbols: ~S │ │ │ │ │ -ibWdYk[dXP[mk` │ │ │ │ │ -BBBBBBBBBBBBEEE[! │ │ │ │ │ -shadowing symbol~P ~{~A~^, ~} │ │ │ │ │ -SUB-CHAR must not be a decimal digit: ~S │ │ │ │ │ -2.5.2.debian │ │ │ │ │ -~@ │ │ │ │ │ -Can't LOAD a directory: ~s. │ │ │ │ │ -Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ │ -(yes or no) │ │ │ │ │ Can not USE-PACKAGE ~S │ │ │ │ │ ~S can't use packages │ │ │ │ │ using package~P ~{~A~^, ~} │ │ │ │ │ no host specified │ │ │ │ │ ~S is not a valid logical namestring: │ │ │ │ │ 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. │ │ │ │ │ @@ -25639,61 +25610,59 @@ │ │ │ │ │ unexporting symbol~P ~{~A~^, ~} │ │ │ │ │ /proc/sys/kernel/osrelease │ │ │ │ │ Vector axis is not zero: ~S │ │ │ │ │ Axis number ~W is too big; ~S only has ~D dimension~:P. │ │ │ │ │ ~@ │ │ │ │ │ ~@<~S as EOF-ERROR-P argument to ~S: probable error. Two optional arguments must be provided before the first keyword argument.~:@> │ │ │ │ │ importing symbol~P ~{~A~^, ~} │ │ │ │ │ +SETF of APPLY is only defined for function args like #'SYMBOL. │ │ │ │ │ +Vars is not a list of symbols: ~S │ │ │ │ │ +ibWdYk[dXP[mk` │ │ │ │ │ K[XYM[Ph │ │ │ │ │ The option ~S appears more than once. │ │ │ │ │ bad list length for ~S │ │ │ │ │ unequal sets for :ARGUMENT-PRECEDENCE-ORDER clause: ~S and ~S │ │ │ │ │ argument count discrepancy in :ARGUMENT-PRECEDENCE-ORDER clause. │ │ │ │ │ METHOD-COMBINATION name not a symbol: ~S │ │ │ │ │ Ignoring unrecognized declaration in DEFGENERIC: ~S │ │ │ │ │ The declaration specifier ~S is not allowed inside DEFGENERIC. │ │ │ │ │ ~@ │ │ │ │ │ unsupported option ~S │ │ │ │ │ ~S is not one of :INTERNAL, :EXTERNAL, or :INHERITED. │ │ │ │ │ At least one of :INTERNAL, :EXTERNAL, or :INHERITED must be supplied. │ │ │ │ │ +Idiosyncrasies │ │ │ │ │ +standard readtable │ │ │ │ │ +standard pprint dispatch table │ │ │ │ │ +Package Locks │ │ │ │ │ +parameter specializer name │ │ │ │ │ +Extensible Sequences │ │ │ │ │ BJ ] < ; │ │ │ │ │ Kf[Xf\\uY │ │ │ │ │ dn[[aXfh\[pY │ │ │ │ │ JtJgKf[]a\ap^^^`vOfO │ │ │ │ │ dn[[a]ah\[p^^WO │ │ │ │ │ cannot specify values for both PREFIX and PER-LINE-PREFIX. │ │ │ │ │ O^adXu^R │ │ │ │ │ \J"L Ys} │ │ │ │ │ Unnamed restart does not have a report function: ~S │ │ │ │ │ ill-formed restart binding: ~S │ │ │ │ │ ~@<~S argument to the short form of ~S must be a string.~:@> │ │ │ │ │ cannot define a compiler-macro for a special operator: ~S │ │ │ │ │ -STRUCTURE-CLASSOID- │ │ │ │ │ -RANDOM-STATE- │ │ │ │ │ -defaulted │ │ │ │ │ -inline (unsigned-byte 32) integer-length │ │ │ │ │ -inline (signed-byte 32) integer-length │ │ │ │ │ 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 │ │ │ │ │ -ROYYhYXp │ │ │ │ │ XX^{M8(3. │ │ │ │ │ +STRUCTURE-CLASSOID- │ │ │ │ │ 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# JOD │ │ │ │ │ Return T │ │ │ │ │ Syscall ~A failed: ~A │ │ │ │ │ ~a is not a proper list │ │ │ │ │ @@ -25706,52 +25675,44 @@ │ │ │ │ │ ~@ │ │ │ │ │ BBBBBBBBBBBBEEK │ │ │ │ │ shadowing-importing symbol~P ~ │ │ │ │ │ ~{~A~^, ~} │ │ │ │ │ ~S is not a subtype of CHARACTER │ │ │ │ │ c2(/4,:( │ │ │ │ │ ~&; disassembly for ~S │ │ │ │ │ --D2CJD53@JJ) │ │ │ │ │ -not currently dribbling │ │ │ │ │ +XIV}\UJlNh │ │ │ │ │ +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. │ │ │ │ │ +SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ │ UlXi\XddQ\XXda` │ │ │ │ │ xV^[`t[PPRkW^todjj │ │ │ │ │ a DEFSETF lambda list │ │ │ │ │ Ill-formed DEFSETF for ~S │ │ │ │ │ a DEFINE-MODIFY-MACRO lambda list │ │ │ │ │ UOi__cddgX │ │ │ │ │ -SYS:SRC;CODE;IRRAT.LISP │ │ │ │ │ `X= ]D! │ │ │ │ │ sKX\Of[kKd │ │ │ │ │ ~S is an illegal form for a ~S varlist. │ │ │ │ │ ~S step variable is not a symbol: ~S │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ LaRPYlN_dmj`gVXrLa^PY^PVkldmf │ │ │ │ │ Quoted type specifier in ~S: ~S │ │ │ │ │ k [ X\ W │ │ │ │ │ Y_fnYbIn_btaV_qdXeWRbWpc[J\`W^OWd │ │ │ │ │ T[EYUTkmd\k │ │ │ │ │ -PPRINT-POP must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ │ -bb n} n| │ │ │ │ │ -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. │ │ │ │ │ +-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 │ │ │ │ │ @@ -25759,15 +25720,15 @@ │ │ │ │ │ :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 │ │ │ │ │ 7V?cIu^LL │ │ │ │ │ ~S doesn't match ~S. │ │ │ │ │ pE)-.@[XY8W │ │ │ │ │ -SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ │ +SYS:SRC;CODE;IRRAT.LISP │ │ │ │ │ uninterning ~A │ │ │ │ │ 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 │ │ │ │ │ ~S cannot be casted. │ │ │ │ │ @@ -25792,38 +25753,66 @@ │ │ │ │ │ SYS:SRC;**;*.*.* │ │ │ │ │ SYS:CONTRIB;**;*.*.* │ │ │ │ │ SYS:OUTPUT;**;*.*.* │ │ │ │ │ SYS:SRC; │ │ │ │ │ SYS:CONTRIB; │ │ │ │ │ SYS:OUTPUT; │ │ │ │ │ ~@<~A does not make sense without ~A.~@:> │ │ │ │ │ -Couldn't change directory to ~S: ~A │ │ │ │ │ -Couldn't execute ~S: ~A │ │ │ │ │ -Couldn't fork child process: ~A │ │ │ │ │ -can't specify :ENV and :ENVIRONMENT simultaneously │ │ │ │ │ -Error creating pipe │ │ │ │ │ +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` │ │ │ │ │ U\aRVMPddpd │ │ │ │ │ Something is wrong; local-alien-info not found: ~S │ │ │ │ │ XrVhUUPgkdXXddX │ │ │ │ │ XrVcnXgez │ │ │ │ │ [RRO\Yk|gbV[^{UUl │ │ │ │ │ PXYqcdW_Wa │ │ │ │ │ UNLOCKED-PACKAGES- │ │ │ │ │ aZbV[^{UUl │ │ │ │ │ Xt_aUGjge[eq │ │ │ │ │ -Malformed HASH-FUNCTION: ~S │ │ │ │ │ -Cannot redefine standard hash table test ~S. │ │ │ │ │ +SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ │ SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ │ SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ │ SYS:SRC;COMPILER;TARGET-DISASSEM.LISP │ │ │ │ │ SYS:SRC;COMPILER;LTN.LISP │ │ │ │ │ SYS:SRC;CODE;STEP.LISP │ │ │ │ │ +Malformed HASH-FUNCTION: ~S │ │ │ │ │ +Cannot redefine standard hash table test ~S. │ │ │ │ │ +oCMIIHGkUjpja^UY[WjTdk]QY[LaUP_k`kdp|^ │ │ │ │ │ +BIM\Y[Y │ │ │ │ │ +INFO-NUMBER- │ │ │ │ │ +VYbVbV_VV │ │ │ │ │ +tkn_zb_keYYha\qXacXpi[P[ │ │ │ │ │ +F-METHOD- │ │ │ │ │ +F-BUFFER- │ │ │ │ │ +F-INDEX- │ │ │ │ │ +EOF-VAL- │ │ │ │ │ +E7K_Y\t │ │ │ │ │ +Unsupported on this platform. │ │ │ │ │ +~S is unsupported on this platform ~ │ │ │ │ │ + (OS, CPU, whatever). │ │ │ │ │ +Couldn't change directory to ~S: ~A │ │ │ │ │ +Couldn't execute ~S: ~A │ │ │ │ │ +Couldn't fork child process: ~A │ │ │ │ │ +can't specify :ENV and :ENVIRONMENT simultaneously │ │ │ │ │ +Error creating pipe │ │ │ │ │ Could not delete directory ~S │ │ │ │ │ Input is not a proper list of weak pointers. │ │ │ │ │ Could not stop all threads │ │ │ │ │ objects, │ │ │ │ │ candidates, │ │ │ │ │ Unknown object type #x~x ~s │ │ │ │ │ Abort ~A file ~S. │ │ │ │ │ @@ -25865,28 +25854,14 @@ │ │ │ │ │ *BNPqI%3C │ │ │ │ │ Z^`NROd[Pa\ │ │ │ │ │ variable ~S occurs more than once │ │ │ │ │ ~@<~S is a relative pathname. (But we'll try using it anyway.)~@:> │ │ │ │ │ ~@ │ │ │ │ │ Supply an object to be printed instead. │ │ │ │ │ Print unreadably. │ │ │ │ │ -not legal as a function name: ~S │ │ │ │ │ -oCMIIHGkUjpja^UY[WjTdk]QY[LaUP_k`kdp|^ │ │ │ │ │ -BIM\Y[Y │ │ │ │ │ -INFO-NUMBER- │ │ │ │ │ -VYbVbV_VV │ │ │ │ │ -tkn_zb_keYYha\qXacXpi[P[ │ │ │ │ │ -F-METHOD- │ │ │ │ │ -F-BUFFER- │ │ │ │ │ -F-INDEX- │ │ │ │ │ -EOF-VAL- │ │ │ │ │ -E7K_Y\t │ │ │ │ │ -Unsupported on this platform. │ │ │ │ │ -~S is unsupported on this platform ~ │ │ │ │ │ - (OS, CPU, whatever). │ │ │ │ │ VVY_qadkWmp │ │ │ │ │ N-HASH-TABLE- │ │ │ │ │ gWmyU^f^ │ │ │ │ │ kd_aUPnaR\hhSgh │ │ │ │ │ bYYVbVk_YV_kkm^iPGkddgbdY │ │ │ │ │ Not a parser state: ~S │ │ │ │ │ malformed NAMED-LET variable spec: ~S │ │ │ │ │ @@ -25900,35 +25875,21 @@ │ │ │ │ │ malformed ONCE-ONLY binding spec: ~S │ │ │ │ │ XVdYWdURYeHfJgQ\aUPFkWp │ │ │ │ │ bad option: ~S │ │ │ │ │ $53>8Qs?F>> │ │ │ │ │ FW }\ d │ │ │ │ │ EK!hd^_!ajad │ │ │ │ │ ^WgmUZdRO │ │ │ │ │ -haknaReQRPb^^cd`^OW │ │ │ │ │ -TIME-LEFT- │ │ │ │ │ -Bad size for ~S type specifier: ~S. │ │ │ │ │ - ^k ^ wkq │ │ │ │ │ -bY_VYw^tgwh │ │ │ │ │ -~S is valid only inside ~S. │ │ │ │ │ -Uz[OY^RPe[\Xnhhw^^ldd │ │ │ │ │ -WITH-PINNED-OBJECTS-THUNK │ │ │ │ │ -vQJJUgZgm │ │ │ │ │ -WITHOUT-GCING-BODY- │ │ │ │ │ -FF]Xte[Ydd │ │ │ │ │ +not legal as a function name: ~S │ │ │ │ │ interning ~A │ │ │ │ │ No such thing as DEBOOTSTRAP-PACKAGE │ │ │ │ │ info hashtable │ │ │ │ │ Return from ~S. │ │ │ │ │ deleted package │ │ │ │ │ ~@<~S can't be a ~A: ~2I~_It has been reset to ~S.~:> │ │ │ │ │ -SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ │ -DXABLE-ARGS- │ │ │ │ │ - │ │ │ │ │ +haknaReQRPb^^cd`^OW │ │ │ │ │ +TIME-LEFT- │ │ │ │ │ +Bad size for ~S type specifier: ~S. │ │ │ │ │ + ^k ^ wkq │ │ │ │ │ +bY_VYw^tgwh │ │ │ │ │ +~S is valid only inside ~S. │ │ │ │ │ +Uz[OY^RPe[\Xnhhw^^ldd │ │ │ │ │ +WITH-PINNED-OBJECTS-THUNK │ │ │ │ │ +vQJJUgZgm │ │ │ │ │ +WITHOUT-GCING-BODY- │ │ │ │ │ +FF]Xte[Ydd │ │ │ │ │ LLbUpTPXgTd │ │ │ │ │ +SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ │ [PrYrR\xTdd^[[UX[_ofgJXOXm │ │ │ │ │ OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ │ ~@<~S is not the name of a class.~@:> │ │ │ │ │ +111_1_1* │ │ │ │ │ +@ │ │ │ │ │ -~A~@[ ~S~] │ │ │ │ │ -compiled function │ │ │ │ │ -generic-function │ │ │ │ │ -funcallable-instance │ │ │ │ │ -interpreted function │ │ │ │ │ -compiled closure │ │ │ │ │ -The object is a │ │ │ │ │ -Lambda-list │ │ │ │ │ -Closed over values │ │ │ │ │ BLOCK name form* │ │ │ │ │ Evaluate the FORMS as a PROGN. Within the lexical scope of the body, │ │ │ │ │ RETURN-FROM can be used to exit the form. │ │ │ │ │ -SYS:SRC;COMPILER;EARLY-ASSEM.LISP │ │ │ │ │ -SYS:SRC;CODE;RANDOM.LISP │ │ │ │ │ -SYS:SRC;CODE;HOST-PPRINT.LISP │ │ │ │ │ -SYS:SRC;COMPILER;DISASSEM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;EARLY-CONSTANTP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;SSET.LISP │ │ │ │ │ +ENVIRONMENT- │ │ │ │ │ +TAIL-SET- │ │ │ │ │ +NLX-INFO- │ │ │ │ │ +BASIC-VAR- │ │ │ │ │ +GLOBAL-VAR- │ │ │ │ │ +DEFINED-FUN- │ │ │ │ │ FUNCTIONAL- │ │ │ │ │ OPTIONAL-DISPATCH- │ │ │ │ │ ARG-INFO- │ │ │ │ │ JUMP-TABLE- │ │ │ │ │ BASIC-COMBINATION- │ │ │ │ │ MV-COMBINATION- │ │ │ │ │ ARRAY-INDEX-CAST- │ │ │ │ │ @@ -26048,26 +26015,32 @@ │ │ │ │ │ GLOBAL-CONFLICTS- │ │ │ │ │ CONDITIONAL-FLAGS- │ │ │ │ │ OPERAND-PARSE- │ │ │ │ │ VOP-PARSE- │ │ │ │ │ ALIEN-TYPE-CLASS- │ │ │ │ │ ALIEN-INTEGER-TYPE- │ │ │ │ │ ALIEN-BOOLEAN-TYPE- │ │ │ │ │ +SYS:SRC;COMPILER;EARLY-ASSEM.LISP │ │ │ │ │ +SYS:SRC;CODE;RANDOM.LISP │ │ │ │ │ +SYS:SRC;CODE;HOST-PPRINT.LISP │ │ │ │ │ +SYS:SRC;COMPILER;DISASSEM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;ASSEM.LISP │ │ │ │ │ ALIEN-ENUM-TYPE- │ │ │ │ │ ALIEN-FLOAT-TYPE- │ │ │ │ │ ALIEN-RECORD-FIELD- │ │ │ │ │ ALIEN-VALUES-TYPE- │ │ │ │ │ LOCAL-ALIEN-INFO- │ │ │ │ │ PATTERN- │ │ │ │ │ DEBUG-FUN- │ │ │ │ │ COMPILED-DEBUG-FUN- │ │ │ │ │ FILE-INFO- │ │ │ │ │ SOURCE-INFO- │ │ │ │ │ DEFINITION-SOURCE-LOCATION+PLIST- │ │ │ │ │ PKG-ITER- │ │ │ │ │ +RANDOM-STATE- │ │ │ │ │ HASH-TABLE- │ │ │ │ │ PP-DISPATCH- │ │ │ │ │ VOP-TRANSFORM- │ │ │ │ │ APPROXIMATE-FUN-TYPE- │ │ │ │ │ APPROXIMATE-KEY-INFO- │ │ │ │ │ STDIO-FILE- │ │ │ │ │ %FASL-INPUT- │ │ │ │ │ @@ -26088,33 +26061,31 @@ │ │ │ │ │ LOCAL-CALL-CONTEXT- │ │ │ │ │ VECTOR-LENGTH-CONSTRAINT- │ │ │ │ │ CONSTRAINT- │ │ │ │ │ MODULAR-CLASS- │ │ │ │ │ MODULAR-FUN-INFO- │ │ │ │ │ LOCATION-INFO- │ │ │ │ │ RESTART-LOCATION- │ │ │ │ │ -FIXED-CALL-ARGS-STATE- │ │ │ │ │ -STORAGE-INFO- │ │ │ │ │ -ARG-STATE- │ │ │ │ │ -RESULT-STATE- │ │ │ │ │ -SYS:SRC;COMPILER;ASSEM.LISP │ │ │ │ │ SYS:SRC;COMPILER;LOCALL.LISP │ │ │ │ │ SYS:SRC;COMPILER;TARGET-DSTATE.LISP │ │ │ │ │ SYS:SRC;COMPILER;X86;INSTS.LISP │ │ │ │ │ SYS:SRC;COMPILER;X86;C-CALL.LISP │ │ │ │ │ SYS:SRC;COMPILER;PACK-ITERATIVE.LISP │ │ │ │ │ SYS:SRC;CODE;BROTHERTREE.LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-LFLIST.LISP │ │ │ │ │ SYS:SRC;CODE;UNIX-PATHNAME.LISP │ │ │ │ │ SYS:SRC;CODE;LOOP.LISP │ │ │ │ │ SYS:SRC;CODE;EARLY-NTRACE.LISP │ │ │ │ │ SYS:SRC;PCL;FNGEN.LISP │ │ │ │ │ SYS:SRC;PCL;CACHE.LISP │ │ │ │ │ SYS:SRC;PCL;VECTOR.LISP │ │ │ │ │ -bad thing to be a type specifier: ~// │ │ │ │ │ +FIXED-CALL-ARGS-STATE- │ │ │ │ │ +STORAGE-INFO- │ │ │ │ │ +ARG-STATE- │ │ │ │ │ +RESULT-STATE- │ │ │ │ │ HANDLER- │ │ │ │ │ POLLFDS- │ │ │ │ │ BINARY-NODE- │ │ │ │ │ TERNARY-NODE- │ │ │ │ │ ENCAPSULATION-INFO- │ │ │ │ │ TOKEN-BUF- │ │ │ │ │ QUEUED-OP- │ │ │ │ │ @@ -26144,14 +26115,28 @@ │ │ │ │ │ LOCATION-GROUP- │ │ │ │ │ UNPRINTABLE-OBJECT- │ │ │ │ │ LOOP-COLLECTOR- │ │ │ │ │ LOOP-MINIMAX- │ │ │ │ │ LOOP-UNIVERSE- │ │ │ │ │ LOOP-PATH- │ │ │ │ │ TRACE-INFO- │ │ │ │ │ +Changing meta-class of ~S from ~S to ~S. │ │ │ │ │ +J%#L%(>@ │ │ │ │ │ +~A~@[ ~S~] │ │ │ │ │ +compiled function │ │ │ │ │ +generic-function │ │ │ │ │ +funcallable-instance │ │ │ │ │ +interpreted function │ │ │ │ │ +compiled closure │ │ │ │ │ +The object is a │ │ │ │ │ +Lambda-list │ │ │ │ │ +Closed over values │ │ │ │ │ +d\bgadRa]\ │ │ │ │ │ +mjm\F3jdXE3d^dgvod │ │ │ │ │ +attempt to multiply define ~A ~S │ │ │ │ │ ROOM-INFO- │ │ │ │ │ METHOD-CALL- │ │ │ │ │ CONSTANT-METHOD-CALL- │ │ │ │ │ CONSTANT-FAST-METHOD-CALL- │ │ │ │ │ FAST-INSTANCE-BOUNDP- │ │ │ │ │ PV-TABLE- │ │ │ │ │ DFUN-INFO- │ │ │ │ │ @@ -26171,14 +26156,24 @@ │ │ │ │ │ PROFILE-INFO- │ │ │ │ │ OVERHEAD- │ │ │ │ │ TIME-INFO- │ │ │ │ │ PROCESS- │ │ │ │ │ %PQUEUE- │ │ │ │ │ SYS:SRC;PCL;CPL.LISP │ │ │ │ │ SYS:SRC;CODE;PROFILE.LISP │ │ │ │ │ +defaulted │ │ │ │ │ +inline (unsigned-byte 32) integer-length │ │ │ │ │ +inline (signed-byte 32) integer-length │ │ │ │ │ +CLASSOID-CELL- │ │ │ │ │ +CONS-TYPE- │ │ │ │ │ +NUMERIC-UNION-TYPE- │ │ │ │ │ +DD-NAMED │ │ │ │ │ +UNION-TYPE- │ │ │ │ │ +ARRAY-TYPE- │ │ │ │ │ +NAMED-TYPE- │ │ │ │ │ Implements CL:MAP for extended sequences. │ │ │ │ │ RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:MAP but │ │ │ │ │ receives a prototype instance of an extended sequence class │ │ │ │ │ instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ │ methods on this generic function specify how extended sequence │ │ │ │ │ classes act when they are specified as the result type in a CL:MAP │ │ │ │ │ call. RESULT-PROTOTYPE may not be fully initialized and thus │ │ │ │ │ @@ -26191,43 +26186,15 @@ │ │ │ │ │ instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ │ methods on this generic function specify how extended sequence │ │ │ │ │ classes act when they are specified as the result type in a │ │ │ │ │ CL:MERGE call. RESULT-PROTOTYPE may not be fully initialized and │ │ │ │ │ thus should only be used for dispatch and to determine its class. │ │ │ │ │ Another difference to CL:MERGE is that PREDICATE is a function, │ │ │ │ │ not a function designator. │ │ │ │ │ -CLASSOID-CELL- │ │ │ │ │ -CONS-TYPE- │ │ │ │ │ -NUMERIC-UNION-TYPE- │ │ │ │ │ -UNION-TYPE- │ │ │ │ │ -Changing meta-class of ~S from ~S to ~S. │ │ │ │ │ -d\bgadRa]\ │ │ │ │ │ -mjm\F3jdXE3d^dgvod │ │ │ │ │ -attempt to multiply define ~A ~S │ │ │ │ │ -setting the macro-function of ~S │ │ │ │ │ -~S names a special form. │ │ │ │ │ -Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ │ -Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ │ -Cannot compare-and-swap slot ~S on: ~S │ │ │ │ │ -~@ │ │ │ │ │ -Interactive interrupt at #x~X. │ │ │ │ │ -A deadline was reached after ~A second~:P. │ │ │ │ │ -~&Cannot return values from ~:[frame~;~:*~S~] since the debug information lacks details about returning values here. │ │ │ │ │ -~&~S has no debug-block information. │ │ │ │ │ -~&~S has no debug variable information. │ │ │ │ │ -~&~S has no lambda-list information available. │ │ │ │ │ -~&~S has :invalid or :unknown value in ~S. │ │ │ │ │ -~&~S names more than one valid variable in ~S. │ │ │ │ │ -~@ │ │ │ │ │ -ARRAY-TYPE- │ │ │ │ │ -NAMED-TYPE- │ │ │ │ │ -INSTANCE │ │ │ │ │ y^v8u4qTXdh │ │ │ │ │ -DD-NAMED │ │ │ │ │ -BASE+BOUNDS │ │ │ │ │ INSTANCE │ │ │ │ │ }UFeg?9~HQ │ │ │ │ │ CONDITION-CLASS │ │ │ │ │ SLOT-NAME │ │ │ │ │ INSTANCE │ │ │ │ │ LL E[caUzp │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -26236,29 +26203,29 @@ │ │ │ │ │ POSITIVE │ │ │ │ │ INSTANCE │ │ │ │ │ EXPRESSION │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ │ +~@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ "(PHA=@gC │ │ │ │ │ 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. │ │ │ │ │ SXSTATE8Jg │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ CLASSOID │ │ │ │ │ SB-INT8!g" │ │ │ │ │ -Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ │ -~@ │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ DEFSTRUCT │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REAL-RESTART0 │ │ │ │ │ @@ -26278,18 +26245,18 @@ │ │ │ │ │ PREDICATE- │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ -INSTANCE │ │ │ │ │ Return true if OBJECT is a FLOAT, and NIL otherwise. │ │ │ │ │ SLOT-SPECS │ │ │ │ │ SLOT-VARS │ │ │ │ │ +INSTANCE │ │ │ │ │ SPECIFIER │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ CLAUSE-INDEX │ │ │ │ │ LAYOUT-LISTS │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ @@ -26305,14 +26272,15 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ ELEMENT-TYPE0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-C82g! │ │ │ │ │ +BASE+BOUNDS │ │ │ │ │ CLASSOID8 │ │ │ │ │ CLOS-HASH │ │ │ │ │ INHERITS0 │ │ │ │ │ INSTANCE │ │ │ │ │ INTERESTING-SUPERTYPES0 │ │ │ │ │ SUPERTYPES │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -26356,14 +26324,23 @@ │ │ │ │ │ TYPE-CLASS0 │ │ │ │ │ CHARACTERS │ │ │ │ │ FP-ZEROS │ │ │ │ │ OTHER-REALS │ │ │ │ │ INSTANCE │ │ │ │ │ .DEFAULTING-TEMP.0 │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ + KV-VECTOR │ │ │ │ │ +TABLE8 g │ │ │ │ │ +EMPTY-KV-INDEX │ │ │ │ │ +HASH-TABLE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + KV-VECTOR0 │ │ │ │ │ +HASH-TABLE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + KV-VECTOR │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ INSTANCE │ │ │ │ │ @@ -26390,44 +26367,46 @@ │ │ │ │ │ NEW-HIGH │ │ │ │ │ RATIONAL-HIGH │ │ │ │ │ COMMON-LISP │ │ │ │ │ dL8.h!C& │ │ │ │ │ COMMON-LISP │ │ │ │ │ DIMENSIONS │ │ │ │ │ SB-C9;gD │ │ │ │ │ +:NAMED option is incompatible with element type ~// │ │ │ │ │ +Attempt to remove :PRIMITIVE type: ~// │ │ │ │ │ +Can't displace an array of type ~// into another of type ~// │ │ │ │ │ +bad modulus specified for MOD type specifier: ~// │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ -:NAMED option is incompatible with element type ~// │ │ │ │ │ -Attempt to remove :PRIMITIVE type: ~// │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ ELEMENT-TYPE0 │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ POSITIVE │ │ │ │ │ -ERROR-NUMBER0 │ │ │ │ │ SYS:SRC;CODE;BIT-BASH.LISP │ │ │ │ │ SYS:SRC;COMPILER;SAPTRAN.LISP │ │ │ │ │ +ERROR-NUMBER0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP86g │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE │ │ │ │ │ +EXTRA-ID-WORDS │ │ │ │ │ COMMON-LISP │ │ │ │ │ CAR-TYPE0 │ │ │ │ │ CDR-TYPE │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ -EXTRA-ID-WORDS │ │ │ │ │ b3JBRU:q │ │ │ │ │ COMMON-LISP │ │ │ │ │ PREDICATE-NAME │ │ │ │ │ SUPER-OR-NAME8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE │ │ │ │ │ *_MGy93lP │ │ │ │ │ @@ -26629,22 +26608,22 @@ │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ COMMON-LISP │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-ALIEN │ │ │ │ │ -MAX-INDEX │ │ │ │ │ dR}8#;t[ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ SB-ALIEN │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ +MAX-INDEX │ │ │ │ │ INSTANCE │ │ │ │ │ OUTPUT-TYPE-SPEC │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ CODE-OBJ0 │ │ │ │ │ INSTANCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -26702,18 +26681,14 @@ │ │ │ │ │ INDICATOR │ │ │ │ │ NEW-VALUE8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ The VALUE is added as a property of SYMBOL under the specified INDICATOR. │ │ │ │ │ Returns VALUE. │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-ALIEN │ │ │ │ │ -Can't displace an array of type ~// into another of type ~// │ │ │ │ │ -bad modulus specified for MOD type specifier: ~// │ │ │ │ │ -redefining ~S to be: │ │ │ │ │ -~// is a built-in alien type. │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-ALIEN │ │ │ │ │ COMMON-LISP │ │ │ │ │ TEST-NOT │ │ │ │ │ COMMON-LISP │ │ │ │ │ i3DbE-H| │ │ │ │ │ INSTANCE │ │ │ │ │ @@ -26813,16 +26788,16 @@ │ │ │ │ │ +0;A73VX │ │ │ │ │ DEBUG-FUN │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ - DEBUG-FUN │ │ │ │ │ CODE-LOCATIONS │ │ │ │ │ + DEBUG-FUN │ │ │ │ │ DEBUG-FUN8 │ │ │ │ │ COMPILER-DEBUG-FUN │ │ │ │ │ COMPONENT │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP85g% │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -26945,14 +26920,23 @@ │ │ │ │ │ SB-ASSEM │ │ │ │ │ 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 │ │ │ │ │ CURRENT0 │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ ALL-DUMMIES │ │ │ │ │ +REF-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +CSET-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +LAMBDA-VAR-EQUALP │ │ │ │ │ +CONSET-EQUALP │ │ │ │ │ +SSET-ELEMENT-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +B SB-KERNEL8 g │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ NEW-VALUE │ │ │ │ │ EARLY-METHOD0-g │ │ │ │ │ CLASSES-LIST │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -26968,14 +26952,16 @@ │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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. │ │ │ │ │ H@FE \Tu │ │ │ │ │ +redefining ~S to be: │ │ │ │ │ +~// is a built-in alien type. │ │ │ │ │ Warn about a situation by signalling a condition formed by DATUM and │ │ │ │ │ ARGUMENTS. While the condition is being signaled, a MUFFLE-WARNING restart │ │ │ │ │ exists that causes WARN to immediately return NIL. │ │ │ │ │ Decodes a relative timeout in SECONDS into five values, taking any │ │ │ │ │ global deadlines into account: TO-SEC, TO-USEC, STOP-SEC, STOP-USEC, │ │ │ │ │ DEADLINEP. │ │ │ │ │ TO-SEC and TO-USEC indicate the relative timeout in seconds and microseconds. │ │ │ │ │ @@ -27140,28 +27126,28 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ EXTERNAL-FORMAT8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ TYPED-LAMBDA-LIST │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +TYPE20$g │ │ │ │ │ +FUN-TYPE │ │ │ │ │ +RESULT-TYPE │ │ │ │ │ +TYPED-LAMBDA-LIST │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ LAMBDA-FORM │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ -TYPE20$g │ │ │ │ │ -FUN-TYPE │ │ │ │ │ -RESULT-TYPE │ │ │ │ │ -TYPED-LAMBDA-LIST │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REF-FUN8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -27186,23 +27172,98 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CONVENTION │ │ │ │ │ RESULT-TYPE8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +%PATHNAME- │ │ │ │ │ +setting the macro-function of ~S │ │ │ │ │ +~S names a special form. │ │ │ │ │ +Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ │ +Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ │ +Cannot compare-and-swap slot ~S on: ~S │ │ │ │ │ +A deadline was reached after ~A second~:P. │ │ │ │ │ +~@ │ │ │ │ │ +Interactive interrupt at #x~X. │ │ │ │ │ +~&Cannot return values from ~:[frame~;~:*~S~] since the debug information lacks details about returning values here. │ │ │ │ │ +~&~S has no debug-block information. │ │ │ │ │ +~&~S has no debug variable information. │ │ │ │ │ +~&~S has no lambda-list information available. │ │ │ │ │ +~&~S has :invalid or :unknown value in ~S. │ │ │ │ │ +~&~S names more than one valid variable in ~S. │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +Evaluating call: │ │ │ │ │ +~< ~@;~A~:> │ │ │ │ │ +~:[With arguments: │ │ │ │ │ +~}~;With unknown arguments~] │ │ │ │ │ +Returning from STEP │ │ │ │ │ +redefining ~S~{ ~S~} ~S in DEFMETHOD │ │ │ │ │ +Overwriting ~S │ │ │ │ │ +~@?, even though the name follows │ │ │ │ │ +the usual naming convention (names like *FOO*) for special variables │ │ │ │ │ +~@ │ │ │ │ │ +Character decoding error in a ~A-comment at position ~A reading source stream ~A, resyncing. │ │ │ │ │ +~@ │ │ │ │ │ +Duplicate key ~S in ~S form, occurring in~{~#[~; and~]~{ clause ~a: │ │ │ │ │ +~< ~S~:>~}~^,~}. │ │ │ │ │ +skipped) │ │ │ │ │ + is out of date │ │ │ │ │ + =X7 J`7 J` │ │ │ │ │ +Deprecated │ │ │ │ │ +recursive │ │ │ │ │ +visiting │ │ │ │ │ +dependencies │ │ │ │ │ +contains │ │ │ │ │ +secondary │ │ │ │ │ +systems │ │ │ │ │ +starting │ │ │ │ │ +WARNING: │ │ │ │ │ +Computing just-done stamp │ │ │ │ │ +in plan │ │ │ │ │ + for action │ │ │ │ │ +, but dependency │ │ │ │ │ + wasn't done yet! │ │ │ │ │ +Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ │ +Repeated labels in ASSEMBLE body │ │ │ │ │ +Wnvi]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 │ │ │ │ │ +data start │ │ │ │ │ +text start │ │ │ │ │ +elsewhere start │ │ │ │ │ +Oversized code component? │ │ │ │ │ +4E4i4<4`4 │ │ │ │ │ +*9@9d979[9. │ │ │ │ │ +failed to resolve home directory for Unix uid=~S │ │ │ │ │ +Syscall poll(2) failed: ~A │ │ │ │ │ +Error reading directory entry~@[ from ~S~] │ │ │ │ │ +Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ │ +:TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ │ +Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ │ +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. │ │ │ │ │ COMMON-LISP │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ EXTERNAL-FORMAT │ │ │ │ │ NOT-NULL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -Return the reason that a JOIN-THREAD-ERROR was signaled. Possible values are │ │ │ │ │ -:TIMEOUT, :ABORT, :FOREIGN, and :SELF-JOIN. │ │ │ │ │ -Return the offending thread that the THREAD-ERROR pertains to. │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ TYPE20*g$ │ │ │ │ │ COMMON-LISP8'g │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -27307,58 +27368,14 @@ │ │ │ │ │ wC x'ALO │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -iR4h0(`] │ │ │ │ │ -Returns T if thread had been running in background, NIL if it was │ │ │ │ │ -interactive. │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -VMTHREAD │ │ │ │ │ -Acquire MUTEX for the dynamic scope of BODY. │ │ │ │ │ -If WAIT-P is true (the default), and the MUTEX is not immediately available or │ │ │ │ │ -held by the current thread, sleep until it is available. │ │ │ │ │ -If TIMEOUT is given, it specifies a relative timeout, in seconds, on how long │ │ │ │ │ -the system should try to acquire the lock in the contested case. │ │ │ │ │ -If the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the │ │ │ │ │ -body is not executed, and WITH-RECURSIVE-LOCK returns NIL. │ │ │ │ │ -Otherwise body is executed with the mutex held by current thread, and │ │ │ │ │ -WITH-RECURSIVE-LOCK returns the values of BODY. │ │ │ │ │ -Unlike WITH-MUTEX, which signals an error on attempt to re-acquire an already │ │ │ │ │ -held mutex, WITH-RECURSIVE-LOCK allows recursive lock attempts to succeed. │ │ │ │ │ -Acquire MUTEX for the dynamic scope of BODY. If WAIT-P 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 │ │ │ │ │ -the system should try to acquire the lock in the contested case. │ │ │ │ │ -If the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the │ │ │ │ │ -body is not executed, and WITH-MUTEX returns NIL. │ │ │ │ │ -Otherwise body is executed with the mutex held by current thread, and │ │ │ │ │ -WITH-MUTEX returns the values of BODY. │ │ │ │ │ -Historically WITH-MUTEX also accepted a VALUE argument, which when provided │ │ │ │ │ -was used as the new owner of the mutex instead of the current thread. This is │ │ │ │ │ -no longer supported: if VALUE is provided, it must be either NIL or the │ │ │ │ │ -current thread. │ │ │ │ │ -THREAD-SAP │ │ │ │ │ -NODE0!'Q │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ - DEADLINEP │ │ │ │ │ -STOP-SEC │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -STOP-SEC8 │ │ │ │ │ - STOP-USEC0 │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ 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. │ │ │ │ │ Convert ALIEN to an Alien of the specified TYPE (not evaluated.) Both types │ │ │ │ │ must be Alien array, pointer or function types. │ │ │ │ │ @@ -27448,16 +27465,60 @@ │ │ │ │ │ (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))) │ │ │ │ │ Return an Alien pointer to the data addressed by Expr, which must be a call │ │ │ │ │ to SLOT or DEREF, or a reference to an Alien variable. │ │ │ │ │ TIMEOUT0 │ │ │ │ │ +Acquire MUTEX for the dynamic scope of BODY. │ │ │ │ │ +If WAIT-P is true (the default), and the MUTEX is not immediately available or │ │ │ │ │ +held by the current thread, sleep until it is available. │ │ │ │ │ +If TIMEOUT is given, it specifies a relative timeout, in seconds, on how long │ │ │ │ │ +the system should try to acquire the lock in the contested case. │ │ │ │ │ +If the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the │ │ │ │ │ +body is not executed, and WITH-RECURSIVE-LOCK returns NIL. │ │ │ │ │ +Otherwise body is executed with the mutex held by current thread, and │ │ │ │ │ +WITH-RECURSIVE-LOCK returns the values of BODY. │ │ │ │ │ +Unlike WITH-MUTEX, which signals an error on attempt to re-acquire an already │ │ │ │ │ +held mutex, WITH-RECURSIVE-LOCK allows recursive lock attempts to succeed. │ │ │ │ │ +Acquire MUTEX for the dynamic scope of BODY. If WAIT-P 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 │ │ │ │ │ +the system should try to acquire the lock in the contested case. │ │ │ │ │ +If the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the │ │ │ │ │ +body is not executed, and WITH-MUTEX returns NIL. │ │ │ │ │ +Otherwise body is executed with the mutex held by current thread, and │ │ │ │ │ +WITH-MUTEX returns the values of BODY. │ │ │ │ │ +Historically WITH-MUTEX also accepted a VALUE argument, which when provided │ │ │ │ │ +was used as the new owner of the mutex instead of the current thread. This is │ │ │ │ │ +no longer supported: if VALUE is provided, it must be either NIL or the │ │ │ │ │ +current thread. │ │ │ │ │ C-THREAD │ │ │ │ │ THREAD0;g" │ │ │ │ │ +iR4h0(`] │ │ │ │ │ +Returns T if thread had been running in background, NIL if it was │ │ │ │ │ +interactive. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +VMTHREAD │ │ │ │ │ +THREAD-SAP │ │ │ │ │ +NODE0!'Q │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ + DEADLINEP │ │ │ │ │ +STOP-SEC │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +STOP-SEC8 │ │ │ │ │ + STOP-USEC0 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ 5So% │ │ │ │ │ -Evaluating call: │ │ │ │ │ -~< ~@;~A~:> │ │ │ │ │ -~:[With arguments: │ │ │ │ │ -~}~;With unknown arguments~] │ │ │ │ │ -Returning from STEP │ │ │ │ │ -redefining ~S~{ ~S~} ~S in DEFMETHOD │ │ │ │ │ -Overwriting ~S │ │ │ │ │ -~@?, even though the name follows │ │ │ │ │ -the usual naming convention (names like *FOO*) for special variables │ │ │ │ │ -~@ │ │ │ │ │ -Character decoding error in a ~A-comment at position ~A reading source stream ~A, resyncing. │ │ │ │ │ -~@ │ │ │ │ │ -Duplicate key ~S in ~S form, occurring in~{~#[~; and~]~{ clause ~a: │ │ │ │ │ -~< ~S~:>~}~^,~}. │ │ │ │ │ -skipped) │ │ │ │ │ - is out of date │ │ │ │ │ - =X7 J`7 J` │ │ │ │ │ -Deprecated │ │ │ │ │ -recursive │ │ │ │ │ -visiting │ │ │ │ │ -dependencies │ │ │ │ │ -contains │ │ │ │ │ -secondary │ │ │ │ │ -systems │ │ │ │ │ -starting │ │ │ │ │ -WARNING: │ │ │ │ │ -Computing just-done stamp │ │ │ │ │ -in plan │ │ │ │ │ - for action │ │ │ │ │ -, but dependency │ │ │ │ │ - wasn't done yet! │ │ │ │ │ -data start │ │ │ │ │ -text start │ │ │ │ │ -elsewhere start │ │ │ │ │ -Oversized code component? │ │ │ │ │ -4E4i4<4`4 │ │ │ │ │ -*9@9d979[9. │ │ │ │ │ -failed to resolve home directory for Unix uid=~S │ │ │ │ │ -Syscall poll(2) failed: ~A │ │ │ │ │ -Error reading directory entry~@[ from ~S~] │ │ │ │ │ -select(2) │ │ │ │ │ -Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ │ -4E4i4<4`4 │ │ │ │ │ -*9@9d979[9. │ │ │ │ │ -found no match for Unix uid=~S │ │ │ │ │ -Error closing directory~@[ ~S~] │ │ │ │ │ -Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ │ -Repeated labels in ASSEMBLE body │ │ │ │ │ -Wnvi]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 │ │ │ │ │ +NODE-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +VALUED-NODE-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +CLOOP-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +CLEANUP-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +B SB-KERNEL0 │ │ │ │ │ +ALIEN-FUN-TYPE-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +B SB-KERNEL │ │ │ │ │ +ALIEN-ARRAY-TYPE-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +B SB-KERNEL │ │ │ │ │ + READTABLE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ SYS:SRC;CODE;TARGET-SXHASH.LISP │ │ │ │ │ SYS:SRC;CODE;SETF.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ │ N"R@SdXzX │ │ │ │ │ SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ │ q2t|uNv$w │ │ │ │ │ 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. │ │ │ │ │ 1.0.56.55 │ │ │ │ │ -WITH-PRETTY-STREAM │ │ │ │ │ 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. │ │ │ │ │ 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. │ │ │ │ │ -Assignment to virtual DISPATCH-TABLES slot not allowed │ │ │ │ │ -%PATHNAME- │ │ │ │ │ -NODE-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -VALUED-NODE-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -CLOOP-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -CLEANUP-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -B SB-KERNEL0 │ │ │ │ │ -ENVIRONMENT-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -TAIL-SET-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -B SB-KERNEL │ │ │ │ │ -NLX-INFO-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -LEAF-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -BASIC-VAR-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -GLOBAL-VAR-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -DEFINED-FUN-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -ALIEN-FUN-TYPE-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -B SB-KERNEL │ │ │ │ │ -ALIEN-ARRAY-TYPE-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -B SB-KERNEL │ │ │ │ │ - READTABLE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ +WITH-PRETTY-STREAM │ │ │ │ │ +bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ │ +Input type (~//) and output type (~//) are unrelated? │ │ │ │ │ +could not find any input routine for ~// │ │ │ │ │ +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. │ │ │ │ │ +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. │ │ │ │ │ 5d"1(H66 │ │ │ │ │ EOF-VAL- │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ READTABLE │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ @@ -27980,33 +27979,32 @@ │ │ │ │ │ eightieth │ │ │ │ │ ninetieth │ │ │ │ │ thirteen │ │ │ │ │ fourteen │ │ │ │ │ seventeen │ │ │ │ │ eighteen │ │ │ │ │ nineteen │ │ │ │ │ -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. │ │ │ │ │ -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. │ │ │ │ │ zs:'7c7uiSw5 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ DIRECTIVE │ │ │ │ │ MORE-DIRECTIVES │ │ │ │ │ DIRECTIVE │ │ │ │ │ DIRECTIVES │ │ │ │ │ PARAM-NAME │ │ │ │ │ DIRECTIVE │ │ │ │ │ DIRECTIVES │ │ │ │ │ COMMON-LISP │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ DIRECTIVES │ │ │ │ │ STOP-AT-SEMI │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ NON-BLANK1 │ │ │ │ │ @@ -28087,31 +28085,24 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ PER-LINE-P │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ DIRECTIVE0 │ │ │ │ │ MODIFIERS8 │ │ │ │ │ -PATHSPEC8 │ │ │ │ │ -Convert PATHSPEC (a pathname designator) into a pathname. │ │ │ │ │ COMMON-LISP │ │ │ │ │ HOST SB-KERNEL │ │ │ │ │ TRANSLATION-LIST │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ -bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ │ -Input type (~//) and output type (~//) are unrelated? │ │ │ │ │ -could not find any input routine for ~// │ │ │ │ │ -STRING-INPUT-STREAM- │ │ │ │ │ -FINITE-BASE-STRING-OUTPUT-STREAM- │ │ │ │ │ -STUB-STREAM- │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ UNPARSED0fg │ │ │ │ │ COMMON-LISP │ │ │ │ │ +STRING-INPUT-STREAM- │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ TEMP SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -28187,28 +28178,29 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ LEXENV SB-KERNEL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ BbDhGQ>J: │ │ │ │ │ - TYPE-SPEC │ │ │ │ │ -DESCRIPTION-FORMAT8 │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -REVERSED-ELEMENTS │ │ │ │ │ FORM SB-KERNEL8 │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ DEFAULTS │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ + TYPE-SPEC │ │ │ │ │ +DESCRIPTION-FORMAT8 │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +REVERSED-ELEMENTS │ │ │ │ │ COMMON-LISP │ │ │ │ │ STREAMS0 │ │ │ │ │ *q/X"#y$ │ │ │ │ │ TEST-NOT │ │ │ │ │ COMMON-LISP │ │ │ │ │ INDICATOR │ │ │ │ │ PREDECESSOR0 │ │ │ │ │ @@ -28225,19 +28217,22 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-INT9$ │ │ │ │ │ MORE-ARG │ │ │ │ │ Return a list of the arguments with last cons a dotted pair. │ │ │ │ │ 5L`dJ.'~ │ │ │ │ │ -CASE-FROB-STREAM- │ │ │ │ │ -~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ │ -PACKED-INFO- │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ │ +INITIAL-STAMP │ │ │ │ │ +FINITE-BASE-STRING-OUTPUT-STREAM- │ │ │ │ │ +STUB-STREAM- │ │ │ │ │ +CASE-FROB-STREAM- │ │ │ │ │ +PACKED-INFO- │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -28271,30 +28266,29 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ +o|wRa&2 │ │ │ │ │ FORMAT-ARG1 SB- │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ ALWAYS-BOUNDP │ │ │ │ │ ASSIGN-IT-P │ │ │ │ │ -~@:_Lambda-list: ~// │ │ │ │ │ -package nicknames │ │ │ │ │ -~@:_Declared type: ~// │ │ │ │ │ -~@:_Argument precedence order: ~// │ │ │ │ │ -INITIAL-STAMP │ │ │ │ │ COMMON-LISP │ │ │ │ │ &;fk&Hq= │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ (PHPp=0QSs │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ NOGzP#[e#MH │ │ │ │ │ +~@:_Lambda-list: ~// │ │ │ │ │ +package nicknames │ │ │ │ │ +~@:_Declared type: ~// │ │ │ │ │ +~@:_Argument precedence order: ~// │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ 8#JJKK67 │ │ │ │ │ HASH-TABLE │ │ │ │ │ @@ -28303,15 +28297,14 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ Remove and return ITEM from PRIORITY-QUEUE. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ pF: │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +BITMAP-ALL-TAGGEDP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -28408,17 +28402,14 @@ │ │ │ │ │ SUB-CHAR │ │ │ │ │ CLOSURE SB-KERNEL8 │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ STRING-DESIGNATORS │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ -MORE-ARG │ │ │ │ │ -Construct and return a list by concatenating LISTS. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return any available status information on child process with PID. │ │ │ │ │ fmt$8H3QYS │ │ │ │ │ cn!8U@U1 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -28463,32 +28454,25 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ HOST SB-KERNEL │ │ │ │ │ EF-ENTRY │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ -CODE-VAR8 │ │ │ │ │ -MISS-VALUE │ │ │ │ │ -PAGE-VAR │ │ │ │ │ -SHIFTED-VAR0Eg" │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ SUB-CHAR │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ -BITMAP-ALL-TAGGEDP │ │ │ │ │ -POSSIBLY-RATIONAL │ │ │ │ │ -DESCRIPTOR-IDX │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ EXTERNAL-FORMAT │ │ │ │ │ @@ -28545,26 +28529,32 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ EXTERNAL-FORMAT │ │ │ │ │ qv2V>iOS.F: │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +CODE-VAR8 │ │ │ │ │ +MISS-VALUE │ │ │ │ │ +PAGE-VAR │ │ │ │ │ +SHIFTED-VAR0Eg" │ │ │ │ │ REST-ARG │ │ │ │ │ f<~u! p$ │ │ │ │ │ COMMON-LISP │ │ │ │ │ qv2V>iOS.F: │ │ │ │ │ xyWp|nA,&$ │ │ │ │ │ HASH-FUN-STATE │ │ │ │ │ SYNCHRONIZED │ │ │ │ │ COMMON-P │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ +POSSIBLY-RATIONAL │ │ │ │ │ +DESCRIPTOR-IDX │ │ │ │ │ o8WO`K]) │ │ │ │ │ r-yI7_IG]u │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ v1jIkkj\ │ │ │ │ │ @@ -28646,16 +28636,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ SB-C91g4 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ - PREDICATE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ %Z7I@4,4 │ │ │ │ │ --noinform │ │ │ │ │ --version │ │ │ │ │ --dynamic-space-size │ │ │ │ │ --control-stack-size │ │ │ │ │ --tls-limit │ │ │ │ │ @@ -28724,14 +28712,16 @@ │ │ │ │ │ CURRENT-PACKAGE8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ CODE-OBJ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ + PREDICATE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -28805,20 +28795,20 @@ │ │ │ │ │ T#z*s=M" │ │ │ │ │ BACKSLASH │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPERATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ +ELEMENT8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ fmt$3H0OL4 │ │ │ │ │ fmt$LEMTK │ │ │ │ │ unbound slot │ │ │ │ │ -COMMON-LISP │ │ │ │ │ ~@:_Derived type: ~// │ │ │ │ │ ~@:_(~A ~{~S ~}~//) │ │ │ │ │ ~@:_~:(~A~) type: ~// │ │ │ │ │ ~@:_A ~(~a~) for ~// │ │ │ │ │ ~@:_An accessor for ~// │ │ │ │ │ ~&Evaluation took: │ │ │ │ │ ~@< ~@;~// of real time │ │ │ │ │ @@ -28848,14 +28838,17 @@ │ │ │ │ │ SB-DISASSEM │ │ │ │ │ private: stuff related to the implementation of the disassembler │ │ │ │ │ SB-DEBUG │ │ │ │ │ sorta public: Eventually this should become the debugger interface, with │ │ │ │ │ basic stuff like BACKTRACE and ARG. For now, the actual supported interface │ │ │ │ │ is still mixed indiscriminately with low-level internal implementation stuff │ │ │ │ │ like *STACK-TOP-HINT* and unsupported stuff like *TRACED-FUN-LIST*. │ │ │ │ │ +SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ │ +SYS:SRC;COMPILER;LTV.LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ NULL-PADDING │ │ │ │ │ REPLACEMENT │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ fmt$6N4D95 │ │ │ │ │ {.5-nwR\ │ │ │ │ │ @@ -28923,17 +28916,16 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ SB-C9.g4 │ │ │ │ │ COMMON-LISP │ │ │ │ │ REPLACEMENT │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ -REST-ARG │ │ │ │ │ -ELEMENT8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ +REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ REPLACEMENT │ │ │ │ │ 7k*]>6S( │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -28966,14 +28958,15 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ HASH-FUN-STATE │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ .DEFAULTING-TEMP.0 │ │ │ │ │ +degraded │ │ │ │ │ DEFAULTS │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ KV-VECTOR │ │ │ │ │ TABLE8ug │ │ │ │ │ @@ -28998,16 +28991,16 @@ │ │ │ │ │ SLOT-NAME │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ EOF-ERROR-P │ │ │ │ │ EOF-VALUE │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ fmt$ILOT5 │ │ │ │ │ fmt$2Z388B │ │ │ │ │ @@ -29085,17 +29078,14 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REPLACEMENT │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ EXPANDER │ │ │ │ │ SETF-FN-NAME0 │ │ │ │ │ -SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ │ -SYS:SRC;COMPILER;LTV.LISP │ │ │ │ │ -VOP-INFO- │ │ │ │ │ COMMON-LISP │ │ │ │ │ DESCRIPTOR8 │ │ │ │ │ DIRECTION │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ HASHSET0 │ │ │ │ │ @@ -29260,30 +29250,24 @@ │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ -REST-ARG │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -PREV-KIND │ │ │ │ │ -degraded │ │ │ │ │ -without-hashing │ │ │ │ │ The type declarations ~// and ~// for ~S conflict. │ │ │ │ │ Recursion limit reached while expanding local macro ~// │ │ │ │ │ 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 │ │ │ │ │ Not a function type: ~// │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -undefined ~(~A~): ~// │ │ │ │ │ +REST-ARG │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ ENVIRONMENT │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -29342,14 +29326,17 @@ │ │ │ │ │ SAP argument move │ │ │ │ │ character untagging │ │ │ │ │ character tagging │ │ │ │ │ character move │ │ │ │ │ character arg move │ │ │ │ │ inline (unsigned-byte 32) logcount │ │ │ │ │ more-arg-context │ │ │ │ │ +VOP-INFO- │ │ │ │ │ +PREV-KIND │ │ │ │ │ +without-hashing │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -29444,14 +29431,21 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INDEX-VAR │ │ │ │ │ CONSTRAINTS0 │ │ │ │ │ REST-ARG │ │ │ │ │ DEFINITION-SOURCE-LOCATION- │ │ │ │ │ +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 │ │ │ │ │ +Xt_UpUX~ │ │ │ │ │ REST-ARG │ │ │ │ │ SEQUENCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ DECL-SPEC │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ BT-S8tqr │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -29472,25 +29466,25 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ dD ~ex8{K │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ :yW4^+I# │ │ │ │ │ -SUPPLIED-P-P │ │ │ │ │ -LVAR-SINGLE-VALUE-P │ │ │ │ │ -FUNCTIONAL-LETLIKE-P │ │ │ │ │ -FUNCTIONAL-KIND-EQ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMBINATION │ │ │ │ │ PREDICATES │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +SUPPLIED-P-P │ │ │ │ │ +LVAR-SINGLE-VALUE-P │ │ │ │ │ +FUNCTIONAL-LETLIKE-P │ │ │ │ │ +FUNCTIONAL-KIND-EQ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ SEQUENCE │ │ │ │ │ @@ -29637,21 +29631,22 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ CODE-LENGTH │ │ │ │ │ FASL-OUTPUT │ │ │ │ │ N-WRITTEN1 │ │ │ │ │ SB-ASSEM │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -REST-ARG │ │ │ │ │ ATTRIBUTES │ │ │ │ │ Automagically generated boolean attribute setter. See │ │ │ │ │ !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ │ Automagically generated boolean attribute test function. │ │ │ │ │ See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ │ +FORM SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ SEQUENCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ DISPATCHER │ │ │ │ │ 8V.1Ws|LV │ │ │ │ │ CONSTRAINTS │ │ │ │ │ @@ -29700,30 +29695,29 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ BLOCK-TN │ │ │ │ │ MORE-OPS0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -SAW-LAST │ │ │ │ │ -COMPONENT-LAMBDA │ │ │ │ │ -ORIGINAL-FUN │ │ │ │ │ -ORIGINAL-START │ │ │ │ │ FIRST-ARG8 │ │ │ │ │ MORE-ARGS0 gA │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ FILTERED-LVAR │ │ │ │ │ NEW-START │ │ │ │ │ OLD-BLOCK │ │ │ │ │ PLACEHER │ │ │ │ │ TRANSFORM │ │ │ │ │ COMMON-LISP0tg$ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +SAW-LAST │ │ │ │ │ +COMPONENT-LAMBDA │ │ │ │ │ +ORIGINAL-FUN │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ LTN-POLICY │ │ │ │ │ @@ -29777,16 +29771,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ -FORM SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ b3qld"lo │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -29904,20 +29896,19 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ ARG-COUNT │ │ │ │ │ N-TEMPLATE │ │ │ │ │ NOPERANDS │ │ │ │ │ -Automagically generated boolean attribute creation function. │ │ │ │ │ - See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CTYPE SB-KERNEL0 │ │ │ │ │ FROM-END │ │ │ │ │ SEQUENCE │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -29931,14 +29922,38 @@ │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ MODIFIED │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +undefined ~(~A~): ~// │ │ │ │ │ +violating package lock on ~// │ │ │ │ │ +Objects of type ~// can't be dumped into fasl files. │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +using the lexical binding of the symbol ~//, not the │ │ │ │ │ +dynamic binding │ │ │ │ │ +~@ │ │ │ │ │ +~:[This~;~:*~A~] is not a ~< │ │ │ │ │ +~9T~:;~//:~> │ │ │ │ │ +~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ │ +~9T~:;not a ~//.~> │ │ │ │ │ +ORIGINAL-START │ │ │ │ │ +LVAR-KIND │ │ │ │ │ +TAILP-LVAR │ │ │ │ │ +TARGET-ENV │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ BRANCH-IF0 │ │ │ │ │ SORTED-VALUES │ │ │ │ │ @@ -29975,34 +29990,14 @@ │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ V?YmLDJ) │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ SB-ALIEN │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -violating package lock on ~// │ │ │ │ │ -Objects of type ~// can't be dumped into fasl files. │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -using the lexical binding of the symbol ~//, not the │ │ │ │ │ -dynamic binding │ │ │ │ │ -~@ │ │ │ │ │ -~:[This~;~:*~A~] is not a ~< │ │ │ │ │ -~9T~:;~//:~> │ │ │ │ │ -~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ │ -~9T~:;not a ~//.~> │ │ │ │ │ -LVAR-KIND │ │ │ │ │ -TAILP-LVAR │ │ │ │ │ -TARGET-ENV │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ sR2eP^}F │ │ │ │ │ NEW-LEAF │ │ │ │ │ OLD-LEAF │ │ │ │ │ CHUNK-EXPR │ │ │ │ │ 3\1l0d^\ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -30066,14 +30061,16 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ +Automagically generated boolean attribute creation function. │ │ │ │ │ + See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ NOT-P8.' │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ TEMPLATE │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -30244,14 +30241,16 @@ │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CODE-HANDLE │ │ │ │ │ ENTRY-HANDLE │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ FUNCTIONAL │ │ │ │ │ +COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ │ +N-SIMPLE-FUNS │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ UNBOXED1tg │ │ │ │ │ FUN-NAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ FASL-OUTPUT │ │ │ │ │ @@ -30272,16 +30271,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CONTEXT0 │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ KEY-LISTS0 │ │ │ │ │ -COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ │ -N-SIMPLE-FUNS │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -30489,26 +30486,18 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ K!{K)eUf │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ ZBVpCK/1> │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ +SYS:SRC;COMPILER;X86;CELL.LISP │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ -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 │ │ │ │ │ -Xt_UpUX~ │ │ │ │ │ -H^R33ddRdandddW │ │ │ │ │ -,gZWh]gzv\cS │ │ │ │ │ REST-ARG │ │ │ │ │ .MXA\-|Y.- │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CLASSOID SB-KERNEL0 │ │ │ │ │ SUBCLASSOID │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -30611,15 +30600,14 @@ │ │ │ │ │ NOT-P8.' │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ %(PF`Nu0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -ELEMENT-CTYPE │ │ │ │ │ FASL-OUTPUT0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ REST-VAR0!g │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -30782,14 +30770,19 @@ │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ REST-ARG │ │ │ │ │ COMPILE-TIME-TOO │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ +ELEMENT-CTYPE │ │ │ │ │ +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). │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ SAME-LEAF │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -30857,14 +30850,17 @@ │ │ │ │ │ EXPLICIT-CHECK │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ UNIVERSE │ │ │ │ │ FUN-TYPE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +NAME0$g" │ │ │ │ │ +T@>s?(#f} │ │ │ │ │ +Define a function at top level. │ │ │ │ │ FASL-OUTPUT │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEXT-SEGMENT │ │ │ │ │ FUNCTIONAL │ │ │ │ │ IR2-BLOCK │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -30955,14 +30951,25 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ SB-ASSEM │ │ │ │ │ +close_current_thread_tlab │ │ │ │ │ +close_code_region │ │ │ │ │ +wrapped_environ │ │ │ │ │ +wifcontinued │ │ │ │ │ +wifstopped │ │ │ │ │ +unlockpt │ │ │ │ │ +wait_for_exec │ │ │ │ │ +gc_pathfind │ │ │ │ │ +gc_and_save │ │ │ │ │ +~S can't be used to initialize an array of type ~//. │ │ │ │ │ + ~V@<~//~> │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ SB-ALIEN │ │ │ │ │ WRITE-P8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -31003,36 +31010,22 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ BIT-ARRAY-1 │ │ │ │ │ RESULT-BIT-ARRAY │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ 2x*N │ │ │ │ │ ERROR-CODE │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ Cause a continuable error. ERROR-CODE is the error to cause. │ │ │ │ │ -NAME0$g" │ │ │ │ │ -T@>s?(#f} │ │ │ │ │ -Define a function at top level. │ │ │ │ │ -LAMBDA-LIST │ │ │ │ │ -NEXT-VAR │ │ │ │ │ -Move SRC into DST unless they are location=. │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ N-BITS-SHIFT0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ IMAG-TN8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -31044,15 +31037,14 @@ │ │ │ │ │ SB-ALIEN │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ FILL-POINTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -SYS:SRC;COMPILER;X86;CELL.LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ SB-ALIEN │ │ │ │ │ {7BG9kOv │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ RETURN-PC8 │ │ │ │ │ @@ -31060,18 +31052,14 @@ │ │ │ │ │ CHUNK-SIZE │ │ │ │ │ REV-DIM-LIST │ │ │ │ │ REV-SUBSCRIPTS │ │ │ │ │ SB-ALIEN │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ COMMON-LISP │ │ │ │ │ N-BITS-SHIFT9 │ │ │ │ │ -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). │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ NUM-RESULTS │ │ │ │ │ SB-ALIEN │ │ │ │ │ @@ -31182,30 +31170,14 @@ │ │ │ │ │ actually exist, and attempt to create them if they do not. │ │ │ │ │ The MODE argument is a CMUCL/SBCL-specific extension to control │ │ │ │ │ the Unix permission bits. │ │ │ │ │ Bitwise OR INTEGER1 with (LOGNOT INTEGER2). │ │ │ │ │ Return the 9th object in a list or NIL if there is no 9th object. │ │ │ │ │ MORE-ARG │ │ │ │ │ Return the bit-wise or of its arguments. Args must be integers. │ │ │ │ │ -Makes a new pathname from the component arguments. Note that host is │ │ │ │ │ -a host-structure or string. │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -Return the element type of the most specialized COMPLEX number type that │ │ │ │ │ - can hold parts of type SPEC. │ │ │ │ │ -COMMON-LISP1 │ │ │ │ │ -The argument must be a character object. ALPHA-CHAR-P returns T if the │ │ │ │ │ -argument is an alphabetic character, A-Z or a-z; otherwise NIL. │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -Return the cdr of the cdar of a list. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -Return NUMBER - 1. │ │ │ │ │ -Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS. │ │ │ │ │ -Return list of results. │ │ │ │ │ -Read from STREAM and return the value read, preserving any whitespace │ │ │ │ │ - that followed the object. │ │ │ │ │ ELIDE-IF │ │ │ │ │ SB-ASSEM0 │ │ │ │ │ PA-BITS-EA │ │ │ │ │ ARRAY-VAR │ │ │ │ │ COMMON-LISP82'"( │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ Define a parameter that is not normally changed by the program, │ │ │ │ │ @@ -31235,25 +31207,30 @@ │ │ │ │ │ (IMPLEMENT {package-name}*) │ │ │ │ │ (DOCUMENTATION doc-string) │ │ │ │ │ (INTERN {symbol-name}*) │ │ │ │ │ (SIZE ) │ │ │ │ │ (NICKNAMES {package-name}*) │ │ │ │ │ All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple │ │ │ │ │ times. │ │ │ │ │ -Place may be any place expression acceptable to SETF, and is expected │ │ │ │ │ - to hold a property list or (). This list is destructively altered to │ │ │ │ │ - remove the property specified by the indicator. Returns T if such a │ │ │ │ │ - property was present, NIL if not. │ │ │ │ │ -(HANDLER-BIND ( {(type handler)}* ) body) │ │ │ │ │ -Executes body in a dynamic context where the given handler bindings are in │ │ │ │ │ -effect. Each handler must take the condition being signalled as an argument. │ │ │ │ │ -The bindings are searched first to last in the event of a signalled │ │ │ │ │ -condition. │ │ │ │ │ -DECLAIM Declaration* │ │ │ │ │ - Do a declaration or declarations for the global environment. │ │ │ │ │ +Makes a new pathname from the component arguments. Note that host is │ │ │ │ │ +a host-structure or string. │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +Return the element type of the most specialized COMPLEX number type that │ │ │ │ │ + can hold parts of type SPEC. │ │ │ │ │ +COMMON-LISP1 │ │ │ │ │ +The argument must be a character object. ALPHA-CHAR-P returns T if the │ │ │ │ │ +argument is an alphabetic character, A-Z or a-z; otherwise NIL. │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +Return the cdr of the cdar of a list. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +Return NUMBER - 1. │ │ │ │ │ +Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS. │ │ │ │ │ +Return list of results. │ │ │ │ │ +Read from STREAM and return the value read, preserving any whitespace │ │ │ │ │ + that followed the object. │ │ │ │ │ kznUEa +r │ │ │ │ │ gjV │ │ │ │ │ +JMi ? 7 -$ │ │ │ │ │ +~S cannot handle the second argument ~S. │ │ │ │ │ +Backtrace for: ~S │ │ │ │ │ +Skip printing frame ~S │ │ │ │ │ +while printing frame ~S. The partial output is: ~S │ │ │ │ │ +environment argument present and not null │ │ │ │ │ +can't open-code test of non-constant type │ │ │ │ │ +~S~:[~;~:*~S~] │ │ │ │ │ Define a compiler-macro for NAME. │ │ │ │ │ DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)} │ │ │ │ │ Define the structure type Name. Instances are created by MAKE-, │ │ │ │ │ which takes &KEY arguments allowing initial slot values to the specified. │ │ │ │ │ A SETF'able function - is defined for each slot to read and │ │ │ │ │ write slot values. -p is a type predicate. │ │ │ │ │ Popular DEFSTRUCT options (see manual for others): │ │ │ │ │ @@ -31981,61 +31972,30 @@ │ │ │ │ │ The first argument is a byte specifier. The second is any place form │ │ │ │ │ acceptable to SETF. Replace the specified byte of the number in this │ │ │ │ │ place with bits from the low-order end of the new value. │ │ │ │ │ The form is evaluated with single stepping enabled. Function calls │ │ │ │ │ outside the lexical scope of the form can be stepped into only if the │ │ │ │ │ functions in question have been compiled with sufficient DEBUG policy │ │ │ │ │ to be at least partially steppable. │ │ │ │ │ -MD%~!$5\ │ │ │ │ │ -Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ │ -tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ │ -Define a special variable at top level. Declare the variable │ │ │ │ │ - SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ │ - value, the old value is not clobbered. The third argument is an optional │ │ │ │ │ - documentation string for the variable. │ │ │ │ │ -Cause the iteration to terminate "normally", the same as implicit │ │ │ │ │ -termination by an iteration driving clause, or by use of WHILE or │ │ │ │ │ -UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ │ -collected result will be returned as the value of the LOOP. │ │ │ │ │ -CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ │ - Keyform. If none of the keys matches then a correctable error is │ │ │ │ │ - signalled. │ │ │ │ │ -Bind the reader and printer control variables to values that enable READ │ │ │ │ │ - to reliably read the results of PRINT. These values are: │ │ │ │ │ - *PACKAGE* the COMMON-LISP-USER package │ │ │ │ │ - *PRINT-ARRAY* T │ │ │ │ │ - *PRINT-BASE* 10 │ │ │ │ │ - *PRINT-CASE* :UPCASE │ │ │ │ │ - *PRINT-CIRCLE* NIL │ │ │ │ │ - *PRINT-ESCAPE* T │ │ │ │ │ - *PRINT-GENSYM* T │ │ │ │ │ - *PRINT-LENGTH* NIL │ │ │ │ │ - *PRINT-LEVEL* NIL │ │ │ │ │ - *PRINT-LINES* NIL │ │ │ │ │ - *PRINT-MISER-WIDTH* NIL │ │ │ │ │ - *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ │ - *PRINT-PRETTY* NIL │ │ │ │ │ - *PRINT-RADIX* NIL │ │ │ │ │ - *PRINT-READABLY* T │ │ │ │ │ - *PRINT-RIGHT-MARGIN* NIL │ │ │ │ │ - *READ-BASE* 10 │ │ │ │ │ - *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ │ - *READ-EVAL* T │ │ │ │ │ - *READ-SUPPRESS* NIL │ │ │ │ │ - *READTABLE* the standard readtable │ │ │ │ │ - SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ │ - SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ │ +Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise. │ │ │ │ │ +Return true if OBJECT is a VECTOR, and NIL otherwise. │ │ │ │ │ +Destructively return the intersection of LIST1 and LIST2. │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ -ELEMENT-TYPE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -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. │ │ │ │ │ +Return the cdr of the cadr of a list. │ │ │ │ │ +FUN-NAME │ │ │ │ │ +MORE-ARG │ │ │ │ │ +Examine the substring of string delimited by start and end │ │ │ │ │ + (default to the beginning and end of the string) It skips over │ │ │ │ │ + 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. │ │ │ │ │ +Return a copy of a subsequence of SEQUENCE starting with element number │ │ │ │ │ + START and continuing to the end of SEQUENCE or the optional END. │ │ │ │ │ COMMON-LISP │ │ │ │ │ Is this number zero? │ │ │ │ │ CSar,H#KE │ │ │ │ │ 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. │ │ │ │ │ @@ -32050,28 +32010,14 @@ │ │ │ │ │ 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. │ │ │ │ │ -Perform a bit-wise LOGANDC2 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 │ │ │ │ │ -Bitwise AND INTEGER1 with (LOGNOT INTEGER2). │ │ │ │ │ -Complement the logical OR of INTEGER1 and INTEGER2. │ │ │ │ │ -Given two strings, if the first string is lexicographically less than │ │ │ │ │ - or equal to the second string, returns the longest common prefix │ │ │ │ │ - (using char=) of the two strings. Otherwise, returns (). │ │ │ │ │ -Performs the cdr function n times on a list. │ │ │ │ │ RETURN-FROM name value │ │ │ │ │ Evaluate the VALUE, returning its values from the lexically enclosing │ │ │ │ │ block NAME. This is constrained to be used only within the dynamic │ │ │ │ │ extent of the block. │ │ │ │ │ SYMBOL-MACROLET ({(name expansion)}*) decl* form* │ │ │ │ │ Define the NAMES as symbol macros with the given EXPANSIONS. Within the │ │ │ │ │ body, references to a NAME will effectively be replaced with the EXPANSION. │ │ │ │ │ @@ -32083,20 +32029,29 @@ │ │ │ │ │ MULTIPLE-VALUE-PROG1 values-form form* │ │ │ │ │ Evaluate VALUES-FORM and then the FORMS, but return all the values of │ │ │ │ │ VALUES-FORM. │ │ │ │ │ QUOTE value │ │ │ │ │ Return VALUE without evaluating it. │ │ │ │ │ THROW tag form │ │ │ │ │ Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ │ │ │ │ │ -TAGBODY {tag | statement}* │ │ │ │ │ -Define tags for use with GO. The STATEMENTS are evaluated in order, skipping │ │ │ │ │ -TAGS, and NIL is returned. If a statement contains a GO to a defined TAG │ │ │ │ │ -within the lexical scope of the form, then control is transferred to the next │ │ │ │ │ -statement following that tag. A TAG must be an integer or a symbol. A │ │ │ │ │ -STATEMENT must be a list. Other objects are illegal within the body. │ │ │ │ │ +Can STREAM perform input operations? │ │ │ │ │ +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. │ │ │ │ │ +Perform a bit-wise LOGANDC2 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 │ │ │ │ │ +Bitwise AND INTEGER1 with (LOGNOT INTEGER2). │ │ │ │ │ +Complement the logical OR of INTEGER1 and INTEGER2. │ │ │ │ │ +Given two strings, if the first string is lexicographically less than │ │ │ │ │ + or equal to the second string, returns the longest common prefix │ │ │ │ │ + (using char=) of the two strings. Otherwise, returns (). │ │ │ │ │ +Performs the cdr function n times on a list. │ │ │ │ │ Perform a bit-wise LOGNOR 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. │ │ │ │ │ COMMON-LISP │ │ │ │ │ The argument must be a character object. BOTH-CASE-P returns T if the │ │ │ │ │ argument is an alphabetic character and if the character exists in both upper │ │ │ │ │ @@ -32109,15 +32064,14 @@ │ │ │ │ │ $0$ G]D │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ │ COMMON-LISP │ │ │ │ │ SLOT-NAME │ │ │ │ │ Exports SYMBOLS from PACKAGE, checking that no name conflicts result. │ │ │ │ │ -Can STREAM perform input operations? │ │ │ │ │ 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. │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return T if and only if calling ADJUST-ARRAY on ARRAY will return │ │ │ │ │ the identical object. │ │ │ │ │ @@ -32496,27 +32450,61 @@ │ │ │ │ │ to the second string, returns the longest common prefix (using char=) │ │ │ │ │ of the two strings. Otherwise, returns (). │ │ │ │ │ Substitute NEW for subtrees of TREE for which TEST is true. │ │ │ │ │ Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise. │ │ │ │ │ MORE-ARG │ │ │ │ │ Return the least common multiple of one or more integers. LCM of no │ │ │ │ │ arguments is defined to be 1. │ │ │ │ │ +MD%~!$5\ │ │ │ │ │ +Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ │ +tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ │ +Define a special variable at top level. Declare the variable │ │ │ │ │ + SPECIAL and, optionally, initialize it. If the variable already has a │ │ │ │ │ + value, the old value is not clobbered. The third argument is an optional │ │ │ │ │ + documentation string for the variable. │ │ │ │ │ +Cause the iteration to terminate "normally", the same as implicit │ │ │ │ │ +termination by an iteration driving clause, or by use of WHILE or │ │ │ │ │ +UNTIL -- the epilogue code (if any) will be run, and any implicitly │ │ │ │ │ +collected result will be returned as the value of the LOOP. │ │ │ │ │ +CCASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ │ + Keyform. If none of the keys matches then a correctable error is │ │ │ │ │ + signalled. │ │ │ │ │ +Bind the reader and printer control variables to values that enable READ │ │ │ │ │ + to reliably read the results of PRINT. These values are: │ │ │ │ │ + *PACKAGE* the COMMON-LISP-USER package │ │ │ │ │ + *PRINT-ARRAY* T │ │ │ │ │ + *PRINT-BASE* 10 │ │ │ │ │ + *PRINT-CASE* :UPCASE │ │ │ │ │ + *PRINT-CIRCLE* NIL │ │ │ │ │ + *PRINT-ESCAPE* T │ │ │ │ │ + *PRINT-GENSYM* T │ │ │ │ │ + *PRINT-LENGTH* NIL │ │ │ │ │ + *PRINT-LEVEL* NIL │ │ │ │ │ + *PRINT-LINES* NIL │ │ │ │ │ + *PRINT-MISER-WIDTH* NIL │ │ │ │ │ + *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table │ │ │ │ │ + *PRINT-PRETTY* NIL │ │ │ │ │ + *PRINT-RADIX* NIL │ │ │ │ │ + *PRINT-READABLY* T │ │ │ │ │ + *PRINT-RIGHT-MARGIN* NIL │ │ │ │ │ + *READ-BASE* 10 │ │ │ │ │ + *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT │ │ │ │ │ + *READ-EVAL* T │ │ │ │ │ + *READ-SUPPRESS* NIL │ │ │ │ │ + *READTABLE* the standard readtable │ │ │ │ │ + SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ │ + SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ -Return the cdr of the cadar of a list. │ │ │ │ │ -Return the length of LIST, or NIL if LIST is circular. │ │ │ │ │ -MORE-ARG │ │ │ │ │ -Return the bit-wise equivalence of its arguments. Args must be integers. │ │ │ │ │ +ELEMENT-TYPE │ │ │ │ │ COMMON-LISP │ │ │ │ │ -Return the complex conjugate of NUMBER. For non-complex numbers, this is │ │ │ │ │ - an identity. │ │ │ │ │ -With a file name as an argument, dribble opens the file and sends a │ │ │ │ │ - record of further I/O to that file. Without an argument, it closes │ │ │ │ │ - the dribble file, and quits logging. │ │ │ │ │ -RAW-FORM │ │ │ │ │ -Return the arc tangent of Y if X is omitted or Y/X if X is supplied. │ │ │ │ │ +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. │ │ │ │ │ @@ -32587,74 +32575,36 @@ │ │ │ │ │ except for changing or removing elements corresponding to the current key. The │ │ │ │ │ applies to all threads, not just the current one -- even for synchronized │ │ │ │ │ hash-tables. If the table may be mutated by another thread during iteration, │ │ │ │ │ use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR │ │ │ │ │ COMMON-LISP │ │ │ │ │ Remove tracing from the specified functions. Untraces all │ │ │ │ │ functions when called with no arguments. │ │ │ │ │ -EVAL-WHEN (situation*) form* │ │ │ │ │ -Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, │ │ │ │ │ -:LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL). │ │ │ │ │ -LOCALLY declaration* form* │ │ │ │ │ -Sequentially evaluate the FORMS in a lexical environment where the │ │ │ │ │ -DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are │ │ │ │ │ -also processed as top level forms. │ │ │ │ │ -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. │ │ │ │ │ -FORM SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -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. │ │ │ │ │ +TAGBODY {tag | statement}* │ │ │ │ │ +Define tags for use with GO. The STATEMENTS are evaluated in order, skipping │ │ │ │ │ +TAGS, and NIL is returned. If a statement contains a GO to a defined TAG │ │ │ │ │ +within the lexical scope of the form, then control is transferred to the next │ │ │ │ │ +statement following that tag. A TAG must be an integer or a symbol. A │ │ │ │ │ +STATEMENT must be a list. Other objects are illegal within the body. │ │ │ │ │ +Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ │ +or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ │ +Form associated with the STEP-CONDITION. │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +Return the cdr of the cadar of a list. │ │ │ │ │ +Return the length of LIST, or NIL if LIST is circular. │ │ │ │ │ +MORE-ARG │ │ │ │ │ +Return the bit-wise equivalence of its arguments. Args must be integers. │ │ │ │ │ COMMON-LISP │ │ │ │ │ -(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. │ │ │ │ │ -;J8O"K(* │ │ │ │ │ -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. │ │ │ │ │ +Return the complex conjugate of NUMBER. For non-complex numbers, this is │ │ │ │ │ + an identity. │ │ │ │ │ +With a file name as an argument, dribble opens the file and sends a │ │ │ │ │ + record of further I/O to that file. Without an argument, it closes │ │ │ │ │ + the dribble file, and quits logging. │ │ │ │ │ +RAW-FORM │ │ │ │ │ +Return the arc tangent of Y if X is omitted or Y/X if X is supplied. │ │ │ │ │ INRz~D)?Oyy& │ │ │ │ │ $0$ GYD │ │ │ │ │ MORE-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return the arc cosine of NUMBER. │ │ │ │ │ Make a new package having the specified NAME, NICKNAMES, and USE │ │ │ │ │ list. :INTERNAL-SYMBOLS and :EXTERNAL-SYMBOLS are estimates for the number of │ │ │ │ │ @@ -32744,27 +32694,28 @@ │ │ │ │ │ Rounds number (or number/divisor) to nearest integer. │ │ │ │ │ The second returned value is the remainder. │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ Return T if all of the arguments are the same character. │ │ │ │ │ Case is ignored. │ │ │ │ │ +Bitwise OR (LOGNOT INTEGER1) with INTEGER2. │ │ │ │ │ + CHARACTER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +MORE-ARG │ │ │ │ │ +Return T if the arguments are in strictly decreasing alphabetic order. │ │ │ │ │ +Case is ignored. │ │ │ │ │ +SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ │ Return true if STREAM is not closed. A default method is provided │ │ │ │ │ by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ │ called on the stream. │ │ │ │ │ Close the given STREAM. No more I/O may be performed, but │ │ │ │ │ inquiries may still be made. If :ABORT is true, an attempt is made │ │ │ │ │ to clean up the side effects of having created the stream. │ │ │ │ │ Can STREAM perform output operations? │ │ │ │ │ -Bitwise OR (LOGNOT INTEGER1) with INTEGER2. │ │ │ │ │ - CHARACTER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -MORE-ARG │ │ │ │ │ -Return T if the arguments are in strictly decreasing alphabetic order. │ │ │ │ │ -Case is ignored. │ │ │ │ │ Same as TRUNCATE, but returns first value as a float. │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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. │ │ │ │ │ @@ -32837,14 +32788,21 @@ │ │ │ │ │ any non-negative real number. │ │ │ │ │ _6@ssCa} │ │ │ │ │ Return the printed representation of OBJECT as a string with │ │ │ │ │ slashification off. │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +EVAL-WHEN (situation*) form* │ │ │ │ │ +Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, │ │ │ │ │ +:LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL). │ │ │ │ │ +LOCALLY declaration* form* │ │ │ │ │ +Sequentially evaluate the FORMS in a lexical environment where the │ │ │ │ │ +DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are │ │ │ │ │ +also processed as top level forms. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return T iff OBJECT is an alien of type TYPE. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return T iff the alien type TYPE1 is a subtype of TYPE2. Currently, the │ │ │ │ │ only supported subtype relationships are is that any pointer type is a │ │ │ │ │ @@ -32880,22 +32838,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ -Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ │ -or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ │ -Form associated with the STEP-CONDITION. │ │ │ │ │ -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 │ │ │ │ │ TARGET-TYPE │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return T iff TYPE1 and TYPE2 describe equivalent alien types. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ TARGET-TYPE │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ @@ -33366,138 +33316,67 @@ │ │ │ │ │ Examples: │ │ │ │ │ (valid-type-specifier-p '(cons * *)) => T │ │ │ │ │ (valid-type-specifier-p '#:foo) => NIL │ │ │ │ │ (valid-type-specifier-p '(cons * #:foo)) => NIL │ │ │ │ │ (valid-type-specifier-p '(cons 1 *) => NIL │ │ │ │ │ Experimental. │ │ │ │ │ The error stream of the process or NIL. │ │ │ │ │ -Minimum average age of objects allocated to GENERATION before that │ │ │ │ │ -generation is may be garbage collected. Default is 0.75. See also │ │ │ │ │ -GENERATION-AVERAGE-AGE. Can be assigned to using SETF. Available on GENCGC │ │ │ │ │ -platforms only. │ │ │ │ │ -Experimental: interface subject to change. │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -Returns T when PACKAGE is locked, NIL otherwise. Signals an error │ │ │ │ │ -if PACKAGE doesn't designate a valid package. │ │ │ │ │ -Removes PACKAGES-TO-REMOVE from the implementation packages of │ │ │ │ │ -PACKAGE. Signals an error if PACKAGE or any of the PACKAGES-TO-REMOVE │ │ │ │ │ -is not a valid package designator. │ │ │ │ │ -A place for clients to stash things. │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -Return the pathname used to log garbage collections. Can be SETF. │ │ │ │ │ -Default is NIL, meaning collections are not logged. If non-null, the │ │ │ │ │ -designated file is opened before and after each collection, and generation │ │ │ │ │ -statistics are appended to it. │ │ │ │ │ -Restore the debugger if it has been turned off by DISABLE-DEBUGGER. │ │ │ │ │ -Initiate a garbage collection. │ │ │ │ │ -The default is to initiate a nursery collection, which may in turn │ │ │ │ │ -trigger a collection of one or more older generations as well. If FULL │ │ │ │ │ -is true, all generations are collected. If GEN is provided, it can be │ │ │ │ │ -used to specify the oldest generation guaranteed to be collected. │ │ │ │ │ -RUN-PROGRAM creates a new process specified by PROGRAM. │ │ │ │ │ -ARGS is a list of strings to be passed literally to the new program. │ │ │ │ │ -In POSIX environments, this list becomes the array supplied as the second │ │ │ │ │ -parameter to the execv() or execvp() system call, each list element becoming │ │ │ │ │ -one array element. The strings should not contain shell escaping, as there is │ │ │ │ │ -no shell involvement. Further note that while conventionally the process │ │ │ │ │ -receives its own pathname in argv[0], that is automatic, and the 0th string │ │ │ │ │ -should not be present in ARGS. │ │ │ │ │ -The program arguments and the environment are encoded using the │ │ │ │ │ -default external format for streams. │ │ │ │ │ -RUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp │ │ │ │ │ -Users Manual for details about the PROCESS structure. │ │ │ │ │ - Notes about Unix environments (as in the :ENVIRONMENT and :ENV args): │ │ │ │ │ - - The SBCL implementation of RUN-PROGRAM, like Perl and many other │ │ │ │ │ - programs, but unlike the original CMU CL implementation, copies │ │ │ │ │ - the Unix environment by default. │ │ │ │ │ - - Running Unix programs from a setuid process, or in any other │ │ │ │ │ - situation where the Unix environment is under the control of someone │ │ │ │ │ - else, is a mother lode of security problems. If you are contemplating │ │ │ │ │ - doing this, read about it first. (The Perl community has a lot of good │ │ │ │ │ - documentation about this and other security issues in script-like │ │ │ │ │ - programs.) │ │ │ │ │ - The &KEY arguments have the following meanings: │ │ │ │ │ - :ENVIRONMENT │ │ │ │ │ - a list of STRINGs describing the new Unix environment │ │ │ │ │ - (as in "man environ"). The default is to copy the environment of │ │ │ │ │ - the current process. │ │ │ │ │ - an alternative lossy representation of the new Unix environment, │ │ │ │ │ - for compatibility with CMU CL │ │ │ │ │ - :SEARCH │ │ │ │ │ - Look for PROGRAM in each of the directories in the child's $PATH │ │ │ │ │ - environment variable. Otherwise an absolute pathname is required. │ │ │ │ │ - :WAIT │ │ │ │ │ - If non-NIL (default), wait until the created process finishes. If │ │ │ │ │ - NIL, continue running Lisp until the program finishes. │ │ │ │ │ - :PTY (not supported on win32) │ │ │ │ │ - Either T, NIL, or a stream. Unless NIL, the subprocess is established │ │ │ │ │ - under a PTY. If :pty is a stream, all output to this pty is sent to │ │ │ │ │ - this stream, otherwise the PROCESS-PTY slot is filled in with a stream │ │ │ │ │ - connected to pty that can read output and write input. │ │ │ │ │ - :INPUT │ │ │ │ │ - Either T, NIL, a pathname, a stream, or :STREAM. │ │ │ │ │ - T: the standard input for the current process is inherited. │ │ │ │ │ - NIL: /dev/null (nul on win32) is used. │ │ │ │ │ - pathname: the specified file is used. │ │ │ │ │ - stream: all the input is read from that stream and sent to the │ │ │ │ │ - subprocess. │ │ │ │ │ - :STREAM: the PROCESS-INPUT slot is filled in with a stream that sends │ │ │ │ │ - its output to the process. │ │ │ │ │ - Defaults to NIL. │ │ │ │ │ - :IF-INPUT-DOES-NOT-EXIST (when :INPUT is the name of a file) │ │ │ │ │ - can be one of: │ │ │ │ │ - :ERROR to generate an error │ │ │ │ │ - :CREATE to create an empty file │ │ │ │ │ - NIL (the default) to return NIL from RUN-PROGRAM │ │ │ │ │ - :OUTPUT │ │ │ │ │ - Either T, NIL, a pathname, a stream, or :STREAM. │ │ │ │ │ - T: the standard output for the current process is inherited. │ │ │ │ │ - NIL: /dev/null (nul on win32) is used. │ │ │ │ │ - pathname: the specified file is used. │ │ │ │ │ - stream: all the output from the process is written to this stream. │ │ │ │ │ - :STREAM: the PROCESS-OUTPUT slot is filled in with a stream that can be │ │ │ │ │ - read to get the output. │ │ │ │ │ - Defaults to NIL. │ │ │ │ │ - :ERROR │ │ │ │ │ - Same as :OUTPUT, additionally accepts :OUTPUT, making all error │ │ │ │ │ - output routed to the same place as normal output. │ │ │ │ │ - Defaults to :OUTPUT. │ │ │ │ │ - :IF-OUTPUT-EXISTS (when :OUTPUT is the name of a file) │ │ │ │ │ - can be one of: │ │ │ │ │ - :ERROR (the default) to generate an error │ │ │ │ │ - :SUPERSEDE to supersede the file with output from the program │ │ │ │ │ - :APPEND to append output from the program to the file │ │ │ │ │ - NIL to return NIL from RUN-PROGRAM, without doing anything │ │ │ │ │ - :IF-ERROR-EXISTS │ │ │ │ │ - Same as :IF-OUTPUT-EXISTS, controlling :ERROR output to files. │ │ │ │ │ - Ignored when :ERROR :OUTPUT. │ │ │ │ │ - Defaults to :ERROR. │ │ │ │ │ - :STATUS-HOOK │ │ │ │ │ - This is a function the system calls whenever the status of the │ │ │ │ │ - process changes. The function takes the process as an argument. │ │ │ │ │ - :EXTERNAL-FORMAT │ │ │ │ │ - The external-format to use for :INPUT, :OUTPUT, and :ERROR :STREAMs. │ │ │ │ │ - :DIRECTORY │ │ │ │ │ - Specifies the directory in which the program should be run. │ │ │ │ │ - NIL (the default) means the directory is unchanged. │ │ │ │ │ - :PRESERVE-FDS │ │ │ │ │ - A sequence of file descriptors which should remain open in the child │ │ │ │ │ - process. │ │ │ │ │ - Windows specific options: │ │ │ │ │ - :ESCAPE-ARGUMENTS (default T) │ │ │ │ │ - Controls escaping of the arguments passed to CreateProcess. │ │ │ │ │ - :WINDOW (default NIL) │ │ │ │ │ - When NIL, the subprocess decides how it will display its window. The │ │ │ │ │ - following options control how the subprocess window should be displayed: │ │ │ │ │ - :HIDE, :SHOW-NORMAL, :SHOW-MAXIMIZED, :SHOW-MINIMIZED, :SHOW-NO-ACTIVATE, │ │ │ │ │ - :SHOW-MIN-NO-ACTIVE, :SHOW-NA. │ │ │ │ │ - Note: console application subprocesses may or may not display a console │ │ │ │ │ - window depending on whether the SBCL runtime is itself a console or GUI │ │ │ │ │ - application. Invoke CMD /C START to consistently display a console window │ │ │ │ │ - or use the :WINDOW :HIDE option to consistently hide the console window. │ │ │ │ │ +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. │ │ │ │ │ +FORM SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +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. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +(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. │ │ │ │ │ +;J8O"K(* │ │ │ │ │ +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. │ │ │ │ │ @@ -33522,14 +33401,28 @@ │ │ │ │ │ - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ │ ATOMIC-DECF of #x-20000000 by one results in #x1FFFFFFF │ │ │ │ │ being stored in PLACE. │ │ │ │ │ DIFF defaults to 1. │ │ │ │ │ EXPERIMENTAL: Interface subject to change. │ │ │ │ │ Ignores all runtime package lock violations during the execution of │ │ │ │ │ body. Body can begin with declarations. │ │ │ │ │ +: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: ~// │ │ │ │ │ Limits concurrent accesses to HASH-TABLE for the duration of BODY. │ │ │ │ │ If HASH-TABLE is synchronized, BODY will execute with exclusive │ │ │ │ │ ownership of the table. If HASH-TABLE is not synchronized, BODY will │ │ │ │ │ execute with other WITH-LOCKED-HASH-TABLE bodies excluded -- exclusion │ │ │ │ │ of hash-table accesses not surrounded by WITH-LOCKED-HASH-TABLE is │ │ │ │ │ unspecified. │ │ │ │ │ Like POP, but atomic. PLACE may be read multiple times before │ │ │ │ │ @@ -33644,14 +33537,21 @@ │ │ │ │ │ Named form when it appears in the compiler input. Lambda-List is a DEFMACRO │ │ │ │ │ style lambda-list used to parse the arguments. The Body should return a │ │ │ │ │ list of subforms suitable for a "~{~S ~}" format string. │ │ │ │ │ Like PUSH, but atomic. PLACE may be read multiple times before │ │ │ │ │ the operation completes -- the write does not occur until such time │ │ │ │ │ that no other thread modified PLACE between the read and the write. │ │ │ │ │ Works on all CASable places. │ │ │ │ │ +SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ │ +NEW-INFO │ │ │ │ │ +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 │ │ │ │ │ HASH-FUNCTION0 │ │ │ │ │ Defines NAME as a new kind of hash table test for use with the :TEST │ │ │ │ │ argument to MAKE-HASH-TABLE, and associates a default HASH-FUNCTION with it. │ │ │ │ │ NAME must be a symbol naming a global two argument equivalence predicate. │ │ │ │ │ Afterwards both 'NAME and #'NAME can be used with :TEST argument. In both │ │ │ │ │ cases HASH-TABLE-TEST will return the symbol NAME. │ │ │ │ │ HASH-FUNCTION must be a symbol naming a global hash function consistent with │ │ │ │ │ @@ -33694,107 +33594,148 @@ │ │ │ │ │ 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. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + FUNCTIONS │ │ │ │ │ +CATEGORY │ │ │ │ │ +INFO-NUMBER │ │ │ │ │ +BINDINGS │ │ │ │ │ +Minimum average age of objects allocated to GENERATION before that │ │ │ │ │ +generation is may be garbage collected. Default is 0.75. See also │ │ │ │ │ +GENERATION-AVERAGE-AGE. Can be assigned to using SETF. Available on GENCGC │ │ │ │ │ +platforms only. │ │ │ │ │ +Experimental: interface subject to change. │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +Returns T when PACKAGE is locked, NIL otherwise. Signals an error │ │ │ │ │ +if PACKAGE doesn't designate a valid package. │ │ │ │ │ +Removes PACKAGES-TO-REMOVE from the implementation packages of │ │ │ │ │ +PACKAGE. Signals an error if PACKAGE or any of the PACKAGES-TO-REMOVE │ │ │ │ │ +is not a valid package designator. │ │ │ │ │ +A place for clients to stash things. │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +Return the pathname used to log garbage collections. Can be SETF. │ │ │ │ │ +Default is NIL, meaning collections are not logged. If non-null, the │ │ │ │ │ +designated file is opened before and after each collection, and generation │ │ │ │ │ +statistics are appended to it. │ │ │ │ │ +Restore the debugger if it has been turned off by DISABLE-DEBUGGER. │ │ │ │ │ +Initiate a garbage collection. │ │ │ │ │ +The default is to initiate a nursery collection, which may in turn │ │ │ │ │ +trigger a collection of one or more older generations as well. If FULL │ │ │ │ │ +is true, all generations are collected. If GEN is provided, it can be │ │ │ │ │ +used to specify the oldest generation guaranteed to be collected. │ │ │ │ │ +RUN-PROGRAM creates a new process specified by PROGRAM. │ │ │ │ │ +ARGS is a list of strings to be passed literally to the new program. │ │ │ │ │ +In POSIX environments, this list becomes the array supplied as the second │ │ │ │ │ +parameter to the execv() or execvp() system call, each list element becoming │ │ │ │ │ +one array element. The strings should not contain shell escaping, as there is │ │ │ │ │ +no shell involvement. Further note that while conventionally the process │ │ │ │ │ +receives its own pathname in argv[0], that is automatic, and the 0th string │ │ │ │ │ +should not be present in ARGS. │ │ │ │ │ +The program arguments and the environment are encoded using the │ │ │ │ │ +default external format for streams. │ │ │ │ │ +RUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp │ │ │ │ │ +Users Manual for details about the PROCESS structure. │ │ │ │ │ + Notes about Unix environments (as in the :ENVIRONMENT and :ENV args): │ │ │ │ │ + - The SBCL implementation of RUN-PROGRAM, like Perl and many other │ │ │ │ │ + programs, but unlike the original CMU CL implementation, copies │ │ │ │ │ + the Unix environment by default. │ │ │ │ │ + - Running Unix programs from a setuid process, or in any other │ │ │ │ │ + situation where the Unix environment is under the control of someone │ │ │ │ │ + else, is a mother lode of security problems. If you are contemplating │ │ │ │ │ + doing this, read about it first. (The Perl community has a lot of good │ │ │ │ │ + documentation about this and other security issues in script-like │ │ │ │ │ + programs.) │ │ │ │ │ + The &KEY arguments have the following meanings: │ │ │ │ │ + :ENVIRONMENT │ │ │ │ │ + a list of STRINGs describing the new Unix environment │ │ │ │ │ + (as in "man environ"). The default is to copy the environment of │ │ │ │ │ + the current process. │ │ │ │ │ + an alternative lossy representation of the new Unix environment, │ │ │ │ │ + for compatibility with CMU CL │ │ │ │ │ + :SEARCH │ │ │ │ │ + Look for PROGRAM in each of the directories in the child's $PATH │ │ │ │ │ + environment variable. Otherwise an absolute pathname is required. │ │ │ │ │ + :WAIT │ │ │ │ │ + If non-NIL (default), wait until the created process finishes. If │ │ │ │ │ + NIL, continue running Lisp until the program finishes. │ │ │ │ │ + :PTY (not supported on win32) │ │ │ │ │ + Either T, NIL, or a stream. Unless NIL, the subprocess is established │ │ │ │ │ + under a PTY. If :pty is a stream, all output to this pty is sent to │ │ │ │ │ + this stream, otherwise the PROCESS-PTY slot is filled in with a stream │ │ │ │ │ + connected to pty that can read output and write input. │ │ │ │ │ + :INPUT │ │ │ │ │ + Either T, NIL, a pathname, a stream, or :STREAM. │ │ │ │ │ + T: the standard input for the current process is inherited. │ │ │ │ │ + NIL: /dev/null (nul on win32) is used. │ │ │ │ │ + pathname: the specified file is used. │ │ │ │ │ + stream: all the input is read from that stream and sent to the │ │ │ │ │ + subprocess. │ │ │ │ │ + :STREAM: the PROCESS-INPUT slot is filled in with a stream that sends │ │ │ │ │ + its output to the process. │ │ │ │ │ + Defaults to NIL. │ │ │ │ │ + :IF-INPUT-DOES-NOT-EXIST (when :INPUT is the name of a file) │ │ │ │ │ + can be one of: │ │ │ │ │ + :ERROR to generate an error │ │ │ │ │ + :CREATE to create an empty file │ │ │ │ │ + NIL (the default) to return NIL from RUN-PROGRAM │ │ │ │ │ + :OUTPUT │ │ │ │ │ + Either T, NIL, a pathname, a stream, or :STREAM. │ │ │ │ │ + T: the standard output for the current process is inherited. │ │ │ │ │ + NIL: /dev/null (nul on win32) is used. │ │ │ │ │ + pathname: the specified file is used. │ │ │ │ │ + stream: all the output from the process is written to this stream. │ │ │ │ │ + :STREAM: the PROCESS-OUTPUT slot is filled in with a stream that can be │ │ │ │ │ + read to get the output. │ │ │ │ │ + Defaults to NIL. │ │ │ │ │ + :ERROR │ │ │ │ │ + Same as :OUTPUT, additionally accepts :OUTPUT, making all error │ │ │ │ │ + output routed to the same place as normal output. │ │ │ │ │ + Defaults to :OUTPUT. │ │ │ │ │ + :IF-OUTPUT-EXISTS (when :OUTPUT is the name of a file) │ │ │ │ │ + can be one of: │ │ │ │ │ + :ERROR (the default) to generate an error │ │ │ │ │ + :SUPERSEDE to supersede the file with output from the program │ │ │ │ │ + :APPEND to append output from the program to the file │ │ │ │ │ + NIL to return NIL from RUN-PROGRAM, without doing anything │ │ │ │ │ + :IF-ERROR-EXISTS │ │ │ │ │ + Same as :IF-OUTPUT-EXISTS, controlling :ERROR output to files. │ │ │ │ │ + Ignored when :ERROR :OUTPUT. │ │ │ │ │ + Defaults to :ERROR. │ │ │ │ │ + :STATUS-HOOK │ │ │ │ │ + This is a function the system calls whenever the status of the │ │ │ │ │ + process changes. The function takes the process as an argument. │ │ │ │ │ + :EXTERNAL-FORMAT │ │ │ │ │ + The external-format to use for :INPUT, :OUTPUT, and :ERROR :STREAMs. │ │ │ │ │ + :DIRECTORY │ │ │ │ │ + Specifies the directory in which the program should be run. │ │ │ │ │ + NIL (the default) means the directory is unchanged. │ │ │ │ │ + :PRESERVE-FDS │ │ │ │ │ + A sequence of file descriptors which should remain open in the child │ │ │ │ │ + process. │ │ │ │ │ + Windows specific options: │ │ │ │ │ + :ESCAPE-ARGUMENTS (default T) │ │ │ │ │ + Controls escaping of the arguments passed to CreateProcess. │ │ │ │ │ + :WINDOW (default NIL) │ │ │ │ │ + When NIL, the subprocess decides how it will display its window. The │ │ │ │ │ + following options control how the subprocess window should be displayed: │ │ │ │ │ + :HIDE, :SHOW-NORMAL, :SHOW-MAXIMIZED, :SHOW-MINIMIZED, :SHOW-NO-ACTIVATE, │ │ │ │ │ + :SHOW-MIN-NO-ACTIVE, :SHOW-NA. │ │ │ │ │ + Note: console application subprocesses may or may not display a console │ │ │ │ │ + window depending on whether the SBCL runtime is itself a console or GUI │ │ │ │ │ + application. Invoke CMD /C START to consistently display a console window │ │ │ │ │ + or use the :WINDOW :HIDE option to consistently hide the console window. │ │ │ │ │ Takes and expands a type specifier once like MACROEXPAND-1. │ │ │ │ │ Returns two values: the expansion, and a boolean that is true when │ │ │ │ │ expansion happened. │ │ │ │ │ Return the number of seconds and microseconds since the beginning of │ │ │ │ │ the UNIX epoch (January 1st 1970.) │ │ │ │ │ -SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ │ -SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ │ -: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 stream line length or NIL. │ │ │ │ │ -This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ │ - optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ │ - The string argument is returned. The default method provided by │ │ │ │ │ - FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ │ - STREAM-WRITE-CHAR. │ │ │ │ │ -Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ │ - method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ │ -Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ │ - returns the integer as the result. │ │ │ │ │ -This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ │ - STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ │ - define their own method since it will usually be trivial and will │ │ │ │ │ - always be more efficient than the default method. │ │ │ │ │ -This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. │ │ │ │ │ - It returns either a character or :EOF. The default method calls │ │ │ │ │ - STREAM-READ-CHAR and STREAM-UNREAD-CHAR. │ │ │ │ │ -This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ │ -Is STREAM known to be positioned at the beginning of a line? │ │ │ │ │ - It is permissible for an implementation to always return │ │ │ │ │ - NIL. This is used in the implementation of FRESH-LINE. Note that │ │ │ │ │ - while a value of 0 from STREAM-LINE-COLUMN also indicates the │ │ │ │ │ - beginning of a line, there are cases where STREAM-START-LINE-P can be │ │ │ │ │ - meaningfully implemented although STREAM-LINE-COLUMN can't be. For │ │ │ │ │ - example, for a window using variable-width characters, the column │ │ │ │ │ - number isn't very meaningful, but the beginning of the line does have │ │ │ │ │ - a clear meaning. The default method for STREAM-START-LINE-P on class │ │ │ │ │ - FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if │ │ │ │ │ - that is defined to return NIL, then a method should be provided for │ │ │ │ │ - either STREAM-START-LINE-P or STREAM-FRESH-LINE. │ │ │ │ │ -This is used by READ-LINE. A string is returned as the first value. The │ │ │ │ │ - second value is true if the string was terminated by end-of-file │ │ │ │ │ - instead of the end of a line. The default method uses repeated │ │ │ │ │ - calls to STREAM-READ-CHAR. │ │ │ │ │ -Return the column number where the next character │ │ │ │ │ - will be written, or NIL if that is not meaningful for this stream. │ │ │ │ │ - The first column on a line is numbered 0. This function is used in │ │ │ │ │ - the implementation of PPRINT and the FORMAT ~T directive. For every │ │ │ │ │ - character output stream class that is defined, a method must be │ │ │ │ │ - defined for this function, although it is permissible for it to │ │ │ │ │ - always return NIL. │ │ │ │ │ -This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given │ │ │ │ │ - output STREAM. The default method does nothing. │ │ │ │ │ -Write enough blank space so that the next character will be │ │ │ │ │ - written at the specified column. Returns true if the operation is │ │ │ │ │ - successful, or NIL if it is not supported for this stream. This is │ │ │ │ │ - intended for use by by PPRINT and FORMAT ~T. The default method uses │ │ │ │ │ - STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a │ │ │ │ │ - #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL. │ │ │ │ │ -This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. │ │ │ │ │ - The default method does nothing. │ │ │ │ │ -This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ │ -Read one character from the stream. Return either a │ │ │ │ │ - character object, or the symbol :EOF if the stream is at end-of-file. │ │ │ │ │ - Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a │ │ │ │ │ - method for this function. │ │ │ │ │ -This is used to implement READ-CHAR-NO-HANG. It returns either a │ │ │ │ │ - character, or NIL if no input is currently available, or :EOF if │ │ │ │ │ - end-of-file is reached. The default method provided by │ │ │ │ │ - FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this │ │ │ │ │ - is sufficient for file streams, but interactive streams should define │ │ │ │ │ - their own method. │ │ │ │ │ -Attempts to ensure that all output sent to the Stream has reached │ │ │ │ │ - its destination, and only then returns false. Implements │ │ │ │ │ - FINISH-OUTPUT. The default method does nothing. │ │ │ │ │ -Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ │ - if the stream is at end-of-file. │ │ │ │ │ -Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. │ │ │ │ │ - Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM │ │ │ │ │ - must define a method for this function. │ │ │ │ │ -Attempts to force any buffered output to be sent. Implements │ │ │ │ │ - FORCE-OUTPUT. The default method does nothing. │ │ │ │ │ When invoked, this function will turn off both the SBCL debugger │ │ │ │ │ and LDB (the low-level debugger). See also ENABLE-DEBUGGER. │ │ │ │ │ Deletes the directory designated by PATHSPEC (a pathname designator). │ │ │ │ │ Returns the truename of the directory deleted. │ │ │ │ │ If RECURSIVE is false (the default), signals an error unless the directory is │ │ │ │ │ empty. If RECURSIVE is true, first deletes all files and subdirectories. If │ │ │ │ │ RECURSIVE is true and the directory contains symbolic links, the links are │ │ │ │ │ @@ -33914,26 +33855,97 @@ │ │ │ │ │ TIMER shall not be triggered again and there are no unfinished │ │ │ │ │ triggers. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ The pid of the child process. │ │ │ │ │ ;$O,H1;Q │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ -NEW-INFO │ │ │ │ │ CURRENT-INFO │ │ │ │ │ INFO-HOLDER0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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. │ │ │ │ │ MEMBERS0 │ │ │ │ │ TYPE-NUM │ │ │ │ │ +Return the stream line length or NIL. │ │ │ │ │ +This is used by WRITE-STRING. It writes the string to the stream, │ │ │ │ │ + optionally delimited by start and end, which default to 0 and NIL. │ │ │ │ │ + The string argument is returned. The default method provided by │ │ │ │ │ + FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to │ │ │ │ │ + STREAM-WRITE-CHAR. │ │ │ │ │ +Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ │ + method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ │ +Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ │ + returns the integer as the result. │ │ │ │ │ +This is used by LISTEN. It returns true or false. The default method uses │ │ │ │ │ + STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should │ │ │ │ │ + define their own method since it will usually be trivial and will │ │ │ │ │ + always be more efficient than the default method. │ │ │ │ │ +This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. │ │ │ │ │ + It returns either a character or :EOF. The default method calls │ │ │ │ │ + STREAM-READ-CHAR and STREAM-UNREAD-CHAR. │ │ │ │ │ +This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ │ +Is STREAM known to be positioned at the beginning of a line? │ │ │ │ │ + It is permissible for an implementation to always return │ │ │ │ │ + NIL. This is used in the implementation of FRESH-LINE. Note that │ │ │ │ │ + while a value of 0 from STREAM-LINE-COLUMN also indicates the │ │ │ │ │ + beginning of a line, there are cases where STREAM-START-LINE-P can be │ │ │ │ │ + meaningfully implemented although STREAM-LINE-COLUMN can't be. For │ │ │ │ │ + example, for a window using variable-width characters, the column │ │ │ │ │ + number isn't very meaningful, but the beginning of the line does have │ │ │ │ │ + a clear meaning. The default method for STREAM-START-LINE-P on class │ │ │ │ │ + FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if │ │ │ │ │ + that is defined to return NIL, then a method should be provided for │ │ │ │ │ + either STREAM-START-LINE-P or STREAM-FRESH-LINE. │ │ │ │ │ +This is used by READ-LINE. A string is returned as the first value. The │ │ │ │ │ + second value is true if the string was terminated by end-of-file │ │ │ │ │ + instead of the end of a line. The default method uses repeated │ │ │ │ │ + calls to STREAM-READ-CHAR. │ │ │ │ │ +Return the column number where the next character │ │ │ │ │ + will be written, or NIL if that is not meaningful for this stream. │ │ │ │ │ + The first column on a line is numbered 0. This function is used in │ │ │ │ │ + the implementation of PPRINT and the FORMAT ~T directive. For every │ │ │ │ │ + character output stream class that is defined, a method must be │ │ │ │ │ + defined for this function, although it is permissible for it to │ │ │ │ │ + always return NIL. │ │ │ │ │ +This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given │ │ │ │ │ + output STREAM. The default method does nothing. │ │ │ │ │ +Write enough blank space so that the next character will be │ │ │ │ │ + written at the specified column. Returns true if the operation is │ │ │ │ │ + successful, or NIL if it is not supported for this stream. This is │ │ │ │ │ + intended for use by by PPRINT and FORMAT ~T. The default method uses │ │ │ │ │ + STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a │ │ │ │ │ + #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL. │ │ │ │ │ +This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. │ │ │ │ │ + The default method does nothing. │ │ │ │ │ +This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ │ +Read one character from the stream. Return either a │ │ │ │ │ + character object, or the symbol :EOF if the stream is at end-of-file. │ │ │ │ │ + Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a │ │ │ │ │ + method for this function. │ │ │ │ │ +This is used to implement READ-CHAR-NO-HANG. It returns either a │ │ │ │ │ + character, or NIL if no input is currently available, or :EOF if │ │ │ │ │ + end-of-file is reached. The default method provided by │ │ │ │ │ + FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this │ │ │ │ │ + is sufficient for file streams, but interactive streams should define │ │ │ │ │ + their own method. │ │ │ │ │ +Attempts to ensure that all output sent to the Stream has reached │ │ │ │ │ + its destination, and only then returns false. Implements │ │ │ │ │ + FINISH-OUTPUT. The default method does nothing. │ │ │ │ │ +Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ │ + if the stream is at end-of-file. │ │ │ │ │ +Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. │ │ │ │ │ + Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM │ │ │ │ │ + must define a method for this function. │ │ │ │ │ +Attempts to force any buffered output to be sent. Implements │ │ │ │ │ + FORCE-OUTPUT. The default method does nothing. │ │ │ │ │ S4*~\5`c$ │ │ │ │ │ SB-ALIEN │ │ │ │ │ NEWCHARSTAR │ │ │ │ │ CERTAIN? │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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 │ │ │ │ │ @@ -34043,26 +34055,14 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP9 │ │ │ │ │ ARG-FORMS │ │ │ │ │ POSSIBLY-LOGICAL-PATHNAME0 │ │ │ │ │ -DEFAULT8 │ │ │ │ │ -EXTERNAL-FORMAT │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -ACCUMULATOR │ │ │ │ │ -LENGTH-LIMIT │ │ │ │ │ -DEPTHOID9 │ │ │ │ │ -FUN-NAME0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - FUNCTIONS │ │ │ │ │ -CATEGORY │ │ │ │ │ -INFO-NUMBER │ │ │ │ │ -BINDINGS │ │ │ │ │ N-HASH-TABLE │ │ │ │ │ REPLACEMENT │ │ │ │ │ {,^\%F:% │ │ │ │ │ CATEGORY0 │ │ │ │ │ SPLICE8Cg" │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0g" │ │ │ │ │ EOF-ERROR-P │ │ │ │ │ EOF-VALUE │ │ │ │ │ ITER-FORM │ │ │ │ │ CATEGORY0 │ │ │ │ │ -DEADLINE0 │ │ │ │ │ - TIME-LEFT │ │ │ │ │ -Binds NAME as a local function for BODY. Each time #'NAME is called, it │ │ │ │ │ -returns SECONDS minus the time that has elapsed since BODY was entered, or │ │ │ │ │ -zero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME │ │ │ │ │ -returns NIL each time. │ │ │ │ │ -CAPACITY │ │ │ │ │ -DEADLINE │ │ │ │ │ -OVERRIDE │ │ │ │ │ -SECONDS0 │ │ │ │ │ -Arranges for a TIMEOUT condition to be signalled if an operation │ │ │ │ │ -respecting deadlines occurs either after the deadline has passed, or │ │ │ │ │ -would take longer than the time left to complete. │ │ │ │ │ -Currently only SLEEP, blocking IO operations, GET-MUTEX, and │ │ │ │ │ -CONDITION-WAIT respect deadlines, but this includes their implicit │ │ │ │ │ -uses inside SBCL itself. │ │ │ │ │ -Unless OVERRIDE is true, existing deadlines can only be restricted, │ │ │ │ │ -not extended. Deadlines are per thread: children are unaffected by │ │ │ │ │ -their parent's deadlines. │ │ │ │ │ -Experimental. │ │ │ │ │ -Arrange with the garbage collector that OBJECTS will not be moved in memory │ │ │ │ │ -for the duration of BODY. Useful for e.g. foreign calls where another thread │ │ │ │ │ -may trigger garbage collection. │ │ │ │ │ -WITHOUT-GCING-BODY │ │ │ │ │ -Executes the forms in the body without doing a garbage collection. It │ │ │ │ │ -inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ │ -upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ │ -Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ │ -enabled in this thread. │ │ │ │ │ -Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ │ -SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ │ -Should be used with great care, and not at all in multithreaded application │ │ │ │ │ -code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ │ -held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ │ -stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ │ -system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ │ -locks, application code can never be certain that this invariant is │ │ │ │ │ -maintained. │ │ │ │ │ -Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ │ -Establish a handler with SYSTEM: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. │ │ │ │ │ +DEFAULT8 │ │ │ │ │ +EXTERNAL-FORMAT │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +ACCUMULATOR │ │ │ │ │ +LENGTH-LIMIT │ │ │ │ │ +DEPTHOID9 │ │ │ │ │ +FUN-NAME0 │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ DOCSTRING8 │ │ │ │ │ MAYBE-PACKAGE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ OLD-CONS │ │ │ │ │ @@ -34238,16 +34203,56 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ DXABLE-ARGS-EQUALP │ │ │ │ │ A SB-KERNEL0 │ │ │ │ │ B SB-KERNEL │ │ │ │ │ ENV-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ Set the name of a compiled function object. Return the function. │ │ │ │ │ -CTRAN-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ +DEADLINE0 │ │ │ │ │ + TIME-LEFT │ │ │ │ │ +Binds NAME as a local function for BODY. Each time #'NAME is called, it │ │ │ │ │ +returns SECONDS minus the time that has elapsed since BODY was entered, or │ │ │ │ │ +zero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME │ │ │ │ │ +returns NIL each time. │ │ │ │ │ +CAPACITY │ │ │ │ │ +DEADLINE │ │ │ │ │ +OVERRIDE │ │ │ │ │ +SECONDS0 │ │ │ │ │ +Arranges for a TIMEOUT condition to be signalled if an operation │ │ │ │ │ +respecting deadlines occurs either after the deadline has passed, or │ │ │ │ │ +would take longer than the time left to complete. │ │ │ │ │ +Currently only SLEEP, blocking IO operations, GET-MUTEX, and │ │ │ │ │ +CONDITION-WAIT respect deadlines, but this includes their implicit │ │ │ │ │ +uses inside SBCL itself. │ │ │ │ │ +Unless OVERRIDE is true, existing deadlines can only be restricted, │ │ │ │ │ +not extended. Deadlines are per thread: children are unaffected by │ │ │ │ │ +their parent's deadlines. │ │ │ │ │ +Experimental. │ │ │ │ │ +Arrange with the garbage collector that OBJECTS will not be moved in memory │ │ │ │ │ +for the duration of BODY. Useful for e.g. foreign calls where another thread │ │ │ │ │ +may trigger garbage collection. │ │ │ │ │ +WITHOUT-GCING-BODY │ │ │ │ │ +Executes the forms in the body without doing a garbage collection. It │ │ │ │ │ +inhibits both automatically and explicitly triggered collections. Finally, │ │ │ │ │ +upon leaving the BODY if gc is not inhibited it runs the pending gc. │ │ │ │ │ +Similarly, if gc is triggered in another thread then it waits until gc is │ │ │ │ │ +enabled in this thread. │ │ │ │ │ +Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested │ │ │ │ │ +SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY. │ │ │ │ │ +Should be used with great care, and not at all in multithreaded application │ │ │ │ │ +code: Any locks that are ever acquired while GC is inhibited need to be always │ │ │ │ │ +held with GC inhibited to prevent deadlocks: if T1 holds the lock and is │ │ │ │ │ +stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the │ │ │ │ │ +system will be deadlocked. Since SBCL does not currently document its internal │ │ │ │ │ +locks, application code can never be certain that this invariant is │ │ │ │ │ +maintained. │ │ │ │ │ +Convenience macro on top of INVOKE-INTERRUPTION. │ │ │ │ │ +Establish a handler with SYSTEM: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 │ │ │ │ │ @@ -34274,14 +34279,16 @@ │ │ │ │ │ ;; 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 ...))) │ │ │ │ │ +CTRAN-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ METHOD-CELL │ │ │ │ │ MORE-ARG │ │ │ │ │ Find a symbol in a package of given string'ified NAME; │ │ │ │ │ unlike CL:FIND-SYMBOL, work well with 'modern' case sensitive syntax │ │ │ │ │ by letting you supply a symbol or keyword for the name; │ │ │ │ │ also works well when the package is not present. │ │ │ │ │ @@ -34360,22 +34367,33 @@ │ │ │ │ │ A SB-KERNEL │ │ │ │ │ LVAR-HOOK-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ LVAR-TYPE-SPEC-ANNOTATION-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ LVAR-PROPER-SEQUENCE-ANNOTATION-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ -LVAR-DEPENDENT-ANNOTATION-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ -LVAR-FUNCTION-DESIGNATOR-ANNOTATION-EQUALP │ │ │ │ │ -A SB-KERNEL │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ +ENVIRONMENT-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +TAIL-SET-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +B SB-KERNEL │ │ │ │ │ +NLX-INFO-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +LEAF-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +BASIC-VAR-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +GLOBAL-VAR-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ +DEFINED-FUN-EQUALP │ │ │ │ │ +A SB-KERNEL │ │ │ │ │ FUNCTIONAL-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ CLAMBDA-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ OPTIONAL-DISPATCH-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ A SB-KERNEL │ │ │ │ │ @@ -34798,18 +34816,14 @@ │ │ │ │ │ PROCESS-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ PRIORITY-QUEUE-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ B SB-KERNEL0 │ │ │ │ │ TIMER-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ -u+(`$0Df │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -FORMAT-ARG2 SB-FORMAT │ │ │ │ │ -COMMON-LISP │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ @@ -34817,17 +34831,14 @@ │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ -SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ │ -redefining DEFTYPE type to be a class: ~// │ │ │ │ │ -Cannot redefine standard type ~//. │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ @@ -34857,14 +34868,16 @@ │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ +redefining DEFTYPE type to be a class: ~// │ │ │ │ │ +Cannot redefine standard type ~//. │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ @@ -34889,26 +34902,30 @@ │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ .NEWVAL. │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ -INSTANCE8 │ │ │ │ │ +u+(`$0Df │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +FORMAT-ARG2 SB-FORMAT │ │ │ │ │ +COMMON-LISP │ │ │ │ │ INPUT-STREAM │ │ │ │ │ UIOP/LAUNCH-PROGRAM0 │ │ │ │ │ OUTPUT-STREAM │ │ │ │ │ UIOP/LAUNCH-PROGRAM0 │ │ │ │ │ fold division by 1 │ │ │ │ │ convert integer division to multiplication │ │ │ │ │ convert division by 2^k to shift │ │ │ │ │ COMMON-LISP │ │ │ │ │ VALUE-TN │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ +INSTANCE8 │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ .NEWVAL. │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ FDEFN SB-KERNEL8 │ │ │ │ │ INSTANCE8 │ │ │ │ │ @@ -35075,14 +35092,41 @@ │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/dumper.lisp │ │ │ │ │ +SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ │ +SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ │ +SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ │ +SYS:SRC;CODE;CMACROS.LISP │ │ │ │ │ +SYS:SRC;CODE;TYPEP.LISP │ │ │ │ │ +OPTIMIZE-DECL │ │ │ │ │ +BEFORE-USES │ │ │ │ │ +SYS:SRC;CODE;STUBS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;ARRAY-TRAN.LISP │ │ │ │ │ +SYS:SRC;CODE;COERCE.LISP │ │ │ │ │ +SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ │ +~@ │ │ │ │ │ +redefining ~// in DEFUN │ │ │ │ │ +redefining ~// in DEFMACRO │ │ │ │ │ +redefining ~// in DEFGENERIC │ │ │ │ │ +~@ │ │ │ │ │ +~@<~@(~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.~@:> │ │ │ │ │ +bytes_allocated │ │ │ │ │ +SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ │ +SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ │ +ARGS-MINIMAL │ │ │ │ │ +WRAPPER3 │ │ │ │ │ +ZO]batiOn │ │ │ │ │ +SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ │ +SYS:SRC;CODE;C-CALL.LISP │ │ │ │ │ +SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -35133,19 +35177,17 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ SEMAPHORE8 │ │ │ │ │ SUBFORMS8 │ │ │ │ │ REST-ARG │ │ │ │ │ 1;N]jwd//x │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ + SLOT-NAME │ │ │ │ │ CLASS-DEFAULT-INITARGS │ │ │ │ │ SUPPLIED │ │ │ │ │ - SLOT-NAME │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ @@ -35172,81 +35214,14 @@ │ │ │ │ │ optimize away possible call to FDEFINITION at runtime │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ -automatically-generated reader method │ │ │ │ │ -automatically-generated writer method │ │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/dumper.lisp │ │ │ │ │ -OPTIMIZE-DECL │ │ │ │ │ -BEFORE-USES │ │ │ │ │ -SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ │ -SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ │ -SYS:SRC;CODE;CMACROS.LISP │ │ │ │ │ -SYS:SRC;CODE;TYPEP.LISP │ │ │ │ │ -SYS:SRC;CODE;STUBS.LISP │ │ │ │ │ -illegal instruction at #X~X │ │ │ │ │ -bus error at #X~X │ │ │ │ │ -automatically-generated makunbound method │ │ │ │ │ -~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 -$ │ │ │ │ │ -~S cannot handle the second argument ~S. │ │ │ │ │ -Backtrace for: ~S │ │ │ │ │ -Skip printing frame ~S │ │ │ │ │ -while printing frame ~S. The partial output is: ~S │ │ │ │ │ -environment argument present and not null │ │ │ │ │ -can't open-code test of non-constant type │ │ │ │ │ -~S~:[~;~:*~S~] │ │ │ │ │ -~S at ~S │ │ │ │ │ -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. │ │ │ │ │ -02# 23 4>Z#7* 22 │ │ │ │ │ -$*$%`-OX%<+J │ │ │ │ │ -~S structure class ~A │ │ │ │ │ -Don't know how to allocate ~S │ │ │ │ │ -Structure slots can't be unbound. │ │ │ │ │ -$Bf^(!5u │ │ │ │ │ -SYS:SRC;COMPILER;ARRAY-TRAN.LISP │ │ │ │ │ -SYS:SRC;CODE;COERCE.LISP │ │ │ │ │ -SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ │ -SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ │ -bytes_allocated │ │ │ │ │ -SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ │ -ARGS-MINIMAL │ │ │ │ │ -ZO]batiOn │ │ │ │ │ -SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ │ -WRAPPER3 │ │ │ │ │ -SYS:SRC;CODE;C-CALL.LISP │ │ │ │ │ -SYS:SRC;CODE;UNIX-FOREIGN-LOAD.LISP │ │ │ │ │ -SYS:SRC;CODE;BARRIER.LISP │ │ │ │ │ -5y5C9b:8;?< │ │ │ │ │ -AJBDC8DnE{FXG │ │ │ │ │ -SYS:SRC;PCL;WRAPPER.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;MOVE.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;TYPE-VOPS.LISP │ │ │ │ │ -SYS:SRC;COMPILER;VMDEF.LISP │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -redefining ~// in DEFUN │ │ │ │ │ -redefining ~// in DEFMACRO │ │ │ │ │ -redefining ~// in DEFGENERIC │ │ │ │ │ -~@ │ │ │ │ │ -~@<~@(~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.~@:> │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ @@ -35269,22 +35244,22 @@ │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONDITION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -Set NAME's global function definition. │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -SB-ALIEN │ │ │ │ │ - SLOT-NAME │ │ │ │ │ - SLOT-NAME │ │ │ │ │ - SLOT-NAME │ │ │ │ │ - SLOT-NAME │ │ │ │ │ +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. │ │ │ │ │ +HASH-TABLE │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +MNEMONIC │ │ │ │ │ +Emit the specified instruction to the current segment. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ STATEMENT │ │ │ │ │ Return the current position for LABEL. Chooser maybe-shrink functions │ │ │ │ │ should supply IF-AFTER and DELTA in order to ensure correct results. │ │ │ │ │ *k_iz`:,q │ │ │ │ │ @@ -35325,17 +35300,75 @@ │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ SB-ALIEN │ │ │ │ │ UNIX-GETITIMER returns the INTERVAL and VALUE slots of one of │ │ │ │ │ three system timers (:real :virtual or :profile). On success, │ │ │ │ │ unix-getitimer returns 5 values, │ │ │ │ │ T, it-interval-secs, it-interval-usec, it-value-secs, it-value-usec. │ │ │ │ │ SB-ALIEN │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +Set NAME's global function definition. │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +SB-ALIEN │ │ │ │ │ + SLOT-NAME │ │ │ │ │ + SLOT-NAME │ │ │ │ │ + SLOT-NAME │ │ │ │ │ + SLOT-NAME │ │ │ │ │ StQ,geKLJ\'| │ │ │ │ │ K}VHOxd-JI │ │ │ │ │ SB-ALIEN │ │ │ │ │ +SYS:SRC;CODE;BARRIER.LISP │ │ │ │ │ +~@ │ │ │ │ │ +~S at ~S │ │ │ │ │ +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. │ │ │ │ │ +02# 23 4>Z#7* 22 │ │ │ │ │ +$*$%`-OX%<+J │ │ │ │ │ +~S structure class ~A │ │ │ │ │ +Don't know how to allocate ~S │ │ │ │ │ +Structure slots can't be unbound. │ │ │ │ │ +$Bf^(!5u │ │ │ │ │ +(~:[~;*~]~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 )Sj │ │ │ │ │ + │ │ │ │ │ +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;I#G(? │ │ │ │ │ ++4+G("%m │ │ │ │ │ +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 │ │ │ │ │ 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 │ │ │ │ │ SB-ALIEN │ │ │ │ │ @@ -35357,37 +35390,16 @@ │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ -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. │ │ │ │ │ -HASH-TABLE │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -MNEMONIC │ │ │ │ │ -Emit the specified instruction to the current segment. │ │ │ │ │ -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) │ │ │ │ │ - * a list of the form (SPECIALIZER-KIND &rest SPECIFIC-SYNTAX) │ │ │ │ │ -* an instance of a subclass of SPECIALIZER │ │ │ │ │ -When SPECIALIZER cannot be parsed/used as a specializer for │ │ │ │ │ -PROTO-GENERIC-FUNCTION and PROTO-METHOD, a STYLE-WARNING is signaled │ │ │ │ │ -and NIL is returned. No type declaration will be generated in this │ │ │ │ │ -NIL can also be returned if SPECIALIZER is valid but its type should │ │ │ │ │ -not be declared, for example for efficiency reasons. │ │ │ │ │ -NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ -protocol. Interface subject to change. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ @@ -35534,29 +35546,14 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -REST-ARG │ │ │ │ │ -REST-ARG │ │ │ │ │ -REST-ARG │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -iRZZ6JD) │ │ │ │ │ -SB-IMPL0 │ │ │ │ │ -SB-IMPL0 │ │ │ │ │ -SB-IMPL0 │ │ │ │ │ -SB-IMPL0 │ │ │ │ │ - NEW-VALUE │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -35570,14 +35567,29 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +REST-ARG │ │ │ │ │ +REST-ARG │ │ │ │ │ +REST-ARG │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +iRZZ6JD) │ │ │ │ │ +SB-IMPL0 │ │ │ │ │ +SB-IMPL0 │ │ │ │ │ +SB-IMPL0 │ │ │ │ │ +SB-IMPL0 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -35784,262 +35796,57 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ -Takes an object and a location holding a list. Conses the object onto │ │ │ │ │ - the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ │ -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 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -(~:[~;*~]~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 )Sj │ │ │ │ │ - │ │ │ │ │ -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;I#G(? │ │ │ │ │ -+4+G("%m │ │ │ │ │ -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 │ │ │ │ │ -~@ │ │ │ │ │ -~d keys, ~d bins │ │ │ │ │ -&7 e8B │ │ │ │ │ -(~D+~D)/~D [~@[~,3f words/sym,~]load=~,1f%] │ │ │ │ │ -structure-object │ │ │ │ │ -compiling │ │ │ │ │ -*7 e8B │ │ │ │ │ -*7 e8B 3 │ │ │ │ │ -SYS:SRC;CODE;SHOW.LISP │ │ │ │ │ -lisp_package_vector │ │ │ │ │ +5y5C9b:8;?< │ │ │ │ │ +AJBDC8DnE{FXG │ │ │ │ │ +SYS:SRC;PCL;WRAPPER.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;MOVE.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;TYPE-VOPS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;VMDEF.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) │ │ │ │ │ + * a list of the form (SPECIALIZER-KIND &rest SPECIFIC-SYNTAX) │ │ │ │ │ +* an instance of a subclass of SPECIALIZER │ │ │ │ │ +When SPECIALIZER cannot be parsed/used as a specializer for │ │ │ │ │ +PROTO-GENERIC-FUNCTION and PROTO-METHOD, a STYLE-WARNING is signaled │ │ │ │ │ +and NIL is returned. No type declaration will be generated in this │ │ │ │ │ +NIL can also be returned if SPECIALIZER is valid but its type should │ │ │ │ │ +not be declared, for example for efficiency reasons. │ │ │ │ │ +NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ +protocol. Interface subject to change. │ │ │ │ │ the current number of recursive LOADs │ │ │ │ │ -SYS:SRC;PCL;ENV.LISP │ │ │ │ │ +SYS:SRC;CODE;SHOW.LISP │ │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UCS.LISP │ │ │ │ │ 3J6+8k8}A │ │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-CYR.LISP │ │ │ │ │ +lisp_package_vector │ │ │ │ │ +SYS:SRC;PCL;ENV.LISP │ │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-MAC.LISP │ │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-UTF.LISP │ │ │ │ │ 4M4P:S@w@ │ │ │ │ │ XXX/cfc~e │ │ │ │ │ W0_U`QbUcSd │ │ │ │ │ SYS:SRC;CODE;FILESYS.LISP │ │ │ │ │ SYS:SRC;CODE;EXTERNAL-FORMATS;ENC-EBCDIC.LISP │ │ │ │ │ +~@ │ │ │ │ │ +~d keys, ~d bins │ │ │ │ │ +&7 e8B │ │ │ │ │ +(~D+~D)/~D [~@[~,3f words/sym,~]load=~,1f%] │ │ │ │ │ +structure-object │ │ │ │ │ +compiling │ │ │ │ │ +*7 e8B │ │ │ │ │ +*7 e8B 3 │ │ │ │ │ #)0&0&0&0=& │ │ │ │ │ internal symbols. │ │ │ │ │ Implements-list │ │ │ │ │ Nicknames │ │ │ │ │ Use-list │ │ │ │ │ Used-by-list │ │ │ │ │ Implemented-by-list │ │ │ │ │ @@ -36213,33 +36020,224 @@ │ │ │ │ │ ~@[next=~S~] │ │ │ │ │ q56*"!*< │ │ │ │ │ ~A on ~:[~;BOGUS ~]descriptor ~W: ~S │ │ │ │ │ +~W~@[ in ~S~] │ │ │ │ │ :SYMBOL ~S │ │ │ │ │ *7 e8B │ │ │ │ │ + ! ! % (Y │ │ │ │ │ -SYS:SRC;CODE;QUERY.LISP │ │ │ │ │ -KV-VECTOR-REHASHING │ │ │ │ │ -REHASHING-STAMP │ │ │ │ │ -OLD-KV-VECTOR │ │ │ │ │ -NEW-KV-VECTOR │ │ │ │ │ -HASH-TABLE-PAIRS-CAPACITY │ │ │ │ │ _jga[a\SPh^X[hvshXIQ │ │ │ │ │ -SYS:SRC;CODE;TARGET-STREAM.LISP │ │ │ │ │ a method lambda list │ │ │ │ │ ~S is a set, not a map │ │ │ │ │ Starting a ~A without a timeout while interrupts are disabled. │ │ │ │ │ ~&=== Starting a ~A without a timeout while interrupts are disabled. === │ │ │ │ │ f%&x(# │ │ │ │ │ -NEW-CELLS │ │ │ │ │ +KV-VECTOR-REHASHING │ │ │ │ │ +REHASHING-STAMP │ │ │ │ │ +SYS:SRC;CODE;QUERY.LISP │ │ │ │ │ +SYS:SRC;CODE;TARGET-STREAM.LISP │ │ │ │ │ +OLD-KV-VECTOR │ │ │ │ │ +NEW-KV-VECTOR │ │ │ │ │ +HASH-TABLE-PAIRS-CAPACITY │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +Takes an object and a location holding a list. Conses the object onto │ │ │ │ │ + the list, returning the modified list. OBJ is evaluated before PLACE. │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ CLEANUP-FUN-1 │ │ │ │ │ +NEW-CELLS │ │ │ │ │ HAS-TRUNCATED-FLAG │ │ │ │ │ -SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ │ -SYS:SRC;CODE;FORMAT-TIME.LISP │ │ │ │ │ -SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ @@ -36852,14 +36850,68 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ +SYS:SRC;CODE;EXTERNAL-FORMATS;MB-UTIL.LISP │ │ │ │ │ +SYS:SRC;CODE;FORMAT-TIME.LISP │ │ │ │ │ +SYS:SRC;CODE;LATE-GLOBALDB.LISP │ │ │ │ │ +LAST-LOSE │ │ │ │ │ +COALESCED │ │ │ │ │ +SYS:SRC;COMPILER;DFO.LISP │ │ │ │ │ +SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ │ +SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ │ +?'FBG?H=I9J │ │ │ │ │ +0 c++++" │ │ │ │ │ +) '& ',^ │ │ │ │ │ +)5l(&/&8&j"# │ │ │ │ │ +)5l(&/&I"&n0 │ │ │ │ │ +/ d(&/&n6 │ │ │ │ │ +, 5o(&a"# │ │ │ │ │ +(333_$+." │ │ │ │ │ +v(&/&j"# │ │ │ │ │ + 5g%&a"# │ │ │ │ │ +" W0&j"# │ │ │ │ │ +7$ (?$ (- │ │ │ │ │ ++ 9 *&j"# │ │ │ │ │ + 5o%&a"# │ │ │ │ │ +gc_card_mark │ │ │ │ │ +&@"&I"&I"&n0 │ │ │ │ │ +&@"&I"&I"&I"&n0 │ │ │ │ │ +** tail-call old-fp in reg not S0 │ │ │ │ │ +** tail-call old-fp not S0 │ │ │ │ │ +nvalues is 1 │ │ │ │ │ + 1d(&e0 │ │ │ │ │ + 1l%&a"# │ │ │ │ │ +;:H@4V"& │ │ │ │ │ ++(((+++" │ │ │ │ │ +1++...."S │ │ │ │ │ ++(((+++" │ │ │ │ │ +1++...."S │ │ │ │ │ ++(((+++$ │ │ │ │ │ +.(((+++$ │ │ │ │ │ +_oXONwax │ │ │ │ │ +gUvrgUlETE │ │ │ │ │ +WRRNgqCcT │ │ │ │ │ +encountered the non-standard lambda list keyword ~S │ │ │ │ │ +q[uXl`pOae| │ │ │ │ │ +31#[d[Xds\ │ │ │ │ │ +[d[Xdsbdd │ │ │ │ │ +jit-code.txt │ │ │ │ │ +~&; Logging code allocation to ~S │ │ │ │ │ +~&New code(~Db,~A): ~A │ │ │ │ │ +load TN allocated, but no move function?~@ │ │ │ │ │ + VM definition is inconsistent, recompile and try again. │ │ │ │ │ +SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ │ +SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ │ +$&%B%X%m& │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ @@ -37124,92 +37176,476 @@ │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ -SYS:SRC;COMPILER;DFO.LISP │ │ │ │ │ -SYS:SRC;COMPILER;CALLABLE-ARGS.LISP │ │ │ │ │ -SYS:SRC;COMPILER;ENTRY.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;STATIC-SYMS.LISP │ │ │ │ │ -SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ │ -?'FBG?H=I9J │ │ │ │ │ -LAST-LOSE │ │ │ │ │ -COALESCED │ │ │ │ │ -load TN allocated, but no move function?~@ │ │ │ │ │ - VM definition is inconsistent, recompile and try again. │ │ │ │ │ -0 c++++" │ │ │ │ │ -) '& ',^ │ │ │ │ │ -)5l(&/&8&j"# │ │ │ │ │ -)5l(&/&I"&n0 │ │ │ │ │ -/ d(&/&n6 │ │ │ │ │ -, 5o(&a"# │ │ │ │ │ -(333_$+." │ │ │ │ │ -v(&/&j"# │ │ │ │ │ - 5g%&a"# │ │ │ │ │ -" W0&j"# │ │ │ │ │ -7$ (?$ (- │ │ │ │ │ -+ 9 *&j"# │ │ │ │ │ - 5o%&a"# │ │ │ │ │ -gc_card_mark │ │ │ │ │ -&@"&I"&I"&n0 │ │ │ │ │ -&@"&I"&I"&I"&n0 │ │ │ │ │ -** tail-call old-fp in reg not S0 │ │ │ │ │ -** tail-call old-fp not S0 │ │ │ │ │ -nvalues is 1 │ │ │ │ │ - 1d(&e0 │ │ │ │ │ - 1l%&a"# │ │ │ │ │ -;:H@4V"& │ │ │ │ │ -+(((+++" │ │ │ │ │ -1++...."S │ │ │ │ │ -+(((+++" │ │ │ │ │ -1++...."S │ │ │ │ │ -+(((+++$ │ │ │ │ │ -.(((+++$ │ │ │ │ │ -SYS:SRC;COMPILER;LOOP.LISP │ │ │ │ │ -SYS:SRC;COMPILER;REPRESENT.LISP │ │ │ │ │ -$&%B%X%m& │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ + BIT-ARRAY │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +MORE-ARG │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ + READTABLE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +MORE-ARG │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +HOST SB-KERNEL │ │ │ │ │ + SB-KERNEL8 │ │ │ │ │ +TRANSLATIONS │ │ │ │ │ +Set the translations list for the logical host argument. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +SEQUENCE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE8 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + READTABLE │ │ │ │ │ +COMMON-LISP8&gZ │ │ │ │ │ +Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE. │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +PATHNAME │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +SB-ALIEN │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + READTABLE │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +Sets the READTABLE-NORMALIZATION of the given READTABLE to NEW-VALUE. │ │ │ │ │ +Pass T to make READTABLE normalize symbols to NFKC (the default behavior), │ │ │ │ │ +and NIL to suppress normalization. │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +CATEGORY │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +The argument is a location holding a list. Pops one item off the front │ │ │ │ │ + of the list and returns it. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ SYS:SRC;COMPILER;ENVANAL.LISP │ │ │ │ │ SYS:SRC;COMPILER;STACK.LISP │ │ │ │ │ SYS:SRC;COMPILER;GTN.LISP │ │ │ │ │ SYS:SRC;COMPILER;PACK.LISP │ │ │ │ │ -_oXONwax │ │ │ │ │ -gUvrgUlETE │ │ │ │ │ -WRRNgqCcT │ │ │ │ │ -encountered the non-standard lambda list keyword ~S │ │ │ │ │ -q[uXl`pOae| │ │ │ │ │ -31#[d[Xds\ │ │ │ │ │ -[d[Xdsbdd │ │ │ │ │ -jit-code.txt │ │ │ │ │ -~&; Logging code allocation to ~S │ │ │ │ │ -~&New code(~Db,~A): ~A │ │ │ │ │ +ORIGINAL-KIND │ │ │ │ │ +Argument and/or result bit arrays are not the same length:~ │ │ │ │ │ + ~% ~S~% ~S ~% ~S │ │ │ │ │ +LAST-POP │ │ │ │ │ +LEXICAL-DEF │ │ │ │ │ +BLOCK-DELETE-P │ │ │ │ │ +FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ │ +SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ │ +$s%H(++|/ │ │ │ │ │ +USE-HOME │ │ │ │ │ +JUMPTABLE-WORD │ │ │ │ │ ~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? │ │ │ │ │ +TEMPLATE-CONDITIONAL-P │ │ │ │ │ +SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ │ address ~X not in the code component ~S │ │ │ │ │ ; Jump table (~d entries) @ ~X │ │ │ │ │ ; ~vt~v,'02x = ~a │ │ │ │ │ because │ │ │ │ │ The object file ~A is~@ │ │ │ │ │ older than the presumed source:~% ~A. │ │ │ │ │ load object file │ │ │ │ │ load source file │ │ │ │ │ attempt to load an empty FASL file: │ │ │ │ │ -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. │ │ │ │ │ -ORIGINAL-KIND │ │ │ │ │ -Argument and/or result bit arrays are not the same length:~ │ │ │ │ │ - ~% ~S~% ~S ~% ~S │ │ │ │ │ -LAST-POP │ │ │ │ │ +t]R]oN{XbxQ │ │ │ │ │ +~S structure class │ │ │ │ │ +~Aconstructor │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +tKS[^\tKR[[oQd │ │ │ │ │ +unknown TRACE option: ~S │ │ │ │ │ +Replace the function binding │ │ │ │ │ X|!bMXg) │ │ │ │ │ }T*4p]1>< │ │ │ │ │ n>S7Auh7 │ │ │ │ │ T*4p]1>< │ │ │ │ │ }T*4p*W │ │ │ │ │ 4"YsOpG6 │ │ │ │ │ Rrvcgvg w │ │ │ │ │ @@ -37805,582 +38241,63 @@ │ │ │ │ │ qRr,'KHY │ │ │ │ │ tr`^m"R6 │ │ │ │ │ r|t."@rSU │ │ │ │ │ ^,=(Q,gD │ │ │ │ │ h]m2_]rxc] │ │ │ │ │ |8wfyQS8 │ │ │ │ │ H>p|[by6 │ │ │ │ │ -LEXICAL-DEF │ │ │ │ │ -BLOCK-DELETE-P │ │ │ │ │ -FUNCTIONAL-KIND-ATTRIBUTES │ │ │ │ │ -USE-HOME │ │ │ │ │ -SYS:SRC;PCL;COMPILER-SUPPORT.LISP │ │ │ │ │ -$s%H(++|/ │ │ │ │ │ -JUMPTABLE-WORD │ │ │ │ │ -TEMPLATE-CONDITIONAL-P │ │ │ │ │ -SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ - BIT-ARRAY │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -MORE-ARG │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ - READTABLE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -MORE-ARG │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -HOST SB-KERNEL │ │ │ │ │ - SB-KERNEL8 │ │ │ │ │ -TRANSLATIONS │ │ │ │ │ -Set the translations list for the logical host argument. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -SEQUENCE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE8 │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - READTABLE │ │ │ │ │ -COMMON-LISP8&gZ │ │ │ │ │ -Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE. │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -PATHNAME │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -SB-ALIEN │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - READTABLE │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -Sets the READTABLE-NORMALIZATION of the given READTABLE to NEW-VALUE. │ │ │ │ │ -Pass T to make READTABLE normalize symbols to NFKC (the default behavior), │ │ │ │ │ -and NIL to suppress normalization. │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -CATEGORY │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -The argument is a location holding a list. Pops one item off the front │ │ │ │ │ - of the list and returns it. │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -CLASSOID SB-KERNEL │ │ │ │ │ - FRAGMENTS │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ +U`m< │ │ │ │ │ +WS7Auh7v │ │ │ │ │ +}U~A+%vg) │ │ │ │ │ +loading ~S │ │ │ │ │ +loading stuff from ~S │ │ │ │ │ +;;;;;;;;;;;;;;;; │ │ │ │ │ +non-FIXNUM non-NULL location in cell: ~S │ │ │ │ │ +updating obsolete instance │ │ │ │ │ +can't understand something in the arglist ~S │ │ │ │ │ +lisp_init_function │ │ │ │ │ +tot_gc_nsec │ │ │ │ │ +gc_coalesce_string_literals │ │ │ │ │ +SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ │ SYS:SRC;COMPILER;GENERIC;LATE-NLX.LISP │ │ │ │ │ SYS:SRC;ASSEMBLY;X86;SUPPORT.LISP │ │ │ │ │ SYS:SRC;COMPILER;X86;NLX.LISP │ │ │ │ │ SYS:SRC;COMPILER;X86;ALLOC.LISP │ │ │ │ │ SYS:SRC;CODE;ICF.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;MACROS.LISP │ │ │ │ │ SYS:SRC;COMPILER;TYPE-VOP-MACROS.LISP │ │ │ │ │ -lisp_init_function │ │ │ │ │ -tot_gc_nsec │ │ │ │ │ -gc_coalesce_string_literals │ │ │ │ │ +SYS:SRC;COMPILER;X86;ARRAY.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;SAP.LISP │ │ │ │ │ Dynamic space │ │ │ │ │ Text space │ │ │ │ │ Read-only space │ │ │ │ │ Static space │ │ │ │ │ Control stack │ │ │ │ │ Binding stack │ │ │ │ │ WRAPPER4 │ │ │ │ │ -SYS:SRC;COMPILER;X86;ARRAY.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;SAP.LISP │ │ │ │ │ SYS:SRC;CODE;MISC.LISP │ │ │ │ │ SYS:SRC;CODE;LINUX-OS.LISP │ │ │ │ │ -t]R]oN{XbxQ │ │ │ │ │ -~S structure class │ │ │ │ │ -~Aconstructor │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -tKS[^\tKR[[oQd │ │ │ │ │ -unknown TRACE option: ~S │ │ │ │ │ -U`m< │ │ │ │ │ -WS7Auh7v │ │ │ │ │ -}U~A+%vg) │ │ │ │ │ -loading ~S │ │ │ │ │ -loading stuff from ~S │ │ │ │ │ -;;;;;;;;;;;;;;;; │ │ │ │ │ -non-FIXNUM non-NULL location in cell: ~S │ │ │ │ │ -updating obsolete instance │ │ │ │ │ -can't understand something in the arglist ~S │ │ │ │ │ -dummy macro │ │ │ │ │ -Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ │ SYS:SRC;CODE;FUNUTILS.LISP │ │ │ │ │ SYS:SRC;CODE;NTRACE.LISP │ │ │ │ │ ~S outside of a effective method form │ │ │ │ │ -KV-VECTOR-SUPPLEMENT │ │ │ │ │ -SYS:SRC;CODE;QUANTIFIERS.LISP │ │ │ │ │ -Character-Tabulation-With-Justification │ │ │ │ │ -Start-Selected-Area │ │ │ │ │ -Start-Guarded-Area │ │ │ │ │ -Line-Tabulation-Set │ │ │ │ │ -Message-Waiting │ │ │ │ │ -Single-Shift-Three │ │ │ │ │ -Single-Character-Introducer │ │ │ │ │ -Privacy-Message │ │ │ │ │ -Break-Permitted │ │ │ │ │ -Cancel-Character │ │ │ │ │ -Character-Tabulation-Set │ │ │ │ │ -Formfeed │ │ │ │ │ -End-Guarded-Area │ │ │ │ │ -Control-Sequence-Introducer │ │ │ │ │ -No-Break-Permitted │ │ │ │ │ -Private-Use-One │ │ │ │ │ -Linefeed │ │ │ │ │ -Device-Control-String │ │ │ │ │ -End-Selected-Area │ │ │ │ │ -Private-Use-Two │ │ │ │ │ -Application-Program-Command │ │ │ │ │ -Operating-System-Command │ │ │ │ │ -Start-String │ │ │ │ │ -Single-Shift-Two │ │ │ │ │ -Next-Line │ │ │ │ │ -Partial-Line-Forward │ │ │ │ │ -Reverse-Linefeed │ │ │ │ │ -Set-Transmit-State │ │ │ │ │ -Partial-Line-Backward │ │ │ │ │ -String-Terminator │ │ │ │ │ -SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ │ -SYS:SRC;CODE;WEAK.LISP │ │ │ │ │ -SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ │ -Superclass of all Gray input streams whose element-type │ │ │ │ │ -is a subtype of character. │ │ │ │ │ -Superclass of all Gray output streams. │ │ │ │ │ -Superclass of all Gray streams whose element-type │ │ │ │ │ -is a subtype of unsigned-byte or signed-byte. │ │ │ │ │ -dynamic_space_size │ │ │ │ │ -Superclass of all Gray output streams whose element-type │ │ │ │ │ -is a subtype of character. │ │ │ │ │ -Superclass of all Gray 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. │ │ │ │ │ -Superclass of all Gray input streams whose element-type │ │ │ │ │ -is a subtype of unsigned-byte or signed-byte. │ │ │ │ │ -SYS:SRC;CODE;UNCROSS.LISP │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ │ -SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ │ -SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ │ -*a,X.B/&1 │ │ │ │ │ -SYS:SRC;PCL;WALK.LISP │ │ │ │ │ -Deprecation Conditions │ │ │ │ │ -Saving a Core Image │ │ │ │ │ -SYS:SRC;PCL;DLISP3.LISP │ │ │ │ │ -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. │ │ │ │ │ -Returns a sequence iterator for SEQUENCE or, if START and/or END │ │ │ │ │ - are supplied, the subsequence bounded by START and END as nine │ │ │ │ │ - values: │ │ │ │ │ - 1. iterator state │ │ │ │ │ - 2. limit │ │ │ │ │ - 3. from-end │ │ │ │ │ - 4. step function │ │ │ │ │ - 5. endp function │ │ │ │ │ - 6. element function │ │ │ │ │ - 7. setf element function │ │ │ │ │ - 8. index function │ │ │ │ │ - 9. copy state function │ │ │ │ │ - If FROM-END is NIL, the constructed iterator visits the specified │ │ │ │ │ - elements in the order in which they appear in SEQUENCE. Otherwise, │ │ │ │ │ - the elements are visited in the opposite order. │ │ │ │ │ -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. │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +CLASSOID SB-KERNEL │ │ │ │ │ + FRAGMENTS │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ .ANONYMOUS. │ │ │ │ │ Tests if STRING is normalized to FORM │ │ │ │ │ xBAUUumB │ │ │ │ │ OPERANDS │ │ │ │ │ MNEMONIC │ │ │ │ │ OPERANDS │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -38432,15 +38349,14 @@ │ │ │ │ │ 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. │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ -OBJECT SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -38498,153 +38414,185 @@ │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -REST-ARG │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -REST-ARG │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -REST-ARG │ │ │ │ │ -SPECIALIZER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -CONSTRUCTOR │ │ │ │ │ -REST-ARG │ │ │ │ │ -REST-ARG │ │ │ │ │ -REST-ARG │ │ │ │ │ -.NEXT-METHOD-CALL. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -DIRECT-SLOTDS │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SPECIALIZER │ │ │ │ │ -SIGNED-IMM-BYTE.PREFILTER │ │ │ │ │ -SIGNED-IMM-DATA.PREFILTER │ │ │ │ │ -ACCUM.PRINTER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -ASDF/SYSTEM │ │ │ │ │ -REST-ARG │ │ │ │ │ -Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but do not update the │ │ │ │ │ -system or its dependencies if it has already been loaded. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ +OBJECT SB-KERNEL0 │ │ │ │ │ +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 │ │ │ │ │ +Privacy-Message │ │ │ │ │ +Break-Permitted │ │ │ │ │ +Cancel-Character │ │ │ │ │ +Character-Tabulation-Set │ │ │ │ │ +Formfeed │ │ │ │ │ +End-Guarded-Area │ │ │ │ │ +Control-Sequence-Introducer │ │ │ │ │ +No-Break-Permitted │ │ │ │ │ +Private-Use-One │ │ │ │ │ +Linefeed │ │ │ │ │ +Device-Control-String │ │ │ │ │ +End-Selected-Area │ │ │ │ │ +Private-Use-Two │ │ │ │ │ +Application-Program-Command │ │ │ │ │ +Operating-System-Command │ │ │ │ │ +Start-String │ │ │ │ │ +Single-Shift-Two │ │ │ │ │ +Next-Line │ │ │ │ │ +Partial-Line-Forward │ │ │ │ │ +Reverse-Linefeed │ │ │ │ │ +Set-Transmit-State │ │ │ │ │ +Partial-Line-Backward │ │ │ │ │ +String-Terminator │ │ │ │ │ +dynamic_space_size │ │ │ │ │ +SYS:SRC;CODE;BIGNUM-RANDOM.LISP │ │ │ │ │ +SYS:SRC;CODE;WEAK.LISP │ │ │ │ │ +SYS:SRC;CODE;DESCRIBE-POLICY.LISP │ │ │ │ │ +Superclass of all Gray input streams whose element-type │ │ │ │ │ +is a subtype of character. │ │ │ │ │ +Superclass of all Gray output streams. │ │ │ │ │ +Superclass of all Gray streams whose element-type │ │ │ │ │ +is a subtype of unsigned-byte or signed-byte. │ │ │ │ │ +Superclass of all Gray output streams whose element-type │ │ │ │ │ +is a subtype of character. │ │ │ │ │ +Superclass of all Gray 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. │ │ │ │ │ +Superclass of all Gray input streams whose element-type │ │ │ │ │ +is a subtype of unsigned-byte or signed-byte. │ │ │ │ │ +SYS:SRC;CODE;UNCROSS.LISP │ │ │ │ │ +SYS:SRC;CODE;PARSE-BODY.LISP │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;PINNED-OBJECTS.LISP │ │ │ │ │ +SYS:SRC;PCL;PRECOM2.LISP │ │ │ │ │ +*a,X.B/&1 │ │ │ │ │ +SYS:SRC;PCL;WALK.LISP │ │ │ │ │ +dummy macro │ │ │ │ │ +Bogus slot-cell in SET-SLOT-VALUE: ~S │ │ │ │ │ +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 │ │ │ │ │ UbQgg`mZ │ │ │ │ │ result type unsuitable │ │ │ │ │ RESULT-TYPE argument not constant │ │ │ │ │ can't analyze sequence type relationship │ │ │ │ │ non-trivial :KEY or :TEST │ │ │ │ │ 5%,.($(> │ │ │ │ │ +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. │ │ │ │ │ +Returns a sequence iterator for SEQUENCE or, if START and/or END │ │ │ │ │ + are supplied, the subsequence bounded by START and END as nine │ │ │ │ │ + values: │ │ │ │ │ + 1. iterator state │ │ │ │ │ + 2. limit │ │ │ │ │ + 3. from-end │ │ │ │ │ + 4. step function │ │ │ │ │ + 5. endp function │ │ │ │ │ + 6. element function │ │ │ │ │ + 7. setf element function │ │ │ │ │ + 8. index function │ │ │ │ │ + 9. copy state function │ │ │ │ │ + If FROM-END is NIL, the constructed iterator visits the specified │ │ │ │ │ + elements in the order in which they appear in SEQUENCE. Otherwise, │ │ │ │ │ + the elements are visited in the opposite order. │ │ │ │ │ +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. │ │ │ │ │ V\^jbebp │ │ │ │ │ wrong number of arguments; expected ~W, got ~W │ │ │ │ │ can't tell function type at compile time │ │ │ │ │ -~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ │ ~S doesn't have a precise float representation. │ │ │ │ │ The RATIONAL value isn't known at compile time. │ │ │ │ │ +Deprecation Conditions │ │ │ │ │ +Saving a Core Image │ │ │ │ │ +SYS:SRC;PCL;DLISP3.LISP │ │ │ │ │ +SYS:SRC;PCL;SLOT-NAME.LISP │ │ │ │ │ +~S called with non-nil :VALUE that isn't the current thread. │ │ │ │ │ cannot use optimized accessor in safe code │ │ │ │ │ Cannot make slot ~S in ~S unbound. │ │ │ │ │ slot name is not an interned symbol │ │ │ │ │ can't tell the rank at compile time │ │ │ │ │ -attempt to emit ~S a second time │ │ │ │ │ -Alignment ~S needs more space now? It was ~W, and is ~W now. │ │ │ │ │ -~S shrunk by ~W bytes, but claimed that it preserves ~W bits of alignment. │ │ │ │ │ -~S emitted ~W bytes, but claimed its max was ~W. │ │ │ │ │ -Chooser ~S passed, but not before emitting ~W bytes. │ │ │ │ │ -~S emitted ~W bytes, but claimed it was ~W. │ │ │ │ │ -IN-WITHOUT-SCHEDULING │ │ │ │ │ -No encoder for ~S │ │ │ │ │ FUNCTION doc-type is not supported. │ │ │ │ │ ~2&Assembler input: │ │ │ │ │ ~:@(~A~) ~{~A~^, ~}~A │ │ │ │ │ # Unused labels: │ │ │ │ │ # end of input │ │ │ │ │ # postit ~S~A │ │ │ │ │ # ~{~@[~A~^, ~]~} │ │ │ │ │ (notused) │ │ │ │ │ ~A~{~A: ~}~A │ │ │ │ │ -pv table index lock │ │ │ │ │ -Specializer lock │ │ │ │ │ -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;PCL;SLOT-NAME.LISP │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -2K#"&%6- │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ │ -:GENERIC-FUNCTION-CLASS argument │ │ │ │ │ -:METHOD-CLASS argument │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -No applicable method found for ~S │ │ │ │ │ -No primary method found for ~S among applicable methods: ~S │ │ │ │ │ ZM0%#tXK! │ │ │ │ │ 1.0.11.18 │ │ │ │ │ Load the fasl file anyway │ │ │ │ │ FOP stack underflow │ │ │ │ │ xRUUtRTT │ │ │ │ │ ~&~6x : [~D,~D] ~2,'0x~v@{ ~x~} │ │ │ │ │ ~35t~(~a~) │ │ │ │ │ corrupt fasl file: FOP code #x~x │ │ │ │ │ ~&; While loading ~S: │ │ │ │ │ -cannot load assembler code except at cold load │ │ │ │ │ -fasl stack not empty when it should be │ │ │ │ │ -fasl table of improper size │ │ │ │ │ -~S loaded │ │ │ │ │ -tNQQnNNN │ │ │ │ │ -Compute a method lambda form based on METHOD-LAMBDA, possibly │ │ │ │ │ -taking into account PROTO-GENERIC-FUNCTION, PROTO-METHOD, QUALIFIERS, │ │ │ │ │ -SPECIALIZERS and ENVIRONMENT. │ │ │ │ │ -Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ │ -uninitialized. However, their classes and prototypes can be inspected. │ │ │ │ │ -SPECIALIZERS is a list of specializer objects (i.e. parsed). │ │ │ │ │ -Return three values: │ │ │ │ │ -1. the created method lambda form │ │ │ │ │ -2. initargs for the method instance │ │ │ │ │ -3. a (possibly modified) unspecialized method lambda list or nil if │ │ │ │ │ - the unspecialized lambda list contained in METHOD-LAMBDA should be │ │ │ │ │ -NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ -protocol. Interface subject to change. │ │ │ │ │ -Return a form which, when evaluated in the lexical environment │ │ │ │ │ -described by ENVIRONMENT, parses the specializer SPECIALIZER-NAME and │ │ │ │ │ -yields the appropriate specializer object. │ │ │ │ │ -Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ │ -uninitialized. However their classes and prototypes can be │ │ │ │ │ -inspected. │ │ │ │ │ -NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ -protocol. Interface subject to change. │ │ │ │ │ -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. │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +2K#"&%6- │ │ │ │ │ +pv table index lock │ │ │ │ │ +Specializer lock │ │ │ │ │ ~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 ~//.~:@> │ │ │ │ │ +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. │ │ │ │ │ +SIGNED-IMM-BYTE.PREFILTER │ │ │ │ │ +SIGNED-IMM-DATA.PREFILTER │ │ │ │ │ +ACCUM.PRINTER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +REST-ARG │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +REST-ARG │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +REST-ARG │ │ │ │ │ +SPECIALIZER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +CONSTRUCTOR │ │ │ │ │ +REST-ARG │ │ │ │ │ +REST-ARG │ │ │ │ │ +REST-ARG │ │ │ │ │ +.NEXT-METHOD-CALL. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +DIRECT-SLOTDS │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +SPECIALIZER │ │ │ │ │ +ASDF/SYSTEM │ │ │ │ │ +REST-ARG │ │ │ │ │ +Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but do not update the │ │ │ │ │ +system or its dependencies if it has already been loaded. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ SLOT-NAME0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ NEW-CLASS │ │ │ │ │ REST-ARG │ │ │ │ │ +iiY+SN-.Ib( │ │ │ │ │ @@ -38679,14 +38627,71 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ fmt$34QLWU │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ DOC-TYPE │ │ │ │ │ NEW-VALUE │ │ │ │ │ COMPONENT │ │ │ │ │ OPERATION │ │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ │ +~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ │ +Compute a method lambda form based on METHOD-LAMBDA, possibly │ │ │ │ │ +taking into account PROTO-GENERIC-FUNCTION, PROTO-METHOD, QUALIFIERS, │ │ │ │ │ +SPECIALIZERS and ENVIRONMENT. │ │ │ │ │ +Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ │ +uninitialized. However, their classes and prototypes can be inspected. │ │ │ │ │ +SPECIALIZERS is a list of specializer objects (i.e. parsed). │ │ │ │ │ +Return three values: │ │ │ │ │ +1. the created method lambda form │ │ │ │ │ +2. initargs for the method instance │ │ │ │ │ +3. a (possibly modified) unspecialized method lambda list or nil if │ │ │ │ │ + the unspecialized lambda list contained in METHOD-LAMBDA should be │ │ │ │ │ +NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ +protocol. Interface subject to change. │ │ │ │ │ +Return a form which, when evaluated in the lexical environment │ │ │ │ │ +described by ENVIRONMENT, parses the specializer SPECIALIZER-NAME and │ │ │ │ │ +yields the appropriate specializer object. │ │ │ │ │ +Both PROTO-GENERIC-FUNCTION and PROTO-METHOD may be │ │ │ │ │ +uninitialized. However their classes and prototypes can be │ │ │ │ │ +inspected. │ │ │ │ │ +NOTE: This generic function is part of an SBCL-specific experimental │ │ │ │ │ +protocol. Interface subject to change. │ │ │ │ │ +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. │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@<~S is not a legal specializer for ~S.~@:> │ │ │ │ │ +:GENERIC-FUNCTION-CLASS argument │ │ │ │ │ +:METHOD-CLASS argument │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +No applicable method found for ~S │ │ │ │ │ +No primary method found for ~S among applicable methods: ~S │ │ │ │ │ +a_dgRVaX │ │ │ │ │ +WaWR\fmj │ │ │ │ │ +cannot load assembler code except at cold load │ │ │ │ │ +fasl stack not empty when it should be │ │ │ │ │ +fasl table of improper size │ │ │ │ │ +~S loaded │ │ │ │ │ +tNQQnNNN │ │ │ │ │ +Non-list or improper list spliced in ~ │ │ │ │ │ + the middle of a backquoted list. │ │ │ │ │ fmt$183UB1 │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ FROM-END │ │ │ │ │ ITERATOR │ │ │ │ │ @@ -38700,25 +38705,14 @@ │ │ │ │ │ NEW-VALUE │ │ │ │ │ ITERATOR │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ SUPERCLASS │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ -It has a slot ~//, while ~// is requested. │ │ │ │ │ -~//, slot:~S, ~:S │ │ │ │ │ -~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ │ -Element-type: ~// │ │ │ │ │ -a_dgRVaX │ │ │ │ │ -WaWR\fmj │ │ │ │ │ -Non-list or improper list spliced in ~ │ │ │ │ │ - the middle of a backquoted list. │ │ │ │ │ -Got to T branch in ~S │ │ │ │ │ -ELEMENT-TYPE is not constant. │ │ │ │ │ -can't compile TYPEP of anonymous or undefined class: │ │ │ │ │ fmt$2N2MUH │ │ │ │ │ fmt$346S │ │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ NUMBER-REQUIRED0 │ │ │ │ │ SPECIALIZED-POSITIONS │ │ │ │ │ @@ -38759,14 +38753,18 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ │ COMPONENT │ │ │ │ │ ,&p]UU+S │ │ │ │ │ REST-ARG │ │ │ │ │ SEQUENCE │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ +It has a slot ~//, while ~// is requested. │ │ │ │ │ +~//, slot:~S, ~:S │ │ │ │ │ +~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ │ +Element-type: ~// │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ fmt$8HA6GR │ │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ 4l\M3e U=Z │ │ │ │ │ @@ -39049,65 +39047,77 @@ │ │ │ │ │ Z^OYS+W9 │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEW-VALUE │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ METAOBJECT │ │ │ │ │ +REHASH-STAMP-ELT │ │ │ │ │ +NEW-STAMP │ │ │ │ │ +called NATIVE-NAMESTRING using a ~ │ │ │ │ │ + logical host: ~S │ │ │ │ │ =7_Ud#T1mv7 │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ -REHASH-STAMP-ELT │ │ │ │ │ -NEW-STAMP │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ SPECIALIZERS │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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 │ │ │ │ │ ASMSTREAM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -8;-AZ 0< │ │ │ │ │ -8;-AZ 0< │ │ │ │ │ -called NATIVE-NAMESTRING using a ~ │ │ │ │ │ - logical host: ~S │ │ │ │ │ -PKGNICK-INDEX-BITS │ │ │ │ │ -MISS-FN- │ │ │ │ │ SYS:SRC;COMPILER;POLICIES.LISP │ │ │ │ │ +PKGNICK-INDEX-BITS │ │ │ │ │ called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ │ logical host: ~S │ │ │ │ │ +ELEMENT-TYPE is not constant. │ │ │ │ │ +can't compile TYPEP of anonymous or undefined class: │ │ │ │ │ +Function is not TRACEd: ~S │ │ │ │ │ +cerror trap │ │ │ │ │ +function end breakpoint trap │ │ │ │ │ +halt trap │ │ │ │ │ +pending interrupt trap │ │ │ │ │ +breakpoint trap │ │ │ │ │ +Got to T branch in ~S │ │ │ │ │ +Could not insert ~S:~S to supposedly empty ~S. │ │ │ │ │ +~@ │ │ │ │ │ +~S with non-constant EMF ~S │ │ │ │ │ +~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 │ │ │ │ │ +MISS-FN- │ │ │ │ │ +NODE-BLOCK │ │ │ │ │ CLEANUP-FUN-19 │ │ │ │ │ WITHOUT-INTERRUPTS-BODY-1 │ │ │ │ │ CLEANUP-FUN-10 │ │ │ │ │ CLEANUP-FUN-2 │ │ │ │ │ -NODE-BLOCK │ │ │ │ │ +8;-AZ 0< │ │ │ │ │ +8;-AZ 0< │ │ │ │ │ HN0DQ,Q0 │ │ │ │ │ HN0DQ,Q0 │ │ │ │ │ yYj7C/wh │ │ │ │ │ ,E3A,J'w │ │ │ │ │ )18x,%fl │ │ │ │ │ NOINFNAN │ │ │ │ │ -~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ │ -~@ │ │ │ │ │ %gai057g │ │ │ │ │ WITHIN-RANGE │ │ │ │ │ │ │ │ │ │ +~@<~// already names an ordinary function or a macro.~@:> │ │ │ │ │ U3/adXXad │ │ │ │ │ Unexpectedly small N-RANDOM-CHUNK-BITS │ │ │ │ │ e#(+-** ) 8j │ │ │ │ │ $%!5]Y\XeXXs@YXX │ │ │ │ │ ZZZZwdi`\ │ │ │ │ │ UB~D-BASH-COPY │ │ │ │ │ +START-LVAR │ │ │ │ │ RMYANCB_V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ │ -BINDINGS │ │ │ │ │ -CONSTANT SB-KERNEL0 │ │ │ │ │ - CLASS-ARG │ │ │ │ │ -CLASS-OR-NAME8 │ │ │ │ │ -NUMBER-MATCHABLE-P8 │ │ │ │ │ -ONLY-INITIAL-ENTRIES0 │ │ │ │ │ -b-t/-o"e │ │ │ │ │ -6#kG1NoBw │ │ │ │ │ - vBGj'pe │ │ │ │ │ Backspace │ │ │ │ │ COMMON-LISP │ │ │ │ │ -FUN-NAME │ │ │ │ │ + CLASS-ARG │ │ │ │ │ +CLASS-OR-NAME8 │ │ │ │ │ +LAMBDA-LIST │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ NEW-VALUE │ │ │ │ │ -LAMBDA-LIST │ │ │ │ │ V7PUs03Sd>w │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ -SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ │ -START-LVAR │ │ │ │ │ -CLEANUP-FUN-11 │ │ │ │ │ -WITHOUT-GCING-BODY-10 │ │ │ │ │ -WITHOUT-GCING-BODY-0 │ │ │ │ │ -unable to avoid inline argument range check │ │ │ │ │ -because the argument range (~S) was not within 2^63 │ │ │ │ │ -,gZWh]gzv\cT │ │ │ │ │ -~S is an illegal control arg to BOOLE. │ │ │ │ │ -BOOLE code is not a constant. │ │ │ │ │ -array bounds unknown │ │ │ │ │ -~@ │ │ │ │ │ -The array has dimensions ~S, ~W is too large. │ │ │ │ │ -The array dimensions are unknown; must call ARRAY-DIMENSION at runtime. │ │ │ │ │ -The axis is not constant. │ │ │ │ │ -The operands might not be the same type. │ │ │ │ │ -Implements CL:CONCATENATE for extended sequences. │ │ │ │ │ - RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:CONCATENATE │ │ │ │ │ - but receives a prototype instance of an extended sequence class │ │ │ │ │ - instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ │ - methods on this generic function specify how extended sequence │ │ │ │ │ - classes act when they are specified as the result type in a │ │ │ │ │ - CL:CONCATENATE call. RESULT-PROTOTYPE may not be fully initialized │ │ │ │ │ - and thus should only be used for dispatch and to determine its │ │ │ │ │ - class. │ │ │ │ │ -Returns the element at position INDEX of SEQUENCE or signals a │ │ │ │ │ - PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not │ │ │ │ │ - implemented for the class of SEQUENCE. │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ +FUN-NAME │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ }3\5v%ZT │ │ │ │ │ -CDR-OF-FORM │ │ │ │ │ -QUALIFIERS │ │ │ │ │ OPERATION │ │ │ │ │ PPRINT-DISPATCH │ │ │ │ │ COMMON-LISP │ │ │ │ │ PRIORITY8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ CTYPE SB-KERNEL │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ TYPE-SPEC │ │ │ │ │ +6#kG1NoBw │ │ │ │ │ + vBGj'pe │ │ │ │ │ g ,gKs33R$ │ │ │ │ │ -METHOD-ARGS │ │ │ │ │ -PV-TABLE0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -LOCATION0 │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - SLOT-NAME │ │ │ │ │ -FILL-PTR │ │ │ │ │ -NEW-BUFFER8 │ │ │ │ │ -NEW-LENGTH │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - METATYPES │ │ │ │ │ -Pys'(PFP │ │ │ │ │ +CLEANUP-FUN-11 │ │ │ │ │ +WITHOUT-GCING-BODY-10 │ │ │ │ │ +WITHOUT-GCING-BODY-0 │ │ │ │ │ +Implements CL:CONCATENATE for extended sequences. │ │ │ │ │ + RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:CONCATENATE │ │ │ │ │ + but receives a prototype instance of an extended sequence class │ │ │ │ │ + instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ │ + methods on this generic function specify how extended sequence │ │ │ │ │ + classes act when they are specified as the result type in a │ │ │ │ │ + CL:CONCATENATE call. RESULT-PROTOTYPE may not be fully initialized │ │ │ │ │ + and thus should only be used for dispatch and to determine its │ │ │ │ │ + class. │ │ │ │ │ +Returns the element at position INDEX of SEQUENCE or signals a │ │ │ │ │ + PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not │ │ │ │ │ + implemented for the class of SEQUENCE. │ │ │ │ │ +SYS:SRC;COMPILER;GENERIC;TYPE-VOPS.LISP │ │ │ │ │ +SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ │ +SYS:SRC;PCL;ECD.LISP │ │ │ │ │ +Default number of frames to backtrace. Defaults to 1000. │ │ │ │ │ +Determines how frames corresponding to method functions are represented in │ │ │ │ │ +backtraces. Possible values are :MINIMAL, :NORMAL, and :FULL. │ │ │ │ │ + :MINIMAL represents them as │ │ │ │ │ + ( ...args...) │ │ │ │ │ + if all arguments are available, and only a single method is applicable to │ │ │ │ │ + the arguments -- otherwise behaves as :NORMAL. │ │ │ │ │ + :NORMAL represents them as │ │ │ │ │ + ((:method [*] (*)) ...args...) │ │ │ │ │ + The frame is then followed by either [fast-method] or [slow-method], │ │ │ │ │ + designating the kind of method function. (See below.) │ │ │ │ │ + :FULL represents them using the actual funcallable method function name: │ │ │ │ │ + ((sb-pcl:fast-method [*] (*)) ...args...) │ │ │ │ │ + ((sb-pcl:slow-method [*] (*)) ...args...) │ │ │ │ │ + In the this case arguments may include values internal to SBCL's method │ │ │ │ │ + dispatch machinery. │ │ │ │ │ +unable to avoid inline argument range check │ │ │ │ │ +because the argument range (~S) was not within 2^63 │ │ │ │ │ +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 │ │ │ │ │ +unexpected special form ~S │ │ │ │ │ +["2L++ *H │ │ │ │ │ +,gZWh]gzv\cT │ │ │ │ │ +~S is an illegal control arg to BOOLE. │ │ │ │ │ +BOOLE code is not a constant. │ │ │ │ │ +array bounds unknown │ │ │ │ │ +~@ │ │ │ │ │ +The array has dimensions ~S, ~W is too large. │ │ │ │ │ +The array dimensions are unknown; must call ARRAY-DIMENSION at runtime. │ │ │ │ │ +The axis is not constant. │ │ │ │ │ +WRAPPER6 │ │ │ │ │ +The operands might not be the same type. │ │ │ │ │ The dimension list is not constant; cannot open code array creation. │ │ │ │ │ ~S is not a ~S. │ │ │ │ │ ~@<~S is not a ~S (which is the ~S of ~S).~@:> │ │ │ │ │ ELEMENT-TYPE ~s is not a known type │ │ │ │ │ Can't specify :DISPLACED-TO and ~S │ │ │ │ │ :DISPLACED-TO potentially used with ~S │ │ │ │ │ SAP-REF- │ │ │ │ │ @@ -39263,96 +39281,95 @@ │ │ │ │ │ U[tr`n`p\ │ │ │ │ │ IJJn\eedgZ │ │ │ │ │ Uknown upgraded array element type of the result │ │ │ │ │ The function doesn't have a fixed argument count. │ │ │ │ │ second argument type too vague │ │ │ │ │ ~S is an unknown vector type │ │ │ │ │ ~S ~S is not a ~S │ │ │ │ │ +auxiliary │ │ │ │ │ This shouldn't happen. │ │ │ │ │ The type is not constant at compile time; can't open code. │ │ │ │ │ -CLEANUP-FUN-43 │ │ │ │ │ -CLEANUP-FUN-31 │ │ │ │ │ -CLEANUP-FUN-16 │ │ │ │ │ Aliens of type ~S cannot be represented immediately. │ │ │ │ │ The alien type is not constant, so access cannot be open coded. │ │ │ │ │ [X^TX[XXXR^ │ │ │ │ │ [X^TX[XXXR^ │ │ │ │ │ -auxiliary │ │ │ │ │ -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 │ │ │ │ │ +CLEANUP-FUN-43 │ │ │ │ │ +CLEANUP-FUN-31 │ │ │ │ │ +CLEANUP-FUN-16 │ │ │ │ │ missing arg │ │ │ │ │ -Default number of frames to backtrace. Defaults to 1000. │ │ │ │ │ -Determines how frames corresponding to method functions are represented in │ │ │ │ │ -backtraces. Possible values are :MINIMAL, :NORMAL, and :FULL. │ │ │ │ │ - :MINIMAL represents them as │ │ │ │ │ - ( ...args...) │ │ │ │ │ - if all arguments are available, and only a single method is applicable to │ │ │ │ │ - the arguments -- otherwise behaves as :NORMAL. │ │ │ │ │ - :NORMAL represents them as │ │ │ │ │ - ((:method [*] (*)) ...args...) │ │ │ │ │ - The frame is then followed by either [fast-method] or [slow-method], │ │ │ │ │ - designating the kind of method function. (See below.) │ │ │ │ │ - :FULL represents them using the actual funcallable method function name: │ │ │ │ │ - ((sb-pcl:fast-method [*] (*)) ...args...) │ │ │ │ │ - ((sb-pcl:slow-method [*] (*)) ...args...) │ │ │ │ │ - In the this case arguments may include values internal to SBCL's method │ │ │ │ │ - dispatch machinery. │ │ │ │ │ -Could not insert ~S:~S to supposedly empty ~S. │ │ │ │ │ -~@ │ │ │ │ │ -~S with non-constant EMF ~S │ │ │ │ │ -~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 │ │ │ │ │ -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 │ │ │ │ │ -unexpected special form ~S │ │ │ │ │ -["2L++ *H │ │ │ │ │ +The RESTP argument is not constant. │ │ │ │ │ ]YikNXp^ggd^ │ │ │ │ │ Something strange where symbol or class expected. │ │ │ │ │ ~@<~S of ~S is neither ~S nor a ~S.~@:> │ │ │ │ │ No SLOT-INFO for ~S in ~S │ │ │ │ │ -Component name: designator for a string composed of portable pathname characters │ │ │ │ │ -SYS:SRC;CODE;UNICODE-NORM.LISP │ │ │ │ │ -SYS:SRC;PCL;ECD.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ │ +early method with no method-function │ │ │ │ │ +Retry calling the generic function. │ │ │ │ │ +REST-ARG │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +OLD-CONS0 │ │ │ │ │ +w>Ks33R$ │ │ │ │ │ +Pys'(PFP │ │ │ │ │ + METATYPES │ │ │ │ │ + METATYPES │ │ │ │ │ + METATYPES │ │ │ │ │ +GENERIC-FUNCTION │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +METHOD-ARGS │ │ │ │ │ +PV-TABLE0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +LOCATION0 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + SLOT-NAME │ │ │ │ │ + COMPONENT │ │ │ │ │ +Return a path from a root system to the COMPONENT. │ │ │ │ │ +The return value is a list of component NAMES; a list of strings. │ │ │ │ │ +A readable data structure that identifies the action. │ │ │ │ │ +STRINGS0 │ │ │ │ │ +REST-ARG │ │ │ │ │ +Concatenate strings. │ │ │ │ │ +NIL is interpreted as an empty string, a character as a string of length one. │ │ │ │ │ + COMPONENT │ │ │ │ │ + OPERATION0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +NEW-BUFFER │ │ │ │ │ +NEW-BUFFER-SIZE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + ALIGNMENT8 │ │ │ │ │ +MAYBE-SHRINK0 │ │ │ │ │ +WORST-CASE-FUN │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +MNEMONIC0 │ │ │ │ │ +OPERANDS │ │ │ │ │ +PREDECESSOR8 │ │ │ │ │ convert to inline logical operations │ │ │ │ │ COMMON-LISP │ │ │ │ │ CLASSOID SB-KERNEL8 │ │ │ │ │ open code │ │ │ │ │ expand inline │ │ │ │ │ FROM-END │ │ │ │ │ 5%,3\8$ │ │ │ │ │ -WRAPPER6 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ inline non-SIMPLE-vector-handling logic │ │ │ │ │ SB-ALIEN │ │ │ │ │ SB-ALIEN │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ - METATYPES │ │ │ │ │ - METATYPES │ │ │ │ │ -GENERIC-FUNCTION │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ Conditional constant folding │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ DIMENSION │ │ │ │ │ RETURN-TYPE │ │ │ │ │ strength reduce large variable right shift │ │ │ │ │ Convert %ASH/RIGHT by constant back to ASH │ │ │ │ │ COMMON-LISP │ │ │ │ │ +open-code INTEGER to RATIO comparison │ │ │ │ │ +open-code RATIONAL to FLOAT comparison │ │ │ │ │ +invert or open code │ │ │ │ │ +open-code FLOAT to RATIONAL comparison │ │ │ │ │ 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 │ │ │ │ │ its own special values, based on SB-EXT:*DEBUG-PRINT-VARIABLE-ALIST*. │ │ │ │ │ @@ -39398,116 +39415,21 @@ │ │ │ │ │ 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.) │ │ │ │ │ -open-code INTEGER to RATIO comparison │ │ │ │ │ -open-code RATIONAL to FLOAT comparison │ │ │ │ │ -invert or open code │ │ │ │ │ -open-code FLOAT to RATIONAL comparison │ │ │ │ │ - COMPONENT │ │ │ │ │ -Return a path from a root system to the COMPONENT. │ │ │ │ │ -The return value is a list of component NAMES; a list of strings. │ │ │ │ │ -A readable data structure that identifies the action. │ │ │ │ │ -STRINGS0 │ │ │ │ │ -REST-ARG │ │ │ │ │ -Concatenate strings. │ │ │ │ │ -NIL is interpreted as an empty string, a character as a string of length one. │ │ │ │ │ - COMPONENT │ │ │ │ │ - OPERATION0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -NEW-BUFFER │ │ │ │ │ -NEW-BUFFER-SIZE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - ALIGNMENT8 │ │ │ │ │ -MAYBE-SHRINK0 │ │ │ │ │ -WORST-CASE-FUN │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -MNEMONIC0 │ │ │ │ │ -OPERANDS │ │ │ │ │ -PREDECESSOR8 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -INITARGS │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -1#]}>F6n │ │ │ │ │ -$@+n7S&f │ │ │ │ │ -ENVIRONMENT │ │ │ │ │ -KEYWORDS-AND-FORMS │ │ │ │ │ -UNIVERSE │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -PATTERN0 │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -APPLICATOR │ │ │ │ │ -OPCODES1 │ │ │ │ │ -OPCODES2 │ │ │ │ │ -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 │ │ │ │ │ -ATTRIBUTES │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -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-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 │ │ │ │ │ -early method with no method-function │ │ │ │ │ -Retry calling the generic function. │ │ │ │ │ . X gY\ │ │ │ │ │ \ h XtO │ │ │ │ │ More than one method of type ~S ~ │ │ │ │ │ with the same specializers. │ │ │ │ │ ~@<~S of ~S is not a ~S.~@:> │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ -The RESTP argument is not constant. │ │ │ │ │ -[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ │ -illegal kind argument to ~S: ~S │ │ │ │ │ -kqbkwhuXRae^[X][U │ │ │ │ │ Not a property list: ~S │ │ │ │ │ The key for the last case arg to mcase was not T │ │ │ │ │ a define-method-combination arguments lambda list │ │ │ │ │ The class │ │ │ │ │ follows the class │ │ │ │ │ in the supers of the class │ │ │ │ │ appears in the supers of the class │ │ │ │ │ @@ -39517,16 +39439,14 @@ │ │ │ │ │ there ~A in the local precedence relations.~@ │ │ │ │ │ ~A because:~{~% ~A~}. │ │ │ │ │ These arise │ │ │ │ │ are circularities │ │ │ │ │ :8++p.M;b │ │ │ │ │ Remove all methods. │ │ │ │ │ ~@ │ │ │ │ │ -SYS:SRC;PCL;DLISP.LISP │ │ │ │ │ -~@ │ │ │ │ │ ^aaf[d^] │ │ │ │ │ No ~S methods. │ │ │ │ │ EFFECTIVE-METHOD-GENSYM- │ │ │ │ │ ~@<~S, in ~S ~S, is not a ~S.~@:> │ │ │ │ │ ~@<~S of ~S is an improper list.~@:> │ │ │ │ │ ~@ │ │ │ │ │ no way to determine the lambda list for ~S │ │ │ │ │ @@ -39540,48 +39460,180 @@ │ │ │ │ │ by following │ │ │ │ │ the direct superclass chain through: │ │ │ │ │ ending at the class │ │ │ │ │ The class ~A is a forward referenced class.~@ │ │ │ │ │ The class ~A is ~A. │ │ │ │ │ a direct superclass of the class │ │ │ │ │ The class ~A is a forward referenced class. │ │ │ │ │ +[dXRVewpYab^UtnWPYbWPLShWj │ │ │ │ │ +illegal kind argument to ~S: ~S │ │ │ │ │ +kqbkwhuXRae^[X][U │ │ │ │ │ +Invalid eq-p argument: ~S │ │ │ │ │ ~@ │ │ │ │ │ # │ │ │ │ │ @> 54,"$2Am2$47'). │ │ │ │ │ methods matching one of the patterns: │ │ │ │ │ methods matching the pattern: │ │ │ │ │ N9%$!Klq │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ In the method group specifier ~S, │ │ │ │ │ ~S isn't a valid qualifier pattern. │ │ │ │ │ ANY-KEYP │ │ │ │ │ +SYS:SRC;PCL;DLISP.LISP │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +PATTERN0 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +APPLICATOR │ │ │ │ │ +OPCODES1 │ │ │ │ │ +OPCODES2 │ │ │ │ │ +FILL-PTR │ │ │ │ │ +NEW-BUFFER8 │ │ │ │ │ +NEW-LENGTH │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +INITARGS │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +1#]}>F6n │ │ │ │ │ +$@+n7S&f │ │ │ │ │ +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 │ │ │ │ │ +ATTRIBUTES │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +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-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 │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +TABLE-INDEX │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +FASL-INPUT │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +TABLE08g% │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +HASH-TABLE │ │ │ │ │ +COMMON-LISP81g │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +TBL-SLOT │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +TBL-SLOT │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +TBL-SLOT │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ + SLOT-NAME │ │ │ │ │ +VALUE0Pg! │ │ │ │ │ +FASL-INPUT │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +PACKAGE-NAME │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +FASL-INPUT │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +STACK09g% │ │ │ │ │ +FASL-INPUT │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ + CHAR-CODE │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +N-BYTES0 │ │ │ │ │ +.FASL-INPUT.0 │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +.FASL-INPUT.0 │ │ │ │ │ +.FASL-INPUT. │ │ │ │ │ +NEW-VECTOR8 │ │ │ │ │ +OLD-VECTOR │ │ │ │ │ LIST-INITARG- │ │ │ │ │ PATHNAME-INITARG- │ │ │ │ │ BIT-VECTOR-INITARG- │ │ │ │ │ STRING-INITARG- │ │ │ │ │ hURPY\hhjYhURPY\hhjXZXp` │ │ │ │ │ SLOT requested for metatype ~S, but it isn't going to happen. │ │ │ │ │ ~@ │ │ │ │ │ -Invalid eq-p argument: ~S │ │ │ │ │ -nY\[Y[[hknX │ │ │ │ │ -^b^UhgXXPY[XXPLShWj │ │ │ │ │ WRAPPER- │ │ │ │ │ Every metatype is T. │ │ │ │ │ ~S is not a type. │ │ │ │ │ __d\ t X t │ │ │ │ │ slot optimization bewilderment: O-I-A │ │ │ │ │ ~@ │ │ │ │ │ ~s can't be used as a slot option │ │ │ │ │ Slot initarg name ~S for slot ~S in DEFCLASS ~S is not a symbol. │ │ │ │ │ Duplicate slot option ~S for slot ~S in DEFCLASS ~S. │ │ │ │ │ Slot reader name ~S for slot ~S in DEFCLASS ~S is not a symbol. │ │ │ │ │ '$3/"/S2{ -$" │ │ │ │ │ ~@<~S, in ~S ~S, is not a non-~S atom.~@:> │ │ │ │ │ -SPECIALIZER-COUNT │ │ │ │ │ / │ │ │ │ │ a keyword │ │ │ │ │ not a symbol │ │ │ │ │ +nY\[Y[[hknX │ │ │ │ │ +^b^UhgXXPY[XXPLShWj │ │ │ │ │ +^b^UhnW\YbW\LShWj │ │ │ │ │ e(P" " │ │ │ │ │ ~@ │ │ │ │ │ pTLL~ga^pv^ │ │ │ │ │ Weird location in ~S │ │ │ │ │ ~@ │ │ │ │ │ the method has ~A required arguments than the generic function. │ │ │ │ │ the method and generic function differ in whether they accept~_~ │ │ │ │ │ @@ -39618,27 +39673,24 @@ │ │ │ │ │ ~:(~A~) function~@[ for ~S~] not yet initialized. │ │ │ │ │ No generic function named ~S. │ │ │ │ │ ~@ │ │ │ │ │ i^YPP`Ri^YPP`NdP │ │ │ │ │ oUVQO^Zm │ │ │ │ │ UVQik^Z[^ │ │ │ │ │ Cannot make structure slots unbound │ │ │ │ │ -^b^UhnW\YbW\LShWj │ │ │ │ │ ^b^UhgPY[PnWd[ps │ │ │ │ │ C,'6(&&ffu8((,2"6 │ │ │ │ │ operation. │ │ │ │ │ operation │ │ │ │ │ resetting │ │ │ │ │ configuration. │ │ │ │ │ _.=6__X2$8 │ │ │ │ │ .A%" 0#> │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ +SYS:SRC;COMPILER;X86;TARGET-INSTS.LISP │ │ │ │ │ +SYS:SRC;CODE;SOLIST.LISP │ │ │ │ │ METHOD-LAMBDA │ │ │ │ │ PROTO-GF │ │ │ │ │ PROTO-METHOD │ │ │ │ │ LAMBDA-LIST │ │ │ │ │ PROTO-GF │ │ │ │ │ SPECIALIZERS │ │ │ │ │ ENVIRONMENT │ │ │ │ │ @@ -39657,80 +39709,29 @@ │ │ │ │ │ INITARGS │ │ │ │ │ METHOD-LAMBDA │ │ │ │ │ $zk|nf t │ │ │ │ │ APPLICABLE-METHODS0 │ │ │ │ │ NEW-VALUE0 │ │ │ │ │ .GOOD-NEW-VALUE. │ │ │ │ │ NEW-VALUE │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -TABLE-INDEX │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -FASL-INPUT │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -TABLE08g% │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -HASH-TABLE │ │ │ │ │ -COMMON-LISP81g │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -TBL-SLOT │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -TBL-SLOT │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -TBL-SLOT │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ - SLOT-NAME │ │ │ │ │ -VALUE0Pg! │ │ │ │ │ -FASL-INPUT │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -PACKAGE-NAME │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -FASL-INPUT │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -STACK09g% │ │ │ │ │ -FASL-INPUT │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ - CHAR-CODE │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -N-BYTES0 │ │ │ │ │ -.FASL-INPUT.0 │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -.FASL-INPUT.0 │ │ │ │ │ -.FASL-INPUT. │ │ │ │ │ -NEW-VECTOR8 │ │ │ │ │ -OLD-VECTOR │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ TBL-SLOT │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ TABLE-SIZE │ │ │ │ │ +R1% .$"t │ │ │ │ │ +;%G%Zi03 (#),* │ │ │ │ │ +,#3;((P"_ │ │ │ │ │ + ^'!65 W │ │ │ │ │ +>5 Q/F │ │ │ │ │ +$@ 5 \!#6 5 n@ │ │ │ │ │ +$; 5 [ │ │ │ │ │ +SKIPPING │ │ │ │ │ +no unbounded alternate for SC ~S │ │ │ │ │ +SPECIALIZER-COUNT │ │ │ │ │ +~@ │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ FUN-INDEX │ │ │ │ │ Ss@K)f;!) │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ DEPTHOID │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -39741,40 +39742,73 @@ │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ COMMON-LISP │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ TBL-SLOT │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ .FASL-INPUT. │ │ │ │ │ ARG-NAMES │ │ │ │ │ -R1% .$"t │ │ │ │ │ -;%G%Zi03 (#),* │ │ │ │ │ -,#3;((P"_ │ │ │ │ │ - ^'!65 W │ │ │ │ │ ->5 Q/F │ │ │ │ │ -$@ 5 \!#6 5 n@ │ │ │ │ │ -$; 5 [ │ │ │ │ │ -SKIPPING │ │ │ │ │ -no unbounded alternate for SC ~S │ │ │ │ │ -SYS:SRC;CODE;SOLIST.LISP │ │ │ │ │ CONSTANTS │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ +ENVIRONMENT │ │ │ │ │ +KEYWORDS-AND-FORMS │ │ │ │ │ +UNIVERSE │ │ │ │ │ SB-DISASSEM0 │ │ │ │ │ SB-DISASSEM │ │ │ │ │ +MORE-ARG │ │ │ │ │ +MORE-ARG │ │ │ │ │ +Component name: designator for a string composed of portable pathname characters │ │ │ │ │ +autom4te.cache │ │ │ │ │ +cover_db │ │ │ │ │ +SYS:SRC;PCL;FSC.LISP │ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ │ LAMBDA-LIST │ │ │ │ │ LAMBDA-LIST0 │ │ │ │ │ -MORE-ARG │ │ │ │ │ -MORE-ARG │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +FUN-NAME │ │ │ │ │ +COMMON-LISP │ │ │ │ │ WRAPPER8"g │ │ │ │ │ COMMON-LISP │ │ │ │ │ +COMBINE-WITH │ │ │ │ │ +PREVIOUS │ │ │ │ │ +ARG-INFO0 │ │ │ │ │ + LINE-SIZE │ │ │ │ │ +VECTOR-LENGTH │ │ │ │ │ +ARG-INFO │ │ │ │ │ +GENERIC-FUNCTION │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +5dUBnNIUe │ │ │ │ │ +ARG-INFO │ │ │ │ │ +EARLY-METHOD0Dg! │ │ │ │ │ COMMON-LISP │ │ │ │ │ -SYS:SRC;PCL;FSC.LISP │ │ │ │ │ -autom4te.cache │ │ │ │ │ -cover_db │ │ │ │ │ +GENERIC-FUNCTION │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +])p {N/< │ │ │ │ │ +LENGTH-CHECKED-P8 │ │ │ │ │ +Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ │ +fold identity operation │ │ │ │ │ +(Z(}(D)a/02 │ │ │ │ │ +SYS:SRC;COMPILER;X86;MEMORY.LISP │ │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ASSEM-RTNS.LISP │ │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ARITH.LISP │ │ │ │ │ +SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;VALUES.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;SUBPRIM.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ │ +SYS:SRC;COMPILER;X86;SHOW.LISP │ │ │ │ │ +SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ │ +,h2E │ │ │ │ │ +Repacked a block due to TN unpacking. │ │ │ │ │ +The width of instruction bytes. │ │ │ │ │ +the default value for the :ENCAPSULATE option to TRACE │ │ │ │ │ +the default value for the :REPORT option to TRACE │ │ │ │ │ +MORE-ARG │ │ │ │ │ +recode as leas, shifts and adds │ │ │ │ │ *6L(E:qh# │ │ │ │ │ SC ~S doesn't have any :UNBOUNDED alternate SCs, but is │ │ │ │ │ a SC for primitive-type ~S. │ │ │ │ │ SC ~S doesn't have any :UNBOUNDED alternate SCs. │ │ │ │ │ failed to pack restricted TN ~S in its SC ~S │ │ │ │ │ ~&; Size: ~a bytes. Origin: #x~x~@[ (segment 1 of ~D)~] │ │ │ │ │ ~&; Origin #x~x (segment ~D of ~D) │ │ │ │ │ @@ -39785,71 +39819,80 @@ │ │ │ │ │ ~S is already TRACE'd, untracing it first. │ │ │ │ │ :WHEREIN name ~S is not a defined global function. │ │ │ │ │ tracing shared code for ~S: │ │ │ │ │ missing argument to ~S TRACE option │ │ │ │ │ ~S is not a valid ~A ~S type. │ │ │ │ │ ~@ │ │ │ │ │ GGGGAGAGAGGGGGGGGGGGGAGGGG2 │ │ │ │ │ -Output-partial-line called when nothing can be output. │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ The tag :A appears more than once in a tagbody. │ │ │ │ │ ~@ │ │ │ │ │ +Continue using :external-format :default │ │ │ │ │ +~@ │ │ │ │ │ ~@ │ │ │ │ │ Can't bind a global variable: ~S │ │ │ │ │ Can't bind constant symbol: ~S │ │ │ │ │ ~@ │ │ │ │ │ 4O0A"%5i │ │ │ │ │ -~@ │ │ │ │ │ -Repacked a block due to TN unpacking. │ │ │ │ │ -The width of instruction bytes. │ │ │ │ │ -the default value for the :ENCAPSULATE option to TRACE │ │ │ │ │ -the default value for the :REPORT option to TRACE │ │ │ │ │ -(Z(}(D)a/02 │ │ │ │ │ -SYS:SRC;COMPILER;X86;MEMORY.LISP │ │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ASSEM-RTNS.LISP │ │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ARITH.LISP │ │ │ │ │ -SYS:SRC;ASSEMBLY;X86;ALLOC.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;VALUES.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;SUBPRIM.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;DEBUG.LISP │ │ │ │ │ -SYS:SRC;COMPILER;X86;SHOW.LISP │ │ │ │ │ -SYS:SRC;COMPILER;PSEUDO-VOPS.LISP │ │ │ │ │ -LENGTH-CHECKED-P8 │ │ │ │ │ -Fold mask-signed-field/mask-signed-field of constant width │ │ │ │ │ -fold identity operation │ │ │ │ │ -recode as leas, shifts and adds │ │ │ │ │ -FUN-NAME │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ │ optimize to inlined RANDOM-CHUNK operations │ │ │ │ │ Use inline float operations. │ │ │ │ │ 7i>pSs}b0k │ │ │ │ │ convert to simpler equality predicate │ │ │ │ │ associate LOGIOR/(LOGIOR) of constants │ │ │ │ │ -RMYANCB_ │ │ │ │ │ -V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ associate +/(+ -) of constants │ │ │ │ │ check for iteration variable reoptimization │ │ │ │ │ RESULT-TYPE │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ convert (- 0 x) to negate │ │ │ │ │ associate LOGTEST/(LOGAND) of constants │ │ │ │ │ -,h2E │ │ │ │ │ SEQUENCE-TYPE0 │ │ │ │ │ -MORE-ARG │ │ │ │ │ APPEND-ARGS0 │ │ │ │ │ LIST-ARGS │ │ │ │ │ +RMYANCB_ │ │ │ │ │ +V-8QXZ()7695JUITGPFKOHED21430WSL │ │ │ │ │ +~@ │ │ │ │ │ EOF-ERROR-P │ │ │ │ │ convert NTH to CAxxR │ │ │ │ │ associate LOGXOR/(LOGXOR) of constants │ │ │ │ │ CHAR-BAG │ │ │ │ │ SB-IMPL0?'"A │ │ │ │ │ +FRAME-DESIGNATOR │ │ │ │ │ +o!(`$0G> │ │ │ │ │ +Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ │ +Returns the last value returned by FUNCTION. │ │ │ │ │ +COUNT is the number of frames to backtrace, defaulting to │ │ │ │ │ +*BACKTRACE-FRAME-COUNT*. │ │ │ │ │ +START is the number of the frame the backtrace should start from. │ │ │ │ │ +FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ │ +values are an explicit SB-DI:FRAME object, and the │ │ │ │ │ +keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ │ +is :DEBUGGER-FRAME. │ │ │ │ │ + :CURRENT-FRAME │ │ │ │ │ + specifies the caller of MAP-BACKTRACE. │ │ │ │ │ + :INTERRUPTED-FRAME │ │ │ │ │ + specifies the first interrupted frame on the stack (typically the frame │ │ │ │ │ + where the error occurred, as opposed to error handling frames) if any, │ │ │ │ │ + otherwise behaving as :CURRENT-FRAME. │ │ │ │ │ + :DEBUGGER-FRAME │ │ │ │ │ + specifies the currently debugged frame when inside the debugger, and │ │ │ │ │ + behaves as :INTERRUPTED-FRAME outside the debugger. │ │ │ │ │ +REST-ARG │ │ │ │ │ +BINDINGS │ │ │ │ │ +NEW-INDENT │ │ │ │ │ +OLD-INDENT1 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 g3 │ │ │ │ │ +:KE(p$ D │ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ │ CONTROL8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ ARRAY-TYPE SB-KERNEL │ │ │ │ │ COMMON-LISP │ │ │ │ │ RESULT-CTYPE │ │ │ │ │ SEQ-NAMES │ │ │ │ │ constant-fold INTEGER to RATIO comparison │ │ │ │ │ @@ -39862,22 +39905,22 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ M?$sMM^0 │ │ │ │ │ EOF-ERROR-P │ │ │ │ │ COMMON-LISP │ │ │ │ │ convert NTHCDR to CAxxR │ │ │ │ │ 9(FE{N3DF │ │ │ │ │ SEQS-NAMES │ │ │ │ │ +This should be eliminated as dead code. │ │ │ │ │ convert to EQ test │ │ │ │ │ ARRAY-TYPE SB-KERNEL0 │ │ │ │ │ recode as an ODDP check │ │ │ │ │ recode as multiplication or sqrt │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ COMMON-LISP │ │ │ │ │ associate LOGAND/(LOGAND) of constants │ │ │ │ │ -This should be eliminated as dead code. │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ REQUESTED-TYPE0 │ │ │ │ │ CHAR-BAG │ │ │ │ │ SB-IMPL0?'"B │ │ │ │ │ ARRAY-TYPE SB-KERNEL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ SLOT-TYPE │ │ │ │ │ @@ -39886,41 +39929,44 @@ │ │ │ │ │ ALIEN-TYPE │ │ │ │ │ SB-ALIEN-INTERNALS │ │ │ │ │ ELEMENT-TYPE │ │ │ │ │ TARGET-TYPE8Lg │ │ │ │ │ precompute external-format lookup │ │ │ │ │ EXTERNAL-FORMAT │ │ │ │ │ XF-DESIGNATOR │ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +DATA-START │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE 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-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ -DATA-START │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -40168,124 +40214,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ -SRC-SIZE │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ │ -~@ │ │ │ │ │ -REST-ARG │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SIZE8+g% │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -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 │ │ │ │ │ -SIZE8,g! │ │ │ │ │ -SIZE8,g! │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -"kW0333q │ │ │ │ │ -STACK-DELTA0 │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SIZE8&g$ │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -DESTINATION │ │ │ │ │ -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 │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -SEGMENT0 │ │ │ │ │ -.ANONYMOUS. │ │ │ │ │ -MARK-INDEX │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -40469,69 +40405,14 @@ │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ -COMBINE-WITH │ │ │ │ │ -PREVIOUS │ │ │ │ │ -ARG-INFO0 │ │ │ │ │ - LINE-SIZE │ │ │ │ │ -VECTOR-LENGTH │ │ │ │ │ -ARG-INFO │ │ │ │ │ -GENERIC-FUNCTION │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -5dUBnNIUe │ │ │ │ │ -ARG-INFO │ │ │ │ │ -EARLY-METHOD0Dg! │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -GENERIC-FUNCTION │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -])p {N/< │ │ │ │ │ -FRAME-DESIGNATOR │ │ │ │ │ -o!(`$0G> │ │ │ │ │ -Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ │ -Returns the last value returned by FUNCTION. │ │ │ │ │ -COUNT is the number of frames to backtrace, defaulting to │ │ │ │ │ -*BACKTRACE-FRAME-COUNT*. │ │ │ │ │ -START is the number of the frame the backtrace should start from. │ │ │ │ │ -FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ │ -values are an explicit SB-DI:FRAME object, and the │ │ │ │ │ -keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ │ -is :DEBUGGER-FRAME. │ │ │ │ │ - :CURRENT-FRAME │ │ │ │ │ - specifies the caller of MAP-BACKTRACE. │ │ │ │ │ - :INTERRUPTED-FRAME │ │ │ │ │ - specifies the first interrupted frame on the stack (typically the frame │ │ │ │ │ - where the error occurred, as opposed to error handling frames) if any, │ │ │ │ │ - otherwise behaving as :CURRENT-FRAME. │ │ │ │ │ - :DEBUGGER-FRAME │ │ │ │ │ - specifies the currently debugged frame when inside the debugger, and │ │ │ │ │ - behaves as :INTERRUPTED-FRAME outside the debugger. │ │ │ │ │ -REST-ARG │ │ │ │ │ -BINDINGS │ │ │ │ │ -NEW-INDENT │ │ │ │ │ -OLD-INDENT1 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 g3 │ │ │ │ │ -:KE(p$ D │ │ │ │ │ -H)HIU'ke │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -MORE-ARG │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP1 │ │ │ │ │ - COMPONENT │ │ │ │ │ -Has the given COMPONENT been successfully loaded in the current image (yet)? │ │ │ │ │ -Note that this returns true even if the component is not up to date. │ │ │ │ │ -Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details. │ │ │ │ │ -BINDINGS │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ @@ -40549,63 +40430,44 @@ │ │ │ │ │ QUALIFIERS0:g │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ CLASSES-LIST │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEW-CLASS │ │ │ │ │ COMMON-LISP │ │ │ │ │ -VU\Y\eem │ │ │ │ │ -Continue using :external-format :default │ │ │ │ │ -~@ │ │ │ │ │ -ignoring unknown optimization quality ~S in ~S │ │ │ │ │ -~@ │ │ │ │ │ -Tried to set a symbol-macrolet! │ │ │ │ │ -[PM^hN[P │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ Handling of Types │ │ │ │ │ &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. │ │ │ │ │ Overwriting already existing readtable ~S. │ │ │ │ │ When set, avoid calling INVOKE-DEBUGGER recursively when errors occur while │ │ │ │ │ executing in the debugger. │ │ │ │ │ Should the debugger display beginner-oriented help messages? │ │ │ │ │ *READTABLE* for the debugger │ │ │ │ │ If the trace indentation exceeds this value, then indentation restarts at │ │ │ │ │ the increase in trace indentation at each call level │ │ │ │ │ This is T while in the debugger. │ │ │ │ │ -&(1,g o │ │ │ │ │ -") )g │ │ │ │ │ - $","("()@ │ │ │ │ │ -/7&!"@#"@ │ │ │ │ │ -R7z+1F@*b │ │ │ │ │ -:555?<<1F7F │ │ │ │ │ -XV │ │ │ │ │ -YVl\VVVVi_YYoX │ │ │ │ │ -C'#K54i(W8@ │ │ │ │ │ -;; loading file │ │ │ │ │ -;; loading system │ │ │ │ │ - /%/(%+" │ │ │ │ │ -UY]RYck`` │ │ │ │ │ -Not a variable declaration the walker cares about: ~S │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ named ~// │ │ │ │ │ New lambda-list ~// is incompatible with existing methods of ~S. │ │ │ │ │ Old lambda-list ~// │ │ │ │ │ -HASH-KEYS │ │ │ │ │ -HASH-VALUES │ │ │ │ │ -EXTERNAL-SYMBOL │ │ │ │ │ -PRESENT-SYMBOL │ │ │ │ │ -PRESENT-SYMBOLS │ │ │ │ │ ~//~:[~:; ~:S~] │ │ │ │ │ ~@ │ │ │ │ │ ~@ │ │ │ │ │ SI-AROUND │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ +~@ │ │ │ │ │ +ignoring unknown optimization quality ~S in ~S │ │ │ │ │ +~@ │ │ │ │ │ +Tried to set a symbol-macrolet! │ │ │ │ │ +VU\Y\eem │ │ │ │ │ +[PM^hN[P │ │ │ │ │ +&(1,g o │ │ │ │ │ )X ))<6p │ │ │ │ │ CONSTANT SB-KERNEL0 │ │ │ │ │ METHOD-ALIST │ │ │ │ │ WRAPPERS │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ DECLARATIONS │ │ │ │ │ @@ -40614,24 +40476,35 @@ │ │ │ │ │ PRECOMPUTE-P │ │ │ │ │ SPECIALIZER-CACHE0 │ │ │ │ │ 12SN~p1[ │ │ │ │ │ CLASSES-LIST │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ QUALIFIER8 │ │ │ │ │ TYPE-NAME │ │ │ │ │ +") )g │ │ │ │ │ + $","("()@ │ │ │ │ │ +/7&!"@#"@ │ │ │ │ │ +R7z+1F@*b │ │ │ │ │ +:555?<<1F7F │ │ │ │ │ +XV │ │ │ │ │ +YVl\VVVVi_YYoX │ │ │ │ │ +C'#K54i(W8@ │ │ │ │ │ +;; loading file │ │ │ │ │ +;; loading system │ │ │ │ │ + /%/(%+" │ │ │ │ │ +UY]RYck`` │ │ │ │ │ +Output-partial-line called when nothing can be output. │ │ │ │ │ +Not a variable declaration the walker cares about: ~S │ │ │ │ │ COMMON-LISP │ │ │ │ │ CLASS-NAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ INITARGS │ │ │ │ │ FORM SB-KERNEL0 │ │ │ │ │ -METHOD-ARGS │ │ │ │ │ -$x)N5`D │ │ │ │ │ -METHOD-CALL │ │ │ │ │ !OUOC+mL │ │ │ │ │ KF2 wVGF │ │ │ │ │ J5 zV'm^ │ │ │ │ │ APPLICABLE-METHODS │ │ │ │ │ INITARGS │ │ │ │ │ COMMON-LISP │ │ │ │ │ =W4>glNX7 │ │ │ │ │ @@ -40654,17 +40527,14 @@ │ │ │ │ │ .DOLIST-CAREFULLY. │ │ │ │ │ COMMON-LISP │ │ │ │ │ SPECIALIZERS │ │ │ │ │ METATYPES │ │ │ │ │ PV-PARAMETERS0 │ │ │ │ │ PV-TABLE │ │ │ │ │ REST-ARG │ │ │ │ │ -~@ │ │ │ │ │ -OTHER-SPECIALIZERS │ │ │ │ │ OBJECT KERNEL │ │ │ │ │ LAMBDA-LIST │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ SPECIALIZERS │ │ │ │ │ REQUIRED-ARGS0 │ │ │ │ │ CONSTANT SB-KERNEL │ │ │ │ │ @@ -40675,15 +40545,25 @@ │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ CODE-CONVERTER │ │ │ │ │ GENERATOR0 │ │ │ │ │ GENERATOR-LAMBDA │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ TABLE0;g" │ │ │ │ │ +~@ │ │ │ │ │ LAYOUT SB-KERNEL │ │ │ │ │ +METHOD-ARGS │ │ │ │ │ +$x)N5`D │ │ │ │ │ +METHOD-CALL │ │ │ │ │ +PV-PARAMETERS │ │ │ │ │ +REQUIRED │ │ │ │ │ + SLOT-VARS │ │ │ │ │ +METHOD-ARGS0 │ │ │ │ │ +NEXT-METHODS8.g │ │ │ │ │ <]gqqnqF │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ fmt$2J775S │ │ │ │ │ SLOT-NAME │ │ │ │ │ FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ @@ -40712,52 +40592,50 @@ │ │ │ │ │ KNOWN-TYPE │ │ │ │ │ NEW-TYPE │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ n_S0Ku}: │ │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ +Returns destructively modified SEQUENCE or a freshly allocated │ │ │ │ │ + sequence of the same class as SEQUENCE of length LENGTH. Elements │ │ │ │ │ + of the returned sequence are initialized to INITIAL-ELEMENT, if │ │ │ │ │ + supplied, initialized to INITIAL-CONTENTS if supplied, or identical │ │ │ │ │ + to the elements of SEQUENCE if neither is supplied. Signals a │ │ │ │ │ + PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not │ │ │ │ │ + implemented for the class of SEQUENCE. │ │ │ │ │ [&-}tZBI │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ METHOD-ALIST-P │ │ │ │ │ WRAPPERS-P │ │ │ │ │ NEW-CLASS │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ .ANONYMOUS. │ │ │ │ │ REQUIRED │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ -PV-PARAMETERS │ │ │ │ │ -REQUIRED │ │ │ │ │ - SLOT-VARS │ │ │ │ │ -METHOD-ARGS0 │ │ │ │ │ -NEXT-METHODS8.g │ │ │ │ │ -METHOD-CALL │ │ │ │ │ -MORE-CONTEXT │ │ │ │ │ -REQUIRED-ARGS │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -MORE-ARG │ │ │ │ │ -REQUIRED-ARGS │ │ │ │ │ -NEXT-METHOD- │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ EARLY-METHOD │ │ │ │ │ CLASS-OR-NAME0 │ │ │ │ │ REST-ARG │ │ │ │ │ GENERIC-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ CACHED-EMF-P │ │ │ │ │ METATYPES │ │ │ │ │ RETURN-VALUE-P │ │ │ │ │ 6Cl, G]<\, │ │ │ │ │ ARG-NUMBER │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ LINE-SIZE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +MORE-ARG │ │ │ │ │ CLASS-SLOT-P │ │ │ │ │ ARGUMENT-PRECEDENCE-ORDER │ │ │ │ │ LAMBDA-LIST │ │ │ │ │ COMMON-LISP │ │ │ │ │ .DOLIST-CAREFULLY. │ │ │ │ │ COMMON-LISP │ │ │ │ │ QUALIFIERS │ │ │ │ │ @@ -40771,14 +40649,21 @@ │ │ │ │ │ MORE-ARG │ │ │ │ │ f,:CST%ul │ │ │ │ │ INSTANCE SB-KERNEL │ │ │ │ │ FROM-HEAD8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ CLASS-NAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ +METHOD-CALL │ │ │ │ │ +MORE-CONTEXT │ │ │ │ │ +REQUIRED-ARGS │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +MORE-ARG │ │ │ │ │ +REQUIRED-ARGS │ │ │ │ │ +NEXT-METHOD- │ │ │ │ │ COMMON-LISP │ │ │ │ │ SLOT-NAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ CLASS-PROTO │ │ │ │ │ INITARGS │ │ │ │ │ INVALID8 │ │ │ │ │ @@ -40834,33 +40719,28 @@ │ │ │ │ │ SLOT-NAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ PV-TABLE │ │ │ │ │ PV-WRAPPERS │ │ │ │ │ SLOT-NAME-LISTS │ │ │ │ │ ARG-INFO │ │ │ │ │ LAYOUTS8Mg" │ │ │ │ │ -METHOD-CALL │ │ │ │ │ -REQUIRED-ARGS+REST-ARG0+g" │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ +H)HIU'ke │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP1 │ │ │ │ │ + COMPONENT │ │ │ │ │ +Has the given COMPONENT been successfully loaded in the current image (yet)? │ │ │ │ │ +Note that this returns true even if the component is not up to date. │ │ │ │ │ +Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details. │ │ │ │ │ +BINDINGS │ │ │ │ │ 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 │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPERATION-CLASS │ │ │ │ │ @@ -40897,14 +40777,16 @@ │ │ │ │ │ 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 │ │ │ │ │ +METHOD-CALL │ │ │ │ │ +REQUIRED-ARGS+REST-ARG0+g" │ │ │ │ │ Detect circular dependencies │ │ │ │ │ Perform the loading of a Lisp file as associated to specified action (O . C) │ │ │ │ │ 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. │ │ │ │ │ @@ -40946,14 +40828,42 @@ │ │ │ │ │ if such a system exists. NAME is a system designator, to be │ │ │ │ │ normalized by COERCE-NAME. The value returned is a system object, │ │ │ │ │ or NIL if not found. │ │ │ │ │ Load system definitions from PATHNAME. │ │ │ │ │ NAME if supplied is the name of a system expected to be defined in that file. │ │ │ │ │ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD. │ │ │ │ │ Check the warnings associated with the dependencies of an action. │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +LABEL.PREFILTER │ │ │ │ │ +DISPLACEMENT.USE-LABEL │ │ │ │ │ +DISPLACEMENT.PRINTER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +IMM-WORD.PREFILTER │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ REGISTER │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ PATHNAMES │ │ │ │ │ Ensure that for every pathname in PATHNAMES, we ensure its directories exist │ │ │ │ │ COMPONENT │ │ │ │ │ OPERATION │ │ │ │ │ @@ -40989,65 +40899,28 @@ │ │ │ │ │ if you use MERGE-PATHNAMES* but will matter if you use MERGE-PATHNAMES, │ │ │ │ │ which is an important reason to always use MERGE-PATHNAMES*. │ │ │ │ │ Arbitrary keys are accepted, and the parse result is passed to ENSURE-PATHNAME │ │ │ │ │ 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 │ │ │ │ │ -Returns destructively modified SEQUENCE or a freshly allocated │ │ │ │ │ - sequence of the same class as SEQUENCE of length LENGTH. Elements │ │ │ │ │ - of the returned sequence are initialized to INITIAL-ELEMENT, if │ │ │ │ │ - supplied, initialized to INITIAL-CONTENTS if supplied, or identical │ │ │ │ │ - to the elements of SEQUENCE if neither is supplied. Signals a │ │ │ │ │ - PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not │ │ │ │ │ - implemented for the class of SEQUENCE. │ │ │ │ │ -Returns a sequence iterator for SEQUENCE, START, END and FROM-END │ │ │ │ │ - as three values: │ │ │ │ │ - 1. iterator state │ │ │ │ │ - 2. limit │ │ │ │ │ - 3. from-end │ │ │ │ │ - The returned iterator can be used with the generic iterator │ │ │ │ │ - functions ITERATOR-STEP, ITERATOR-ENDP, ITERATOR-ELEMENT, (SETF │ │ │ │ │ - ITERATOR-ELEMENT), ITERATOR-INDEX and ITERATOR-COPY. │ │ │ │ │ -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. │ │ │ │ │ -Destructively modifies SEQUENCE by replacing the sequence element │ │ │ │ │ - associated to position of ITERATOR with NEW-VALUE. │ │ │ │ │ -Returns the position of ITERATOR in SEQUENCE. │ │ │ │ │ -Returns a copy of ITERATOR which also traverses SEQUENCE but can │ │ │ │ │ - be mutated independently of ITERATOR. │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ BUNDLE-TYPE0 │ │ │ │ │ Perform the loading of a FASL associated to specified action (O . C), │ │ │ │ │ an OPERATION and a COMPONENT. │ │ │ │ │ +OTHER-SPECIALIZERS │ │ │ │ │ The unique output file of performing OPERATION on COMPONENT │ │ │ │ │ SB-C0 '); │ │ │ │ │ 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. │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ Variant of PRINC that also calls TERPRI afterwards │ │ │ │ │ Call FUN on all the valid dependencies of the given action in the given plan │ │ │ │ │ TEST-NOT8 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ MORE-ARG │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ Detects the encoding of a specified file, going through user-configurable hooks │ │ │ │ │ Transform a portable ENCODING keyword to an implementation-dependent EXTERNAL-FORMAT, │ │ │ │ │ going through all the proper hooks. │ │ │ │ │ Portable wrapper around LOAD that properly handles loading from a stream. │ │ │ │ │ @@ -41137,20 +41010,14 @@ │ │ │ │ │ DIRECTORY │ │ │ │ │ COMMON-LISP │ │ │ │ │ Compute the transitive sub-components of given COMPONENT that are of given TYPE │ │ │ │ │ IMPLEMENTATION-TYPE │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ 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. │ │ │ │ │ -LABEL.PREFILTER │ │ │ │ │ -DISPLACEMENT.USE-LABEL │ │ │ │ │ -DISPLACEMENT.PRINTER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -IMM-WORD.PREFILTER │ │ │ │ │ - NEW-VALUE │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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 │ │ │ │ │ @@ -41159,160 +41026,175 @@ │ │ │ │ │ Return a new pathname modified from X by adding a trivial random suffix. │ │ │ │ │ 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 │ │ │ │ │ COMMON-LISP │ │ │ │ │ ^ y-L< 6 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ LOCATION0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ NEW-VALUE │ │ │ │ │ FBGGBDH;I │ │ │ │ │ <&UMWu71 │ │ │ │ │ +Returns a sequence iterator for SEQUENCE, START, END and FROM-END │ │ │ │ │ + as three values: │ │ │ │ │ + 1. iterator state │ │ │ │ │ + 2. limit │ │ │ │ │ + 3. from-end │ │ │ │ │ + The returned iterator can be used with the generic iterator │ │ │ │ │ + functions ITERATOR-STEP, ITERATOR-ENDP, ITERATOR-ELEMENT, (SETF │ │ │ │ │ + ITERATOR-ELEMENT), ITERATOR-INDEX and ITERATOR-COPY. │ │ │ │ │ +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. │ │ │ │ │ +Destructively modifies SEQUENCE by replacing the sequence element │ │ │ │ │ + associated to position of ITERATOR with NEW-VALUE. │ │ │ │ │ +Returns the position of ITERATOR in SEQUENCE. │ │ │ │ │ +Returns a copy of ITERATOR which also traverses SEQUENCE but can │ │ │ │ │ + be mutated independently of ITERATOR. │ │ │ │ │ d?J;z\D │ │ │ │ │ ~:<~W~^ ~3I~:_~W~^~1I~@{~:@_~:<~^~W~^ ~:I~@_~@{~W~^ ~_~}~:>~}~:> │ │ │ │ │ +~@ │ │ │ │ │ +error printing ~a {~x} │ │ │ │ │ +error printing object │ │ │ │ │ +Illegal function call in method body: │ │ │ │ │ returned │ │ │ │ │ exited non-locally │ │ │ │ │ -size mismatch: ~S is a ~S and ~S is a ~S. │ │ │ │ │ -can't tell the size of either ~S or ~S │ │ │ │ │ -can't index off of ESP │ │ │ │ │ -can't tell the size of ~S ~S │ │ │ │ │ CLEANUP-FUN-42 │ │ │ │ │ CLEANUP-FUN-131 │ │ │ │ │ Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ │ Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS │ │ │ │ │ asdf-output-translations │ │ │ │ │ Unpacked a TN to satisfy operand SC restriction. │ │ │ │ │ Unpacked some operand TN. │ │ │ │ │ source-registry │ │ │ │ │ +surplus arguments: ~S │ │ │ │ │ +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 │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ +~@ │ │ │ │ │ GFVv#KGE │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ MORE-ARG │ │ │ │ │ +Kv1ZAv1> │ │ │ │ │ COMMON-LISP │ │ │ │ │ MACRO-FUNCTION │ │ │ │ │ COMMON-LISP │ │ │ │ │ -Kv1ZAv1> │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -~@ │ │ │ │ │ -CLEANUP-FUN-5 │ │ │ │ │ -surplus arguments: ~S │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +FP-REG.PRINTER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ NEW-FORM │ │ │ │ │ PATH0)g% │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL0 │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -FP-REG.PRINTER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -4-9LBHKZB │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ +:w5wG$w4 │ │ │ │ │ +Reduce a list as if by STRCAT, accepting KEY START and END keywords like REDUCE. │ │ │ │ │ +NIL is interpreted as an empty string. A character is interpreted as a string of length one. │ │ │ │ │ BODY-ENV │ │ │ │ │ CALLING-ENV │ │ │ │ │ DECLARATIONS │ │ │ │ │ MORE-ARG │ │ │ │ │ tJv9C2_S │ │ │ │ │ FUNCTION-DEF │ │ │ │ │ DOCUMENTATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ FUNCTION-DEF │ │ │ │ │ SPECIALS │ │ │ │ │ BINDING0 │ │ │ │ │ SPECIALS0.g │ │ │ │ │ COMMON-LISP │ │ │ │ │ +4-9LBHKZB │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +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* │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL0 │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ SITUATION8%g! │ │ │ │ │ Bzn$knd!?i │ │ │ │ │ FORM SB-KERNEL │ │ │ │ │ PREVIOUS-EXP0'g │ │ │ │ │ :$X^{%[$cf │ │ │ │ │ BINDING0 │ │ │ │ │ DECLARED-SPECIALS │ │ │ │ │ COMMON-LISP │ │ │ │ │ yk,U~Q& (` │ │ │ │ │ -COMMON-LISP │ │ │ │ │ V-8QXZ()7695JUITGPFK │ │ │ │ │ OHED21430WSL │ │ │ │ │ -The :DISPLACED-TO array is too small │ │ │ │ │ -The number of dimensions is not equal to the rank of the array │ │ │ │ │ -Can't displace an array of type ~S to another of type ~S │ │ │ │ │ +CLEANUP-FUN-5 │ │ │ │ │ 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. │ │ │ │ │ -bogus operands to ~A │ │ │ │ │ -Double shifts can only be used with words. │ │ │ │ │ -~@ │ │ │ │ │ -error printing ~a {~x} │ │ │ │ │ -error printing object │ │ │ │ │ -Illegal function call in method body: │ │ │ │ │ -Ignoring doc-type ~a for ~a. │ │ │ │ │ w(,,(%$"l V │ │ │ │ │ +z 4z 4z 4+ │ │ │ │ │ +Ignoring doc-type ~a for ~a. │ │ │ │ │ +common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ │ NTR(* ! │ │ │ │ │ j+y\L#.* │ │ │ │ │ -asdf-package-system │ │ │ │ │ -OBJECT KERNEL6gZ │ │ │ │ │ -SzKzffioo │ │ │ │ │ =/,_:.-%@+ │ │ │ │ │ -common-lisp/asdf/uiop/contrib/debug.lisp │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -TMP20&g" │ │ │ │ │ -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* │ │ │ │ │ -:w5wG$w4 │ │ │ │ │ -Reduce a list as if by STRCAT, accepting KEY START and END keywords like REDUCE. │ │ │ │ │ -NIL is interpreted as an empty string. A character is interpreted as a string of length one. │ │ │ │ │ -COMMON-LISP │ │ │ │ │ - NEW-VALUE │ │ │ │ │ + uD 3BV,# $! │ │ │ │ │ +*ASDF-VERSION* │ │ │ │ │ +*ASDF-REVISION* │ │ │ │ │ + #: :U j( │ │ │ │ │ +SzKzffioo │ │ │ │ │ +searching │ │ │ │ │ +evaluated │ │ │ │ │ +absolute │ │ │ │ │ +directory. │ │ │ │ │ +replace │ │ │ │ │ +continue. │ │ │ │ │ + NvNii3$( │ │ │ │ │ +invalid argument value │ │ │ │ │ +Unused arguments have no values. │ │ │ │ │ +No argument values are available. │ │ │ │ │ COMMON-LISP │ │ │ │ │ -MACRO-ENVIRONMENT8 │ │ │ │ │ -SOURCE-CODE │ │ │ │ │ -UNIVERSE0 │ │ │ │ │ +OBJECT KERNEL6gZ │ │ │ │ │ COMMON-LISP │ │ │ │ │ FORMAT-ARGUMENTS │ │ │ │ │ FORMAT-CONTROL SB-KERNEL │ │ │ │ │ REST-ARG │ │ │ │ │ B[W$r=e` │ │ │ │ │ pk │ │ │ │ │ +measuring PROFILE overhead.. │ │ │ │ │ +ignoring undefined function ~S │ │ │ │ │ +~S is already profiled, so unprofiling it first. │ │ │ │ │ Push the HOOK function (a designator as per ENSURE-FUNCTION) onto the hook VARIABLE. │ │ │ │ │ When CALL-NOW-P is true, also call the function immediately. │ │ │ │ │ Predicate that is true for an empty sequence │ │ │ │ │ Return the last character of a non-empty string S, or NIL │ │ │ │ │ Converts a boolean VALUE to a form suitable for testing with #+. │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ REST-ARG │ │ │ │ │ @@ -41488,45 +41405,14 @@ │ │ │ │ │ 1- the result of the ERROR-OUTPUT slurping if any, or NIL │ │ │ │ │ 2- either 0 if the subprocess exited with success status, │ │ │ │ │ or an indication of failure via the EXIT-CODE of the process │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ VALUE-LIST │ │ │ │ │ jdHB&3/4p │ │ │ │ │ - uD 3BV,# $! │ │ │ │ │ -*ASDF-VERSION* │ │ │ │ │ -*ASDF-REVISION* │ │ │ │ │ - #: :U j( │ │ │ │ │ -searching │ │ │ │ │ -evaluated │ │ │ │ │ -absolute │ │ │ │ │ -directory. │ │ │ │ │ -replace │ │ │ │ │ -continue. │ │ │ │ │ - NvNii3$( │ │ │ │ │ -invalid argument value │ │ │ │ │ -Unused arguments have no values. │ │ │ │ │ -No argument values are available. │ │ │ │ │ -Specify variable ID to disambiguate ~S. Use one of ~S. │ │ │ │ │ -invalid variable ID, ~W: should have been one of ~S │ │ │ │ │ -specification ambiguous: │ │ │ │ │ -No known valid variables match ~S. │ │ │ │ │ -These functions were not called: │ │ │ │ │ -f?E !CB != │ │ │ │ │ -#x~8,'0x: ~a~@[ +~d~] │ │ │ │ │ -loading to/from SCs that aren't alternates? │ │ │ │ │ -VM definition is inconsistent, try recompiling. │ │ │ │ │ -no load function defined to save SC ~S in its alternate SC ~S │ │ │ │ │ -no load function defined to load SC ~S from its alternate SC ~S │ │ │ │ │ -loading from an invalid constant SC? │ │ │ │ │ -VM definition inconsistent, try recompiling. │ │ │ │ │ -no load function defined to load SC ~S from its constant SC ~S │ │ │ │ │ -STANDARD method combination accepts no options. │ │ │ │ │ -SU\mXxV\HhmX │ │ │ │ │ -<*9Q ; & │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ RESOLVED │ │ │ │ │ NORMALIZED-NAMESTRING │ │ │ │ │ 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/ │ │ │ │ │ @@ -41654,20 +41540,14 @@ │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ fmt$53JDSU │ │ │ │ │ Load ASDF system identified by NAME. │ │ │ │ │ EXECUTABLE │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ INPUT-ACTIVITY-VAR │ │ │ │ │ OUTPUT-ACTIVITY-VAR │ │ │ │ │ COMMON-LISP │ │ │ │ │ DEFINE-PACKAGE takes a PACKAGE and a number of CLAUSES, of the form │ │ │ │ │ (KEYWORD . ARGS). │ │ │ │ │ DEFINE-PACKAGE supports the following keywords: │ │ │ │ │ SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN, NICKNAMES, │ │ │ │ │ @@ -41701,14 +41581,17 @@ │ │ │ │ │ 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. │ │ │ │ │ VALUE0(g( │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ @@ -41718,68 +41601,99 @@ │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ DECLARATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ IMM-ADDR.PREFILTER │ │ │ │ │ IMM-BYTE.PREFILTER │ │ │ │ │ DECLARATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ +MACRO-ENVIRONMENT8 │ │ │ │ │ +SOURCE-CODE │ │ │ │ │ +UNIVERSE0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ DOC-TYPE0 │ │ │ │ │ +CLEANUP-FUN-14 │ │ │ │ │ WRAPPER10 │ │ │ │ │ CLEANUP-FUN-115 │ │ │ │ │ -CLEANUP-FUN-14 │ │ │ │ │ /build/reproducible-path/buildapp-1.5.6/dumper-PTGsyz2X.lisp │ │ │ │ │ CLEANUP-FUN-240 │ │ │ │ │ /build/reproducible-path/buildapp-1.5.6/asdf-files.lisp │ │ │ │ │ +The column in which end-of-line comments for notes are started. │ │ │ │ │ +DEFINITION │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +tN/t@O_4 │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ +COMMON-LISP │ │ │ │ │ + CHARACTER │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +Returns the canonical combining class (CCC) of CHARACTER │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ ah+MiAAI │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ REST-ARG │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -tN/t@O_4 │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -DEFINITION │ │ │ │ │ -OPTIONAL-ARGS │ │ │ │ │ -.3H_,sw7 │ │ │ │ │ NODE-HASH │ │ │ │ │ NODE-HASH │ │ │ │ │ NODE-HASH │ │ │ │ │ SO-DATA0 │ │ │ │ │ +convert (* x 0) to 0 │ │ │ │ │ +associate */(* /) of constants │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +convert x*2^k to shift │ │ │ │ │ +Returns as multiple values a descriptive name for the function responsible │ │ │ │ │ +for FRAME, arguments that that function, and a list providing additional │ │ │ │ │ +information about the frame. │ │ │ │ │ +Unavailable arguments are represented using dummy-objects printing as │ │ │ │ │ +#. │ │ │ │ │ +METHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames │ │ │ │ │ +corresponding to method functions are printed. Possible values │ │ │ │ │ +are :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more │ │ │ │ │ +information. │ │ │ │ │ +If REPLACE-DYNAMIC-EXTENT-OBJECTS is true, objects allocated on the stack of │ │ │ │ │ +the current thread are replaced with dummy objects which can safely escape. │ │ │ │ │ +.3H_,sw7 │ │ │ │ │ ELEMENT-SIZE │ │ │ │ │ PACK-TYPE0 │ │ │ │ │ SIZE-MASK │ │ │ │ │ NODE-DATA8 │ │ │ │ │ NODE-KEY │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ -convert (* x 0) to 0 │ │ │ │ │ -associate */(* /) of constants │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -convert x*2^k to shift │ │ │ │ │ -optimize multiplication by one │ │ │ │ │ -INSTANCE SB-KERNEL │ │ │ │ │ .DEFAULTING-TEMP.0 │ │ │ │ │ LOCATIONS │ │ │ │ │ x`$Fa-&%2 │ │ │ │ │ -DST-SIZE │ │ │ │ │ -SRC-SIZE │ │ │ │ │ -SB-C8/g4 │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -SB-ALIEN │ │ │ │ │ -The column in which end-of-line comments for notes are started. │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL │ │ │ │ │ +optimize multiplication by one │ │ │ │ │ SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST │ │ │ │ │ -measuring PROFILE overhead.. │ │ │ │ │ -ignoring undefined function ~S │ │ │ │ │ -~S is already profiled, so unprofiling it first. │ │ │ │ │ +A function taking no parameters that starts the low-level debug loop. │ │ │ │ │ +When set (the default), evaluations in the debugger's command loop occur │ │ │ │ │ +relative to the current frame's environment without the need of debugger │ │ │ │ │ +forms that explicitly control this kind of evaluation. │ │ │ │ │ +SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ │ +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 │ │ │ │ │ QNNNV"""" │ │ │ │ │ :'*''*$'*%g │ │ │ │ │ :KHKHKHKEKKxf │ │ │ │ │ ~@ │ │ │ │ │ F?(d.O-.p │ │ │ │ │ ~S is not a profiled function. │ │ │ │ │ sec/call │ │ │ │ │ @@ -41787,14 +41701,21 @@ │ │ │ │ │ estimated total profiling overhead: │ │ │ │ │ seconds │ │ │ │ │ overhead estimation parameters: │ │ │ │ │ s/call, │ │ │ │ │ s total profiling, │ │ │ │ │ s internal profiling │ │ │ │ │ ~&~@{ ~v:@<~A~>~^|~} │ │ │ │ │ +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 │ │ │ │ │ ~S is an unknown keyword in FOR or AS clause in LOOP. │ │ │ │ │ Duplicated variable ~s~a │ │ │ │ │ Bad variable ~s~a │ │ │ │ │ [|QaRiURag │ │ │ │ │ Destructuring is not valid for package symbol iteration. │ │ │ │ │ Unknown preposition ~S. │ │ │ │ │ Too many prepositions! │ │ │ │ │ @@ -41847,29 +41768,20 @@ │ │ │ │ │ Value passed back by LOOP iteration path function for path ~S has invalid length. │ │ │ │ │ Unused USING vars: ~S. │ │ │ │ │ "Inclusive" iteration is not possible with the ~S LOOP iteration path. │ │ │ │ │ ~S is not the name of a LOOP iteration path. │ │ │ │ │ ~S was found where a LOOP iteration path name was expected. │ │ │ │ │ ~S was found where ITS or EACH expected in LOOP iteration path syntax. │ │ │ │ │ unrecognizable LOOP iteration path syntax: missing EACH or THE? │ │ │ │ │ -SYS:SRC;CODE;HUFFMAN.LISP │ │ │ │ │ -A function taking no parameters that starts the low-level debug loop. │ │ │ │ │ -When set (the default), evaluations in the debugger's command loop occur │ │ │ │ │ -relative to the current frame's environment without the need of debugger │ │ │ │ │ -forms that explicitly control this kind of evaluation. │ │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ │ -SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ │ Too many prepositions │ │ │ │ │ ~@ │ │ │ │ │ -FROM-END- │ │ │ │ │ -Hn[RJfQ\mUPFkWp| │ │ │ │ │ -~&Your command, ~S, is ambiguous: │ │ │ │ │ -~&error flushed (because ~S is set) │ │ │ │ │ -~@ │ │ │ │ │ +Argument and result bit arrays are not the same length:~ │ │ │ │ │ + ~% ~S~% ~S │ │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/asdf.asd │ │ │ │ │ f)_)_)_) │ │ │ │ │ ~2D: not referenced? │ │ │ │ │ ~2D: ~A (restricted) │ │ │ │ │ ~2D: ~A (wired) │ │ │ │ │ ~2D: ~A (component live) │ │ │ │ │ ~2D: ~A (temporary ~A) │ │ │ │ │ ~2D: ~A (~:R result load TN) │ │ │ │ │ @@ -41888,62 +41800,24 @@ │ │ │ │ │ allowed by the operand restriction: │ │ │ │ │ ~S~:[~; │ │ │ │ │ Current cost info inconsistent with that in effect at compile time. Recompile. │ │ │ │ │ Compilation order may be incorrect.~] │ │ │ │ │ while handling code walker REPEAT: │ │ │ │ │ │ │ │ │ │ ran into STOP while still in REPEAT template │ │ │ │ │ +FROM-END- │ │ │ │ │ +Hn[RJfQ\mUPFkWp| │ │ │ │ │ #X~2,'0x │ │ │ │ │ -~S is not a valid function name, not tracing. │ │ │ │ │ -~S is a special operator, not tracing. │ │ │ │ │ -~S not found, not tracing. │ │ │ │ │ -~S is undefined, not tracing. │ │ │ │ │ -breaking ~A traced call to ~S: │ │ │ │ │ -Argument and result bit arrays are not the same length:~ │ │ │ │ │ - ~% ~S~% ~S │ │ │ │ │ -/build/reproducible-path/sbcl-2.5.2/contrib/asdf/asdf.lisp │ │ │ │ │ V-8QXZ()7695JUI │ │ │ │ │ D21430WSL │ │ │ │ │ -SIZE88g0 │ │ │ │ │ -INTEGER1 │ │ │ │ │ -THING0(g │ │ │ │ │ - CHARACTER │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -Returns the canonical combining class (CCC) of CHARACTER │ │ │ │ │ -Returns as multiple values a descriptive name for the function responsible │ │ │ │ │ -for FRAME, arguments that that function, and a list providing additional │ │ │ │ │ -information about the frame. │ │ │ │ │ -Unavailable arguments are represented using dummy-objects printing as │ │ │ │ │ -#. │ │ │ │ │ -METHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames │ │ │ │ │ -corresponding to method functions are printed. Possible values │ │ │ │ │ -are :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more │ │ │ │ │ -information. │ │ │ │ │ -If REPLACE-DYNAMIC-EXTENT-OBJECTS is true, objects allocated on the stack of │ │ │ │ │ -the current thread are replaced with dummy objects which can safely escape. │ │ │ │ │ - DOC-TYPE9 │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -.GOOD-NEW-VALUE. │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -.GOOD-NEW-VALUE. │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -DOC-TYPE │ │ │ │ │ - NEW-VALUE │ │ │ │ │ -K ```$0$ │ │ │ │ │ -MORE-ARG │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -K ```$0$ │ │ │ │ │ -MORE-ARG │ │ │ │ │ From a parsed version (a list of natural numbers), compute the version string │ │ │ │ │ + }(( =( │ │ │ │ │ +FOB0v 2. │ │ │ │ │ +]c61S_;C │ │ │ │ │ + P1V=Q6i │ │ │ │ │ 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. │ │ │ │ │ @@ -42198,14 +42072,47 @@ │ │ │ │ │ which in practice is thus compulsory, and validates by returning a non-NIL result. │ │ │ │ │ If you're suicidal or extremely confident, just use :VALIDATE T. │ │ │ │ │ Extract an absolute directory pathname from a user-configured environment variable, │ │ │ │ │ as per native OS │ │ │ │ │ Is X the name of a file that exists on the filesystem? │ │ │ │ │ What character does the current OS conventionally uses to separate directories? │ │ │ │ │ Resolve as much of a pathname as possible │ │ │ │ │ + DOC-TYPE9 │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +.GOOD-NEW-VALUE. │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +.GOOD-NEW-VALUE. │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +DOC-TYPE │ │ │ │ │ + NEW-VALUE │ │ │ │ │ +K ```$0$ │ │ │ │ │ +MORE-ARG │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +K ```$0$ │ │ │ │ │ +MORE-ARG │ │ │ │ │ +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. │ │ │ │ │ +PATHNAME-VAR │ │ │ │ │ +Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ │ +Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ │ +where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ │ +on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ │ PATHNAME │ │ │ │ │ COMMON-LISP │ │ │ │ │ Is the PATHNAME under the current installation of the CL implementation? │ │ │ │ │ Delete a file X if it already exists │ │ │ │ │ From a native namestring suitable for use by the operating system, return │ │ │ │ │ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME │ │ │ │ │ Where are the system files of the current installation of the CL implementation? │ │ │ │ │ @@ -42268,30 +42175,26 @@ │ │ │ │ │ Configure a default temporary directory to use. │ │ │ │ │ MORE-ARG │ │ │ │ │ Open FILE with option KEYS, read its contents as a list of lines │ │ │ │ │ BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ │ Reads the specified form from the top of a file using a safe standardized syntax. │ │ │ │ │ Extracts the form using READ-FILE-FORM, │ │ │ │ │ within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ │ -~@<~S ~_= ~:[; No values~;~:*~{~S~^, ~}~]~:> │ │ │ │ │ -; No values │ │ │ │ │ -\E\YXkaSRPXXjkZyd │ │ │ │ │ +contrib/debug.lisp │ │ │ │ │ +common-lisp │ │ │ │ │ +sbcl-2.5.2.debian-linux-x86-s │ │ │ │ │ ENCODING │ │ │ │ │ Open input FILE with option KEYS (except AT), │ │ │ │ │ and read its contents as per SLURP-STREAM-FORM with given AT specifier. │ │ │ │ │ BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ │ Open input FILE with option KEYS (except COUNT), │ │ │ │ │ and read its contents as per SLURP-STREAM-FORMS with given COUNT. │ │ │ │ │ If COUNT is null, read to the end of the stream; │ │ │ │ │ if COUNT is an integer, stop after COUNT forms were read. │ │ │ │ │ BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof │ │ │ │ │ - }(( =( │ │ │ │ │ -FOB0v 2. │ │ │ │ │ -]c61S_;C │ │ │ │ │ - P1V=Q6i │ │ │ │ │ Reads the specified line from the top of a file using a safe standardized syntax. │ │ │ │ │ Extracts the line using READ-FILE-LINE, │ │ │ │ │ within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE. │ │ │ │ │ b((ueE^d │ │ │ │ │ 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. │ │ │ │ │ @@ -42340,56 +42243,14 @@ │ │ │ │ │ Return a directory to use for temporary files │ │ │ │ │ THUNK0?'' │ │ │ │ │ Evaluate a THUNK of code: │ │ │ │ │ If a function, FUNCALL it without arguments. │ │ │ │ │ If a constant literal and not a sequence, return it. │ │ │ │ │ If a cons or a symbol, EVAL it. │ │ │ │ │ If a string, repeatedly read and evaluate from it, returning the last values. │ │ │ │ │ -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. │ │ │ │ │ -PATHNAME-VAR │ │ │ │ │ -Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME │ │ │ │ │ -Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, │ │ │ │ │ -where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except │ │ │ │ │ -on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory. │ │ │ │ │ -Call BODY while the POSIX current working directory is set to DIR │ │ │ │ │ - INPUT-VAR │ │ │ │ │ -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. │ │ │ │ │ -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. │ │ │ │ │ -ELEMENT-TYPE │ │ │ │ │ -OUTPUT-VAR0 │ │ │ │ │ -Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ │ -of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ │ -the scope of this binding. │ │ │ │ │ -Evaluate BODY 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. │ │ │ │ │ -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. │ │ │ │ │ -PATHNAME-VAR │ │ │ │ │ -Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ │ -Establish safe CL reader options around the evaluation of BODY │ │ │ │ │ -Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS │ │ │ │ │ -Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ │ -Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS │ │ │ │ │ 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. │ │ │ │ │ BIDIR-STREAM │ │ │ │ │ COMMON-LISP │ │ │ │ │ Close any stream that the process might own. Needs to be run │ │ │ │ │ @@ -42522,26 +42383,14 @@ │ │ │ │ │ Assume the calling conventions of a generated script that uses -- │ │ │ │ │ if we are not called from a directly executable image. │ │ │ │ │ Given a simple SEXP, return a representation of it as a portable SEXP. │ │ │ │ │ Simple means made of symbols, numbers, characters, simple-strings, pathnames, cons cells. │ │ │ │ │ Is X the specification of a location function? │ │ │ │ │ Is X a designator for a location? │ │ │ │ │ Parse strings as unix namestrings and remove duplicates and non absolute-pathnames in a list. │ │ │ │ │ -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-34 │ │ │ │ │ -CLEANUP-FUN-20 │ │ │ │ │ -BEFORE77 │ │ │ │ │ -common-lisp │ │ │ │ │ -sbcl-2.5.2.debian-linux-x86-s │ │ │ │ │ Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS, │ │ │ │ │ re-intern and raise any warnings that are still meaningful. │ │ │ │ │ Finds the first appropriate file named X in the list of DIRS for I/O │ │ │ │ │ in DIRECTION (which may be :INPUT, :OUTPUT, :IO, or :PROBE). │ │ │ │ │ If direction is :INPUT or :PROBE, will return the first extant file named │ │ │ │ │ X in one of the DIRS. │ │ │ │ │ If direction is :OUTPUT or :IO, will simply return the file named X in the │ │ │ │ │ @@ -42736,14 +42585,60 @@ │ │ │ │ │ Register a system as being preloaded. If the system has not been loaded from the filesystem │ │ │ │ │ yet, or if its build information is later cleared with CLEAR-SYSTEM, a dummy system will be │ │ │ │ │ registered without backing filesystem information, based on KEYS (e.g. to provide a VERSION). │ │ │ │ │ If VERSION is the default T, and a system was already loaded, then its version will be preserved. │ │ │ │ │ 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. │ │ │ │ │ +Call BODY while the POSIX current working directory is set to DIR │ │ │ │ │ + INPUT-VAR │ │ │ │ │ +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. │ │ │ │ │ +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. │ │ │ │ │ +ELEMENT-TYPE │ │ │ │ │ +OUTPUT-VAR0 │ │ │ │ │ +Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding │ │ │ │ │ +of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in │ │ │ │ │ +the scope of this binding. │ │ │ │ │ +Evaluate BODY 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. │ │ │ │ │ +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. │ │ │ │ │ +PATHNAME-VAR │ │ │ │ │ +Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME │ │ │ │ │ +Establish safe CL reader options around the evaluation of BODY │ │ │ │ │ +Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS │ │ │ │ │ +Execute BODY in a context where fatal conditions are appropriately handled │ │ │ │ │ +Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS │ │ │ │ │ +Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ │ +COMMON-LISP0D',J │ │ │ │ │ +A wrapper macro for code that should only be run when upgrading a │ │ │ │ │ +previously-loaded version of ASDF. │ │ │ │ │ +Unwrap any profiling code around the named functions, or if no names │ │ │ │ │ + are given, unprofile all profiled functions. A symbol names │ │ │ │ │ + a function. A string names all the functions named by symbols in the │ │ │ │ │ + named package. NAMES defaults to the list of names of all currently │ │ │ │ │ + profiled functions. │ │ │ │ │ +PROFILE Name* │ │ │ │ │ + If no names are supplied, return the list of profiled functions. │ │ │ │ │ + If names are supplied, wrap profiling code around the named functions. │ │ │ │ │ + As in TRACE, the names are not evaluated. A symbol names a function. │ │ │ │ │ + A string names all the functions named by symbols in the named │ │ │ │ │ + package. If a function is already profiled, then unprofile and │ │ │ │ │ + reprofile (useful to notice function redefinition.) If a name is │ │ │ │ │ + undefined, then we give a warning and ignore it. See also │ │ │ │ │ + UNPROFILE, REPORT and RESET. │ │ │ │ │ fmt$2Q680T │ │ │ │ │ COMPONENT │ │ │ │ │ HASH-TABLE │ │ │ │ │ MON-LISP8a'( │ │ │ │ │ Mark a component as preloaded. │ │ │ │ │ Return a list containing every registered system (as a system object). │ │ │ │ │ ASDF/COMPONENT │ │ │ │ │ @@ -42848,109 +42743,144 @@ │ │ │ │ │ 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. │ │ │ │ │ -Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ │ -COMMON-LISP0D',J │ │ │ │ │ -A wrapper macro for code that should only be run when upgrading a │ │ │ │ │ -previously-loaded version of ASDF. │ │ │ │ │ -Unwrap any profiling code around the named functions, or if no names │ │ │ │ │ - are given, unprofile all profiled functions. A symbol names │ │ │ │ │ - a function. A string names all the functions named by symbols in the │ │ │ │ │ - named package. NAMES defaults to the list of names of all currently │ │ │ │ │ - profiled functions. │ │ │ │ │ -PROFILE Name* │ │ │ │ │ - If no names are supplied, return the list of profiled functions. │ │ │ │ │ - If names are supplied, wrap profiling code around the named functions. │ │ │ │ │ - As in TRACE, the names are not evaluated. A symbol names a function. │ │ │ │ │ - A string names all the functions named by symbols in the named │ │ │ │ │ - package. If a function is already profiled, then unprofile and │ │ │ │ │ - reprofile (useful to notice function redefinition.) If a name is │ │ │ │ │ - undefined, then we give a warning and ignore it. See also │ │ │ │ │ - UNPROFILE, REPORT and RESET. │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ ASDF/SYSTEM │ │ │ │ │ Given a SYSTEM on which operate is called and the specified FORCE argument, │ │ │ │ │ extract a hash-set of systems that are forced, or a predicate on system names, │ │ │ │ │ or NIL if none are forced, or :ALL if all are. │ │ │ │ │ Given a SYSTEM on which operate is called, the specified FORCE-NOT argument, │ │ │ │ │ and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not, │ │ │ │ │ or predicate on system names, or NIL if none are forced, or :ALL if all are. │ │ │ │ │ Is F a build report file containing, e.g., warnings to check? │ │ │ │ │ - BYTE-SPEC │ │ │ │ │ -COMMON-LISP │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ FEATURE-EXPR │ │ │ │ │ FEATURE-SETS │ │ │ │ │ A helper for various feature detection functions │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ Return the same status but with the need bit set, for the given level │ │ │ │ │ -OPTIONS0 │ │ │ │ │ -SETTINGS │ │ │ │ │ -ANSWER-VAR │ │ │ │ │ -FLAG-VAR │ │ │ │ │ -TEMP-VAR8 │ │ │ │ │ -ANSWER-VAR0 │ │ │ │ │ -FLAG-VAR │ │ │ │ │ -TEMP-VAR │ │ │ │ │ + BYTE-SPEC │ │ │ │ │ COMMON-LISP │ │ │ │ │ +OPTIONS0 │ │ │ │ │ +for each substring in SUBSTRINGS, find occurrences of it within STRING │ │ │ │ │ +that don't use parts of matched occurrences of previous strings, and │ │ │ │ │ +FROB them, that is to say, remove them if FROB is NIL, │ │ │ │ │ +replace by FROB if FROB is a STRING, or if FROB is a FUNCTION, │ │ │ │ │ +call FROB with the match and a function that emits a string in the output. │ │ │ │ │ +Return a string made of the parts not omitted or emitted by FROB. │ │ │ │ │ DIRECTION0 │ │ │ │ │ PARAMETER │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ Undoes any initialization of the source registry. │ │ │ │ │ PARAMETER0 │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ Is the underlying operating system Haiku? │ │ │ │ │ Is the underlying operating system Mezzano? │ │ │ │ │ Is the underlying operating system an (emulated?) MacOS 9 or earlier? │ │ │ │ │ Compute (and return) the location of the default user-cache for translate-output │ │ │ │ │ objects. Side-effects for cached file location computation. │ │ │ │ │ +SETTINGS │ │ │ │ │ +ANSWER-VAR │ │ │ │ │ +FLAG-VAR │ │ │ │ │ +TEMP-VAR8 │ │ │ │ │ +ANSWER-VAR0 │ │ │ │ │ +FLAG-VAR │ │ │ │ │ +TEMP-VAR │ │ │ │ │ +COMMON-LISP │ │ │ │ │ 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. │ │ │ │ │ SETTINGS8#G( │ │ │ │ │ Proclaim the optimization settings in *OPTIMIZATION-SETTINGS* │ │ │ │ │ TEMP SB-KERNEL │ │ │ │ │ Detect SB-GROVEL unknown-constant conditions on older versions of SBCL │ │ │ │ │ +Get current compiler optimization settings, ready to PROCLAIM again │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COUNTER0 │ │ │ │ │ +HASH-TABLE │ │ │ │ │ +COMMON-LISP8 │ │ │ │ │ +CLEANUP-FUN-34 │ │ │ │ │ +CLEANUP-FUN-20 │ │ │ │ │ +BEFORE77 │ │ │ │ │ +SYS:CONTRIB;ASDF;ASDF.LISP.NEWEST │ │ │ │ │ +/build/reproducible-path/sbcl-2.5.2/contrib/asdf/asdf.lisp │ │ │ │ │ CLEANUP-FUN-3 │ │ │ │ │ CLEANUP-FUN-0 │ │ │ │ │ CLEANUP-FUN-47 │ │ │ │ │ CLEANUP-FUN-227 │ │ │ │ │ CLEANUP-FUN-36 │ │ │ │ │ +~S is not a valid function name, not tracing. │ │ │ │ │ +~S is a special operator, not tracing. │ │ │ │ │ +~S not found, not tracing. │ │ │ │ │ +~S is undefined, not tracing. │ │ │ │ │ +dynamic-extent: ~S │ │ │ │ │ +error printing dynamic-extent object │ │ │ │ │ +breaking ~A traced call to ~S: │ │ │ │ │ +~@<~S ~_= ~:[; No values~;~:*~{~S~^, ~}~]~:> │ │ │ │ │ +; No values │ │ │ │ │ +Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ │ +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. │ │ │ │ │ +1AO]j"&p( │ │ │ │ │ +:TYPE must be one of ~S │ │ │ │ │ +Must not specify :SORT or :TEST with :KEY-TYPE │ │ │ │ │ +Must specify both :SORT and :TEST │ │ │ │ │ +_+-=@,:/. │ │ │ │ │ /usr/lib/sbcl/contrib/asdf.fasl │ │ │ │ │ -asdf-output-translations.conf.d │ │ │ │ │ -source-registry.conf.d │ │ │ │ │ -Get current compiler optimization settings, ready to PROCLAIM again │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -COUNTER0 │ │ │ │ │ -HASH-TABLE │ │ │ │ │ -COMMON-LISP8 │ │ │ │ │ +/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 │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +THING0(g │ │ │ │ │ +SB-C8/g4 │ │ │ │ │ COMMON-LISP │ │ │ │ │ +DST-SIZE │ │ │ │ │ +SRC-SIZE │ │ │ │ │ +SB-ALIEN │ │ │ │ │ +asdf-output-translations.conf.d │ │ │ │ │ +source-registry.conf.d │ │ │ │ │ +RESTART-FRAME │ │ │ │ │ +LIST-LOCALS │ │ │ │ │ +SIZE88g0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +INTEGER1 │ │ │ │ │ COMMON-LISP │ │ │ │ │ MINIMAX0 │ │ │ │ │ OPERATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEXTFORM │ │ │ │ │ -Cannot ADJUST-ARRAY an array to a size smaller than its fill pointer │ │ │ │ │ -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. │ │ │ │ │ -1AO]j"&p( │ │ │ │ │ -:TYPE must be one of ~S │ │ │ │ │ -Must not specify :SORT or :TEST with :KEY-TYPE │ │ │ │ │ -Must specify both :SORT and :TEST │ │ │ │ │ -_+-=@,:/. │ │ │ │ │ COMMON-LISP │ │ │ │ │ COLLECTOR │ │ │ │ │ DEFAULT-TYPE │ │ │ │ │ SPECIFIED │ │ │ │ │ HASH-TABLE │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ LOOP-TOKEN │ │ │ │ │ @@ -42989,47 +42919,28 @@ │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEGATE SB-KERNEL │ │ │ │ │ RESTRICTIVE │ │ │ │ │ VAR-VAL-PAIRS0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ DATA-TYPE │ │ │ │ │ NEW-VALUE │ │ │ │ │ -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. │ │ │ │ │ -SEQUENCE │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ │ -bound to local functions which execute the iteration state query and │ │ │ │ │ -mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ │ -ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ │ -name, no local functions are established for those names. The │ │ │ │ │ -functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ │ -dynamic extent. │ │ │ │ │ -Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ │ - SEQUENCE, then returns RETURN. │ │ │ │ │ 7ecU]7a'N │ │ │ │ │ INTERFERENCE-GRAPH │ │ │ │ │ PROBABLY-COLORED │ │ │ │ │ PROBABLY-SPILLED8 │ │ │ │ │ VERTICES │ │ │ │ │ COLORED-VERTICES │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ NEIGHBOR │ │ │ │ │ NEW-COLOR │ │ │ │ │ NEIGHBOR │ │ │ │ │ COMMON-LISP │ │ │ │ │ CONFLICT │ │ │ │ │ SB-INT0&g7 │ │ │ │ │ -RESTART-FRAME │ │ │ │ │ -LIST-LOCALS │ │ │ │ │ -V-8QXZ()7695JU │ │ │ │ │ -D21430WS │ │ │ │ │ COMPATIBLE │ │ │ │ │ VERTICES │ │ │ │ │ LOAD-SCS8 │ │ │ │ │ VERTEX0'g@ │ │ │ │ │ DIRECTORY │ │ │ │ │ COMMON-LISP │ │ │ │ │ Return T iff X is to be preferred over Y as a source path │ │ │ │ │ @@ -43039,78 +42950,100 @@ │ │ │ │ │ COMMON-LISP0 '' │ │ │ │ │ DIRECTORY │ │ │ │ │ COMMON-LISP │ │ │ │ │ STOP-FORM │ │ │ │ │ TEMPLATE │ │ │ │ │ COMMON-LISP │ │ │ │ │ MORE-ARG │ │ │ │ │ +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. │ │ │ │ │ +SEQUENCE │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY │ │ │ │ │ +bound to local functions which execute the iteration state query and │ │ │ │ │ +mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and │ │ │ │ │ +ARGS. When some names are not supplied or NIL is supplied for a given │ │ │ │ │ +name, no local functions are established for those names. The │ │ │ │ │ +functions established for STEP, ENDP, ELT, SETF, INDEX and COPY have │ │ │ │ │ +dynamic extent. │ │ │ │ │ +Executes BODY with ELEMENT subsequently bound to each element of │ │ │ │ │ + SEQUENCE, then returns RETURN. │ │ │ │ │ SB-DISASSEM │ │ │ │ │ COMMON-LISP │ │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ │ -VALUE SB-KERNEL │ │ │ │ │ SB-DISASSEM │ │ │ │ │ COMMON-LISP │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ │ +VALUE SB-KERNEL │ │ │ │ │ NEW-VALUE0 │ │ │ │ │ - SC+OFFSET │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -ENCAPSULATED │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -MORE-ARG │ │ │ │ │ -~// is undefined, not tracing. │ │ │ │ │ -WRAPPER7 │ │ │ │ │ -SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ +V-8QXZ()7695JU │ │ │ │ │ +D21430WS │ │ │ │ │ COMMON-LISP │ │ │ │ │ L>7YfLhV │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ 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. │ │ │ │ │ -SUBFORMS │ │ │ │ │ -Set an environment variable. │ │ │ │ │ -STANDARD-OBJECT │ │ │ │ │ -COMMON-LISP0 │ │ │ │ │ -ASDF/COMPONENT │ │ │ │ │ - SLOT-NAME │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ Pre-combines some sequences of characters to make the sentence-break │ │ │ │ │ algorithm simpler.. │ │ │ │ │ Specifically, │ │ │ │ │ - Combines any character with the following extend of format characters │ │ │ │ │ - Combines CR + LF into '(CR LF) │ │ │ │ │ - Combines any run of :cp*:close* into one character │ │ │ │ │ +SUBFORMS │ │ │ │ │ +Set an environment variable. │ │ │ │ │ +STANDARD-OBJECT │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +ASDF/COMPONENT │ │ │ │ │ + SLOT-NAME │ │ │ │ │ +SYS:SRC;CODE;INITIAL-METHOD.LISP │ │ │ │ │ +WRAPPER7 │ │ │ │ │ +/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ │ +WRAPPER228 │ │ │ │ │ +CLEANUP-FUN-4 │ │ │ │ │ +BEFORE199 │ │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/ │ │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/uiop/ │ │ │ │ │ +CLEANUP-FUN-336 │ │ │ │ │ +DUMMY-NODE-P │ │ │ │ │ + SC+OFFSET │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +ARGUMENT-LIMIT │ │ │ │ │ +METHOD-FRAME-STYLE │ │ │ │ │ COMMON-LISP │ │ │ │ │ +ENCAPSULATED │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +MORE-ARG │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ PRE-TAIL │ │ │ │ │ -/build/reproducible-path/buildapp-1.5.6/buildapp.asd │ │ │ │ │ -CLEANUP-FUN-4 │ │ │ │ │ -CLEANUP-FUN-336 │ │ │ │ │ -WRAPPER228 │ │ │ │ │ -BEFORE199 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ -DUMMY-NODE-P │ │ │ │ │ COMMON-LISP8 │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ Returns the mirror image of CHARACTER if it exists. │ │ │ │ │ Otherwise, returns NIL. │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ Returns T if CHARACTER is Case Ignorable as defined in Unicode 6.3, Chapter │ │ │ │ │ +~// is undefined, not tracing. │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ Returns T if CHARACTER needs to be mirrored in bidirectional text. │ │ │ │ │ Otherwise, returns NIL. │ │ │ │ │ Returns the sentence breaking class of CHARACTER, as specified in UAX #29. │ │ │ │ │ CHARACTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -43341,31 +43274,29 @@ │ │ │ │ │ omit the outer double-quotes if key argument :QUOTE is NIL │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ Normalizes a portable I/O specifier for LAUNCH-PROGRAM into an implementation-dependent │ │ │ │ │ argument to pass to the internal RUN-PROGRAM │ │ │ │ │ 3UMaYUHU │ │ │ │ │ SEGMENT0 │ │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/ │ │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/uiop/ │ │ │ │ │ -V-8QXZ()7695J │ │ │ │ │ WRAPPER72 │ │ │ │ │ +V-8QXZ()7695J │ │ │ │ │ CLEANUP-FUN-32 │ │ │ │ │ CLEANUP-FUN-24 │ │ │ │ │ CLEANUP-FUN-57 │ │ │ │ │ CLEANUP-FUN-63 │ │ │ │ │ CLEANUP-FUN-90 │ │ │ │ │ CLEANUP-FUN-179 │ │ │ │ │ CLEANUP-FUN-183 │ │ │ │ │ CLEANUP-FUN-233 │ │ │ │ │ +/usr/share/common-lisp/source/cl-asdf/version.lisp-expr │ │ │ │ │ +lisp-expr │ │ │ │ │ VERTEX-SC │ │ │ │ │ 8QXZ()7695J │ │ │ │ │ sbcl-2.5.2.debian-linux-x86 │ │ │ │ │ -/usr/share/common-lisp/source/cl-asdf/version.lisp-expr │ │ │ │ │ -lisp-expr │ │ │ │ │ Forcing parameters for the session │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/build/ │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/header.lisp │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/contrib/debug.lisp │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/package.lisp │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/common-lisp.lisp │ │ │ │ │ /usr/share/common-lisp/source/cl-asdf/uiop/utility.lisp │ │ │ │ │ @@ -43529,33 +43460,22 @@ │ │ │ │ │ A function with declared result type NIL returned: │ │ │ │ │ Unexpected FILL-POINTER error │ │ │ │ │ ~7a = ~a ~a │ │ │ │ │ ~S cannot be coerced to a character. │ │ │ │ │ Symbol name is not of length one: ~S │ │ │ │ │ String is not of length one: ~S │ │ │ │ │ Invalid alien callback called. │ │ │ │ │ -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 │ │ │ │ │ +HASH-KEYS │ │ │ │ │ +HASH-VALUES │ │ │ │ │ +EXTERNAL-SYMBOL │ │ │ │ │ +PRESENT-SYMBOL │ │ │ │ │ +PRESENT-SYMBOLS │ │ │ │ │ multiple specializing masters: ~S │ │ │ │ │ ~@ │ │ │ │ │ +\E\YXkaSRPXXjkZyd │ │ │ │ │ bF:'eH*E │ │ │ │ │ .~A ~S~:[~:A~;~] │ │ │ │ │ ;;; [~W] │ │ │ │ │ .SKIP ~D │ │ │ │ │ ~&~@<(A ~S was caught when trying to print ~S when entering the debugger. Printing was aborted and the ~S was stored in ~S.)~@:> │ │ │ │ │ ~&(CELL-ERROR-NAME ~S) = ~S │ │ │ │ │ ~@ │ │ │ │ │ @@ -43600,16 +43520,18 @@ │ │ │ │ │ There is no variable information available. │ │ │ │ │ ~W~:[~;[~W~]] │ │ │ │ │ return: │ │ │ │ │ ~@ │ │ │ │ │ ~&OUT can only be used step out of frames that were originally stepped into with STEP. │ │ │ │ │ ; No debug variables for current frame: using EVAL instead of EVAL-IN-FRAME. │ │ │ │ │ more unavailable arguments │ │ │ │ │ -dynamic-extent: ~S │ │ │ │ │ -error printing dynamic-extent object │ │ │ │ │ +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. │ │ │ │ │ the value of the most recent top level EVAL │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-INT0"' │ │ │ │ │ CE:2j&SiG │ │ │ │ │ COMMON-LISP │ │ │ │ │ @@ -43747,37 +43669,14 @@ │ │ │ │ │ OPERATION │ │ │ │ │ COMMON-LISP │ │ │ │ │ This function simply returns what was passed to it. │ │ │ │ │ SYNONYM-STREAM-EQUALP │ │ │ │ │ A SB-KERNEL0 │ │ │ │ │ REST-ARG │ │ │ │ │ REST-ARG │ │ │ │ │ -/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 │ │ │ │ │ SEGMENT0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ GENERAL0 │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP0 │ │ │ │ │ @@ -43787,62 +43686,61 @@ │ │ │ │ │ CUR-OFFS │ │ │ │ │ COMMON-LISP │ │ │ │ │ SLOTS-TAIL0 │ │ │ │ │ LIMIT-STRING │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ DEBUG-FUN │ │ │ │ │ COMMON-LISP │ │ │ │ │ -COMMON-LISP │ │ │ │ │ ARG-COUNT │ │ │ │ │ ESCAPED0 │ │ │ │ │ DEFAULT0 │ │ │ │ │ LOCATION │ │ │ │ │ -ARGUMENT-LIMIT │ │ │ │ │ -METHOD-FRAME-STYLE │ │ │ │ │ UWP-BLOCK │ │ │ │ │ DECODE-PCS │ │ │ │ │ COMMON-LISP │ │ │ │ │ OPTIONAL-ARGS │ │ │ │ │ EOF-MARKER0 │ │ │ │ │ EOF-RESTART │ │ │ │ │ COMMON-LISP │ │ │ │ │ COMMON-LISP │ │ │ │ │ -WORD-ACCUM.PRINTER │ │ │ │ │ -COMMON-LISP │ │ │ │ │ -IMM-WORD-16.PREFILTER │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ +WORD-ACCUM.PRINTER │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +IMM-WORD-16.PREFILTER │ │ │ │ │ +SB-DISASSEM │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL0 │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ │ VALUE SB-KERNEL │ │ │ │ │ SB-DISASSEM │ │ │ │ │ SB-DISASSEM │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-DISASSEM │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ COMMON-LISP │ │ │ │ │ SB-DISASSEM │ │ │ │ │ -SB-DISASSEM │ │ │ │ │ x )x_7/v │ │ │ │ │ ARGUMENTS │ │ │ │ │ COMPONENT │ │ │ │ │ ASDF/COMPONENT │ │ │ │ │ ARGUMENTS0 │ │ │ │ │ COMPONENT │ │ │ │ │ ASDF/COMPONENT │ │ │ │ │ -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. │ │ │ │ │ +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 │ │ │ │ │ +asdf-package-system │ │ │ │ │ PACKED-INFO-EQUALP │ │ │ │ │ SPLIT-ORDERED-LIST-EQUALP │ │ │ │ │ LAYOUT-EQUALP │ │ │ │ │ CLASSOID-CELL-EQUALP │ │ │ │ │ NAMED-TYPE-EQUALP │ │ │ │ │ DEFINITION-SOURCE-LOCATION-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ @@ -43859,27 +43757,130 @@ │ │ │ │ │ LAST-GEN │ │ │ │ │ VOP-INFO-EQUALP │ │ │ │ │ STRING-INPUT-STREAM-EQUALP │ │ │ │ │ FINITE-BASE-STRING-OUTPUT-STREAM-EQUALP │ │ │ │ │ CASE-FROB-STREAM-EQUALP │ │ │ │ │ A SB-KERNEL │ │ │ │ │ STUB-STREAM-EQUALP │ │ │ │ │ +REST-ARG │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SIZE8+g% │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +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 │ │ │ │ │ +SIZE8,g! │ │ │ │ │ +SIZE8,g! │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +"kW0333q │ │ │ │ │ +STACK-DELTA0 │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +COMMON-LISP │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SIZE8&g$ │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +COMMON-LISP0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +DESTINATION │ │ │ │ │ +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 │ │ │ │ │ +OPTIONAL-ARGS │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +SEGMENT0 │ │ │ │ │ +.ANONYMOUS. │ │ │ │ │ +MARK-INDEX │ │ │ │ │ WIDTH.PREFILTER │ │ │ │ │ IMM.PREFILTER │ │ │ │ │ WIDTH.PRINTER │ │ │ │ │ COMMON-LISP │ │ │ │ │ SEG.PREFILTER │ │ │ │ │ +X66.PREFILTER │ │ │ │ │ XUdKw\iXU │ │ │ │ │ The control string is not a constant. │ │ │ │ │ ~~// directive mentions unknown package │ │ │ │ │ k!(+--- ) Aj │ │ │ │ │ /IL@\^Xa[Xp │ │ │ │ │ \^Xa[X{[[X │ │ │ │ │ not a word-sized integer │ │ │ │ │ -X66.PREFILTER │ │ │ │ │ +SRC-SIZE │ │ │ │ │ WITHOUT-INTERRUPTS-BODY-3 │ │ │ │ │ CLEANUP-FUN-21 │ │ │ │ │ CLEANUP-FUN-13 │ │ │ │ │ Combine %negate/* │ │ │ │ │ Eliminate %negate/%negate of rationals │ │ │ │ │ ARG-NAMES │ │ │ │ │ ARG-NAMES