--- /srv/rebuilderd/tmp/rebuilderdcc0IQX/inputs/cafeobj_1.6.0-2_riscv64.deb +++ /srv/rebuilderd/tmp/rebuilderdcc0IQX/out/cafeobj_1.6.0-2_riscv64.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2020-02-18 20:27:40.000000 debian-binary │ --rw-r--r-- 0 0 0 2752 2020-02-18 20:27:40.000000 control.tar.xz │ --rw-r--r-- 0 0 0 12401772 2020-02-18 20:27:40.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 2748 2020-02-18 20:27:40.000000 control.tar.xz │ +-rw-r--r-- 0 0 0 12383492 2020-02-18 20:27:40.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./control │ │ │ @@ -1,12 +1,12 @@ │ │ │ Package: cafeobj │ │ │ Version: 1.6.0-2 │ │ │ Architecture: riscv64 │ │ │ Maintainer: Norbert Preining │ │ │ -Installed-Size: 53637 │ │ │ +Installed-Size: 53653 │ │ │ Depends: libc6 (>= 2.38), libzstd1 (>= 1.5.5) │ │ │ Section: science │ │ │ Priority: optional │ │ │ Homepage: http://cafeobj.org/ │ │ │ Description: new generation algebraic specification and programming language │ │ │ CafeOBJ is a most advanced formal specification language which │ │ │ inherits many advanced features (e.g. flexible mix-fix syntax, │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── file list │ │ │ @@ -1,15 +1,15 @@ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/bin/ │ │ │ -rwxr-xr-x 0 root (0) root (0) 5442 2020-02-18 20:27:40.000000 ./usr/bin/cafeobj │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/lib/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/lib/cafeobj-1.6/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/lib/cafeobj-1.6/sbcl/ │ │ │ --rwxr-xr-x 0 root (0) root (0) 52002144 2020-02-18 20:27:40.000000 ./usr/lib/cafeobj-1.6/sbcl/cafeobj.sbcl │ │ │ +-rwxr-xr-x 0 root (0) root (0) 52018568 2020-02-18 20:27:40.000000 ./usr/lib/cafeobj-1.6/sbcl/cafeobj.sbcl │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/share/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/lib/ │ │ │ -rw-r--r-- 0 root (0) root (0) 1785 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/lib/2tuple.cafe │ │ │ -rw-r--r-- 0 root (0) root (0) 1939 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/lib/3tuple.cafe │ │ │ -rw-r--r-- 0 root (0) root (0) 2103 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/lib/4tuple.cafe │ │ │ -rw-r--r-- 0 root (0) root (0) 2211 2020-02-18 20:27:40.000000 ./usr/share/cafeobj-1.6/lib/base_bool.cafe │ │ ├── ./usr/lib/cafeobj-1.6/sbcl/cafeobj.sbcl │ │ │ ├── strings --all --bytes=8 {} │ │ │ │ @@ -1690,15 +1690,15 @@ │ │ │ │ .got.plt │ │ │ │ .riscv.attributes │ │ │ │ .gnu_debuglink │ │ │ │ hostname-id-1731495447 │ │ │ │ '01 '4A '8Q '8U │ │ │ │ >>>>>>>> │ │ │ │ #0C #4# #8 │ │ │ │ ~~~~~~~~JJJJJJJJ │ │ │ │ I iS%Ob;O │ │ │ │ #0# #4C #8 │ │ │ │ +d1wg_uYC%BO │ │ │ │ #0c #4C #8# #< │ │ │ │ ~~~~~~~~JJJJJJJJ │ │ │ │ #8s #R │ │ │ │ ++*,*-j/J │ │ │ │ +IMJ-JmLmJmM │ │ │ │ +q7w7xWyWz │ │ │ │ +5z6:5Z6Z9 │ │ │ │ +CZDzCZFZEzC │ │ │ │ #0# #4C #8 │ │ │ │ #0# #4C #8 │ │ │ │ #<# #0C │ │ │ │ #4# #8C #4 │ │ │ │ #8# #g<'@ │ │ │ │ +0(4h4h6(4H8h8 │ │ │ │ +6 8I8)9) │ │ │ │ +CID)@ID H │ │ │ │ +PjT*XjXJP │ │ │ │ +,K0k4+2K,K │ │ │ │ + , ,"L l$ │ │ │ │ +DMHMLML- │ │ │ │ +4N4N6N4n8n8n:.8 │ │ │ │ +L.PNPnL.P │ │ │ │ +PoTOTOPOT │ │ │ │ +tqt1pqtquQx1t │ │ │ │ +PrRRP2TrT │ │ │ │ +prrrpRt2t │ │ │ │ +LsPsNsLSP │ │ │ │ +Z3X3\3\SXS\ │ │ │ │ +`s^SX3`3dsd │ │ │ │ +ntrTpttTt4v │ │ │ │ +DwHwLWLwH │ │ │ │ +lzhz`zp:p │ │ │ │ #0s #FIXNUM │ │ │ │ -FAST-*/UNSIGNED=>UNSIGNED │ │ │ │ DEFINE-ALIEN-TYPE-TRANSLATOR │ │ │ │ FREEZE-TYPE │ │ │ │ REQUIRED-ARG │ │ │ │ FUN-START │ │ │ │ CALLABLE │ │ │ │ %ALIEN-VALUE │ │ │ │ SLOT-ACCESSOR │ │ │ │ +FAST-*/FIXNUM=>FIXNUM │ │ │ │ +FAST-*/UNSIGNED=>UNSIGNED │ │ │ │ FAST-*/SIGNED=>SIGNED │ │ │ │ */SINGLE-FLOAT │ │ │ │ */DOUBLE-FLOAT │ │ │ │ INSTALL-GUARD-FUNCTION │ │ │ │ SOURCE-TRANSFORM-NULL │ │ │ │ MULTI-COMPARE │ │ │ │ -*SAVED-FINALIZERS* │ │ │ │ *-DERIVE-TYPE-OPTIMIZER │ │ │ │ *-CONSTRAINT-PROPAGATE-BACK-OPTIMIZER │ │ │ │ +*SAVED-FINALIZERS* │ │ │ │ *FINALIZER-THREAD* │ │ │ │ *OLD-DEBUGGER-HOOK* │ │ │ │ *EXIT-LOCK* │ │ │ │ *ALLOCATOR-MUTEX* │ │ │ │ *INITIAL-THREAD* │ │ │ │ *PACKAGE-TABLE-LOCK* │ │ │ │ SERVE-EVENTS │ │ │ │ @@ -15472,17 +15477,16 @@ │ │ │ │ FUNCTIONALITY │ │ │ │ ENCAPSULATED-FUN │ │ │ │ CONTEXT-ARGUMENTS │ │ │ │ GC-RUN-TIME │ │ │ │ ANCESTOR │ │ │ │ GATHER-TYPE │ │ │ │ COMPONENT-TYPE │ │ │ │ -START-OF-END-STRING-P │ │ │ │ -NO-NEWLINE-P │ │ │ │ MULTI-LINE-P │ │ │ │ +NO-NEWLINE-P │ │ │ │ SINGLE-LINE-P │ │ │ │ NEGATEDP │ │ │ │ ELSE-REGEX │ │ │ │ SYMBOL-CALL │ │ │ │ COMPILE-CONDITION-DESCRIPTION │ │ │ │ COMPILE-CONDITION-CONTEXT-FORMAT │ │ │ │ COMPILE-CONDITION-CONTEXT-ARGUMENTS │ │ │ │ @@ -17472,53 +17476,59 @@ │ │ │ │ READTABLE-NORMALIZATION │ │ │ │ UNSCHEDULE-TIMER │ │ │ │ DECIMAL-WITH-GROUPED-DIGITS-WIDTH │ │ │ │ PROCESS-PID │ │ │ │ LONG-FLOAT-NEGATIVE-INFINITY │ │ │ │ LONG-FLOAT-POSITIVE-INFINITY │ │ │ │ ATOMIC-PUSH │ │ │ │ -SORT-RELATIONS │ │ │ │ PRINCIPAL-SORT │ │ │ │ +SORT-RELATIONS │ │ │ │ +$$ACTION-STACK │ │ │ │ +SPECIAL-BINDINGS │ │ │ │ $$RULE-COUNTER │ │ │ │ -$$SELECTION-STACK │ │ │ │ SIGNATURE │ │ │ │ -SORT-NAME-MAP │ │ │ │ -SEM-AXIOMS │ │ │ │ -ERR-SORTS │ │ │ │ +SORT-ORDER │ │ │ │ +SEM-RELATIONS │ │ │ │ OP-INFO-MAP │ │ │ │ -SORT-GRAPH │ │ │ │ +SEM-AXIOMS │ │ │ │ +DUMMY-METHODS │ │ │ │ +OPINFO-TABLE │ │ │ │ +OP-REV-TABLE │ │ │ │ +SUBMODULES │ │ │ │ +TOKEN-SEQ │ │ │ │ STRATEGY │ │ │ │ +ID-SYMBOL │ │ │ │ +LOWER-METHODS │ │ │ │ COHERENT │ │ │ │ -RULES-WITH-SAME-TOP │ │ │ │ -RULES-WITH-DIFFERENT-TOP │ │ │ │ -NEXT-MATCH-METHOD │ │ │ │ -SYS-TO-SOLVE │ │ │ │ -THEORY-INFO │ │ │ │ +ID-CONDITION │ │ │ │ +TRACE-FLAG │ │ │ │ +EXTENSIONS │ │ │ │ THEORY-STATE │ │ │ │ -RULE-NUM │ │ │ │ IS-FINAL │ │ │ │ +CUR-DEPTH │ │ │ │ LAST-SIBLINGS │ │ │ │ -STATE-PREDICATE │ │ │ │ -FINAL-CHECK │ │ │ │ SOL-FOUND │ │ │ │ -INDVAR-SUBST │ │ │ │ +MAX-DEPTH │ │ │ │ +NEXT-CHILD │ │ │ │ +NUM-CHILDREN │ │ │ │ +NUM-GEN-CONST-IND │ │ │ │ +CONSTRUCTOR-OPS │ │ │ │ VAR-SUBST │ │ │ │ +INDVAR-SUBST │ │ │ │ +DEFS-SO-FAR │ │ │ │ +NUM-GEN-CONST │ │ │ │ +BASE-OPS │ │ │ │ CRITICAL-PAIRS │ │ │ │ +STEP-OPS │ │ │ │ STAT-BITS │ │ │ │ -PICK-WEIGHT │ │ │ │ -HEAT-LEVEL │ │ │ │ -BI-DEMODS │ │ │ │ -DEMODULATORS │ │ │ │ -CLAUSE-COUNTER │ │ │ │ CLAUSE-HASH │ │ │ │ CLASHABLES │ │ │ │ -EVALUABLE │ │ │ │ -INITIAL-STATE │ │ │ │ -AFTER-NUM │ │ │ │ AFTER-LOOP │ │ │ │ +AFTER-NUM │ │ │ │ +EVALUATOR │ │ │ │ WALK-LABELS │ │ │ │ STREAM-LINE-LENGTH │ │ │ │ STREAM-LINE-COLUMN │ │ │ │ STREAM-FRESH-LINE │ │ │ │ STREAM-PEEK-CHAR │ │ │ │ STREAM-CLEAR-INPUT │ │ │ │ STREAM-READ-CHAR │ │ │ │ @@ -17876,14 +17886,15 @@ │ │ │ │ ENABLE-INTERRUPT │ │ │ │ UPDATE-ALIEN-LINKAGE-TABLE │ │ │ │ SAP-REF-SINGLE │ │ │ │ GEN-LABEL │ │ │ │ EMIT-LABEL │ │ │ │ SLOT-DEFINITION-ALWAYS-BOUND-P │ │ │ │ SLOT-DEFINITION-INTERNAL-READER-FUNCTION │ │ │ │ +INSTRUCTIONS │ │ │ │ MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION │ │ │ │ CHECKING-SLOT-BOUNDP │ │ │ │ ERROR-OUTPUT-STREAM │ │ │ │ BIDIR-STREAM │ │ │ │ SIGNAL-CODE │ │ │ │ PREFIX-LISP-OBJECT-FILES │ │ │ │ POSTFIX-LISP-OBJECT-FILES │ │ │ │ @@ -25306,15 +25317,14 @@ │ │ │ │ OLD-SYNTAX │ │ │ │ %IS-CHAOS-TERM? │ │ │ │ METHOD-CONTAINED-IN │ │ │ │ *CURRENT-TERM-DEPTH* │ │ │ │ DICTIONARY-ADD-TOKEN-INFO │ │ │ │ THEORY-STATE-MATCH-NEXT-STATE │ │ │ │ %AXIOMS--TYPE │ │ │ │ -INSTRUCTIONS │ │ │ │ MAKE-CAFEOBJ │ │ │ │ *CHAOS-ROOT* │ │ │ │ MAKE-EXEC-IMAGE │ │ │ │ CHAOS-ROOT │ │ │ │ UNIX-OPEN │ │ │ │ POSIX-GETCWD/ │ │ │ │ SIGINT-HANDLER │ │ │ │ @@ -25442,24 +25452,24 @@ │ │ │ │ PRETTY-STREAM-PREFIX │ │ │ │ PRETTY-STREAM-SUFFIX │ │ │ │ PRETTY-STREAM-QUEUE-TAIL │ │ │ │ PRETTY-STREAM-QUEUE-HEAD │ │ │ │ PRETTY-STREAM-PENDING-BLOCKS │ │ │ │ PRETTY-STREAM-PENDING-BLOCKS-LENGTH │ │ │ │ MULTIPLE-VALUES │ │ │ │ +IGNORE-ALL │ │ │ │ INTERPRETED-FUNCTION-NAME │ │ │ │ INTERPRETED-FUNCTION-DEBUG-NAME │ │ │ │ INTERPRETED-FUNCTION-LAMBDA-LIST │ │ │ │ INTERPRETED-FUNCTION-DEBUG-LAMBDA-LIST │ │ │ │ INTERPRETED-FUNCTION-ENV │ │ │ │ INTERPRETED-FUNCTION-DECLARATIONS │ │ │ │ INTERPRETED-FUNCTION-DOCUMENTATION │ │ │ │ INTERPRETED-FUNCTION-BODY │ │ │ │ INTERPRETED-FUNCTION-SOURCE-LOCATION │ │ │ │ -IGNORE-ALL │ │ │ │ MAKE-EVAL-LEXENV │ │ │ │ ANNOTATION-POSN │ │ │ │ ANNOTATION-INDEX │ │ │ │ LABEL-INDEX │ │ │ │ LABEL-POSN │ │ │ │ LABEL-COMMENT │ │ │ │ NON-PACKED │ │ │ │ @@ -25468,26 +25478,25 @@ │ │ │ │ STANDARD-FUNCALLABLE-INSTANCE-HASH-CODE │ │ │ │ MAKE-PPRINT-DISPATCH-TABLE │ │ │ │ PP-DISPATCH-ENTRIES │ │ │ │ PP-DISPATCH-CONS-ENTRIES │ │ │ │ PP-DISPATCH-NUMBER-MATCHABLE-P │ │ │ │ PP-DISPATCH-ONLY-INITIAL-ENTRIES │ │ │ │ BIVALENT │ │ │ │ +MAKE-FASL-INPUT │ │ │ │ +%MAKE-ARG │ │ │ │ +MAKE-INST-FORMAT │ │ │ │ %FASL-INPUT-STREAM │ │ │ │ %FASL-INPUT-TABLE │ │ │ │ %FASL-INPUT-STACK │ │ │ │ %FASL-INPUT-NAME-BUFFER │ │ │ │ %FASL-INPUT-PRINT │ │ │ │ %FASL-INPUT-PARTIAL-SOURCE-INFO │ │ │ │ FASL-GROUP-HEADER-LABEL │ │ │ │ FASL-GROUP-FUN-NAMES │ │ │ │ -MAKE-FASL-INPUT │ │ │ │ -%MAKE-ARG │ │ │ │ -MAKE-INST-FORMAT │ │ │ │ -MAKE-INSTRUCTION │ │ │ │ ARG-FIELDS │ │ │ │ ARG-VALUE │ │ │ │ ARG-SIGN-EXTEND-P │ │ │ │ ARG-PRINTER │ │ │ │ ARG-PREFILTER │ │ │ │ ARG-USE-LABEL │ │ │ │ DISASSEM-LENGTH │ │ │ │ @@ -25510,47 +25519,48 @@ │ │ │ │ SEGMENT-WRITERS │ │ │ │ SEGMENT-BRANCH-COUNTDOWN │ │ │ │ SEGMENT-EMITTABLE-INSTS-SSET │ │ │ │ SEGMENT-QUEUED-BRANCHES │ │ │ │ SEGMENT-DELAYED │ │ │ │ SEGMENT-EMITTABLE-INSTS-QUEUE │ │ │ │ SEGMENT-FIXUP-NOTES │ │ │ │ +MAKE-INSTRUCTION │ │ │ │ INST-EMITTER │ │ │ │ INST-ATTRIBUTES │ │ │ │ INST-DELAY │ │ │ │ INST-DEPTH │ │ │ │ INST-READ-DEPENDENCIES │ │ │ │ INST-WRITE-DEPENDENCIES │ │ │ │ INST-WRITE-DEPENDENTS │ │ │ │ INST-READ-DEPENDENTS │ │ │ │ +MAKE-STMT │ │ │ │ +MAKE-ALIGNMENT │ │ │ │ +MAKE-BACK-PATCH │ │ │ │ STMT-VOP │ │ │ │ ASMSTREAM-DATA-ORIGIN-LABEL │ │ │ │ ASMSTREAM-TEXT-ORIGIN-LABEL │ │ │ │ ASMSTREAM-INTER-FUNCTION-PADDING │ │ │ │ ASMSTREAM-ALLOC-POINTS │ │ │ │ -MAKE-STMT │ │ │ │ -MAKE-ALIGNMENT │ │ │ │ -MAKE-BACK-PATCH │ │ │ │ -MAKE-CHOOSER │ │ │ │ -MAKE-FILLER │ │ │ │ -MAKE-STORAGE-INFO │ │ │ │ -%MAKE-SEGMENT │ │ │ │ -%MAKE-DSTATE │ │ │ │ -%MAKE-VERTEX │ │ │ │ -%MAKE-INTERFERENCE-GRAPH │ │ │ │ ASMSTREAM-INDIRECTION-TABLE │ │ │ │ ASMSTREAM-TRACING-STATE │ │ │ │ ALIGNMENT-INDEX │ │ │ │ ALIGNMENT-POSN │ │ │ │ ALIGNMENT-BITS │ │ │ │ ALIGNMENT-SIZE │ │ │ │ ALIGNMENT-PATTERN │ │ │ │ BACK-PATCH-INDEX │ │ │ │ BACK-PATCH-POSN │ │ │ │ BACK-PATCH-SIZE │ │ │ │ +MAKE-CHOOSER │ │ │ │ +MAKE-FILLER │ │ │ │ +MAKE-STORAGE-INFO │ │ │ │ +%MAKE-SEGMENT │ │ │ │ +%MAKE-DSTATE │ │ │ │ +%MAKE-VERTEX │ │ │ │ +%MAKE-INTERFERENCE-GRAPH │ │ │ │ BACK-PATCH-FUN │ │ │ │ CHOOSER-INDEX │ │ │ │ CHOOSER-POSN │ │ │ │ CHOOSER-SIZE │ │ │ │ CHOOSER-ALIGNMENT │ │ │ │ CHOOSER-MAYBE-SHRINK │ │ │ │ CHOOSER-WORST-CASE-FUN │ │ │ │ @@ -25659,80 +25669,80 @@ │ │ │ │ TAB-RELATIVEP │ │ │ │ TAB-COLNUM │ │ │ │ TAB-COLINC │ │ │ │ PPRINT-DISPATCH-ENTRY-TYPE │ │ │ │ PPRINT-DISPATCH-ENTRY-TEST-FN │ │ │ │ PPRINT-DISPATCH-ENTRY-PRIORITY │ │ │ │ PPRINT-DISPATCH-ENTRY-FUN │ │ │ │ -MAKE-INST-SPACE │ │ │ │ -MAKE-INST-SPACE-CHOICE │ │ │ │ -MAKE-OFFS-HOOK │ │ │ │ -MAKE-SOURCE-FORM-CACHE │ │ │ │ -MAKE-LOCATION-GROUP │ │ │ │ INST-NAME │ │ │ │ INST-FORMAT-NAME │ │ │ │ INST-MASK │ │ │ │ DCHUNK-ZERO │ │ │ │ INST-LENGTH │ │ │ │ INST-PRINT-NAME │ │ │ │ INST-PREFILTER │ │ │ │ INST-LABELLER │ │ │ │ INST-PRINTER │ │ │ │ INST-CONTROL │ │ │ │ INST-SPECIALIZERS │ │ │ │ +MAKE-INST-SPACE │ │ │ │ +MAKE-INST-SPACE-CHOICE │ │ │ │ +MAKE-OFFS-HOOK │ │ │ │ +MAKE-SOURCE-FORM-CACHE │ │ │ │ +MAKE-LOCATION-GROUP │ │ │ │ ISPACE-VALID-MASK │ │ │ │ ISPACE-CHOICES │ │ │ │ ISCHOICE-COMMON-ID │ │ │ │ ISCHOICE-SUBSPACE │ │ │ │ OFFS-HOOK-OFFSET │ │ │ │ OFFS-HOOK-FUN │ │ │ │ OFFS-HOOK-BEFORE-ADDRESS │ │ │ │ SFCACHE-DEBUG-SOURCE │ │ │ │ SFCACHE-TOPLEVEL-FORM-INDEX │ │ │ │ SFCACHE-LAST-LOCATION-RETRIEVED │ │ │ │ SFCACHE-LAST-FORM-RETRIEVED │ │ │ │ LOCATION-GROUP-LOCATIONS │ │ │ │ UNPRINTABLE-OBJECT-STRING │ │ │ │ +FAST-METHOD-CALL-FUNCTION │ │ │ │ +FAST-METHOD-CALL-PV │ │ │ │ +FAST-METHOD-CALL-NEXT-METHOD-CALL │ │ │ │ +FAST-METHOD-CALL-ARG-INFO │ │ │ │ +SLOT-INFO-TYPECHECK │ │ │ │ +SLOT-INFO-ALLOCATION │ │ │ │ +SLOT-INFO-LOCATION │ │ │ │ +SLOT-INFO-READER │ │ │ │ +SLOT-INFO-WRITER │ │ │ │ +SLOT-INFO-BOUNDP │ │ │ │ +SLOT-INFO-MAKUNBOUND │ │ │ │ MAKE-FAST-METHOD-CALL │ │ │ │ MAKE-SLOT-INFO │ │ │ │ MAKE-LOOP-COLLECTOR │ │ │ │ MAKE-LOOP-MINIMAX-INTERNAL │ │ │ │ MAKE-LOOP-PATH │ │ │ │ MAKE-TRACE-INFO │ │ │ │ MAKE-FGEN │ │ │ │ %MAKE-CACHE │ │ │ │ MAKE-METHOD-CALL │ │ │ │ MAKE-CONSTANT-METHOD-CALL │ │ │ │ METHOD-CALL-CALL-METHOD-ARGS │ │ │ │ METHOD-CALL-FUNCTION │ │ │ │ MAKE-CONSTANT-FAST-METHOD-CALL │ │ │ │ -FAST-METHOD-CALL-ARG-INFO │ │ │ │ -FAST-METHOD-CALL-NEXT-METHOD-CALL │ │ │ │ -FAST-METHOD-CALL-PV │ │ │ │ -FAST-METHOD-CALL-FUNCTION │ │ │ │ MAKE-FAST-INSTANCE-BOUNDP │ │ │ │ MAKE-PV-TABLE │ │ │ │ NO-METHODS-DFUN-INFO │ │ │ │ DFUN-INFO-CACHE │ │ │ │ DISPATCH-DFUN-INFO │ │ │ │ DEFAULT-METHOD-ONLY-DFUN-INFO │ │ │ │ ACCESSOR-DFUN-INFO-ACCESSOR-TYPE │ │ │ │ ACCESSOR-DFUN-INFO-CACHE │ │ │ │ N-N-DFUN-INFO │ │ │ │ ONE-CLASS-DFUN-INFO │ │ │ │ ONE-INDEX-DFUN-INFO-INDEX │ │ │ │ ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE │ │ │ │ ONE-INDEX-DFUN-INFO-CACHE │ │ │ │ -SLOT-INFO-TYPECHECK │ │ │ │ -SLOT-INFO-ALLOCATION │ │ │ │ -SLOT-INFO-LOCATION │ │ │ │ -SLOT-INFO-READER │ │ │ │ -SLOT-INFO-WRITER │ │ │ │ -SLOT-INFO-BOUNDP │ │ │ │ -SLOT-INFO-MAKUNBOUND │ │ │ │ LOOP-COLLECTOR-NAME │ │ │ │ LOOP-COLLECTOR-CLASS │ │ │ │ LOOP-COLLECTOR-HISTORY │ │ │ │ LOOP-COLLECTOR-TEMPVARS │ │ │ │ LOOP-COLLECTOR-SPECIFIED-TYPE │ │ │ │ LOOP-COLLECTOR-DTYPE │ │ │ │ LOOP-COLLECTOR-DATA │ │ │ │ @@ -25800,28 +25810,28 @@ │ │ │ │ N-N-ACCESSOR-TYPE │ │ │ │ ONE-CLASS-CACHE │ │ │ │ ONE-CLASS-ACCESSOR-TYPE │ │ │ │ ONE-CLASS-INDEX │ │ │ │ ONE-CLASS-WRAPPER0 │ │ │ │ DEFAULT-INITARGS │ │ │ │ *CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P* │ │ │ │ +TWO-CLASS-DFUN-INFO │ │ │ │ +CHECKING-DFUN-INFO │ │ │ │ +CACHING-DFUN-INFO │ │ │ │ +CONSTANT-VALUE-DFUN-INFO │ │ │ │ TWO-CLASS-CACHE │ │ │ │ TWO-CLASS-ACCESSOR-TYPE │ │ │ │ TWO-CLASS-INDEX │ │ │ │ TWO-CLASS-WRAPPER0 │ │ │ │ TWO-CLASS-WRAPPER1 │ │ │ │ ONE-INDEX-CACHE │ │ │ │ ONE-INDEX-ACCESSOR-TYPE │ │ │ │ ONE-INDEX-INDEX │ │ │ │ CHECKING-CACHE │ │ │ │ CHECKING-FUNCTION │ │ │ │ -TWO-CLASS-DFUN-INFO │ │ │ │ -CHECKING-DFUN-INFO │ │ │ │ -CACHING-DFUN-INFO │ │ │ │ -CONSTANT-VALUE-DFUN-INFO │ │ │ │ CACHING-CACHE │ │ │ │ CONSTANT-VALUE-CACHE │ │ │ │ CTOR-TYPE │ │ │ │ CTOR-CLASS-OR-NAME │ │ │ │ CTOR-CLASS │ │ │ │ CTOR-INITARGS │ │ │ │ CTOR-STATE │ │ │ │ @@ -25841,47 +25851,47 @@ │ │ │ │ ENV-FUNS │ │ │ │ ENV-EXPANDERS │ │ │ │ ENV-SYMBOL-EXPANSIONS │ │ │ │ ENV-TAGS │ │ │ │ ENV-BLOCKS │ │ │ │ ENV-DECLARATIONS │ │ │ │ ENV-NATIVE-LEXENV │ │ │ │ +LINE-RELATIVE │ │ │ │ COUNTER-WORD │ │ │ │ COUNTER-OVERFLOW │ │ │ │ -LINE-RELATIVE │ │ │ │ PROFILE-INFO-NAME │ │ │ │ PROFILE-INFO-ENCAPSULATED-FUN │ │ │ │ PROFILE-INFO-ENCAPSULATION-FUN │ │ │ │ PROFILE-INFO-READ-STATS-FUN │ │ │ │ PROFILE-INFO-CLEAR-STATS-FUN │ │ │ │ OVERHEAD-CALL │ │ │ │ OVERHEAD-INTERNAL │ │ │ │ OVERHEAD-TOTAL │ │ │ │ PPRINT-BLOCK │ │ │ │ -MAKE-TIME-INFO │ │ │ │ TIME-INFO-NAME │ │ │ │ TIME-INFO-CALLS │ │ │ │ TIME-INFO-SECONDS │ │ │ │ TIME-INFO-CONSING │ │ │ │ TIME-INFO-GC-RUN-TIME │ │ │ │ +MAKE-TIME-INFO │ │ │ │ CLASS-SLOT-CELLS │ │ │ │ MAKE-CHARSET │ │ │ │ MAKE-CHARMAP% │ │ │ │ CHARSET-DEPTH │ │ │ │ +PROBE-DEPTH+ │ │ │ │ CHARSET-COUNT │ │ │ │ CHARSET-VECTOR │ │ │ │ CHARMAP-VECTOR │ │ │ │ CHARMAP-START │ │ │ │ CHARMAP-END │ │ │ │ CHARMAP-COUNT │ │ │ │ CHARMAP-COMPLEMENTP │ │ │ │ OPERATION-DESIGNATOR │ │ │ │ -SOURCE-FILE │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-REQUIRE-SYSTEM-NOTIFIED-P* │ │ │ │ +SOURCE-FILE │ │ │ │ LEXER-STR │ │ │ │ LEXER-LEN │ │ │ │ LEXER-REG │ │ │ │ LEXER-POS │ │ │ │ LEXER-LAST-POS │ │ │ │ NO-OUTPUT-FILE │ │ │ │ MAKE-LEXER-INTERNAL │ │ │ │ @@ -26026,30 +26036,31 @@ │ │ │ │ DESTRUCTIVE │ │ │ │ REGEX-STRING │ │ │ │ TARGET-STRING │ │ │ │ UNSUPPLIED │ │ │ │ MAKE-STRUCTURE-SLOT-MAKUNBOUND-FUNCTION │ │ │ │ CAN-MAKUNBOUND │ │ │ │ CANNOT-MAKUNBOUND │ │ │ │ +TRAM-EOF │ │ │ │ +HORIZONTAL │ │ │ │ UNWIND-TO-FRAME-AND-CALL │ │ │ │ *FLUSH-DEBUG-ERRORS* │ │ │ │ FRAME-HAS-DEBUG-TAG-P │ │ │ │ *DEBUG-HELP-STRING* │ │ │ │ MAP-BACKTRACE │ │ │ │ BACKTRACE-AS-LIST │ │ │ │ *MAX-TRACE-INDENTATION* │ │ │ │ *TRACE-INDENTATION-STEP* │ │ │ │ BACKTRACE │ │ │ │ LIST-BACKTRACE │ │ │ │ UNPROFILE │ │ │ │ -TRAM-EOF │ │ │ │ -HORIZONTAL │ │ │ │ WALK-SETQ │ │ │ │ WALK-LET* │ │ │ │ ABSOLUTE │ │ │ │ +INTERPRET │ │ │ │ GET-TIMEZONE │ │ │ │ MICROSECONDS-PER-INTERNAL-TIME-UNIT │ │ │ │ INTERRUPT-IT │ │ │ │ LIBC-NAME-FOR │ │ │ │ TIMEOUT-SECS │ │ │ │ *ON-DANGEROUS-WAIT* │ │ │ │ NEWCHARSTAR │ │ │ │ @@ -26088,18 +26099,17 @@ │ │ │ │ SIGINFO-CODE │ │ │ │ VAL-SECS │ │ │ │ RETURN-TYPE │ │ │ │ EXCEPTION-FDS │ │ │ │ ITIMERVAL │ │ │ │ INTERRUPTION │ │ │ │ RELATIVE-TO │ │ │ │ -INTERPRET │ │ │ │ CHAOS-ERROR-HANDLER │ │ │ │ -WALK-LET │ │ │ │ FORTHCOMING-DEFCLASS-TYPE │ │ │ │ +WALK-LET │ │ │ │ COMPACT-SYMBOL │ │ │ │ COMPARE-AND-SWAP-VOPS │ │ │ │ GENERATIONAL │ │ │ │ MEMORY-BARRIER-VOPS │ │ │ │ OS-PROVIDES-GETPROTOBY-R │ │ │ │ OS-PROVIDES-POSIX-SPAWN │ │ │ │ OS-PROVIDES-SUSECONDS-T │ │ │ │ @@ -26123,14 +26133,15 @@ │ │ │ │ COMPUTE-APPLICABLE-METHODS-USING-TYPES │ │ │ │ BACKTRACE-START-FRAME │ │ │ │ PRINT-FRAME-CALL │ │ │ │ GENERIC-FUNCTION-METHODS │ │ │ │ EARLY-METHOD-CLASS │ │ │ │ GLOBAL-MAKUNBOUND-METHOD-P │ │ │ │ GLOBAL-BOUNDP-METHOD-P │ │ │ │ +FUNCTION-TYPE │ │ │ │ STANDARD-WRITER-METHOD-P │ │ │ │ ACCESSOR-METHOD-SLOT-DEFINITION │ │ │ │ SLOT-DEFINITION-CLASS │ │ │ │ GLOBAL-WRITER-METHOD-P │ │ │ │ STANDARD-READER-METHOD-P │ │ │ │ GLOBAL-READER-METHOD-P │ │ │ │ MAKE-ACCESSOR-TABLE │ │ │ │ @@ -26145,15 +26156,14 @@ │ │ │ │ !BOOTSTRAP-SET-SLOT │ │ │ │ CACHE-MISS-VALUES │ │ │ │ INVOKE-EMF │ │ │ │ USE-CACHING-DFUN-P │ │ │ │ MAKE-CACHING-DFUN │ │ │ │ UPDATE-DFUN │ │ │ │ MAKE-CHECKING-DFUN │ │ │ │ -FUNCTION-TYPE │ │ │ │ FORWARD-REFERENCED-CLASS-P │ │ │ │ CLASS-DIRECT-SUPERCLASSES │ │ │ │ MAKE-WRAPPER │ │ │ │ %UPDATE-LISP-CLASS-LAYOUT │ │ │ │ %INVALIDATE-WRAPPER │ │ │ │ CLASSIFY-SLOTDS │ │ │ │ FIND-SLOT-CELL │ │ │ │ @@ -26318,21 +26328,21 @@ │ │ │ │ MORE-ARGUMENT │ │ │ │ MORE-RESULT │ │ │ │ PRESERVE │ │ │ │ MAKE-FOP-VECTOR │ │ │ │ INSTRUCTION-ATTRIBUTES │ │ │ │ MAKE-SECTION │ │ │ │ POSSIBLY-SIGNED-ASSEMBLY-UNIT │ │ │ │ +LONG-NOP │ │ │ │ STRUCT-SET │ │ │ │ SLOT-SET │ │ │ │ BIG-ENDIAN │ │ │ │ MAX-FILTERED-VALUE-INDEX │ │ │ │ BLOCK-BOUNDARY │ │ │ │ RESTRICTED │ │ │ │ -LONG-NOP │ │ │ │ ENSURE-NON-STANDARD-CLASS │ │ │ │ MAKE-GF-HASHSET │ │ │ │ FIND-SYMBOL* │ │ │ │ SESSION-CACHE │ │ │ │ OPERATE-LEVEL │ │ │ │ ASDF-UPGRADED-P │ │ │ │ LONG-DESCRIPTION │ │ │ │ @@ -26397,119 +26407,120 @@ │ │ │ │ **TOKENIZE-CONTROL-STRING-CACHE-VECTOR**-STATS │ │ │ │ *SOFTWARE-VERSION* │ │ │ │ WALK-NAMED-LAMBDA │ │ │ │ INSTRUCTION-HOOKS │ │ │ │ PERFORM-OPERAND-LOWERING │ │ │ │ TRACE-INST │ │ │ │ EXTRACT-PREFIX-KEYWORDS │ │ │ │ +*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ MACROEXPANDS │ │ │ │ WRITER-METHOD-CLASS │ │ │ │ METHOD-CLASS-SUPPLIED-P │ │ │ │ +*THE-CLASS-METHOD* │ │ │ │ METHOD-COMBINATION-SUPPLIED-P │ │ │ │ +DIRECT-SUPERCLASSES-P │ │ │ │ +DIRECT-SLOTS-P │ │ │ │ +DIRECT-DEFAULT-INITARGS-P │ │ │ │ READER-METHOD-CLASS │ │ │ │ ENSURE-CLASS-USING-CLASS │ │ │ │ ADD-WRITER-METHOD │ │ │ │ ADD-READER-METHOD │ │ │ │ -*THE-CLASS-METHOD* │ │ │ │ -*THE-CLASS-STRUCTURE-OBJECT* │ │ │ │ -*THE-CLASS-STANDARD-OBJECT* │ │ │ │ -*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT* │ │ │ │ -*THE-CLASS-T* │ │ │ │ -OBJECT-CLASS │ │ │ │ -METHOD-CLASS-FUNCTION │ │ │ │ COMPUTE-SLOT-ACCESSOR-INFO │ │ │ │ COMPUTE-EFFECTIVE-SLOT-DEFINITION │ │ │ │ SLOT-ACCESSOR-STD-P │ │ │ │ SLOT-ACCESSOR-FUNCTION │ │ │ │ REMOVE-WRITER-METHOD │ │ │ │ REMOVE-READER-METHOD │ │ │ │ REMOVE-DEPENDENT │ │ │ │ MAP-DEPENDENTS │ │ │ │ MAKE-WRITER-METHOD-FUNCTION │ │ │ │ MAKE-READER-METHOD-FUNCTION │ │ │ │ COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS │ │ │ │ -DIRECT-SUPERCLASSES-P │ │ │ │ -DIRECT-SLOTS-P │ │ │ │ -DIRECT-DEFAULT-INITARGS-P │ │ │ │ +COMPUTE-APPLICABLE-METHODS-USING-CLASSES │ │ │ │ REAL-GET-METHOD │ │ │ │ REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION │ │ │ │ REAL-ENSURE-GF-USING-CLASS--NULL │ │ │ │ REAL-MAKE-METHOD-LAMBDA │ │ │ │ REAL-MAKE-METHOD-LAMBDA-USING-SPECIALIZERS │ │ │ │ REAL-MAKE-METHOD-SPECIALIZERS-FORM │ │ │ │ REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/T │ │ │ │ REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/SPECIALIZER │ │ │ │ -COMPUTE-APPLICABLE-METHODS-USING-CLASSES │ │ │ │ +REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/SYMBOL │ │ │ │ +REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/CONS │ │ │ │ +REAL-SPECIALIZER-TYPE-SPECIFIER/T │ │ │ │ +REAL-PARSE-SPECIALIZER-USING-CLASS │ │ │ │ +*THE-CLASS-STRUCTURE-OBJECT* │ │ │ │ +*THE-CLASS-STANDARD-OBJECT* │ │ │ │ +*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT* │ │ │ │ +*THE-CLASS-T* │ │ │ │ +OBJECT-CLASS │ │ │ │ +METHOD-CLASS-FUNCTION │ │ │ │ +DEPENDENTS │ │ │ │ COMPATIBLE-META-CLASS-CHANGE-P │ │ │ │ ADD-DEPENDENT │ │ │ │ -DEPENDENTS │ │ │ │ COMPUTE-PRIMARY-METHODS │ │ │ │ INVALID-QUALIFIERS │ │ │ │ NO-PRIMARY-METHOD │ │ │ │ GET-METHOD │ │ │ │ ENSURE-GENERIC-FUNCTION-USING-CLASS │ │ │ │ MAKE-METHOD-LAMBDA │ │ │ │ MAKE-METHOD-LAMBDA-USING-SPECIALIZERS │ │ │ │ MAKE-METHOD-SPECIALIZERS-FORM │ │ │ │ MAKE-SPECIALIZER-FORM-USING-CLASS │ │ │ │ -*METHOD-LAMBDA-LIST* │ │ │ │ -INTERN-EQL-SPECIALIZER │ │ │ │ -REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/SYMBOL │ │ │ │ -REAL-MAKE-SPECIALIZER-FORM-USING-CLASS/CONS │ │ │ │ -REAL-SPECIALIZER-TYPE-SPECIFIER/T │ │ │ │ -REAL-PARSE-SPECIALIZER-USING-CLASS │ │ │ │ -REAL-UNPARSE-SPECIALIZER-USING-CLASS │ │ │ │ -REAL-MAKE-METHOD-INITARGS-FORM │ │ │ │ -STANDARD-COMPUTE-EFFECTIVE-METHOD │ │ │ │ -SHORT-COMPUTE-EFFECTIVE-METHOD │ │ │ │ -FIND-METHOD-COMBINATION │ │ │ │ SPECIALIZER-TYPE-SPECIFIER │ │ │ │ PARSE-SPECIALIZER-USING-CLASS │ │ │ │ UNPARSE-SPECIALIZER-USING-CLASS │ │ │ │ MAKE-METHOD-INITARGS-FORM │ │ │ │ COMPUTE-EFFECTIVE-METHOD │ │ │ │ +*METHOD-LAMBDA-LIST* │ │ │ │ +INTERN-EQL-SPECIALIZER │ │ │ │ MAKE-METHOD-INITARGS │ │ │ │ +REAL-UNPARSE-SPECIALIZER-USING-CLASS │ │ │ │ +REAL-MAKE-METHOD-INITARGS-FORM │ │ │ │ +STANDARD-COMPUTE-EFFECTIVE-METHOD │ │ │ │ +SHORT-COMPUTE-EFFECTIVE-METHOD │ │ │ │ MOST-SPECIFIC-LAST │ │ │ │ MOST-SPECIFIC-FIRST │ │ │ │ **METHOD-COMBINATIONS** │ │ │ │ +FIND-METHOD-COMBINATION │ │ │ │ *LONG-METHOD-COMBINATION-FUNCTIONS* │ │ │ │ FINISHED │ │ │ │ │ │ │ │ ADJUST-SEQUENCE │ │ │ │ MAKE-SEQUENCE-ITERATOR │ │ │ │ ITERATOR-STEP │ │ │ │ ITERATOR-ENDP │ │ │ │ ITERATOR-ELEMENT │ │ │ │ ITERATOR-INDEX │ │ │ │ ITERATOR-COPY │ │ │ │ RENAME-AND-DELETE │ │ │ │ ASDF/INTERFACE │ │ │ │ COLLECT-DEPENDENCIES │ │ │ │ -ON-WARNINGS │ │ │ │ -ON-FAILURE │ │ │ │ OVERRIDE-CACHE │ │ │ │ OVERRIDE-FORCING │ │ │ │ +ON-WARNINGS │ │ │ │ +ON-FAILURE │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-PROPERTY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-(SETF COMPONENT-PROPERTY)-NOTIFIED-P* │ │ │ │ CASE-SENSITIVE │ │ │ │ CASE-INSENSITIVE │ │ │ │ CASE-MODE │ │ │ │ COMPUTE-OFFSETS │ │ │ │ CONVERT-COMPOUND-PARSE-TREE │ │ │ │ +CONVERT-SIMPLE-PARSE-TREE │ │ │ │ ACCUMULATE-START-P │ │ │ │ POSITIVE-LOOKAHEAD │ │ │ │ POSITIVE-LOOKBEHIND │ │ │ │ REG-SEEN │ │ │ │ REMOVE-REGISTERS-P │ │ │ │ STARTS-WITH │ │ │ │ GREEDY-REPETITION │ │ │ │ REG-NAMES │ │ │ │ NAMED-REG-SEEN │ │ │ │ MAX-BACK-REF │ │ │ │ -CONVERT-SIMPLE-PARSE-TREE │ │ │ │ COMPUTE-MIN-REST │ │ │ │ CREATE-MATCHER-AUX │ │ │ │ CREATE-GREEDY-CONSTANT-LENGTH-MATCHER │ │ │ │ CREATE-GREEDY-NO-ZERO-MATCHER │ │ │ │ CREATE-GREEDY-MATCHER │ │ │ │ CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER │ │ │ │ CREATE-NON-GREEDY-NO-ZERO-MATCHER │ │ │ │ @@ -26533,37 +26544,33 @@ │ │ │ │ END-STRING-OFFSET │ │ │ │ END-ANCHORED-P │ │ │ │ MULTI-LINE-MODE-P │ │ │ │ SINGLE-LINE-MODE-P │ │ │ │ REAL-START-POS │ │ │ │ ARGUMENT-TEST │ │ │ │ IMPORTANT-RESULT-DISCARDED │ │ │ │ -*PPRINT-QUOTE-WITH-SYNTACTIC-SUGAR* │ │ │ │ -TYPED-STRUCTURE │ │ │ │ ID-THEOREM │ │ │ │ IDEM-THEORY │ │ │ │ ID-EXT-THEORY │ │ │ │ AC-THEORY │ │ │ │ A-MIDDLE-THEORY │ │ │ │ A-RIGHT-THEORY │ │ │ │ A-LEFT-THEORY │ │ │ │ DECL-TOPLEVEL │ │ │ │ BAD-RULE │ │ │ │ INNER-MODULE │ │ │ │ DOC-ONLY │ │ │ │ +TYPED-STRUCTURE │ │ │ │ PARTIAL-MACROEXPANDER │ │ │ │ +OBJ-SUPPLIED-P │ │ │ │ NEGATIVE-INFINITY │ │ │ │ POSITIVE-INFINITY │ │ │ │ ENSURE-CLASS-FINALIZED │ │ │ │ CLASS-PROTOTYPE │ │ │ │ -OBJ-SUPPLIED-P │ │ │ │ BODY-NAME- │ │ │ │ -***HERE*** │ │ │ │ -AMBIGUOUS │ │ │ │ -UNKNOWN-RETURN │ │ │ │ EMIT-BYTES │ │ │ │ IF-AFTER │ │ │ │ PROCESS-BACK-PATCHES │ │ │ │ COMPACT-SEGMENT-BUFFER │ │ │ │ OPCODES1 │ │ │ │ STATEMENT │ │ │ │ %EMIT-SKIP │ │ │ │ @@ -26594,14 +26601,16 @@ │ │ │ │ ..INHERITED-LABELS.. │ │ │ │ TOTAL-BITS │ │ │ │ SEGMENT-CURRENT-INDEX │ │ │ │ ADJUST-ALIGNMENT-AFTER-CHOOSER │ │ │ │ FIND-ALIGNMENT │ │ │ │ %ASSEMBLE │ │ │ │ %EMIT-ALIGNMENT │ │ │ │ +***HERE*** │ │ │ │ +AMBIGUOUS │ │ │ │ FOP-PUSH │ │ │ │ FOP-LISP-SYMBOL-SAVE │ │ │ │ FASL-HEADER-P │ │ │ │ CHECK-FASL-HEADER │ │ │ │ FOP-COMPLEX │ │ │ │ READ-WORD-ARG │ │ │ │ OLD-VECTOR │ │ │ │ @@ -26713,14 +26722,15 @@ │ │ │ │ *LOAD-DEPTH* │ │ │ │ LOAD-STREAM │ │ │ │ FOP-INT-CONST1 │ │ │ │ FOP-NAMED-CONSTANT-SET │ │ │ │ FOP-RPLACD │ │ │ │ FOP-NTHCDR │ │ │ │ FOP-COPY-SYMBOL-SAVE │ │ │ │ +UNKNOWN-RETURN │ │ │ │ UPDATE-DEPENDENT │ │ │ │ STANDARD-INSTANCE-ACCESS │ │ │ │ SPECIALIZER-DIRECT-METHODS │ │ │ │ SPECIALIZER-DIRECT-GENERIC-FUNCTIONS │ │ │ │ SLOT-DEFINITION-TYPE │ │ │ │ SLOT-DEFINITION-WRITERS │ │ │ │ SLOT-DEFINITION-READERS │ │ │ │ @@ -26815,23 +26825,23 @@ │ │ │ │ ALIGNED-STACK │ │ │ │ *SYMBOL-MACRO* │ │ │ │ ARG-LVARS │ │ │ │ GOVERNMENT │ │ │ │ VARIANT-COST │ │ │ │ ARG-REFS │ │ │ │ RESULT-REFS │ │ │ │ -SAFE-GF-DFUN-STATE │ │ │ │ SEQUENCE-TYPE │ │ │ │ SINGLE-VALUE-RETURN │ │ │ │ PRE-IR2-OPTIMIZE │ │ │ │ PROGRESS │ │ │ │ STRUCTURE-ALLOC │ │ │ │ -*THE-CLASS-STANDARD-GENERIC-FUNCTION* │ │ │ │ +SAFE-GF-DFUN-STATE │ │ │ │ .NEXT-METHOD-CALL. │ │ │ │ CLASSES-LIST │ │ │ │ +*THE-CLASS-STANDARD-GENERIC-FUNCTION* │ │ │ │ EMIT-N-N-READERS │ │ │ │ EMIT-N-N-BOUNDPS │ │ │ │ EMIT-N-N-MAKUNBOUNDS │ │ │ │ EMIT-N-N-WRITERS │ │ │ │ EMIT-ONE-INDEX-READERS │ │ │ │ EMIT-ONE-INDEX-BOUNDPS │ │ │ │ EMIT-ONE-INDEX-MAKUNBOUNDS │ │ │ │ @@ -26846,16 +26856,16 @@ │ │ │ │ EMIT-ONE-CLASS-WRITER │ │ │ │ EMIT-CACHING │ │ │ │ EMIT-DEFAULT-ONLY │ │ │ │ DEFAULT-ONLY │ │ │ │ EMIT-CHECKING │ │ │ │ WRAPPER-SLOT-LIST │ │ │ │ *THE-CLASS-STANDARD-CLASS* │ │ │ │ -GENERIC-FUNCTION-P │ │ │ │ CALL-NO-NEXT-METHOD │ │ │ │ +GENERIC-FUNCTION-P │ │ │ │ ENSURE-SPACE-IN-BUFFER │ │ │ │ DONT-KNOW │ │ │ │ OWRAPPER │ │ │ │ NWRAPPER │ │ │ │ EXIT-IF-NULL │ │ │ │ +CTOR-TABLE-MAX-SIZE+ │ │ │ │ +SLOT-UNBOUND+ │ │ │ │ @@ -28545,57 +28555,58 @@ │ │ │ │ MAX-PROOFS-EXIT │ │ │ │ MODIFIER-TONE-LETTERS │ │ │ │ VITHKUQI │ │ │ │ PPRINT-LENGTH-CHECK* │ │ │ │ NORMALIZED-P │ │ │ │ SESSION-OPERATE-LEVEL │ │ │ │ *EXTENDED-MODE-P* │ │ │ │ -MAKE-ARRAY-FROM-TWO-CHARS │ │ │ │ ALIEN-STAT │ │ │ │ +MAKE-ARRAY-FROM-TWO-CHARS │ │ │ │ WITH-ALIEN-STAT │ │ │ │ COMPUTE-CODE-FROM-RA │ │ │ │ REPLACEMENT-FUNCTION │ │ │ │ LOOP-STANDARD-EXPANSION │ │ │ │ -*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ -*DISASSEM-INST-SPACE* │ │ │ │ WALKER-ENVIRONMENT-BIND-1 │ │ │ │ WITH-AUGMENTED-ENVIRONMENT-INTERNAL │ │ │ │ +*ASSEMBLER-ROUTINES-BY-ADDR* │ │ │ │ +*DISASSEM-INST-SPACE* │ │ │ │ WALK-ARGLIST │ │ │ │ WALK-REPEAT-EVAL │ │ │ │ WALK-DECLARATIONS │ │ │ │ CONVERT-MACRO-TO-LAMBDA │ │ │ │ +DCHUNK-EXTRACT │ │ │ │ NOTE-SIGNIFICANT-SPACE │ │ │ │ CANONIZE-TEST │ │ │ │ CANONIZE-KEY │ │ │ │ N-ARRAY26 │ │ │ │ %COMPONENT-ENCODING │ │ │ │ %ADDITIONAL-INPUT-FILES │ │ │ │ MODULE-COMPONENTS-BY-NAME │ │ │ │ +REQUIRED-MODULE │ │ │ │ ACTION-OVERRIDE-P │ │ │ │ MERGE-ACTION-STATUS │ │ │ │ -REQUIRED-MODULE │ │ │ │ PREBUILT-SYSTEM-STATIC-LIBRARY │ │ │ │ REGEX-LENGTH │ │ │ │ REGEX-MIN-LENGTH │ │ │ │ MAYBE-SPLIT-REPETITION │ │ │ │ REMOVE-REGISTERS │ │ │ │ EVERYTHINGP │ │ │ │ CONVERT-CHAR-CLASS-TO-TEST-FUNCTION │ │ │ │ RESOLVE-PROPERTY │ │ │ │ COMPLEMENT* │ │ │ │ -FLOCK-TYPE │ │ │ │ -FLOCK-WHENCE │ │ │ │ -FLOCK-START │ │ │ │ -FLOCK-LEN │ │ │ │ CREATE-GREEDY-EVERYTHING-MATCHER │ │ │ │ GATHER-STRINGS │ │ │ │ START-ANCHORED-P │ │ │ │ CREATE-SCANNER-AUX │ │ │ │ CREATE-BMH-MATCHER │ │ │ │ CREATE-CHAR-SEARCHER │ │ │ │ +FLOCK-TYPE │ │ │ │ +FLOCK-WHENCE │ │ │ │ +FLOCK-START │ │ │ │ +FLOCK-LEN │ │ │ │ PASSWD-NAME │ │ │ │ PASSWD-PASSWD │ │ │ │ PASSWD-UID │ │ │ │ PASSWD-GID │ │ │ │ PASSWD-GECOS │ │ │ │ PASSWD-DIR │ │ │ │ PASSWD-SHELL │ │ │ │ @@ -28606,15 +28617,14 @@ │ │ │ │ TIMEVAL-SEC │ │ │ │ TIMEVAL-USEC │ │ │ │ TERMIOS-IFLAG │ │ │ │ TERMIOS-OFLAG │ │ │ │ TERMIOS-CFLAG │ │ │ │ TERMIOS-LFLAG │ │ │ │ TERMIOS-CC │ │ │ │ -DCHUNK-EXTRACT │ │ │ │ COMPUTE-OVERHEAD-AUX │ │ │ │ COMPUTE-OVERHEAD │ │ │ │ PROFILE-1-UNPROFILED-FUN │ │ │ │ *ENCLOSED-CONSING* │ │ │ │ INCF-COUNTER │ │ │ │ %INCF-OVERFLOW │ │ │ │ *ENCLOSED-TICKS* │ │ │ │ @@ -28694,14 +28704,42 @@ │ │ │ │ ASSERT-NOT-STANDARD-PPRINT-DISPATCH-TABLE │ │ │ │ PPRINT-QUOTE │ │ │ │ PPRINT-DEFMETHOD │ │ │ │ COMPUTE-TEST-FN │ │ │ │ PPRINT-DEFPACKAGE │ │ │ │ PPRINT-DECLARE │ │ │ │ PPRINT-ARRAY-P │ │ │ │ +MACHINE-WORD │ │ │ │ +AMOSWAP.W │ │ │ │ +AMOSWAP.D │ │ │ │ +AMOADD.W │ │ │ │ +AMOADD.D │ │ │ │ +AMOXOR.W │ │ │ │ +AMOXOR.D │ │ │ │ +AMOAND.W │ │ │ │ +AMOAND.D │ │ │ │ +AMOMIN.W │ │ │ │ +AMOMIN.D │ │ │ │ +AMOMAX.W │ │ │ │ +AMOMAX.D │ │ │ │ +AMOMINU.W │ │ │ │ +AMOMINU.D │ │ │ │ +AMOMAXU.W │ │ │ │ +AMOMAXU.D │ │ │ │ +FCVTWU<- │ │ │ │ +FCVTLU<- │ │ │ │ +FCVTWU-> │ │ │ │ +COMPUTE-CODE-FROM-FN │ │ │ │ +COMPUTE-RA-FROM-CODE │ │ │ │ +SIMPLE-FUN-HEADER-WORD │ │ │ │ +.LAYOUT-ID-FIXUP │ │ │ │ +STORE-COVERAGE-MARK │ │ │ │ +C.ADDISP16 │ │ │ │ +C.ADDI4SPN │ │ │ │ +C.EBREAK │ │ │ │ VECTOR-SAP-MAKER │ │ │ │ ADD-SEGMENT-LABELS │ │ │ │ ADD-DEBUGGING-HOOKS │ │ │ │ PRINT-BLOCK-BOUNDARY │ │ │ │ ERROR-PARSE-FUN │ │ │ │ MEMORY-SAP-MAKER │ │ │ │ *DISASSEM-INST-COLUMN-WIDTH* │ │ │ │ @@ -29088,23 +29126,23 @@ │ │ │ │ SEPARATORP │ │ │ │ COLLECTORS │ │ │ │ +SIMPLE-CONDITION-FORMAT-CONTROL-SLOT+ │ │ │ │ TIMESTAMPS │ │ │ │ FROB-SUBSTRINGS │ │ │ │ WHITESPACEP │ │ │ │ GREEDY-QUANT │ │ │ │ -SESSION-ANCESTOR │ │ │ │ ADJUSTMENT │ │ │ │ REIFIED-DEFERRED-WARNINGS │ │ │ │ CHECK-FLAG │ │ │ │ SETTINGS │ │ │ │ CALL-WITH-SAVED-DEFERRED-WARNINGS │ │ │ │ SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P │ │ │ │ REIFY-UNDEFINED-WARNING │ │ │ │ +OPTIMIZATION-VARIABLES+ │ │ │ │ +SESSION-ANCESTOR │ │ │ │ RETURNER │ │ │ │ REDUCED-OUTPUT-VAR │ │ │ │ PLACE-SETTER │ │ │ │ %REDIRECTED-SYSTEM-COMMAND │ │ │ │ REDUCED-ERROR-OUTPUT-VAR │ │ │ │ %HANDLE-IF-DOES-NOT-EXIST │ │ │ │ %INTERACTIVEP │ │ │ │ @@ -29149,18 +29187,18 @@ │ │ │ │ SELFWARD-OPERATION-DEPENDS-ON │ │ │ │ AT-SIGN-P │ │ │ │ SIDEWAY-OPERATION-DEPENDS-ON │ │ │ │ UPWARD-OPERATION-DEPENDS-ON │ │ │ │ BACKWARD-COMPATIBLE-DEPENDS-ON │ │ │ │ CHECK-OPERATION-CONSTRUCTOR │ │ │ │ DOWNWARD-OPERATION-DEPENDS-ON │ │ │ │ -STATUS-BITS │ │ │ │ -STATUS-LEVEL │ │ │ │ START-OF-SUBEXPR-P │ │ │ │ ALIEN-TO-STAT │ │ │ │ +STATUS-BITS │ │ │ │ +STATUS-LEVEL │ │ │ │ CURR-OFFSET │ │ │ │ CONVERTED-PARSE-TREE │ │ │ │ PARSE-START │ │ │ │ GREEDY-CONSTANT-LENGTH-MATCHER │ │ │ │ LAST-STR │ │ │ │ END-OF-STRING-P │ │ │ │ WRITER-FORM │ │ │ │ @@ -29745,62 +29783,34 @@ │ │ │ │ PACKAGE-DEPENDENCIES │ │ │ │ INITIAL-PACKAGE-INFERRED-SYSTEMS-TABLE │ │ │ │ DEFPACKAGE-FORM │ │ │ │ DEFPACKAGE-FORM-P │ │ │ │ PACKAGE-NAME-SYSTEM │ │ │ │ FILE-DEFPACKAGE-FORM │ │ │ │ STREAM-DEFPACKAGE-FORM │ │ │ │ +UNICODE-1-CHAR->NAME │ │ │ │ NCLOSURE15 │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-RUN-SHELL-COMMAND-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-DEFINITION-PATHNAME-NOTIFIED-P* │ │ │ │ DESTINATION-DIRECTORY │ │ │ │ PRIMARY-SYSTEM │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-SYSTEM-REGISTERED-P-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-EXPLAIN-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-TRAVERSE-NOTIFIED-P* │ │ │ │ *DEPRECATED-FUNCTION-STYLE-WARNING-COMPONENT-LOAD-DEPENDENCIES-NOTIFIED-P* │ │ │ │ -UNICODE-1-CHAR->NAME │ │ │ │ +*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ +WALK-DEFINITIONS │ │ │ │ +KEY-INDEX- │ │ │ │ COERCE-UNSIGNED │ │ │ │ COERCE-SIGNED │ │ │ │ LOAD-SIGNED-BYTE-32-IMMEDIATE │ │ │ │ -*KEY-TO-WALKER-ENVIRONMENT* │ │ │ │ -MACHINE-WORD │ │ │ │ -AMOSWAP.W │ │ │ │ -AMOSWAP.D │ │ │ │ -AMOADD.W │ │ │ │ -AMOADD.D │ │ │ │ -AMOXOR.W │ │ │ │ -AMOXOR.D │ │ │ │ -AMOAND.W │ │ │ │ -AMOAND.D │ │ │ │ -AMOMIN.W │ │ │ │ -AMOMIN.D │ │ │ │ -AMOMAX.W │ │ │ │ -AMOMAX.D │ │ │ │ -AMOMINU.W │ │ │ │ -AMOMINU.D │ │ │ │ -AMOMAXU.W │ │ │ │ -AMOMAXU.D │ │ │ │ -FCVTWU<- │ │ │ │ -FCVTLU<- │ │ │ │ -FCVTWU-> │ │ │ │ -COMPUTE-CODE-FROM-FN │ │ │ │ -COMPUTE-RA-FROM-CODE │ │ │ │ -SIMPLE-FUN-HEADER-WORD │ │ │ │ -.LAYOUT-ID-FIXUP │ │ │ │ -STORE-COVERAGE-MARK │ │ │ │ -C.ADDISP16 │ │ │ │ -C.ADDI4SPN │ │ │ │ -C.EBREAK │ │ │ │ -KEY-INDEX- │ │ │ │ -WALK-DEFINITIONS │ │ │ │ +PRINT-REG │ │ │ │ SYSTEM-NAME │ │ │ │ *IN-MAKE-OPERATION* │ │ │ │ -PRINT-REG │ │ │ │ %QUASIQUOTED-MACROEXPAND-ALL │ │ │ │ *DEFAULT-OUTPUT-TRANSLATIONS* │ │ │ │ MAKE-SIMPLE-SEQUENCE-ITERATOR │ │ │ │ +CHARACTER-MISC-DATABASE+ │ │ │ │ REDEFINED-CLASSES │ │ │ │ OLDEST-COMPATIBLE-VERSION │ │ │ │ REDEFINED-FUNCTIONS │ │ │ │ @@ -30178,33 +30188,33 @@ │ │ │ │ ENTRY-POINT-P │ │ │ │ *IMAGE-RESTORED-P* │ │ │ │ POSTLUDEP │ │ │ │ LIST-INITARG-0 │ │ │ │ STRING-INITARG-0 │ │ │ │ *!DELAYED-DEFMETHOD-ARGS* │ │ │ │ FIELD-VALUES-12 │ │ │ │ +ARG-FOR-(BYTE 12 20)- │ │ │ │ +ARG-FOR-(BYTE 5 15)- │ │ │ │ +ARG-FOR-(BYTE 3 12)- │ │ │ │ +ARG-FOR-(BYTE 5 7)- │ │ │ │ +ARG-FOR-(BYTE 7 0)- │ │ │ │ +ARG-FOR-(BYTE 4 12)- │ │ │ │ +ARG-FOR-(BYTE 5 2)- │ │ │ │ +ARG-FOR-(BYTE 2 0)- │ │ │ │ +ARG-FOR-(BYTE 6 10)- │ │ │ │ +ARG-FOR-(BYTE 3 7)- │ │ │ │ +ARG-FOR-(BYTE 2 5)- │ │ │ │ +ARG-FOR-(BYTE 3 2)- │ │ │ │ +ARG-FOR-(BYTE 3 13)- │ │ │ │ +ARG-FOR-(BYTE 1 12)- │ │ │ │ FIELD-VALUES-5 │ │ │ │ FIELD-VALUES-6 │ │ │ │ FIELD-VALUES-3 │ │ │ │ FIELD-VALUES-38 │ │ │ │ FIELD-VALUES-8 │ │ │ │ -ARG-FOR-(BYTE 7 0)- │ │ │ │ -ARG-FOR-(BYTE 5 7)- │ │ │ │ -ARG-FOR-(BYTE 3 12)- │ │ │ │ -ARG-FOR-(BYTE 5 15)- │ │ │ │ -ARG-FOR-(BYTE 12 20)- │ │ │ │ -ARG-FOR-(BYTE 2 0)- │ │ │ │ -ARG-FOR-(BYTE 5 2)- │ │ │ │ -ARG-FOR-(BYTE 4 12)- │ │ │ │ -ARG-FOR-(BYTE 3 2)- │ │ │ │ -ARG-FOR-(BYTE 2 5)- │ │ │ │ -ARG-FOR-(BYTE 3 7)- │ │ │ │ -ARG-FOR-(BYTE 6 10)- │ │ │ │ -ARG-FOR-(BYTE 1 12)- │ │ │ │ -ARG-FOR-(BYTE 3 13)- │ │ │ │ ARG-FOR-(BYTE 5 20)- │ │ │ │ ARG-FOR-(BYTE 7 25)- │ │ │ │ ARG-FOR-(BYTE 1 2)- │ │ │ │ ARG-FOR-(BYTE 3 3)- │ │ │ │ ARG-FOR-(BYTE 1 6)- │ │ │ │ ARG-FOR-(BYTE 1 7)- │ │ │ │ ARG-FOR-(BYTE 1 8)- │ │ │ │ @@ -31483,22 +31493,22 @@ │ │ │ │ defining │ │ │ │ system: │ │ │ │ components │ │ │ │ Circular │ │ │ │ dependency: │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/comlib/misc.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/errors.lisp │ │ │ │ - in string │ │ │ │ - at position │ │ │ │ - is out of date │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/charset.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/charmap.lisp │ │ │ │ CHARSET- │ │ │ │ CHARMAP- │ │ │ │ DAG-NODE- │ │ │ │ + in string │ │ │ │ + at position │ │ │ │ + is out of date │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/comlib/dag.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/lexer.lisp │ │ │ │ SYS:CONTRIB;SB-POSIX;INTERFACE.LISP.NEWEST │ │ │ │ Deprecated │ │ │ │ recursive │ │ │ │ visiting │ │ │ │ dependencies │ │ │ │ @@ -31604,27 +31614,27 @@ │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cafeobj/define.lisp │ │ │ │ public: home of symbols defined by the ANSI language specification │ │ │ │ SB-ALIEN-INTERNALS │ │ │ │ private: stuff for implementing ALIENs and friends │ │ │ │ public: miscellaneous supported extensions to the ANSI Lisp spec │ │ │ │ public: an implementation of the stream-definition-by-user │ │ │ │ Lisp extension proposal by David N. Gray │ │ │ │ -REHASHING-STAMP │ │ │ │ -HAS-TRUNCATED-FLAG │ │ │ │ -KV-VECTOR-REHASHING │ │ │ │ private: miscellaneous unsupported extensions to the ANSI spec. Much of │ │ │ │ the stuff in here originated in CMU CL's EXTENSIONS package and is retained, │ │ │ │ possibly temporarily, because it might be used internally. │ │ │ │ private: In theory, this "contains functions and information │ │ │ │ necessary for system interfacing" (said cmu-user.tex at the time │ │ │ │ of the SBCL code fork). That probably was and is a good idea, but in │ │ │ │ practice, the distinctions between this package and SB-KERNEL │ │ │ │ and even SB-VM seem to have become somewhat blurred over the years. │ │ │ │ Some anomalies (e.g. FIND-IF-IN-CLOSURE being in SB-SYS instead of │ │ │ │ SB-KERNEL) have been undone, but probably more remain. │ │ │ │ +REHASHING-STAMP │ │ │ │ +HAS-TRUNCATED-FLAG │ │ │ │ +KV-VECTOR-REHASHING │ │ │ │ ~S used on non-constant LVAR ~S │ │ │ │ The control string is not a constant. │ │ │ │ No package named ~S │ │ │ │ ~~// directive mentions unknown package │ │ │ │ Upgraded element type of array is not known at compile time. │ │ │ │ not a word-sized integer │ │ │ │ VQ[xd#nZpIs │ │ │ │ @@ -31662,31 +31672,30 @@ │ │ │ │ Return T if its arguments are in strictly decreasing order, NIL otherwise. │ │ │ │ Return T if its arguments are in strictly increasing order, NIL otherwise. │ │ │ │ Return T if all of its arguments are numerically equal, NIL otherwise. │ │ │ │ Return T if arguments are in strictly non-decreasing order, NIL otherwise. │ │ │ │ Return T if arguments are in strictly non-increasing order, NIL otherwise. │ │ │ │ Return T if all of the arguments are the same character. │ │ │ │ Case is ignored. │ │ │ │ -SYS:SRC;CODE;COLD-INIT.LISP │ │ │ │ Place ~S in PSETQ is not a SYMBOL │ │ │ │ Odd number of args to ~S. │ │ │ │ ~S called with too few arguments: ~S │ │ │ │ +SYS:SRC;CODE;COLD-INIT.LISP │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cafeobj/command-top.lisp │ │ │ │ A list of function designators which are called in an unspecified │ │ │ │ order when a saved core image starts up, after the system itself has │ │ │ │ been initialized, but before non-user threads such as the finalizer │ │ │ │ thread have been started. │ │ │ │ Unused by SBCL itself: reserved for user and applications. │ │ │ │ A list of function designators which are called in an unspecified │ │ │ │ order when SBCL process exits. │ │ │ │ Unused by SBCL itself: reserved for user and applications. │ │ │ │ Using (SB-EXT:EXIT :ABORT T), or calling exit(3) directly circumvents │ │ │ │ these hooks. │ │ │ │ What case should the printer should use default? │ │ │ │ -SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ Problem running ~A hook ~S: │ │ │ │ Problem running ~A hook ~S:~% ~A │ │ │ │ Skip this ~A hook. │ │ │ │ finalizer │ │ │ │ Exit Lock │ │ │ │ Allocator │ │ │ │ Make-Thread Lock │ │ │ │ @@ -31712,14 +31721,15 @@ │ │ │ │ more than one prelude files are specified. │ │ │ │ is ignored. │ │ │ │ more than one secondary prelude files are specified: │ │ │ │ After trying to die in EXIT. │ │ │ │ hash-table lock │ │ │ │ Too many arguments (~D) to ~S ~S ~S: uses at most ~D. │ │ │ │ Too few arguments (~D) to ~S ~S ~S: requires at least ~D. │ │ │ │ +SYS:SRC;CODE;WARM-ERROR.LISP │ │ │ │ All DEBUG-CONDITIONs inherit from this type. These are serious conditions │ │ │ │ that must be handled, but they are not programmer errors. │ │ │ │ SYS:SRC;COMPILER;SXHASH.LISP │ │ │ │ Set specified value and use it. │ │ │ │ while restarting unbound variable │ │ │ │ ~@ │ │ │ │ nothing to unread │ │ │ │ @@ -32733,24 +32743,24 @@ │ │ │ │ System that was not defined yet. │ │ │ │ Base class for operations that apply the load-time effects of a file │ │ │ │ Base class for operations that apply the compile-time effects of a file │ │ │ │ (unnamed) │ │ │ │ Warning condition related to definition of obsolete OPERATION objects. │ │ │ │ Error condition related to definition of incorrect OPERATION objects. │ │ │ │ condition signaled when a system is detected as being out of date │ │ │ │ +Load the dependencies for the COMPILE-OP or LOAD-OP of a given COMPONENT. │ │ │ │ +Base class for a plan based on which ASDF can build a system │ │ │ │ +Base class for plans that simply traverse dependencies │ │ │ │ +Simplest, default plan class, accumulating a sequence of actions │ │ │ │ CHARSET-EQUALP │ │ │ │ A SB-KERNELH │ │ │ │ B SB-KERNEL@ │ │ │ │ CHARMAP-EQUALP │ │ │ │ DAG-NODE-EQUALP │ │ │ │ BDAG-EQUALP │ │ │ │ -Load the dependencies for the COMPILE-OP or LOAD-OP of a given COMPONENT. │ │ │ │ -Base class for a plan based on which ASDF can build a system │ │ │ │ -Base class for plans that simply traverse dependencies │ │ │ │ -Simplest, default plan class, accumulating a sequence of actions │ │ │ │ Status of an action in a plan │ │ │ │ Since ASDF3, BUILD-OP is the recommended 'master' operation, │ │ │ │ to operate by default on a system or component, via the function BUILD. │ │ │ │ Its meaning is configurable via the :BUILD-OPERATION option of a component. │ │ │ │ which typically specifies the name of a specific operation to which to delegate the build, │ │ │ │ as a symbol or as a string later read as a symbol (after loading the defsystem-depends-on); │ │ │ │ if NIL is specified (the default), BUILD-OP falls back to LOAD-OP, │ │ │ │ @@ -32902,36 +32912,36 @@ │ │ │ │ CHAR-TYPE( │ │ │ │ COMMON-LISP │ │ │ │ INPUT-TYPES@ │ │ │ │ REST-ARG │ │ │ │ Concatenates the lists given as arguments (by changing them) │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ +function name │ │ │ │ +cannot define a compiler-macro for a special operator: ~S │ │ │ │ $}$($0$8$@ P │ │ │ │ DERIVE-FUN8 │ │ │ │ RATIO-TO-NAL │ │ │ │ -function name │ │ │ │ -cannot define a compiler-macro for a special operator: ~S │ │ │ │ qs1loig_/n │ │ │ │ COMMON-LISP8 │ │ │ │ Return the bit-wise logical not of integer. │ │ │ │ MORE-ARG │ │ │ │ Return all arguments, in order, as values. │ │ │ │ ARG-NAMES( │ │ │ │ ARG-NAMES( │ │ │ │ ARG-NAMES( │ │ │ │ convert to simpler equality predicate │ │ │ │ -bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ avoid runtime dispatch on array element type │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ +bad size specified for UNSIGNED-BYTE type specifier: ~// │ │ │ │ +automatically generated writer method │ │ │ │ convert to inline logical operations │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -automatically generated writer method │ │ │ │ automatically-generated reader method │ │ │ │ automatically-generated boundp method │ │ │ │ automatically-generated writer method │ │ │ │ Number of nested calls to operate we're under (for toplevel session only) │ │ │ │ Was ASDF already upgraded in this session - only valid for toplevel-asdf-session. │ │ │ │ Forcing parameters for the session │ │ │ │ Component name: designator for a string composed of portable pathname characters │ │ │ │ @@ -32963,31 +32973,29 @@ │ │ │ │ ~@ │ │ │ │ note: ~A │ │ │ │ Calling an ignored function: ~S │ │ │ │ reading an ignored variable: ~S │ │ │ │ Error during compiler-macroexpansion │ │ │ │ ~@<~A of ~S. Use ~S to intercept. │ │ │ │ during macroexpansion │ │ │ │ -SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ -SB-PROFILE │ │ │ │ -public: the interface to the profiler │ │ │ │ Wrong number of subscripts, ~W, for array of rank ~W. │ │ │ │ Wrong number of subscripts, ~W, for array of rank 1. │ │ │ │ -Ignoring legacy attribute UNSAFE. Replaced by its inverse: DX-SAFE. │ │ │ │ -function cannot have both good and bad attributes: ~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 │ │ │ │ -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 │ │ │ │ +SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP │ │ │ │ REST-ARG │ │ │ │ `$]$($0'g │ │ │ │ $9$0$`$= │ │ │ │ BIT-ARRAY │ │ │ │ NEW-VALUE │ │ │ │ MORE-ARG │ │ │ │ +Ignoring legacy attribute UNSAFE. Replaced by its inverse: DX-SAFE. │ │ │ │ +function cannot have both good and bad attributes: ~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 │ │ │ │ +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 │ │ │ │ BIT-VECTOR │ │ │ │ COMMON-LISPH │ │ │ │ END-WORD) │ │ │ │ N-BITS-REMAINING1 │ │ │ │ N-BUCKETS( │ │ │ │ HASH-FUN-STATE │ │ │ │ HASH-TABLE │ │ │ │ @@ -33037,18 +33045,20 @@ │ │ │ │ RATIONAL produces a rational number for any real numeric argument. This is │ │ │ │ more efficient than RATIONALIZE, but it assumes that floating-point is │ │ │ │ completely accurate, giving a result that isn't as pretty. │ │ │ │ Converts any REAL to a float. If OTHER is not provided, it returns a │ │ │ │ SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the │ │ │ │ result is the same float format as OTHER. │ │ │ │ Return a list with SE1 as the CAR and SE2 as the CDR. │ │ │ │ +SB-PROFILE │ │ │ │ +public: the interface to the profiler │ │ │ │ SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP │ │ │ │ +inline comparison │ │ │ │ High bound is not * or a rational or list of one rational: ~S │ │ │ │ Low bound is not * or a rational or list of one rational: ~S │ │ │ │ -inline comparison │ │ │ │ inline (unsigned-byte 64) comparison │ │ │ │ inline (signed-byte 64) comparison │ │ │ │ inline fixnum comparison │ │ │ │ inline float comparison │ │ │ │ SYS:SRC;CODE;LIST.LISP │ │ │ │ SYS:SRC;CODE;SIMPLE-FUN.LISP │ │ │ │ ?SBNn~f@ │ │ │ │ @@ -33086,14 +33096,19 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +~&~@ │ │ │ │ +A nested error within --disable-debugger error handling prevents printing the backtrace. Sorry, exiting. │ │ │ │ +A nested error within --disable-debugger error handling prevents displaying the original error. Attempting to print a backtrace. │ │ │ │ +unhandled condition in --disable-debugger mode, quitting │ │ │ │ +~&Unhandled ~S~@[ in thread ~S~]: │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -33118,19 +33133,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -~&~@ │ │ │ │ -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~]: │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -33159,14 +33169,18 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ +Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ + method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ Nd**>;<) │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ @@ -33178,22 +33192,17 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE(5G4 │ │ │ │ -SYS:SRC;CODE;TARGET-EXTENSIONS.LISP │ │ │ │ -Writes an end of line, as for TERPRI. Returns NIL. The default │ │ │ │ - method does (STREAM-WRITE-CHAR stream #NEWLINE). │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN.LISP │ │ │ │ When invoked, this function will turn off both the SBCL debugger │ │ │ │ and LDB (the low-level debugger). See also ENABLE-DEBUGGER. │ │ │ │ Enable all the default signals that Lisp knows how to deal with. │ │ │ │ -2.4.10.debian │ │ │ │ Returns a SAP corresponding to the foreign symbol. DATAP must be true if the │ │ │ │ symbol designates a variable. May enter the symbol into the linkage-table. │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ Return the alien callable function associated with NAME. │ │ │ │ $($0$8$@ │ │ │ │ COMMON-LISP │ │ │ │ @@ -33262,14 +33271,18 @@ │ │ │ │ (c) the immediately containing section cannot be printed on one │ │ │ │ line and miser-style is in effect. │ │ │ │ :MANDATORY - A line break is always inserted. │ │ │ │ When a line break is inserted by any type of conditional newline, any │ │ │ │ blanks that immediately precede the conditional newline are omitted │ │ │ │ from the output and indentation is introduced at the beginning of the │ │ │ │ next line. (See PPRINT-INDENT.) │ │ │ │ +2.4.10.debian │ │ │ │ +no translator for primitive alien type ~// │ │ │ │ +no definition for alien type ~// │ │ │ │ +unknown alien type: ~// │ │ │ │ $}$($0 8 │ │ │ │ CONSTRAINTSH │ │ │ │ CONSTRAINTSH │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPERATOR0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -33278,62 +33291,59 @@ │ │ │ │ REST-ARG │ │ │ │ CONSTRAINTSP │ │ │ │ INTERSECTION │ │ │ │ COMMON-LISP` │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ -no translator for primitive alien type ~// │ │ │ │ -no definition for alien type ~// │ │ │ │ -unknown alien type: ~// │ │ │ │ -~S can't be converted to type ~//. │ │ │ │ complex single float realpart │ │ │ │ complex double float realpart │ │ │ │ complex single float imagpart │ │ │ │ complex double float imagpart │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ This is like CL:READ-SEQUENCE, but for Gray streams. │ │ │ │ +~S can't be converted to type ~//. │ │ │ │ UxeR|cL+cM │ │ │ │ Coerce the Object to an object of type Output-Type-Spec. │ │ │ │ COMMON-LISP0 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Return the greatest of its arguments; among EQUALP greatest, return │ │ │ │ the first. │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Return the least of its arguments; among EQUALP least, return │ │ │ │ the first. │ │ │ │ !=ME&zZ< │ │ │ │ +SYS:SRC;CODE;STEP.LISP │ │ │ │ SYS:SRC;CODE;ERROR-ERROR.LISP │ │ │ │ Comma not inside a backquote. │ │ │ │ Backtrace for: ~S │ │ │ │ Skip printing frame ~S │ │ │ │ while printing frame ~S. The partial output is: ~S │ │ │ │ method ~S not defined for ~S │ │ │ │ bogus stack frame │ │ │ │ ~&Enter a form to be evaluated: │ │ │ │ Unknown :TEST for MAKE-HASH-TABLE: ~S │ │ │ │ Set PC-OFFSET to zero and continue backtrace. │ │ │ │ ~@ │ │ │ │ -PCL global mutex │ │ │ │ SYS:SRC;CODE;SC-OFFSET.LISP │ │ │ │ SYS:SRC;CODE;CLASS.LISP │ │ │ │ -SYS:SRC;CODE;STEP.LISP │ │ │ │ COMMON-LISP0 │ │ │ │ Return the 1st object in a list. │ │ │ │ CONTEXT` │ │ │ │ inline complex single-float creation │ │ │ │ inline complex double-float creation │ │ │ │ +PCL global mutex │ │ │ │ ARG-COUNT │ │ │ │ N-TEMPLATE │ │ │ │ NOPERANDS │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33357,17 +33367,17 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ as the argument to FUNCTION │ │ │ │ ~S is not a legal function name. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ SYS:SRC;CODE;SYMBOL.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33429,16 +33439,14 @@ │ │ │ │ setting the value of ~S │ │ │ │ Can't ~@? (global variable). │ │ │ │ compare-and-swap SYMBOL-VALUE of ~S │ │ │ │ define ~S as a constant │ │ │ │ make ~S unbound │ │ │ │ set SYMBOL-VALUE of ~S │ │ │ │ debugger invoked on a ~S~@[ @~x~] in thread ~_~A: ~2I~_~A │ │ │ │ -Can't displace an array of type ~// into another of type ~// │ │ │ │ -The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ 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. │ │ │ │ can't specify both :TEST and :TEST-NOT │ │ │ │ ~@ │ │ │ │ ~&restarts (invokable by number or by possibly-abbreviated name): │ │ │ │ ~& ~2D: [~VA] ~A │ │ │ │ @@ -33460,40 +33468,42 @@ │ │ │ │ provide bindings for printer control variables. │ │ │ │ the form currently being evaluated │ │ │ │ COMMON-LISPP │ │ │ │ AXIS-NUMBER= │ │ │ │ Return the length of dimension AXIS-NUMBER of ARRAY. │ │ │ │ COMMON-LISPE │ │ │ │ COMMON-LISP │ │ │ │ -No matching closing slash │ │ │ │ -Too many #\@ characters supplied │ │ │ │ -Too many colons supplied │ │ │ │ -Parameters found after #\: or #\@ modifier │ │ │ │ -String ended before directive was found │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ Return the type of the elements of the array │ │ │ │ COMMON-LISP │ │ │ │ Adjust ARRAY's dimensions to the given DIMENSIONS and stuff. │ │ │ │ SLOT-SPECS │ │ │ │ +No matching closing slash │ │ │ │ +Too many #\@ characters supplied │ │ │ │ +Too many colons supplied │ │ │ │ +Parameters found after #\: or #\@ modifier │ │ │ │ +String ended before directive was found │ │ │ │ +Can't displace an array of type ~// into another of type ~// │ │ │ │ +The new element type, ~//, is incompatible with old type, ~//. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ SB-PRETTY │ │ │ │ private: implementation of pretty-printing │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -WITH-PRETTY-STREAM │ │ │ │ Type of CHARACTERs that aren't BASE-CHARs. │ │ │ │ Type corresponding to the characters required by the standard. │ │ │ │ The pprint-dispatch-table that controls how to pretty-print objects. │ │ │ │ +WITH-PRETTY-STREAM │ │ │ │ SYS:SRC;COMPILER;IR1OPT.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -33502,41 +33512,41 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -no host specified │ │ │ │ -~S is not a valid logical namestring: │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +no host specified │ │ │ │ +~S is not a valid logical namestring: │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP0 │ │ │ │ Means the same as the cdr of a list. │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP( │ │ │ │ COMPONENT │ │ │ │ (~S ~S) is not a defined info type. │ │ │ │ +Symbol ~// cannot be both the name of a type and the name of a declaration │ │ │ │ SYS:SRC;PCL;FIXUP.LISP │ │ │ │ 3 4N4y4Z5c9 │ │ │ │ No format-control for ~S │ │ │ │ ~2I~@[~:@_ ~:@_~:{~:(~A~): ~S~:^, ~:_~}~]~:@_ ~:@_Stream: ~S │ │ │ │ Should the contents of arrays be printed? │ │ │ │ Ignore the package lock. │ │ │ │ Unlock the package. │ │ │ │ Ignore all package locks in the context of this operation. │ │ │ │ ~@ │ │ │ │ Bogus slot cell in SLOT-VALUE: ~S │ │ │ │ -Symbol ~// cannot be both the name of a type and the name of a declaration │ │ │ │ │ │ │ │ Z$8%0-h- │ │ │ │ │ │ │ │ ~:[~*~;error in ~S: ~]~?~@[ │ │ │ │ ~V@T^~@[~V@T^~]~] │ │ │ │ Unhandled EVAL-ERROR │ │ │ │ VPXPZK^b_9o │ │ │ │ @@ -33564,16 +33574,16 @@ │ │ │ │ SYS:SRC;PCL;GRAY-STREAMS-CLASS.LISP │ │ │ │ =BPIWJ │ │ │ │ /build/reproducible-path/sbcl-2.4.10/contrib/asdf/uiop.lisp │ │ │ │ Top level session that this is part of │ │ │ │ Memoize expensive computations │ │ │ │ The output base for RATIONALs (including integers). │ │ │ │ Should base be verified when printing RATIONALs? │ │ │ │ -/build/reproducible-path/sbcl-2.4.10/contrib/asdf/asdf.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/regex-class.lisp │ │ │ │ +/build/reproducible-path/sbcl-2.4.10/contrib/asdf/asdf.lisp │ │ │ │ A pair of operation and component uniquely identifies a node in the dependency graph │ │ │ │ of steps to be performed while building a system. │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ 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. │ │ │ │ @@ -33582,32 +33592,23 @@ │ │ │ │ or NIL if no the status is considered outside of a specific plan. │ │ │ │ 7"V"9$a$~& │ │ │ │ /u2&:.>,@ │ │ │ │ ;SBpDbEaL │ │ │ │ y8{m}t~~ │ │ │ │ SYS:SRC;CODE;FUNUTILS.LISP │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/BigPink/codes/glob.lisp │ │ │ │ -SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ -SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ 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. │ │ │ │ +SYS:SRC;CODE;DEFSETFS.LISP │ │ │ │ Define a new type, with syntax like DEFMACRO. │ │ │ │ Define a compiler-macro for NAME. │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -Unexpected %MAKE-HAIRY-TYPE │ │ │ │ -MEMBER type contains ~S │ │ │ │ -unknown SC to SC-CASE for ~S: │ │ │ │ -immediate structure-object ~S │ │ │ │ -~W is too big for a fixnum. │ │ │ │ -SYS:SRC;COMPILER;RISCV;ARITH.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;FLOAT.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;SUBPRIM.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33627,14 +33628,19 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ +Unexpected %MAKE-HAIRY-TYPE │ │ │ │ +MEMBER type contains ~S │ │ │ │ +unknown SC to SC-CASE for ~S: │ │ │ │ +immediate structure-object ~S │ │ │ │ +~W is too big for a fixnum. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33658,14 +33664,19 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +SYS:SRC;COMPILER;BITOPS-DERIVE-TYPE.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;ARITH.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;FLOAT.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;SUBPRIM.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -33697,38 +33708,37 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -fmt$~36R │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP │ │ │ │ +fmt$~36R │ │ │ │ SYS:SRC;PCL;FSC.LISP │ │ │ │ SYS:SRC;PCL;DOCUMENTATION.LISP │ │ │ │ SYS:SRC;CODE;TARGET-RANDOM.LISP │ │ │ │ SYS:SRC;PCL;PRINT-OBJECT.LISP │ │ │ │ SYS:SRC;CODE;DESCRIBE.LISP │ │ │ │ SYS:SRC;CODE;INSPECT.LISP │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/regex-class-util.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/convert.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/optimize.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/closures.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/repetition-closures.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cl-ppcre/api.lisp │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +array dimensions are ~A but :INITIAL-CONTENTS dimensions are ~A │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ check-type │ │ │ │ SB-IMPL( │ │ │ │ 8+VpVY78 │ │ │ │ qTbjdp~9 │ │ │ │ A"aoNG.5 │ │ │ │ DIVISOR@ │ │ │ │ @@ -33736,68 +33746,56 @@ │ │ │ │ Return second result of FLOOR. │ │ │ │ Return T if X is NIL, otherwise return NIL. │ │ │ │ The elements of SEQUENCE are compared pairwise, and if any two match, │ │ │ │ the one occurring earlier is discarded, unless FROM-END is true, in │ │ │ │ which case the one later in the sequence is discarded. The resulting │ │ │ │ sequence is returned. │ │ │ │ The :TEST-NOT argument is deprecated. │ │ │ │ -Recursion limit reached while expanding local macro ~// │ │ │ │ COMMON-LISP0 │ │ │ │ Return the total number of elements in the Array. │ │ │ │ CLOSURE SB-KERNEL │ │ │ │ PERMIT-COPY │ │ │ │ CONTEXT` │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -Recursive lock attempt ~S. │ │ │ │ -The SATISFIES predicate name is not a symbol: ~S │ │ │ │ -forced to do runtime allocation of alien-value structure │ │ │ │ +Recursion limit reached while expanding local macro ~// │ │ │ │ bad modulus specified for MOD type specifier: ~// │ │ │ │ bad size specified for SIGNED-BYTE type specifier: ~// │ │ │ │ REST-ARG │ │ │ │ -SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ REST-ARG │ │ │ │ +SYS:SRC;CODE;DEFTYPE.LISP │ │ │ │ +The SATISFIES predicate name is not a symbol: ~S │ │ │ │ +Recursive lock attempt ~S. │ │ │ │ +odd number of args to ~A: ~S │ │ │ │ +forced to do runtime allocation of alien-value structure │ │ │ │ fold identity operations │ │ │ │ convert (* x 0) to 0 │ │ │ │ associate */(* /) of constants │ │ │ │ COMMON-LISP │ │ │ │ convert x*2^k to shift │ │ │ │ optimize multiplication by one │ │ │ │ +Package Table Lock │ │ │ │ ~S doesn't have a precise float representation. │ │ │ │ The RATIONAL value isn't known at compile time. │ │ │ │ The operands might not be the same type. │ │ │ │ +Cannot finalize ~S. │ │ │ │ SYS:SRC;CODE;SETF.LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ CONTEXTP │ │ │ │ List of available buffers. │ │ │ │ The absolute pathname of the running SBCL core. │ │ │ │ The absolute pathname of the running SBCL runtime. │ │ │ │ -Package Table Lock │ │ │ │ -odd number of args to ~A: ~S │ │ │ │ -Cannot finalize ~S. │ │ │ │ -undefined_alien_function │ │ │ │ -after-GC │ │ │ │ -File descriptor must be opened either for input or output. │ │ │ │ -Undefined external-format: ~S │ │ │ │ -descriptor ~W │ │ │ │ -~&rehash: size=(~D -> ~D), ~D avg=~f │ │ │ │ -The HOST argument doesn't match the pathname host: │ │ │ │ - ~S and ~S. │ │ │ │ -A LIST representing a pathname host is not supported in this implementation: │ │ │ │ -SBCL_HOME │ │ │ │ -../lib/sbcl/ │ │ │ │ -contrib/ │ │ │ │ -illegal instruction at #X~X │ │ │ │ -bus error at #X~X │ │ │ │ -unknown rounding mode: ~S │ │ │ │ -Invalid function name: ~S │ │ │ │ +Map from Lisp symbols to the alien callable functions they name. │ │ │ │ +Default amount of seconds, if any, EXIT should wait for other │ │ │ │ +threads to finish after terminating them. Default value is 60. NIL │ │ │ │ +means to wait indefinitely. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ Transfer control to a restart named CONTINUE, or return NIL if none exists. │ │ │ │ CONDITION │ │ │ │ COMMON-LISPH │ │ │ │ OPTIONAL-ARGS │ │ │ │ @@ -33808,25 +33806,48 @@ │ │ │ │ MORE-ARG │ │ │ │ Call FUNCTION with the given ARGUMENTS. │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ Transfer control to a restart named MUFFLE-WARNING, signalling a │ │ │ │ CONTROL-ERROR if none exists. │ │ │ │ +undefined_alien_function │ │ │ │ +after-GC │ │ │ │ +File descriptor must be opened either for input or output. │ │ │ │ +Undefined external-format: ~S │ │ │ │ +descriptor ~W │ │ │ │ +~&rehash: size=(~D -> ~D), ~D avg=~f │ │ │ │ +The HOST argument doesn't match the pathname host: │ │ │ │ + ~S and ~S. │ │ │ │ +A LIST representing a pathname host is not supported in this implementation: │ │ │ │ +SBCL_HOME │ │ │ │ +../lib/sbcl/ │ │ │ │ +contrib/ │ │ │ │ +illegal instruction at #X~X │ │ │ │ +bus error at #X~X │ │ │ │ +unknown rounding mode: ~S │ │ │ │ +Invalid function name: ~S │ │ │ │ +there is no ~S component. │ │ │ │ SYS:SRC;CODE;FOREIGN.LISP │ │ │ │ SYS:SRC;CODE;COMMON-OS.LISP │ │ │ │ SYS:SRC;CODE;TARGET-SIGNAL.LISP │ │ │ │ -Map from Lisp symbols to the alien callable functions they name. │ │ │ │ -Default amount of seconds, if any, EXIT should wait for other │ │ │ │ -threads to finish after terminating them. Default value is 60. NIL │ │ │ │ -means to wait indefinitely. │ │ │ │ +SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ How many elements at any level should be printed before abbreviating │ │ │ │ with "..."? │ │ │ │ -SYS:SRC;CODE;FLOAT-TRAP.LISP │ │ │ │ -there is no ~S component. │ │ │ │ +How many levels should be printed before abbreviating with "#"? │ │ │ │ +INPUT-TYPES@ │ │ │ │ +REST-ARG │ │ │ │ +ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ + Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ + Keyform. If none of the keys matches then an error is signalled. │ │ │ │ +ETYPECASE Keyform {(Type Form*)}* │ │ │ │ + Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ + is true. If no form is satisfied then an error is signalled. │ │ │ │ +SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ +k!w#[&_' │ │ │ │ processing input : │ │ │ │ Options: [defaults in brackets after descriptions] │ │ │ │ print this help message. │ │ │ │ do not load user's initialization file. │ │ │ │ runs in batch mode. │ │ │ │ -p PATH │ │ │ │ standard prelude file defining modules. │ │ │ │ @@ -33834,59 +33855,48 @@ │ │ │ │ additional prelude file. │ │ │ │ -l DIR-LIST │ │ │ │ set list of pathnames as module search paths. │ │ │ │ [ /usr/local/cafeobj/lib:/usr/local/cafeobj/exs ] │ │ │ │ +l DIR-LIST │ │ │ │ adds list of pathnames as mdoule search paths. │ │ │ │ internal error: Control should never reach here, i.e. │ │ │ │ -INPUT-TYPES@ │ │ │ │ -REST-ARG │ │ │ │ -ECASE Keyform {({(Key*) | Key} Form*)}* │ │ │ │ - Evaluates the Forms in the first clause with a Key EQL to the value of │ │ │ │ - Keyform. If none of the keys matches then an error is signalled. │ │ │ │ -ETYPECASE Keyform {(Type Form*)}* │ │ │ │ - Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ - is true. If no form is satisfied then an error is signalled. │ │ │ │ -SYS:SRC;CODE;MACROEXPAND.LISP │ │ │ │ -k!w#[&_' │ │ │ │ -How many levels should be printed before abbreviating with "#"? │ │ │ │ -default input stream │ │ │ │ -ill-formed handler binding: ~S │ │ │ │ IT%&|_();>~ │ │ │ │ No corresponding close brace │ │ │ │ +ill-formed handler binding: ~S │ │ │ │ Changing meta-class of ~S from ~S to ~S. │ │ │ │ -~S can't be coerced to a function. │ │ │ │ -The length requested (~S) does not match the type restriction in ~S. │ │ │ │ -weird type in S-T-L-M-ERROR │ │ │ │ -~S is too hairy for sequence functions. │ │ │ │ -~S is not defined for ~S │ │ │ │ +default input stream │ │ │ │ SYS:SRC;CODE;COERCE.LISP │ │ │ │ jq0htX0t │ │ │ │ DEFAULTH │ │ │ │ KV-VECTOR8 │ │ │ │ TABLE0 g@)d$ │ │ │ │ EMPTY-KV-INDEX= │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPP │ │ │ │ KV-VECTOR0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP@ │ │ │ │ KV-VECTOR0 │ │ │ │ convert x/2^k to shift │ │ │ │ fold zero arg │ │ │ │ +~S can't be coerced to a function. │ │ │ │ +The length requested (~S) does not match the type restriction in ~S. │ │ │ │ +weird type in S-T-L-M-ERROR │ │ │ │ +~S is too hairy for sequence functions. │ │ │ │ +~S is not defined for ~S │ │ │ │ SYS:SRC;PCL;PRE-WARM.LISP │ │ │ │ Cache of existing lisp wrappers, indexed with SPECIFER. Used for memoization: │ │ │ │ we don't create new wrappers if one for the same specifier already exists. │ │ │ │ -shared object list lock │ │ │ │ Maps SAPs to corresponding CALLBACK-INFO structures: contains all the │ │ │ │ information we need to manipulate callbacks after their creation. Used for │ │ │ │ changing the lisp-side function they point to, invalidation, etc. │ │ │ │ Cache of existing callback SAPs, indexed with (SPECIFER . FUNCTION). Used for │ │ │ │ memoization: we don't create new callbacks if one pointing to the correct │ │ │ │ function with the same specifier already exists. │ │ │ │ +shared object list lock │ │ │ │ A hashtable used to detect cycles while comparing record types. │ │ │ │ Spinlock type. │ │ │ │ Scheduler lock │ │ │ │ A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector. │ │ │ │ Package Graph Lock │ │ │ │ Around spawn(). │ │ │ │ List of all the currently active handlers for file descriptors │ │ │ │ @@ -33915,14 +33925,15 @@ │ │ │ │ convert to multiplication by reciprocal │ │ │ │ ARGUMENTS │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUEH │ │ │ │ COMMON-LISPP │ │ │ │ Set SYMBOL's value cell to NEW-VALUE. │ │ │ │ +COND clause is not a ~S: ~S │ │ │ │ Print a listing of the call stack to STREAM, defaulting to *DEBUG-IO*. │ │ │ │ COUNT is the number of frames to backtrace, defaulting to │ │ │ │ *BACKTRACE-FRAME-COUNT*. │ │ │ │ START is the number of the frame the backtrace should start from. │ │ │ │ FROM specifies the frame relative to which the frames are numbered. Possible │ │ │ │ values are an explicit SB-DI:FRAME object, and the │ │ │ │ keywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default │ │ │ │ @@ -34022,20 +34033,16 @@ │ │ │ │ DEBUG-FUN` │ │ │ │ DEBUG-FUN` │ │ │ │ MORE-ARG │ │ │ │ Invokes the signal facility on a condition formed from DATUM and │ │ │ │ ARGUMENTS. If the condition is not handled, NIL is returned. If │ │ │ │ (TYPEP condition *BREAK-ON-SIGNALS*) is true, the debugger is invoked │ │ │ │ before any signalling is done. │ │ │ │ -~S is not the name of a defined VOP. │ │ │ │ -No restart ~S is active~@[ for ~S~]. │ │ │ │ -setting the symbol-function of ~A │ │ │ │ -Can't make ~A variable unbound: ~S │ │ │ │ -COND clause is not a ~S: ~S │ │ │ │ bad thing to be a type specifier: ~// │ │ │ │ +~S is not the name of a defined VOP. │ │ │ │ UNDERLYING-STREAM@)g< │ │ │ │ Notify N threads waiting on QUEUE. │ │ │ │ IMPORTANT: The same mutex that is used in the corresponding CONDITION-WAIT │ │ │ │ must be held by this thread during this call. │ │ │ │ SESSION@1g4 │ │ │ │ SESSION8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ @@ -34045,14 +34052,17 @@ │ │ │ │ COMMON-P( │ │ │ │ Return a copy of SEQUENCE with elements satisfying the test (default is │ │ │ │ EQL) with ITEM removed. │ │ │ │ COMMON-LISP@ │ │ │ │ Predicate returns T if bit index of integer is a 1. │ │ │ │ $H$0$8$( │ │ │ │ COMMON-LISP │ │ │ │ +No restart ~S is active~@[ for ~S~]. │ │ │ │ +setting the symbol-function of ~A │ │ │ │ +Can't make ~A variable unbound: ~S │ │ │ │ defaulted │ │ │ │ COMMON-LISP` │ │ │ │ COMMON-LISPP$g< │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ ^,fzzX;L │ │ │ │ REST-ARG │ │ │ │ @@ -34101,36 +34111,41 @@ │ │ │ │ However, whereas ABORT restart may be rebound, ABORT-THREAD always │ │ │ │ unwinds the entire thread. (Behaviour of the initial ABORT restart for │ │ │ │ main thread depends on the :TOPLEVEL argument to │ │ │ │ SB-EXT:SAVE-LISP-AND-DIE.) │ │ │ │ See also: RETURN-FROM-THREAD and SB-EXT:EXIT. │ │ │ │ Background this thread. If NEXT is supplied, arrange for it to │ │ │ │ have the foreground next. │ │ │ │ -Malformed ~~/ directive │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -PDA@ ZFa │ │ │ │ -MJ UeMIeM │ │ │ │ Incompatible array element types: ~a and ~a │ │ │ │ The source sequence has an element ~s incompatible with the target array element type ~a. │ │ │ │ Too many parameters, expected no more than ~W │ │ │ │ Unreachable ~S │ │ │ │ SB-RISCV-ASM │ │ │ │ private: backend-specific assembler mnemonics │ │ │ │ SB-WALKER │ │ │ │ internal: a code walker used by PCL │ │ │ │ SB-SEQUENCE │ │ │ │ semi-public: implements something which might eventually │ │ │ │ be submitted as a CDR │ │ │ │ +PDA@ ZFa │ │ │ │ +MJ UeMIeM │ │ │ │ COMPLAINTH │ │ │ │ REST-ARG │ │ │ │ +hOG2E=}y │ │ │ │ +7u)3'MnU │ │ │ │ +Performs the cdr function n times on a list. │ │ │ │ +COMMON-LISP@ │ │ │ │ +Convert the alien-type structure TYPE back into a list specification of │ │ │ │ + the type. │ │ │ │ No corresponding close paren │ │ │ │ no corresponding open paren │ │ │ │ Index ~W is out of bounds. It should have been between 0 and ~W. │ │ │ │ ~~; not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ @ modifier not allowed in close directive of justification block (i.e. ~~<...~~@>. │ │ │ │ ~D illegal directive~:P found inside justification block │ │ │ │ while processing indirect format string: │ │ │ │ @@ -34138,20 +34153,16 @@ │ │ │ │ No previous argument │ │ │ │ ~S is not of type INTEGER. │ │ │ │ Can only specify one section │ │ │ │ Must specify exactly two sections │ │ │ │ No corresponding open bracket │ │ │ │ Attempt to use ~~:^ outside a ~~:{...~~} construct │ │ │ │ No corresponding open brace │ │ │ │ -hOG2E=}y │ │ │ │ -7u)3'MnU │ │ │ │ -Performs the cdr function n times on a list. │ │ │ │ -COMMON-LISP@ │ │ │ │ -Convert the alien-type structure TYPE back into a list specification of │ │ │ │ - the type. │ │ │ │ +Malformed ~~/ directive │ │ │ │ +Topological sort failed due to constraint on ~S. │ │ │ │ SYS:SRC;COMPILER;TYPETRAN.LISP │ │ │ │ COMMON-LISP@ │ │ │ │ RESULTS0 │ │ │ │ Return a list whose elements are the dimensions of the array │ │ │ │ Return T if and only if THING is a standard-char. Differs from │ │ │ │ STANDARD-CHAR-P in that THING doesn't have to be a character. │ │ │ │ SXSTATE0Lg4 │ │ │ │ @@ -34159,16 +34170,14 @@ │ │ │ │ Convert PATHSPEC (a pathname designator) into a pathname. │ │ │ │ cq#AJ#KCJ │ │ │ │ Converts the pathspec argument to a logical-pathname and returns it. │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISPH │ │ │ │ MEMBER-TYPE SB-KERNEL@4g< │ │ │ │ COMMON-LISP@*gd │ │ │ │ -SYS:SRC;COMPILER;IR2TRAN.LISP │ │ │ │ -Topological sort failed due to constraint on ~S. │ │ │ │ shouldn't happen? │ │ │ │ shouldn't happen: weird state of OLD-LAYOUT? │ │ │ │ defining ~S as a ~(~A~) │ │ │ │ change in superclasses of class ~S: │ │ │ │ ~A superclasses: ~S │ │ │ │ ~A superclasses: ~S │ │ │ │ change in instance length of class ~S: │ │ │ │ @@ -34207,14 +34216,15 @@ │ │ │ │ ~]~@[ These slots were deleted: │ │ │ │ NOT VALUES too confusing on ~S │ │ │ │ Off-heap MEMBER type member @ ~X │ │ │ │ Off-heap MEMBER type members │ │ │ │ ~@ │ │ │ │ /dev/urandom │ │ │ │ SUBTYPEP is illegal on this type: │ │ │ │ +SYS:SRC;COMPILER;IR2TRAN.LISP │ │ │ │ EQUALP ~S ~S │ │ │ │ when setting slot ~s │ │ │ │ when setting slot ~s of structure ~s │ │ │ │ when binding ~s │ │ │ │ for the result type of │ │ │ │ from the function type declaration. │ │ │ │ when setting an element of (ARRAY ~s) │ │ │ │ @@ -34234,15 +34244,14 @@ │ │ │ │ DEFSTRUCT option ~S ~[requires at least~;requires exactly~;accepts at most~] one argument │ │ │ │ More than one ~S option is not allowed │ │ │ │ The current │ │ │ │ the most recently loaded │ │ │ │ ~@ │ │ │ │ The most recently compiled │ │ │ │ malformed :INITIAL-CONTENTS: ~S should have dimensions ~S │ │ │ │ -SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ unrecognized DEFSTRUCT option: ~S │ │ │ │ (:CONSTRUCTOR NIL) combined with other :CONSTRUCTORs │ │ │ │ :TYPE option precludes specification of ~S option │ │ │ │ :PREDICATE cannot be used with :TYPE unless :NAMED is also specified. │ │ │ │ :OFFSET can't be specified unless :TYPE is specified. │ │ │ │ slot name ~S not present in included structure │ │ │ │ included slot name ~S specified more than once │ │ │ │ @@ -34250,14 +34259,15 @@ │ │ │ │ :TYPE option mismatch between structures ~S and ~S │ │ │ │ defining ~S as a structure │ │ │ │ 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 │ │ │ │ Keyword type description is not a two-list: ~S. │ │ │ │ +SYS:OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP │ │ │ │ Class is not a structure class: ~S │ │ │ │ Class is not yet defined or was undefined: ~S │ │ │ │ NOT CONSTANT too confusing on ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~S is not a defined type class. │ │ │ │ @@ -34268,87 +34278,85 @@ │ │ │ │ bad dimension in array type: ~S │ │ │ │ array type with too many dimensions: ~S │ │ │ │ Array dimensions is not a list, integer or *: │ │ │ │ Arrays can't have a negative number of dimensions: ~S │ │ │ │ Invalid :TYPE for slot ~S in ~S ~S: ~A. │ │ │ │ There is no slot named ~S in ~S. │ │ │ │ type intersection │ │ │ │ -SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ -NCLOSURE │ │ │ │ -DEFAULTED-END- │ │ │ │ -CUMULATIVE-OFFSET- │ │ │ │ Supply a new value for ~S. │ │ │ │ ~S has an odd number of items in its property list. │ │ │ │ Key-Info │ │ │ │ Key-Info-Set │ │ │ │ ~&ctype cache metrics: Count LF Seek Hit maxPSL Mask │ │ │ │ ~&Alien: │ │ │ │ ~16a: ~7D ~5,1,2F%~#[~:; ~:[ ~;~:*~8D~] ~:[ ~;~:*~4,1,2f%~]~ │ │ │ │ ~6D ~6X~]~% │ │ │ │ ~16A: ~7D │ │ │ │ +NCLOSURE │ │ │ │ +SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP │ │ │ │ +DEFAULTED-END- │ │ │ │ +CUMULATIVE-OFFSET- │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ ~S was previously defined as a macro. │ │ │ │ proclaiming ~S as a function │ │ │ │ uninterned │ │ │ │ * is not permitted as a type specifier │ │ │ │ bad float format: ~S │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP │ │ │ │ -SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ bad float arg │ │ │ │ +SYS:SRC;CODE;PRIMORDIAL-TYPE.LISP │ │ │ │ ~S is not a character output stream. │ │ │ │ ~S is too large an index for SETF of NTH. │ │ │ │ ~S isn't an integer type? │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ +no &REST context for FAST-REST-NTH │ │ │ │ (no LAYOUT-INFO) │ │ │ │ Compile-time package lock violation: │ │ │ │ unsealing sealed class ~S in order to subclass it │ │ │ │ -no &REST context for FAST-REST-NTH │ │ │ │ -N-SVALUE │ │ │ │ -N-EVALUE │ │ │ │ malformed :INITIAL-CONTENTS: Dimension of axis ~W is ~W, but ~S is ~W long. │ │ │ │ malformed :INITIAL-CONTENTS: ~S is not a sequence, but ~W more layer~:P needed. │ │ │ │ ~S names a special operator. │ │ │ │ ~S names a macro. │ │ │ │ +N-SVALUE │ │ │ │ +N-EVALUE │ │ │ │ +Slot ~S not found in ~S. │ │ │ │ Not enough room left in static space to allocate vector. │ │ │ │ unknown internal error: ~S │ │ │ │ The value of ~S is ~S, which is not ~:[of type ~S~;~:*~A~]. │ │ │ │ -Slot ~S not found in ~S. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -N-POLICY │ │ │ │ -of the directory segment ~S. │ │ │ │ -user homedir not known~@[ for ~S~]: ~A │ │ │ │ undeclaring functions for old subclasses of ~S: │ │ │ │ layout depth conflict: ~S │ │ │ │ ~@ │ │ │ │ Retry assertion │ │ │ │ with new value~P for ~{~S~^, ~}. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +N-POLICY │ │ │ │ +of the directory segment ~S. │ │ │ │ +user homedir not known~@[ for ~S~]: ~A │ │ │ │ SYS:SRC;CODE;EARLY-FULL-EVAL.LISP │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ If SYMBOL names a macro in ENV, returns the expansion function, │ │ │ │ else returns NIL. If ENV is unspecified or NIL, use the global environment │ │ │ │ @)hAAjT: │ │ │ │ -bounding index designator │ │ │ │ -SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ $8$H$p$= │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ }vBxK%o, │ │ │ │ CONTEXTp │ │ │ │ COMMON-LISP │ │ │ │ CONDITION │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP` │ │ │ │ Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset │ │ │ │ options to MAKE-ARRAY, or NIL and 0 if not a displaced array. │ │ │ │ -~@ │ │ │ │ -Can't LOAD a directory: ~s. │ │ │ │ +bounding index designator │ │ │ │ +SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR │ │ │ │ $p$0$8$@$( │ │ │ │ NAMESPACE │ │ │ │ REPLACEMENTS │ │ │ │ SOFTWARE │ │ │ │ EXTERNAL-FORMAT │ │ │ │ COMMON-LISP │ │ │ │ info hashtable │ │ │ │ @@ -34357,14 +34365,16 @@ │ │ │ │ must be Alien array, pointer or function types. │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP │ │ │ │ Returns the value of the alien variable bound to SYMBOL. Signals an │ │ │ │ error if SYMBOL is not bound to an alien variable, or if the alien │ │ │ │ variable is undefined. │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ +~@ │ │ │ │ +Can't LOAD a directory: ~s. │ │ │ │ ~W :START c~W │ │ │ │ ~W :TAIL │ │ │ │ ~W :HEAD │ │ │ │ PKGLIST@ │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ CONDITION │ │ │ │ @@ -34390,14 +34400,16 @@ │ │ │ │ COMMON-LISPp │ │ │ │ INVALID-KEYS` │ │ │ │ SYS:SRC;PCL;CTOR.LISP │ │ │ │ $8$H$`$= │ │ │ │ FORMAT-CONTROL SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ +missing arg │ │ │ │ +Metaobject Protocol │ │ │ │ X SB-KERNEL8 │ │ │ │ $H$8$`$= │ │ │ │ FORMAT-ARGUMENTSp │ │ │ │ FORMAT-CONTROL │ │ │ │ FUNCTIONALITY │ │ │ │ REST-ARG │ │ │ │ Signal an error because some FUNCTIONALITY or its specific implementation on a given underlying │ │ │ │ @@ -34406,47 +34418,45 @@ │ │ │ │ OPERATION │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISPp │ │ │ │ Signal an error because some FUNCTIONALITY is not implemented in the current version │ │ │ │ of the software on the current platform; it may or may not be implemented in different combinations │ │ │ │ of version of the software and of the underlying platform. Optionally, report a formatted error │ │ │ │ message. │ │ │ │ -missing arg │ │ │ │ -Metaobject Protocol │ │ │ │ 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 │ │ │ │ -'[:signature " │ │ │ │ -':axset[" │ │ │ │ Returns the ACTION-STATUS associated to the action of OPERATION on COMPONENT │ │ │ │ in the PLAN, or NIL if the action wasn't visited yet as part of the PLAN. │ │ │ │ Name of the COMPONENT, unique relative to its parent │ │ │ │ +'[:signature " │ │ │ │ +':axset[" │ │ │ │ COMPONENT8 │ │ │ │ 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. │ │ │ │ Return PATHNAME's name. │ │ │ │ STRINGS8 │ │ │ │ REST-ARG │ │ │ │ Concatenate strings. │ │ │ │ NIL is interpreted as an empty string, a character as a string of length one. │ │ │ │ OPTIONAL-ARGS │ │ │ │ +:module[" │ │ │ │ Return the source file in which system is defined. │ │ │ │ Parses and consumes a . │ │ │ │ The productions are: -> | . │ │ │ │ Will return or (:SEQUENCE ). │ │ │ │ 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. │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ SYS:CONTRIB;SB-POSIX;DEFPACKAGE.LISP.NEWEST │ │ │ │ -:module[" │ │ │ │ /etc/sbclrc │ │ │ │ '[:trs " │ │ │ │ Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE? │ │ │ │ the previous value of ** │ │ │ │ The TRUENAME of the file currently being compiled, or NIL if not │ │ │ │ compiling. │ │ │ │ the TRUENAME of the file that LOAD is currently loading │ │ │ │ @@ -34602,18 +34612,14 @@ │ │ │ │ cond-ok : │ │ │ │ condition : │ │ │ │ #> │ │ │ │ -- sentence │ │ │ │ to be proved │ │ │ │ -- introduced axiom │ │ │ │ @@ -34622,14 +34628,16 @@ │ │ │ │ for induction │ │ │ │ -- introduced constant │ │ │ │ -- user specified induction step │ │ │ │ -- user specified induction base │ │ │ │ -- induction variable │ │ │ │ position: │ │ │ │ critical pairs │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/op-theory.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/bterm.lisp │ │ │ │ No context module is set. │ │ │ │ │ │ │ │ @@ -34781,16 +34793,17 @@ │ │ │ │ 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. │ │ │ │ -CONTROL`.g< │ │ │ │ dv2[>GzHv │ │ │ │ +Vars is not a list of symbols: ~S │ │ │ │ +unrecognized instance type in ~S │ │ │ │ Xl-'pQTI │ │ │ │ $}$($0 8 │ │ │ │ COMMON-LISP( │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -34798,16 +34811,19 @@ │ │ │ │ INDEX-VAR │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ 5@@\tT96 │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Return the element of the ARRAY specified by the SUBSCRIPTS. │ │ │ │ -Vars is not a list of symbols: ~S │ │ │ │ -unrecognized instance type in ~S │ │ │ │ +$($0$8$@$H │ │ │ │ +ACCESSOR-NAME8 │ │ │ │ +DEFAULTH │ │ │ │ +COMMON-LISP0 │ │ │ │ +Return the length of LIST, or NIL if LIST is circular. │ │ │ │ ~@ │ │ │ │ a subclass of the class METHOD │ │ │ │ not supplied │ │ │ │ a method combination object │ │ │ │ when initializing the generic function ~S: │ │ │ │ The ~S initialization argument was: ~A. │ │ │ │ It must be ~A. │ │ │ │ @@ -34828,14 +34844,20 @@ │ │ │ │ has an invalid qualifier │ │ │ │ ~@ │ │ │ │ has too many qualifiers │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +:GENERIC-FUNCTION-CLASS argument │ │ │ │ +:METHOD-CLASS argument │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ 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: │ │ │ │ @@ -34849,20 +34871,14 @@ │ │ │ │ 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. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -:GENERIC-FUNCTION-CLASS argument │ │ │ │ -:METHOD-CLASS argument │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ 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) │ │ │ │ @@ -34966,15 +34982,14 @@ │ │ │ │ │ │ │ │ NULL-LEXENV │ │ │ │ ~S ~S, ~D │ │ │ │ ~D/~D entr~:@P │ │ │ │ no REPORT? shouldn't happen! │ │ │ │ ~:[anonymous~;~:*~S~]~@[ (~(~A~))~] │ │ │ │ ~S ~D/~D keys, psl=~D │ │ │ │ -, depth │ │ │ │ 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. │ │ │ │ Returns the element at position INDEX of SEQUENCE or signals a │ │ │ │ @@ -35014,26 +35029,27 @@ │ │ │ │ elements in the order in which they appear in SEQUENCE. Otherwise, │ │ │ │ the elements are visited in the opposite order. │ │ │ │ Moves ITERATOR one position forward or backward in SEQUENCE │ │ │ │ depending on the iteration direction encoded in FROM-END. │ │ │ │ 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. │ │ │ │ +, depth │ │ │ │ +expected-type: │ │ │ │ +~@ │ │ │ │ +See also: │ │ │ │ +supplied both ~S and ~S to ~S │ │ │ │ +length mismatch in ~S │ │ │ │ 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. │ │ │ │ -expected-type: │ │ │ │ -~@ │ │ │ │ -See also: │ │ │ │ -supplied both ~S and ~S to ~S │ │ │ │ -length mismatch in ~S │ │ │ │ Char-code: │ │ │ │ Char-name: │ │ │ │ Storage vector: │ │ │ │ Displaced: no │ │ │ │ Displaced-to: │ │ │ │ Displaced-offset: │ │ │ │ Adjustable: │ │ │ │ @@ -35095,20 +35111,20 @@ │ │ │ │ * if PROCESSOR is a string, its contents will be printed to the OUTPUT-STREAM. │ │ │ │ * if PROCESSOR is T, it is treated the same as *standard-input*. If it is NIL, nothing is done. │ │ │ │ Programmers are encouraged to define their own methods for this generic function. │ │ │ │ Invalid ~S destination ~S │ │ │ │ Invalid ~S source ~S │ │ │ │ Updates the version of a COMPONENT, which must be a string of dot-separated │ │ │ │ natural numbers, or NIL. │ │ │ │ -Requested version ~S but ~S has no version │ │ │ │ -~@<~A on ~A~@:> │ │ │ │ The pathname of the COMPONENT's parent, if any, or NIL │ │ │ │ Check whether a COMPONENT satisfies the constraint of being at least as recent │ │ │ │ as the specified VERSION, which must be a string of dot-separated natural numbers, or NIL. │ │ │ │ Find an operation by resolving the SPEC in the CONTEXT │ │ │ │ +Requested version ~S but ~S has no version │ │ │ │ +~@<~A on ~A~@:> │ │ │ │ returns a phrase that describes performing this operation │ │ │ │ on this component, e.g. "loading /a/b/c". │ │ │ │ You can put together sentences using this phrase. │ │ │ │ Returns a list of dependencies needed by the component to perform │ │ │ │ the operation. A dependency has one of the following forms: │ │ │ │ ( *), where is an operation designator │ │ │ │ with respect to FIND-OPERATION in the context of the OPERATION argument, │ │ │ │ @@ -35133,32 +35149,23 @@ │ │ │ │ Returns a boolean which is NIL if the action must be performed (again). │ │ │ │ Additional input files for the operation on this │ │ │ │ component. These are files that are inferred, rather than │ │ │ │ explicitly specified, and these are typically NOT files that │ │ │ │ undergo operations directly. Instead, they are files that it is │ │ │ │ important for ASDF to know about in order to compute operation times,etc. │ │ │ │ Return the timestamp for when an action was last performed │ │ │ │ +No defined method for ~S on ~/asdf-action:format-action/ │ │ │ │ +invalid null stamp for ~A │ │ │ │ Update the timestamp for when an action was last performed │ │ │ │ PERFORM an action, consuming its input-files and building its output-files │ │ │ │ PERFORM an action in a context where suitable restarts are in place. │ │ │ │ A method to be called around the PERFORM'ing of actions that apply the │ │ │ │ compile-time side-effects of file (i.e., COMPILE-OP or LOAD-SOURCE-OP). This method can be used │ │ │ │ to setup readtables and other variables that control reading, macroexpanding, and compiling, etc. │ │ │ │ Note that it will NOT be called around the performing of LOAD-OP. │ │ │ │ -No defined method for ~S on ~/asdf-action:format-action/ │ │ │ │ -invalid null stamp for ~A │ │ │ │ -~@ │ │ │ │ -Continue, │ │ │ │ -treating │ │ │ │ -successful. │ │ │ │ -~@ │ │ │ │ -required │ │ │ │ -~@<~A, required by ~A~@:> │ │ │ │ -Component │ │ │ │ -~@ │ │ │ │ Find a component by resolving the PATH starting from BASE parent. │ │ │ │ If REGISTERED is true, only search currently registered systems. │ │ │ │ Return a component satisfying the dependency specification (COMBINATOR . ARGUMENTS) │ │ │ │ in the context of COMPONENT │ │ │ │ Is this action forced to happen in this plan? │ │ │ │ Is this action forced to not happen in this plan? │ │ │ │ Takes precedence over action-forced-p. │ │ │ │ @@ -35174,14 +35181,23 @@ │ │ │ │ at which point we want compute the actual stamp and warn if files are missing; │ │ │ │ otherwise we are making plans, anticipating the effects of the action. │ │ │ │ Returns two values: │ │ │ │ * a STAMP saying when it was done or will be done, │ │ │ │ or T if the action involves files that need to be recomputed. │ │ │ │ * a boolean DONE-P that indicates whether the action has actually been done, │ │ │ │ and both its output-files and its in-image side-effects are up to date. │ │ │ │ +~@ │ │ │ │ +Continue, │ │ │ │ +treating │ │ │ │ +successful. │ │ │ │ +~@ │ │ │ │ +required │ │ │ │ +~@<~A, required by ~A~@:> │ │ │ │ +Component │ │ │ │ +~@ │ │ │ │ version │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~A completed without ~:[~*~;~*its input file~:p~2:*~{ ~S~}~*~]~ │ │ │ │ ~:[~; or ~]~:[~*~;~*its output file~:p~2:*~{ ~S~}~*~] │ │ │ │ Computing just-done stamp in plan ~S for action ~S, but dependency ~S wasn't done yet! │ │ │ │ Given an action, build a plan for all of its dependencies. │ │ │ │ @@ -35232,16 +35248,28 @@ │ │ │ │ and instead use ASDF-OUTPUT-TRANSLATIONS. See the ASDF manual for details. │ │ │ │ In case you insist on preserving your previous A-B-L configuration, but │ │ │ │ do not know how to achieve the same effect with A-O-T, you may use function │ │ │ │ ASDF:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY as documented in the manual; │ │ │ │ call that function where you would otherwise have loaded and configured A-B-L. │ │ │ │ LEXICAL-DEF │ │ │ │ FUNCTIONAL-KIND-EQ │ │ │ │ +More subscripts for ~a (~a) than ~a (~a) │ │ │ │ STORE-VARS │ │ │ │ COMMON-LISP │ │ │ │ +confused about home lambda for ~S │ │ │ │ +~&quitting because IR1-TRANSFORM result was NIL │ │ │ │ +~&trying transform ~s for ~s │ │ │ │ +The return value of ~A should not be discarded. │ │ │ │ +~&xform (~a) ~S │ │ │ │ +Simple equality transform │ │ │ │ +8(ZKXj u │ │ │ │ +EXPR( g0 │ │ │ │ +COMMON-LISPP │ │ │ │ +N-RESULTP │ │ │ │ +SB-IMPL( │ │ │ │ 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*. │ │ │ │ @@ -35287,36 +35315,27 @@ │ │ │ │ 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.) │ │ │ │ -More subscripts for ~a (~a) than ~a (~a) │ │ │ │ -Simple equality transform │ │ │ │ -8(ZKXj u │ │ │ │ -EXPR( g0 │ │ │ │ -COMMON-LISPP │ │ │ │ -N-RESULTP │ │ │ │ -SB-IMPL( │ │ │ │ -confused about home lambda for ~S │ │ │ │ -~&quitting because IR1-TRANSFORM result was NIL │ │ │ │ -~&trying transform ~s for ~s │ │ │ │ -The return value of ~A should not be discarded. │ │ │ │ -~&xform (~a) ~S │ │ │ │ +~S is not a defined template. │ │ │ │ DEFSTRUCT: ~S is not a symbol. │ │ │ │ unknown alignment: ~S │ │ │ │ unknown size: ~S │ │ │ │ Continue, clobbering the old definition. │ │ │ │ Incompatible alien record type definition~%Old: ~S~%New: ~S │ │ │ │ -$($0$8$@$H │ │ │ │ -ACCESSOR-NAME8 │ │ │ │ -DEFAULTH │ │ │ │ -COMMON-LISP0 │ │ │ │ -Return the length of LIST, or NIL if LIST is circular. │ │ │ │ +~S is being set even though it was declared to be ignored. │ │ │ │ +~S is a constant and thus can't be set. │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ +N"R@SdXzX │ │ │ │ +ALIEN-TYPE │ │ │ │ +SB-ALIEN-INTERNALS` │ │ │ │ +PREDICATE-NAMEP │ │ │ │ bL-*`o:0L │ │ │ │ Return five values needed by the SETF machinery: a list of temporary │ │ │ │ variables, a list of values with which to fill them, a list of temporaries │ │ │ │ for the new values, the setting function, and the accessing function. │ │ │ │ Construct and return a list by concatenating LISTS. │ │ │ │ COMMON-LISP │ │ │ │ Return CHAR converted to upper-case if that is possible. Don't convert │ │ │ │ @@ -35343,37 +35362,36 @@ │ │ │ │ CHARACTERS │ │ │ │ CODE=0g< │ │ │ │ The elements of SEQUENCE are examined, and if any two match, one is │ │ │ │ discarded. The resulting sequence, which may be formed by destroying the │ │ │ │ given sequence, is returned. │ │ │ │ The :TEST-NOT argument is deprecated. │ │ │ │ ALIGNMENT │ │ │ │ -ALIEN-TYPE │ │ │ │ -SB-ALIEN-INTERNALS` │ │ │ │ -PREDICATE-NAMEP │ │ │ │ -optimize away %SAP-ALIEN │ │ │ │ -~S is not a defined template. │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-IR2TRAN.LISP │ │ │ │ -N"R@SdXzX │ │ │ │ -~S is being set even though it was declared to be ignored. │ │ │ │ -~S is a constant and thus can't be set. │ │ │ │ -open-code INTEGER to RATIO comparison │ │ │ │ -open-code RATIONAL to FLOAT comparison │ │ │ │ -open-code FLOAT to RATIONAL comparison │ │ │ │ -constant-fold INTEGER to RATIO comparison │ │ │ │ -open code │ │ │ │ Creates a new symbol interned in package PACKAGE with the given PREFIX. │ │ │ │ Creates a new uninterned symbol whose name is a prefix string (defaults │ │ │ │ to "G"), followed by a decimal number. Thing, when supplied, will │ │ │ │ alter the prefix if it is a string, or be used for the decimal number │ │ │ │ if it is a number, of this symbol. The default value of the number is │ │ │ │ the current value of *gensym-counter* which is incremented each time │ │ │ │ it is used. │ │ │ │ ENVIRONMENT │ │ │ │ FORM SB-KERNEL │ │ │ │ +optimize away %SAP-ALIEN │ │ │ │ +open-code INTEGER to RATIO comparison │ │ │ │ +open-code RATIONAL to FLOAT comparison │ │ │ │ +open-code FLOAT to RATIONAL comparison │ │ │ │ +unknown bound type in MAKE-INTERVAL │ │ │ │ +no clauses in ~S │ │ │ │ +Clause ~s is shadowed by ~s │ │ │ │ +~S is not a proper list │ │ │ │ +~@<~IBad ~S clause:~:@_ ~S~:@_~S allowed as the key designator only in the final otherwise-clause, not in a normal-clause. Use (~S) instead, or move the clause to the correct position.~:@> │ │ │ │ +~@<~IBad ~S clause:~:@_ ~S~:@_~S is allowed only in the final clause. Use T instead, or move the clause to the correct position.~:@> │ │ │ │ +~S -- bad clause in ~S │ │ │ │ +constant-fold INTEGER to RATIO comparison │ │ │ │ +open code │ │ │ │ Initiate a garbage collection. │ │ │ │ The default is to initiate a nursery collection, which may in turn │ │ │ │ trigger a collection of one or more older generations as well. If FULL │ │ │ │ is true, all generations are collected. If GEN is provided, it can be │ │ │ │ used to specify the oldest generation guaranteed to be collected. │ │ │ │ Arrange for the designated FUNCTION to be called when there │ │ │ │ are no more references to OBJECT, including references in │ │ │ │ @@ -35409,21 +35427,14 @@ │ │ │ │ (let ((*rec* t)) │ │ │ │ (gc))) ; or just cons enough to cause one │ │ │ │ (progn │ │ │ │ (finalize "oops" #'oops) │ │ │ │ (oops)) ; GC causes re-entry to #'oops due to the finalizer │ │ │ │ ; -> ERROR, caught, WARNING signalled │ │ │ │ Create a semaphore with the supplied COUNT and NAME. │ │ │ │ -unknown bound type in MAKE-INTERVAL │ │ │ │ -no clauses in ~S │ │ │ │ -Clause ~s is shadowed by ~s │ │ │ │ -~S is not a proper list │ │ │ │ -~@<~IBad ~S clause:~:@_ ~S~:@_~S allowed as the key designator only in the final otherwise-clause, not in a normal-clause. Use (~S) instead, or move the clause to the correct position.~:@> │ │ │ │ -~@<~IBad ~S clause:~:@_ ~S~:@_~S is allowed only in the final clause. Use T instead, or move the clause to the correct position.~:@> │ │ │ │ -~S -- bad clause in ~S │ │ │ │ INPUT-STREAM │ │ │ │ Return a bidirectional stream which gets its input from INPUT-STREAM and │ │ │ │ sends its output to OUTPUT-STREAM. │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP8 │ │ │ │ ELEMENT-TYPE8 │ │ │ │ EXTERNAL-FORMATP │ │ │ │ @@ -35437,15 +35448,14 @@ │ │ │ │ directory. │ │ │ │ PATHSPEC8 │ │ │ │ Convert PATHSPEC (a pathname designator) into a pathname, assuming │ │ │ │ the operating system native pathname conventions. │ │ │ │ Construct a filled in pathname by completing the unspecified components │ │ │ │ from the defaults. │ │ │ │ .ANONYMOUS. │ │ │ │ -SB-IMPL( │ │ │ │ This function sets options controlling the floating-point │ │ │ │ hardware. If a keyword is not supplied, then the current value is │ │ │ │ preserved. Possible keywords: │ │ │ │ A list of the exception conditions that should cause traps. │ │ │ │ Possible exceptions are :UNDERFLOW, :OVERFLOW, :INEXACT, :INVALID, │ │ │ │ :DIVIDE-BY-ZERO, and on the X86 :DENORMALIZED-OPERAND. │ │ │ │ :ROUNDING-MODE │ │ │ │ @@ -35467,22 +35477,14 @@ │ │ │ │ GET-FLOATING-POINT-MODES may be used to find the floating point modes │ │ │ │ currently in effect. SAVE-LISP-AND-DIE preserves the floating point modes │ │ │ │ in effect. │ │ │ │ SYNTAX-CHECKER(%g< │ │ │ │ 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. │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/cafeobj/cafeobjvar.lisp │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ ALIEN-NAME │ │ │ │ LISP-NAMEH │ │ │ │ Returns the address of the foreign symbol NAME. DATAP must be true if the │ │ │ │ symbol designates a variable. │ │ │ │ Returns a secondary value T for historical reasons. │ │ │ │ The returned address is always a linkage-table address. │ │ │ │ Symbols are entered into the linkage-table if they aren't there already. │ │ │ │ @@ -35586,25 +35588,37 @@ │ │ │ │ Taken together, these two restrict the "safe" things to do using │ │ │ │ INTERRUPT-THREAD to a fairly minimal set. One useful one -- exclusively for │ │ │ │ interactive development use is using it to force entry to debugger to inspect │ │ │ │ the state of a thread: │ │ │ │ (interrupt-thread thread #'break) │ │ │ │ Short version: be careful out there. │ │ │ │ Return the value of the C library pseudo-variable named "errno". │ │ │ │ -redefining DEFTYPE type to be a class: ~// │ │ │ │ -Cannot redefine standard type ~//. │ │ │ │ MORE-ARG │ │ │ │ Return an abbreviated pathname sufficient to identify PATHNAME │ │ │ │ relative to DEFAULTS. │ │ │ │ Return a string representation of the name in PATHNAME. │ │ │ │ Return a string representation of the directory in PATHNAME. │ │ │ │ Return a string representation of the name of the host in PATHNAME. │ │ │ │ Construct the full (name)string form PATHNAME. │ │ │ │ +SB-IMPL( │ │ │ │ UNIVERSAL-TIME(' │ │ │ │ OPTIONAL-ARGS │ │ │ │ +redefining DEFTYPE type to be a class: ~// │ │ │ │ +Cannot redefine standard type ~//. │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/cafeobj/cafeobjvar.lisp │ │ │ │ +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. │ │ │ │ +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. │ │ │ │ +Can STREAM perform input operations? │ │ │ │ +Can STREAM perform output operations? │ │ │ │ +SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP@ │ │ │ │ Return a new sequence containing the same elements but in reverse order. │ │ │ │ } ( @ 8 │ │ │ │ LOAD-PATHP │ │ │ │ OPTIONAL-ARGS │ │ │ │ REST-ARG │ │ │ │ @@ -35618,17 +35632,29 @@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP0 │ │ │ │ Return the nth object in a list where the car is the zero-th element. │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP │ │ │ │ -SYS:SRC;COMPILER;IR1UTIL.LISP │ │ │ │ -Can STREAM perform input operations? │ │ │ │ -Can STREAM perform output operations? │ │ │ │ +malformed arguments description │ │ │ │ +COMMON-LISP` │ │ │ │ + FIRST-ARGp │ │ │ │ + MORE-ARGSP g| │ │ │ │ +COMMON-P │ │ │ │ +ALIEN-TYPE │ │ │ │ +SB-ALIEN-INTERNALS8 │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +MORE-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +invert or open code │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +BOUND-FORMAT8 │ │ │ │ +COMMON-LISP │ │ │ │ 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. │ │ │ │ Used by READ-BYTE; returns either an integer, or the symbol :EOF │ │ │ │ if the stream is at end-of-file. │ │ │ │ Implements WRITE-BYTE; writes the integer to the stream and │ │ │ │ @@ -35655,36 +35681,21 @@ │ │ │ │ output STREAM. The default method does nothing. │ │ │ │ Attempts to force any buffered output to be sent. Implements │ │ │ │ FORCE-OUTPUT. The default method does nothing. │ │ │ │ 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. │ │ │ │ -COMMON-LISP` │ │ │ │ - FIRST-ARGp │ │ │ │ - MORE-ARGSP g| │ │ │ │ -COMMON-P │ │ │ │ -ALIEN-TYPE │ │ │ │ -SB-ALIEN-INTERNALS8 │ │ │ │ -OPTIONAL-ARGS │ │ │ │ -MORE-ARG │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ -BOUND-FORMAT8 │ │ │ │ -COMMON-LISP │ │ │ │ -malformed arguments description │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ TYPE-SPEC@ │ │ │ │ COMMON-LISPH │ │ │ │ REST-ARG │ │ │ │ -invert or open code │ │ │ │ -REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -35713,30 +35724,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ OUTPUT-STREAM │ │ │ │ COMPILED │ │ │ │ ITEM(,G4$ │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP@ │ │ │ │ -Transfers control to the STEP-CONTINUE restart associated with │ │ │ │ -the condition, continuing execution without stepping. Signals a │ │ │ │ -CONTROL-ERROR if the restart does not exist. │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP@ │ │ │ │ -Transfers control to the STEP-NEXT restart associated with the │ │ │ │ -condition, executing the current form without stepping and continuing │ │ │ │ -stepping with the next form. Signals CONTROL-ERROR if the restart does │ │ │ │ -not exist. │ │ │ │ - CONDITION │ │ │ │ -COMMON-LISP@ │ │ │ │ -Transfers control to the STEP-INTO restart associated with the │ │ │ │ -condition, stepping into the current form. Signals a CONTROL-ERROR if │ │ │ │ -the restart does not exist. │ │ │ │ Breakpoints don't work on RISC-V │ │ │ │ ARG-~V,'0D │ │ │ │ ; Using form offset instead of character position. │ │ │ │ ; File has been modified since compilation: │ │ │ │ foreign function: #x~X │ │ │ │ foreign function: │ │ │ │ ??? Can't get name of debug-block's function. │ │ │ │ @@ -35767,14 +35762,23 @@ │ │ │ │ ~&Enter pathname (evaluated): │ │ │ │ ~&Error: invalid pathname. │ │ │ │ Specify a different pathname to load the shared object from. │ │ │ │ Retry loading this shared object. │ │ │ │ Skip this shared object and continue. │ │ │ │ can't use :OUT or :IN-OUT on pointer-like type: │ │ │ │ bogus argument style ~S in ~S │ │ │ │ +1.0.53.11 │ │ │ │ +1.0.29.17 │ │ │ │ +cannot make an alien of type ~S out of a SAP │ │ │ │ +unknown size for alien type ~S │ │ │ │ +The alignment of ~S is unknown. │ │ │ │ +The size of ~S is unknown. │ │ │ │ +cannot override the size of zero-dimensional arrays │ │ │ │ +~S is not a valid L-value. │ │ │ │ +Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ The element value ~S is used more than once. │ │ │ │ The enumeration element ~S is used more than once. │ │ │ │ The element value ~S is not an integer. │ │ │ │ The enumeration element ~S is not a symbol. │ │ │ │ can't represent enums needing more than 32 bits │ │ │ │ An enumeration must contain at least one element. │ │ │ │ ~S is unsupported as of SBCL 0.8.13. See LOAD-SHARED-OBJECT. │ │ │ │ @@ -35792,26 +35796,18 @@ │ │ │ │ pthread_kill() failed │ │ │ │ Resuming thread ~A │ │ │ │ ~& Bin Size Allocated Count Cum% │ │ │ │ ~& ~2d ~10@a ~13d ~9d ~7,2,2f │ │ │ │ ~& Tot ~23d ~9d │ │ │ │ ; ~D unboxed + ~D boxed bytes (~,1,2F% + ~,1,2F%) │ │ │ │ GET-MUTEX won't get a mutex on behalf of a different thread │ │ │ │ -cannot make an alien of type ~S out of a SAP │ │ │ │ -1.0.53.11 │ │ │ │ -1.0.29.17 │ │ │ │ +Unknown barrier kind ~S │ │ │ │ 1.0.37.33 │ │ │ │ SYS:SRC;CODE;TARGET-MISC.LISP │ │ │ │ -unknown size for alien type ~S │ │ │ │ -The alignment of ~S is unknown. │ │ │ │ -The size of ~S is unknown. │ │ │ │ -cannot override the size of zero-dimensional arrays │ │ │ │ -~S is not a valid L-value. │ │ │ │ -Something is wrong, LOCAL-ALIEN-INFO not found: ~S │ │ │ │ -Unknown barrier kind ~S │ │ │ │ +SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ Argument passed to ~S, ~S, is an improper list. │ │ │ │ Invalid fill-pointer ~a │ │ │ │ INSTEAD not empty in INPUT-WRAPPER for ~S │ │ │ │ Parameters ~S and ~S must be disjoint but have common elements │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ Replacement byte, bytes, character, or string (evaluated): │ │ │ │ @@ -35822,15 +35818,14 @@ │ │ │ │ bad fallthrough in floating point reader │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ failed Unix fstat(2) on ~S │ │ │ │ ~S is not a stream associated with a file. │ │ │ │ -SYS:SRC;CODE;FUNCTION-NAMES.LISP │ │ │ │ Linkage-table full (~D entries): cannot link ~S. │ │ │ │ Failed to find the ~A of ~A │ │ │ │ Couldn't resolve ~S │ │ │ │ Reference to undefined label #~D# │ │ │ │ Missing label for ## │ │ │ │ Frob it anyway! │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ @@ -35881,14 +35876,15 @@ │ │ │ │ [~C~D~@[~*:~2,'0D~@[~*:~2,'0D~]~]] │ │ │ │ invalid keyword: ~S │ │ │ │ cannot specify the version without a type: ~S │ │ │ │ type component can't have a #. inside: ~S │ │ │ │ cannot specify the type without a file: ~S │ │ │ │ too many dots in the name: ~S │ │ │ │ can't read #. while *READ-EVAL* is NIL │ │ │ │ +SYS:SRC;CODE;MODULE.LISP │ │ │ │ /dev/ptmx │ │ │ │ could not find a pty │ │ │ │ /dev/pty │ │ │ │ #\[ with no corresponding #\] │ │ │ │ Vector of length ~D can't be initialized from () │ │ │ │ Vector longer than the specified length: #~S~S. │ │ │ │ Improper list in #(): ~S. │ │ │ │ @@ -36007,15 +36003,14 @@ │ │ │ │ impossible! │ │ │ │ invalid constituent: ~s │ │ │ │ POSSIBLY-FLOAT │ │ │ │ too many dots │ │ │ │ dot context error │ │ │ │ Use symbol anyway. │ │ │ │ inside dispatch character │ │ │ │ -SYS:SRC;CODE;MODULE.LISP │ │ │ │ escape char in a bad place │ │ │ │ :END before :START! │ │ │ │ Currently unbound. │ │ │ │ Address: #x │ │ │ │ Declared always-bound. │ │ │ │ ~A names ~A: │ │ │ │ a symbol macro │ │ │ │ @@ -36109,28 +36104,28 @@ │ │ │ │ can't substitute this into the middle of a word: │ │ │ │ not enough wildcards in FROM pattern to match TO pattern: │ │ │ │ illegal sharp macro character: ~S │ │ │ │ Couldn't find host: ~S │ │ │ │ after REPL │ │ │ │ ~@ │ │ │ │ ~S is not positionable │ │ │ │ -SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ -SYS:SRC;CODE;SORT.LISP │ │ │ │ -SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ A numeric argument was ignored in #~W~A. │ │ │ │ %$%a%b%V%U%c%Q%W%]%\%[% │ │ │ │ %<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j% │ │ │ │ e"d" #!# │ │ │ │ valid file position designator │ │ │ │ c%Q%W%]% │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ +SYS:SRC;CODE;EARLY-PACKAGE.LISP │ │ │ │ +SYS:SRC;CODE;SORT.LISP │ │ │ │ +SYS:SRC;CODE;MAPHASH.LISP │ │ │ │ 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 │ │ │ │ a user-defined │ │ │ │ ~A names ~A declaration. │ │ │ │ @@ -36216,16 +36211,14 @@ │ │ │ │ STUVWXYZ │ │ │ │ 0123456789 │ │ │ │ The object is a CONS. │ │ │ │ defining ~A as a type specifier │ │ │ │ illegal to redefine standard type: ~S │ │ │ │ The class ~S is being redefined to be a DEFTYPE. │ │ │ │ The loader tried loading the symbol named ~a into the package named ~a, but the package did not get defined, and does not exist. │ │ │ │ -SYS:SRC;COMPILER;XREF.LISP │ │ │ │ -SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ from pinned object │ │ │ │ Path to │ │ │ │ Could not allocate ~D bytes for buffer. │ │ │ │ Supply a set of bytes to use in place of the invalid one. │ │ │ │ c%Q%W%]% │ │ │ │ Z%T%i%f%`%P%l% │ │ │ │ Invalid first argument to ~S: ~S │ │ │ │ @@ -36270,31 +36263,33 @@ │ │ │ │ can't reconstitute key of deleted finalizer node │ │ │ │ ~&Unhashed: │ │ │ │ ~&Hashed: │ │ │ │ │ │ │ │ ~D ~X ~S │ │ │ │ Number too large to print in old Roman numerals: ~:D │ │ │ │ negative │ │ │ │ -~~; directive not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ Too many parameters, expected none │ │ │ │ No corresponding close parenthesis │ │ │ │ No corresponding open parenthesis │ │ │ │ +~~; directive not contained within either ~~[...~~] or ~~<...~~> │ │ │ │ Unknown directive ~@[(character: ~A)~] │ │ │ │ │ │ │ │ hundred │ │ │ │ No corresponding close bracket │ │ │ │ Number too large to print in English: ~:D │ │ │ │ FORMAT-ARG │ │ │ │ Number too large to print in Roman numerals: ~:D │ │ │ │ The value of mincol is ~A, should be a non-negative integer │ │ │ │ The value of colinc is ~A, should be a positive integer │ │ │ │ The ~{~A~^ and the ~} modifier~P cannot be used ~:*~[~;~;simultaneously ~]with this directive. │ │ │ │ Too many segments for ~~<...~~:> │ │ │ │ No parameters can be supplied with ~~<...~~:>. │ │ │ │ Cannot include format directives inside the ~:[suffix~;prefix~] segment of ~~<...~~:> │ │ │ │ +SYS:SRC;COMPILER;XREF.LISP │ │ │ │ +SYS:SRC;COMPILER;IR2OPT.LISP │ │ │ │ The slot ~S does not have a suitable default, and no value was provided for it. │ │ │ │ The slot ~S default form ~s doesn't match :type ~s │ │ │ │ dumping anonymous layout: ~S │ │ │ │ attempt to dump reference to obsolete class: ~S │ │ │ │ temporary spec allocates no temps: │ │ │ │ must specify :SC for all temporaries: ~S │ │ │ │ Temporary lifetime doesn't begin before it ends: ~S │ │ │ │ @@ -36345,20 +36340,14 @@ │ │ │ │ expected ~W variant values: ~S │ │ │ │ Duplicate definitions in ~S │ │ │ │ binding ~A as a local function │ │ │ │ The ~S definition spec ~S is malformed. │ │ │ │ ~&; compilation ~:[aborted after~;finished in~] ~A~& │ │ │ │ Primitive was called with ~R argument~:P, but wants at least ~R. │ │ │ │ Primitive was called with ~R argument~:P, but wants exactly ~R. │ │ │ │ -SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ -SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ -SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ -SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ -SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ -SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ DEST-ENV │ │ │ │ Can't preserve function source: ~A │ │ │ │ know how to dump │ │ │ │ Can't preserve function source - missing MAKE-LOAD-FORM methods? │ │ │ │ Unhandled functional-kind ~a │ │ │ │ deleting unused function~:[.~;~:*~% ~S~] │ │ │ │ ~<~@; ~S~:> │ │ │ │ @@ -36398,14 +36387,47 @@ │ │ │ │ The LET ~S has multiple references. │ │ │ │ The LET ~S is not in LETs for HOME. │ │ │ │ The LET ~S has entry function. │ │ │ │ CONSTANT-FORM-VALUE called with invalid expression ~S │ │ │ │ Unexpected metatype for ~S │ │ │ │ function called with ~R argument~:P, but wants at least ~R │ │ │ │ function called with ~R argument~:P, but wants at most ~R │ │ │ │ +SYS:SRC;COMPILER;DEBUG.LISP │ │ │ │ +SYS:SRC;COMPILER;CHECKGEN.LISP │ │ │ │ +SYS:SRC;COMPILER;LIFE.LISP │ │ │ │ +SYS:SRC;COMPILER;BACKEND.LISP │ │ │ │ +SYS:SRC;COMPILER;TARGET-MAIN.LISP │ │ │ │ +SYS:SRC;COMPILER;VOP-EXISTSP.LISP │ │ │ │ +SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ +Control whether the compiler should check for constant │ │ │ │ +modification. Defaults to SAFETY. │ │ │ │ +Control the way to perform runtime type checking: │ │ │ │ +0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ +2: fast checks are performed: declared types are weakened to │ │ │ │ + FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ +3: declared types are fully checked (several exceptions exist; │ │ │ │ + see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ + Implementation Limitations for details). │ │ │ │ +Control inline-substitution of used-once local functions. │ │ │ │ +Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ +more reliable bactracing across foreign calls. │ │ │ │ +Enables possibility of returning from stack frames with the debugger. │ │ │ │ +The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ +When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ +FOO ...) is considered to be the reference to the function being │ │ │ │ +defined. Calls to FOO are compiled as local. This allows better │ │ │ │ +optimization and type checking, but TRACE will not show recursive │ │ │ │ +calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ +bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ +recursive. │ │ │ │ +When disabled, internal references to a function FOO will be │ │ │ │ +considered ti be a call of a function, bound to the symbol at │ │ │ │ +run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ +case of renaming described above, calls to FOO will not be recursive │ │ │ │ +and will refer to the new function, bound to FOO. │ │ │ │ globally declaring ~A ~A │ │ │ │ Cannot proclaim a ~A variable ~A: ~S │ │ │ │ Cannot proclaim an unbound symbol as ~A: ~S │ │ │ │ Cannot proclaim a non-symbol as ~A: ~S │ │ │ │ ~@ │ │ │ │ ~:@_ │ │ │ │ ~:@_IR2 block ~A~@[(#~d)~]~@[ start c~D~]~:@_ │ │ │ │ @@ -36481,52 +36503,14 @@ │ │ │ │ Bad fixup flavor ~s │ │ │ │ ~@ │ │ │ │ trampoline │ │ │ │ a hairy form │ │ │ │ deleted lambda ~S in Lambdas for ~S │ │ │ │ ~S form is too short: ~S │ │ │ │ multiple store variables for ~S │ │ │ │ -SYS:SRC;COMPILER;CONTROL.LISP │ │ │ │ -Control whether the compiler should check for constant │ │ │ │ -modification. Defaults to SAFETY. │ │ │ │ -Control the way to perform runtime type checking: │ │ │ │ -0: declared types are simply trusted; no runtime checks are performed; │ │ │ │ -2: fast checks are performed: declared types are weakened to │ │ │ │ - FIXNUM/SINGLE-FLOAT/FLOAT/NUMBER/structure/specialized array etc.; │ │ │ │ -3: declared types are fully checked (several exceptions exist; │ │ │ │ - see "SBCL User Manual", Compiler->Handling of Types-> │ │ │ │ - Implementation Limitations for details). │ │ │ │ -Control inline-substitution of used-once local functions. │ │ │ │ -Control ALIEN-FUNCALL saving frame-pointer and program counter for │ │ │ │ -more reliable bactracing across foreign calls. │ │ │ │ -Enables possibility of returning from stack frames with the debugger. │ │ │ │ -The default value 1 doesn't prevent tail call optimization, while >1 does. │ │ │ │ -When enabled, reference to a function FOO inside the body of (DEFUN │ │ │ │ -FOO ...) is considered to be the reference to the function being │ │ │ │ -defined. Calls to FOO are compiled as local. This allows better │ │ │ │ -optimization and type checking, but TRACE will not show recursive │ │ │ │ -calls. If the function object is bound to another name BAR, and FOO is │ │ │ │ -bound to another function, calls to FOO inside BAR will remain to be │ │ │ │ -recursive. │ │ │ │ -When disabled, internal references to a function FOO will be │ │ │ │ -considered ti be a call of a function, bound to the symbol at │ │ │ │ -run-time, which is less efficient. TRACE will show recursive calls. In │ │ │ │ -case of renaming described above, calls to FOO will not be recursive │ │ │ │ -and will refer to the new function, bound to FOO. │ │ │ │ -Control instrumentation of code, enabling single-stepping through │ │ │ │ -it in the debugger. │ │ │ │ -This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ -When disabled, LET variable, which is never set and is referenced │ │ │ │ -exactly once, is eliminated and the reference is substituted with the │ │ │ │ -initial value. This allows better type inference and some algebraic │ │ │ │ -optimizations. │ │ │ │ -When enabled, the variable is preserved and can be seen in the │ │ │ │ -debugger. │ │ │ │ -SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ VOP in ~S isn't ~S. │ │ │ │ Read is after write for temp ~S in refs of ~S. │ │ │ │ stray ref with no corresponding temp write: ~S │ │ │ │ stray ref that isn't a READ: ~S │ │ │ │ The ~:R argument is not a constant. │ │ │ │ can't tell whether the ~:R argument is a constant ~S: │ │ │ │ The ~:R argument is not a constant ~S: │ │ │ │ @@ -36566,14 +36550,27 @@ │ │ │ │ can only specify :FROM in a result: ~S │ │ │ │ can only specify :TO in an argument: ~S │ │ │ │ unknown keyword in operand specifier: ~S │ │ │ │ The MORE operand isn't the last operand: ~S │ │ │ │ malformed operand specifier: ~S │ │ │ │ deprecated variable declaration │ │ │ │ can't determine sequence argument type │ │ │ │ +Control instrumentation of code, enabling single-stepping through │ │ │ │ +it in the debugger. │ │ │ │ +This option has no effect without COMPUTE-DEBUG-FUN. │ │ │ │ +When disabled, LET variable, which is never set and is referenced │ │ │ │ +exactly once, is eliminated and the reference is substituted with the │ │ │ │ +initial value. This allows better type inference and some algebraic │ │ │ │ +optimizations. │ │ │ │ +When enabled, the variable is preserved and can be seen in the │ │ │ │ +debugger. │ │ │ │ +SYS:SRC;COMPILER;COPYPROP.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1TRAN-LAMBDA.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ +SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ defining ~S as a macro │ │ │ │ ~S is being redefined as a macro when it was previously ~(~A~) to be a function. │ │ │ │ The special operator ~S can't be redefined as a macro. │ │ │ │ Bad fixup kind ~s │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ --script │ │ │ │ @@ -36614,17 +36611,14 @@ │ │ │ │ unknown phase in time specifier: ~S │ │ │ │ malformed time specifier: ~S │ │ │ │ unknown option specifier: ~S │ │ │ │ malformed option specification: ~S │ │ │ │ Compiling ~A: │ │ │ │ return for unknown block: ~S │ │ │ │ Repeated OPTIMIZE qualit~@P. Using ~{~S~^ and ~} │ │ │ │ -SYS:SRC;COMPILER;GENERIC;VM-TYPETRAN.LISP │ │ │ │ -SYS:SRC;COMPILER;IR1FINAL.LISP │ │ │ │ -SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ ignoring ~S declaration since :BLOCK-COMPILE is not :SPECIFIED │ │ │ │ ~@<~{~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. │ │ │ │ unseen function ~S in ~S │ │ │ │ ~a is not a subtype of ARRAY. │ │ │ │ previous declaration │ │ │ │ @@ -36658,14 +36652,15 @@ │ │ │ │ couldn't find op? bug! │ │ │ │ doing ~A (cost ~W)~:[~2*~; ~:[to~;from~] ~S~], for: │ │ │ │ ~6Tthe ~:R ~:[result~;argument~] of ~A │ │ │ │ illegal type specifier for TYPEP: ~S │ │ │ │ no move function defined to ~:[save~;load~] SC ~S ~:[to~;from~] from SC ~S │ │ │ │ SC ~S has no alternate~:[~; or constant~] SCs, yet it is │ │ │ │ mentioned in the restriction for operand ~S │ │ │ │ +SYS:SRC;COMPILER;PROCLAIM.LISP │ │ │ │ unable to do ~A (cost ~W) because: │ │ │ │ can't trust output type assertion under safe policy │ │ │ │ forced to do ~A (cost ~W) │ │ │ │ ~{~?~^~&~6T~} │ │ │ │ forced to do full call │ │ │ │ unseen successor ~S in ~S │ │ │ │ The successor ~S in ~S is in a different component. │ │ │ │ @@ -36712,15 +36707,14 @@ │ │ │ │ template guard failed │ │ │ │ Redefining vop-info-optimizer for ~S │ │ │ │ This object cannot be dumped into a fasl file: │ │ │ │ assembly code for ~S │ │ │ │ missing generator for ~S │ │ │ │ environment elsewhere start │ │ │ │ Couldn't come up with a value for ~s │ │ │ │ -SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ ~&; [Last message occurs ~W times.] │ │ │ │ Neither LVAR nor TN supplied. │ │ │ │ ~S is not a defined storage class. │ │ │ │ no move function defined to move ~:[from~;to~] SC ~S │ │ │ │ ~:[to~;from~] alternate or constant SC ~S │ │ │ │ ~:@_IR1 block ~D~@[ start c~D~] │ │ │ │ │ │ │ │ @@ -36765,14 +36759,18 @@ │ │ │ │ The list ~S is too short to be a legal local macro definition. │ │ │ │ The ~S binding spec ~S is malformed. │ │ │ │ upgraded array element type not known at compile time │ │ │ │ concatenate │ │ │ │ Can't ~a ~s into ~s │ │ │ │ What? No ir2 blocks have a non-nil number? │ │ │ │ Lisp error during constant folding:~%~A │ │ │ │ +SYS:SRC;COMPILER;CONSTANTP.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;CALL.LISP │ │ │ │ +SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ +SYS:SRC;COMPILER;RISCV;PARMS.LISP │ │ │ │ ~D:~2,'0D:~2,'0D.~3,'0D │ │ │ │ defining ~A as a symbol-macro │ │ │ │ Symbol ~S is already defined as ~A. │ │ │ │ a constant │ │ │ │ Symbol macro name is not a symbol: ~S. │ │ │ │ Defining a ~S keyword not present in ~A. │ │ │ │ The definition lacks the ~S key present in ~A. │ │ │ │ @@ -36838,35 +36836,29 @@ │ │ │ │ Default expression ~S does not match ~S in ~S │ │ │ │ ~@ │ │ │ │ ~S has :MORE results with :TRANSLATE. │ │ │ │ ~&Before IR2-optimize: │ │ │ │ ~S was seen more than once. │ │ │ │ caught ~S: │ │ │ │ ~~@< ~~@;~~A~~:> │ │ │ │ -SYS:SRC;COMPILER;RISCV;CALL.LISP │ │ │ │ -SYS:SRC;COMPILER;GENERIC;INTERR.LISP │ │ │ │ -SYS:SRC;COMPILER;RISCV;PARMS.LISP │ │ │ │ -SYS:SRC;COMPILER;TN.LISP │ │ │ │ IR1-CONVERT- │ │ │ │ a source transform │ │ │ │ -OPTIMIZER │ │ │ │ Bad array dimensions: ~s │ │ │ │ ~&; Base: ~x Data: ~x │ │ │ │ Can't disassemble a special operator │ │ │ │ ; wrote ~A │ │ │ │ ~2&; wrote ~A │ │ │ │ globally declaring the FTYPE of ~A │ │ │ │ Cannot declare FTYPE of illegal function name ~S │ │ │ │ globally declaring the TYPE of ~A │ │ │ │ Cannot proclaim TYPE of a non-symbol: ~S │ │ │ │ -Need ~D fraction bits for divisor ~D and ~D bit dividend │ │ │ │ -__msan_unpoison │ │ │ │ +SYS:SRC;COMPILER;TN.LISP │ │ │ │ malformed SCs spec: ~S │ │ │ │ unknown kind ~S │ │ │ │ -lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ 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. │ │ │ │ @@ -36875,72 +36867,74 @@ │ │ │ │ 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. │ │ │ │ -SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ +lexical environment too hairy, can't inline DEFUN ~S │ │ │ │ +Need ~D fraction bits for divisor ~D and ~D bit dividend │ │ │ │ +__msan_unpoison │ │ │ │ bad EVAL-WHEN situation list: ~S │ │ │ │ note: ~3I~_ │ │ │ │ ~S is not a defined storage base. │ │ │ │ SC ~S has no :UNBOUNDED :SAVE-P NIL alternate SC. │ │ │ │ ~S is not a defined primitive type. │ │ │ │ defining ~S as a function │ │ │ │ Invalid designator for initial backtrace frame: ~S │ │ │ │ +WRAPPER18 │ │ │ │ +WRAPPER14 │ │ │ │ +WRAPPER8 │ │ │ │ +WRAPPER2 │ │ │ │ [~{~(~A~)~^,~}] │ │ │ │ source: ~S │ │ │ │ SYS:SRC; │ │ │ │ ~& no source available for frame │ │ │ │ ~& error printing frame source: ~A │ │ │ │ ~& error finding frame source: ~A │ │ │ │ -WRAPPER18 │ │ │ │ -WRAPPER14 │ │ │ │ -WRAPPER8 │ │ │ │ -WRAPPER2 │ │ │ │ -T case is not last in SC-CASE. │ │ │ │ -illegal SC-CASE clause: ~S │ │ │ │ -This can't happen. │ │ │ │ -invalid number of arguments │ │ │ │ -invalid number of arguments: 0 │ │ │ │ -invalid number of arguments: 1 │ │ │ │ -invalid number of arguments: 2 │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP@ │ │ │ │ +Transfers control to the STEP-CONTINUE restart associated with │ │ │ │ +the condition, continuing execution without stepping. Signals a │ │ │ │ +CONTROL-ERROR if the restart does not exist. │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP@ │ │ │ │ +Transfers control to the STEP-NEXT restart associated with the │ │ │ │ +condition, executing the current form without stepping and continuing │ │ │ │ +stepping with the next form. Signals CONTROL-ERROR if the restart does │ │ │ │ +not exist. │ │ │ │ + CONDITION │ │ │ │ +COMMON-LISP@ │ │ │ │ +Transfers control to the STEP-INTO restart associated with the │ │ │ │ +condition, stepping into the current form. Signals a CONTROL-ERROR if │ │ │ │ +the restart does not exist. │ │ │ │ Return a copy of sequence with elements not satisfying PREDICATE removed. │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP0 │ │ │ │ -Return a copy of a subsequence of SEQUENCE starting with element number │ │ │ │ - START and continuing to the end of SEQUENCE or the optional END. │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISPP │ │ │ │ -MORE-ARG │ │ │ │ -Calls the function associated with the given restart, passing any given │ │ │ │ - arguments. If the argument restart is not a restart or a currently active │ │ │ │ - non-nil restart name, then a CONTROL-ERROR is signalled. │ │ │ │ -Return the intersection of LIST1 and LIST2. │ │ │ │ -Return the number of elements in SEQUENCE satisfying a test with ITEM, │ │ │ │ - which defaults to EQL. │ │ │ │ -Return two values indicating the relationship between type1 and type2. │ │ │ │ - If values are T and T, type1 definitely is a subtype of type2. │ │ │ │ - If values are NIL and T, type1 definitely is not a subtype of type2. │ │ │ │ - If values are NIL and NIL, it couldn't be determined. │ │ │ │ -Make SYMBOL unbound, removing any value it may currently have. │ │ │ │ If the first argument is not true, the rest of the forms are │ │ │ │ evaluated as a PROGN. │ │ │ │ If the first argument is true, the rest of the forms are │ │ │ │ evaluated as a PROGN. │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE0 │ │ │ │ +SYS:SRC;CODE;DEBUG-VAR-IO.LISP │ │ │ │ +T case is not last in SC-CASE. │ │ │ │ +illegal SC-CASE clause: ~S │ │ │ │ This is T while in the debugger. │ │ │ │ A function taking no parameters that starts the low-level debug loop. │ │ │ │ +SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ +This can't happen. │ │ │ │ +invalid number of arguments │ │ │ │ +invalid number of arguments: 0 │ │ │ │ +invalid number of arguments: 1 │ │ │ │ +invalid number of arguments: 2 │ │ │ │ Got to T branch in ~S │ │ │ │ ~S can't be used to initialize an array of type ~//. │ │ │ │ Objects of type ~// can't be dumped into fasl files. │ │ │ │ Return from ~S. │ │ │ │ ~&Your command, ~S, is ambiguous: │ │ │ │ ~&error flushed (because ~S is set) │ │ │ │ ~@ │ │ │ │ @@ -36957,16 +36951,14 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ @@ -36978,15 +36970,45 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP0 │ │ │ │ +Return a copy of a subsequence of SEQUENCE starting with element number │ │ │ │ + START and continuing to the end of SEQUENCE or the optional END. │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISPP │ │ │ │ +MORE-ARG │ │ │ │ +Calls the function associated with the given restart, passing any given │ │ │ │ + arguments. If the argument restart is not a restart or a currently active │ │ │ │ + non-nil restart name, then a CONTROL-ERROR is signalled. │ │ │ │ +Return the intersection of LIST1 and LIST2. │ │ │ │ +Return the number of elements in SEQUENCE satisfying a test with ITEM, │ │ │ │ + which defaults to EQL. │ │ │ │ +Return two values indicating the relationship between type1 and type2. │ │ │ │ + If values are T and T, type1 definitely is a subtype of type2. │ │ │ │ + If values are NIL and T, type1 definitely is not a subtype of type2. │ │ │ │ + If values are NIL and NIL, it couldn't be determined. │ │ │ │ +Make SYMBOL unbound, removing any value it may currently have. │ │ │ │ +COMMON-LISP@ │ │ │ │ +Given a string and a non-negative integer index less than the length of │ │ │ │ + the string, returns the character object representing the character at │ │ │ │ + that position in the string. │ │ │ │ +WEAK-POINTER │ │ │ │ +If WEAK-POINTER is valid, return the value of WEAK-POINTER and T. │ │ │ │ +If the referent of WEAK-POINTER has been garbage collected, │ │ │ │ +returns the values NIL and NIL. │ │ │ │ +^DBJ;c/t& │ │ │ │ +Return a copy of sequence with elements satisfying PREDICATE removed. │ │ │ │ +b(,hh5E| │ │ │ │ REST-ARG │ │ │ │ SIZE-HIGHP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -37005,25 +37027,34 @@ │ │ │ │ PREDPDg< │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -COMMON-LISP@ │ │ │ │ -Given a string and a non-negative integer index less than the length of │ │ │ │ - the string, returns the character object representing the character at │ │ │ │ - that position in the string. │ │ │ │ -WEAK-POINTER │ │ │ │ -If WEAK-POINTER is valid, return the value of WEAK-POINTER and T. │ │ │ │ -If the referent of WEAK-POINTER has been garbage collected, │ │ │ │ -returns the values NIL and NIL. │ │ │ │ -^DBJ;c/t& │ │ │ │ -Return a copy of sequence with elements satisfying PREDICATE removed. │ │ │ │ -b(,hh5E| │ │ │ │ +SB-IMPL( │ │ │ │ +SB-IMPL( │ │ │ │ +SB-IMPL( │ │ │ │ +SB-IMPL0 │ │ │ │ +SB-IMPL( │ │ │ │ +SB-IMPL8 │ │ │ │ +REST-ARG │ │ │ │ +REST-ARG │ │ │ │ +public: algorithms for Unicode data │ │ │ │ +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. │ │ │ │ +REST-ARG │ │ │ │ +0wtzODD' │ │ │ │ +@kJP`:b*.* │ │ │ │ +QsFznCX: │ │ │ │ +environment argument present and not null │ │ │ │ +can't open-code test of non-constant type │ │ │ │ +Bind the variables in LAMBDA-LIST to the corresponding values in the │ │ │ │ +tree structure resulting from the evaluation of EXPRESSION. │ │ │ │ dC6T> │ │ │ │ NEW-NAMESTRING0 │ │ │ │ OLD-NAMESTRING@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ ,/Fj4[6- │ │ │ │ COMMON-LISP( │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISPH │ │ │ │ +COMMON-LISP │ │ │ │ +TYPESH%gL │ │ │ │ TYPE2`+g< │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP` │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ ALIEN-TYPE-1(20 │ │ │ │ @@ -37160,16 +37171,14 @@ │ │ │ │ COMMON-LISPH │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE0 │ │ │ │ TYPE2X.g0 │ │ │ │ INSTANCE0 │ │ │ │ FORTHCOMING-INFO │ │ │ │ -~@ │ │ │ │ -:NAMED option is incompatible with element type ~// │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ $P$0$8$@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE0 │ │ │ │ XS>IZId? │ │ │ │ @@ -37188,23 +37197,27 @@ │ │ │ │ REST-ARG │ │ │ │ RAW-TYPE │ │ │ │ COMMON-LISP │ │ │ │ ALIEN-TYPE │ │ │ │ SB-ALIEN-INTERNALSH │ │ │ │ │ │ │ │ +BASE+BOUNDS │ │ │ │ +DD-NAMED │ │ │ │ !8yoIViN_ │ │ │ │ CLASSOID8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMPLEXP-SUPERTYPEH │ │ │ │ DIMENSIONS8 │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -DD-NAMED │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ TYPE-CLASS │ │ │ │ COMMON-LISP │ │ │ │ DIMENSIONS │ │ │ │ INSTANCE0 │ │ │ │ @@ -37225,16 +37238,14 @@ │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ SPECIFIERH │ │ │ │ INSTANCE0 │ │ │ │ SEEN-UNCERTAINH │ │ │ │ TRIAL-INTERSECTION0 │ │ │ │ -Unhandled representation type in typed DEFSTRUCT: ~//. │ │ │ │ -~@ │ │ │ │ CLASSOID@ │ │ │ │ DEFSTRUCT │ │ │ │ COMMON-LISP8 │ │ │ │ ENUMERABLEH │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ @@ -37252,24 +37263,24 @@ │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ STYPE01gd │ │ │ │ COMMON-LISP` │ │ │ │ INSTANCE0 │ │ │ │ -SLOT-SPECS8 │ │ │ │ - SLOT-VARS0 │ │ │ │ COMMON-LISP0 │ │ │ │ DEFSTRUCT │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +SLOT-SPECS8 │ │ │ │ + SLOT-VARS0 │ │ │ │ x7O.I3j, │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP( │ │ │ │ CLOSURE SB-KERNEL8 │ │ │ │ ]WABUU|_ │ │ │ │ SB-ALIEN │ │ │ │ @@ -37301,17 +37312,14 @@ │ │ │ │ SB-ALIENM │ │ │ │ $($0$8$@"g0 │ │ │ │ FROM-END` │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP( │ │ │ │ COMMON-LISP( │ │ │ │ CODE-OBJ0 │ │ │ │ -NCLOSURE(Bg< │ │ │ │ -PACKAGE- │ │ │ │ -Attempt to remove :PRIMITIVE type: ~// │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISPH │ │ │ │ NEW-VALUE │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37325,14 +37333,17 @@ │ │ │ │ INSTANCE` │ │ │ │ SIMPLE-FUN SB-KERNEL0 │ │ │ │ $}$( H g< │ │ │ │ CONTEXTH │ │ │ │ OPTIONAL-ARGS │ │ │ │ INSTANCE8 │ │ │ │ COMMON-LISP@ │ │ │ │ +NCLOSURE(Bg< │ │ │ │ +PACKAGE- │ │ │ │ +Attempt to remove :PRIMITIVE type: ~// │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE0 │ │ │ │ SIMPLE-FUN SB-KERNEL8 │ │ │ │ COMMON-LISP- │ │ │ │ INITIAL-ELEMENT0 │ │ │ │ CODE-OBJ8 │ │ │ │ FUN-INDEX= │ │ │ │ @@ -37346,30 +37357,30 @@ │ │ │ │ SB-ALIEN │ │ │ │ OPTIONAL-ARGS │ │ │ │ TYPE-SPECIFIER │ │ │ │ $($0$8$@('0 │ │ │ │ INSTANCE SB-KERNELP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP` │ │ │ │ -INSTANCE( │ │ │ │ -TAGGEDP`5'<3 │ │ │ │ -COMMON-LISP │ │ │ │ -TOPMOST8 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP> │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ COMMON-P │ │ │ │ COMMON-LISP@ │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP │ │ │ │ +INSTANCE( │ │ │ │ +TAGGEDP`5'<3 │ │ │ │ +COMMON-LISP │ │ │ │ +TOPMOST8 │ │ │ │ $`$0$8$@"g4 │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPH │ │ │ │ NEW-VALUE │ │ │ │ INSTANCE8 │ │ │ │ SB-ALIEN │ │ │ │ INSTANCE8 │ │ │ │ @@ -37394,34 +37405,40 @@ │ │ │ │ COMMON-LISP(%g< │ │ │ │ INSTANCE0 │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP` │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -EXTRA-ID-WORDS │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP0 │ │ │ │ SB-ALIEN │ │ │ │ $($0$8$@$H5g8 │ │ │ │ -OFFSETM │ │ │ │ SB-ALIENE │ │ │ │ COMMON-LISP │ │ │ │ +LAYOUTpAg< │ │ │ │ +CONTEXT8 │ │ │ │ +COMMON-LISP@ │ │ │ │ + BODY-NAME` │ │ │ │ +COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ $($0$8 '0" │ │ │ │ INSTANCE` │ │ │ │ OUTPUT-TYPE-SPECH │ │ │ │ COMMON-LISP8 │ │ │ │ CODE-OBJ@ │ │ │ │ $H$0$8$@ │ │ │ │ COMMON-LISP │ │ │ │ +EXTRA-ID-WORDS │ │ │ │ +MAX-INDEX │ │ │ │ !SKBQ[ZzI │ │ │ │ COMMON-LISP8)g4 │ │ │ │ INSTANCE0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPH │ │ │ │ $($0$8$@('0 │ │ │ │ INSTANCE SB-KERNELP │ │ │ │ @@ -37434,20 +37451,14 @@ │ │ │ │ SB-INT5 g │ │ │ │ INSTANCE0 │ │ │ │ COMMON-LISP> │ │ │ │ COMMON-LISP │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ SB-C05gT │ │ │ │ -LAYOUTpAg< │ │ │ │ -CONTEXT8 │ │ │ │ -COMMON-LISP@ │ │ │ │ - BODY-NAME` │ │ │ │ -COMMON-LISP │ │ │ │ -MAX-INDEX │ │ │ │ Store NEWVAL as the component of SEQUENCE specified by INDEX. │ │ │ │ COMMON-LISPH │ │ │ │ $($0$8 '0" │ │ │ │ INSTANCE` │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP0 │ │ │ │ CODE-OBJ@ │ │ │ │ @@ -37458,14 +37469,15 @@ │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN │ │ │ │ Return the class of the supplied object, which may be any Lisp object, not │ │ │ │ just a CLOS STANDARD-OBJECT. │ │ │ │ COMMON-LISP0 │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP8 │ │ │ │ + FLET-NAME(%g< │ │ │ │ COMMON-LISP0 │ │ │ │ $`$0$8$@"g4 │ │ │ │ COMMON-LISPP │ │ │ │ NEW-VALUE0 │ │ │ │ NEWCELL@ │ │ │ │ COMMON-LISPP5g4 │ │ │ │ $($0$8$@ │ │ │ │ @@ -37487,25 +37499,14 @@ │ │ │ │ INSTANCE0 │ │ │ │ $($0$8"'0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ COMMON-LISPp!g` │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP@ │ │ │ │ SB-INT9 g │ │ │ │ - FLET-NAME(%g< │ │ │ │ -TEST-NOT(#g< │ │ │ │ -<-Pu:hff │ │ │ │ -OCWmfXmn │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP@ │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP@ │ │ │ │ -DEFAULTSH │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISPP │ │ │ │ INSTANCE SB-KERNELp │ │ │ │ NEW-VALUE` │ │ │ │ NEW-LENGTHH │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISPH │ │ │ │ COH&gH\R │ │ │ │ COMMON-LISP83g4 │ │ │ │ @@ -37513,14 +37514,24 @@ │ │ │ │ SB-ALIEN │ │ │ │ $($0$8 '0" │ │ │ │ INSTANCE` │ │ │ │ INSTANCE0 │ │ │ │ CONDITION │ │ │ │ COMMON-LISPH │ │ │ │ SB-ALIEN │ │ │ │ +TEST-NOT(#g< │ │ │ │ +<-Pu:hff │ │ │ │ +OCWmfXmn │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP@ │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP@ │ │ │ │ +DEFAULTSH │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISPP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37545,17 +37556,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -Package Locks │ │ │ │ -Idiosyncrasies │ │ │ │ -Handling of Types │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37628,23 +37636,23 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -SYS:SRC;CODE;DEFMACRO.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +SYS:SRC;CODE;DEFMACRO.LISP │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -37699,43 +37707,20 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ COMMON-LISP8 │ │ │ │ +Package Locks │ │ │ │ +Idiosyncrasies │ │ │ │ +Handling of Types │ │ │ │ standard readtable │ │ │ │ standard pprint dispatch table │ │ │ │ Deprecation Conditions │ │ │ │ -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. │ │ │ │ -~S is not a ~S │ │ │ │ -~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -Return the last N conses (not the last element!) of a list. │ │ │ │ -CATEGORY │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -FUNCTIONAL0 │ │ │ │ -Load the file given by FILESPEC into the Lisp environment, returning T on │ │ │ │ - success. The file type (a.k.a extension) is defaulted if missing. These │ │ │ │ - options are defined: │ │ │ │ - :IF-DOES-NOT-EXIST │ │ │ │ - If :ERROR (the default), signal an error if the file can't be located. │ │ │ │ - If NIL, simply return NIL (LOAD normally returns T.) │ │ │ │ - :VERBOSE │ │ │ │ - If true, print a line describing each file loaded. │ │ │ │ - :PRINT │ │ │ │ - If true, print information about loaded values. When loading the │ │ │ │ - source, the result of evaluating each top-level form is printed. │ │ │ │ - :EXTERNAL-FORMAT │ │ │ │ - The external-format to use when opening the FILENAME. The default is │ │ │ │ - :DEFAULT which uses the SB-EXT:*DEFAULT-EXTERNAL-FORMAT*. │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37746,14 +37731,16 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +~S is not a ~S │ │ │ │ +~S is not a valid :ELEMENT-TYPE for MAKE-STRING │ │ │ │ SYS:SRC;CODE;LATE-EXTENSIONS.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -37780,14 +37767,38 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ SYS:SRC;COMPILER;GENERIC;PRIMTYPE.LISP │ │ │ │ CATEGORY( │ │ │ │ KIND0='< │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +Return the last N conses (not the last element!) of a list. │ │ │ │ +CATEGORY │ │ │ │ +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. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +FUNCTIONAL0 │ │ │ │ +Load the file given by FILESPEC into the Lisp environment, returning T on │ │ │ │ + success. The file type (a.k.a extension) is defaulted if missing. These │ │ │ │ + options are defined: │ │ │ │ + :IF-DOES-NOT-EXIST │ │ │ │ + If :ERROR (the default), signal an error if the file can't be located. │ │ │ │ + If NIL, simply return NIL (LOAD normally returns T.) │ │ │ │ + :VERBOSE │ │ │ │ + If true, print a line describing each file loaded. │ │ │ │ + :PRINT │ │ │ │ + If true, print information about loaded values. When loading the │ │ │ │ + source, the result of evaluating each top-level form is printed. │ │ │ │ + :EXTERNAL-FORMAT │ │ │ │ + The external-format to use when opening the FILENAME. The default is │ │ │ │ + :DEFAULT which uses the SB-EXT:*DEFAULT-EXTERNAL-FORMAT*. │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -38891,23 +38902,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39063,14 +39065,26 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39347,14 +39361,18 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ +called NATIVE-NAMESTRING using a ~ │ │ │ │ + logical host: ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39421,19 +39439,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -shadowing symbol~P ~{~A~^, ~} │ │ │ │ -uninterning ~A │ │ │ │ -shadowing-importing symbol~P ~ │ │ │ │ - ~{~A~^, ~} │ │ │ │ -importing symbol~P ~{~A~^, ~} │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39475,14 +39488,19 @@ │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +shadowing symbol~P ~{~A~^, ~} │ │ │ │ +uninterning ~A │ │ │ │ +shadowing-importing symbol~P ~ │ │ │ │ + ~{~A~^, ~} │ │ │ │ +importing symbol~P ~{~A~^, ~} │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39561,23 +39579,15 @@ │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -$!$($0$8 │ │ │ │ -$($0$8$`$! │ │ │ │ -RESULT-TYPE │ │ │ │ -MORE-ARG │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ +SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -39587,15 +39597,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39639,14 +39648,37 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +$!$($0$8 │ │ │ │ +$($0$8$`$! │ │ │ │ +RESULT-TYPE │ │ │ │ +MORE-ARG │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +COMMON-LISP8 │ │ │ │ +Return non-NIL if SYMBOL is bound to a value. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39674,18 +39706,14 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ .7Nl?3+>( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -called PARSE-NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ -called NATIVE-NAMESTRING using a ~ │ │ │ │ - logical host: ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ @@ -39810,14 +39838,15 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +parameter specializer name │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -39955,15 +39984,14 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -parameter specializer name │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -40004,58 +40032,41 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -COMMON-LISP8 │ │ │ │ -Return non-NIL if SYMBOL is bound to a value. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ the default value for the :ENCAPSULATE option to TRACE │ │ │ │ the default value for the :REPORT option to TRACE │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -40101,23 +40112,23 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -~@<~S is not the name of a class.~@:> │ │ │ │ -~@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +~@<~S is not the name of a class.~@:> │ │ │ │ +~@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ PZaS>00Lp │ │ │ │ @@ -40151,44 +40162,46 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ Extensible Sequences │ │ │ │ Saving a Core Image │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ NEW-VALUEP │ │ │ │ -There is no symbol ~S in package ~S │ │ │ │ -T if OBJECT is a PROCESS, NIL otherwise. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +There is no symbol ~S in package ~S │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +T if OBJECT is a PROCESS, NIL otherwise. │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNELH │ │ │ │ VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ @@ -40236,86 +40249,84 @@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ Compile the system and produce a linkable static library (.a/.lib) │ │ │ │ for all the linkable object files associated with the system or its dependencies. See LIB-OP. │ │ │ │ produce fasl and asd files for combined system and dependencies. │ │ │ │ Operation to compile the result of monolithic-concatenate-source-op │ │ │ │ Operation to compile the result of concatenate-source-op │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ +Operation class for loading the bundles of a system's dependencies │ │ │ │ +An operation designates itself. NIL designates a context-dependent current operation, │ │ │ │ +and a class-name or class designates the canonical instance of the designated class. │ │ │ │ +USE FUNCTION ANYWAY │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -An operation designates itself. NIL designates a context-dependent current operation, │ │ │ │ -and a class-name or class designates the canonical instance of the designated class. │ │ │ │ -USE FUNCTION ANYWAY │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ +SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ +COMMON-LISP │ │ │ │ +REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -Operation class for loading the bundles of a system's dependencies │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/cl-ppcre/parser.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/fsys.lisp │ │ │ │ create an image file from the system and its dependencies │ │ │ │ This operator is an alternative to COMPILE-OP. Build a system │ │ │ │ and all of its dependencies, but build only a single ("monolithic") FASL, instead │ │ │ │ of one per source file, which may be more resource efficient. That monolithic │ │ │ │ FASL should be loaded with LOAD-BUNDLE-OP, rather than LOAD-OP. │ │ │ │ Operation to concatenate all sources in a system and its dependencies │ │ │ │ into a single file │ │ │ │ Operation to concatenate all sources in a system into a single file │ │ │ │ Compile the system and produce a dynamic loadable library (.so/.dll) │ │ │ │ for all the linkable object files associated with the system or its dependencies. See LIB-OP │ │ │ │ Create a single fasl for the system and its dependencies. │ │ │ │ +/build/reproducible-path/sbcl-2.4.10/contrib/sb-posix/interface.lisp │ │ │ │ Operation to load the result of monolithic-concatenate-source-op as source │ │ │ │ Operation to load the result of concatenate-source-op as source │ │ │ │ -SYS:SRC;CODE;MISC-ALIENS.LISP │ │ │ │ -/build/reproducible-path/sbcl-2.4.10/contrib/sb-posix/interface.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/cl-ppcre/parser.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/fsys.lisp │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ Load a single fasl for the system and its dependencies. │ │ │ │ Operation to load the result of monolithic-compile-concatenated-source-op │ │ │ │ Operation to load the result of compile-concatenated-source-op │ │ │ │ Class for primary systems for which secondary systems are automatically │ │ │ │ in the one-file, one-file, one-system style: system names are mapped to files under the primary │ │ │ │ system's system-source-directory, dependencies are inferred from the first defpackage form in │ │ │ │ every such file │ │ │ │ Class for a system delivered with a linkable static library (.a/.lib) │ │ │ │ Class For a system that is delivered as a precompiled fasl │ │ │ │ a COMPONENT that represents a file │ │ │ │ Component class for a Common Lisp source file using type "lsp" │ │ │ │ Component class for a Common Lisp source file using type "cl" │ │ │ │ Component for a file to be included as is in the build output │ │ │ │ -COMMON-LISP │ │ │ │ -REST-ARG │ │ │ │ Process ID of the process holding the lock; returned with F_GETLK. │ │ │ │ Unknown object type #x~x addr=~x │ │ │ │ Too many result values from c-call. │ │ │ │ usage is: │ │ │ │ bytes overhead) │ │ │ │ Control and binding stack usage is for the current thread only. │ │ │ │ Garbage collection is currently │ │ │ │ @@ -40366,18 +40377,18 @@ │ │ │ │ Tried to fixup with ~a. │ │ │ │ Unaligned instruction? offset=#x~X. │ │ │ │ ~x: ~v,'0x~:[~; = ~@?~] │ │ │ │ page_table │ │ │ │ TEXT_SPACE_START │ │ │ │ next_free_page │ │ │ │ READ_ONLY_SPACE_START │ │ │ │ -DO-REFERENCED-OBJECT usage error │ │ │ │ static_space_free_pointer │ │ │ │ text_space_highwatermark │ │ │ │ DYNAMIC_SPACE_START │ │ │ │ +DO-REFERENCED-OBJECT usage error │ │ │ │ read_only_space_free_pointer │ │ │ │ ~S is a set, not a map │ │ │ │ :TYPE must be one of ~S │ │ │ │ Must not specify :SORT or :TEST with :KEY-TYPE │ │ │ │ Must specify both :SORT and :TEST │ │ │ │ bad place for a wild pathname │ │ │ │ Can't create directory ~A~:[~;,~%a file with ~ │ │ │ │ @@ -40438,15 +40449,14 @@ │ │ │ │ ~S step variable is not a symbol: ~S │ │ │ │ ~@ │ │ │ │ ~@ │ │ │ │ FORM-FUN- │ │ │ │ normal-return │ │ │ │ error-return │ │ │ │ Malformed HANDLER-CASE lambda-list. Should be either () or (symbol), not ~s. │ │ │ │ -~@<~S argument to the short form of ~S must be a string.~:@> │ │ │ │ ~&; disassembly for ~S │ │ │ │ ~S is not a subtype of CHARACTER │ │ │ │ renaming as ~A~@[ with nickname~*~P ~1@*~{~A~^, ~}~] │ │ │ │ Another package is already accessible via name ~S │ │ │ │ Return the existing package. │ │ │ │ A package named ~S already exists │ │ │ │ ~S these symbols into the ~A package. │ │ │ │ @@ -40457,14 +40467,15 @@ │ │ │ │ using package~P ~{~A~^, ~} │ │ │ │ (yes or no) │ │ │ │ removing the function or macro definition of ~A │ │ │ │ Bogus slot-cell in SLOT-MAKUNBOUND: ~S │ │ │ │ (y or n) │ │ │ │ ~@ │ │ │ │ ~S can't be created. │ │ │ │ +~@<~S argument to the short form of ~S must be a string.~:@> │ │ │ │ KV-VECTOR- │ │ │ │ a DEFINE-MODIFY-MACRO lambda list │ │ │ │ Malformed slot entry: ~s, should be (variable-name accessor-name) │ │ │ │ Malformed slot entry: ~s, should be either a symbol or (variable-name slot-name) │ │ │ │ Return T │ │ │ │ Syscall ~A failed: ~A │ │ │ │ sb_gettimeofday │ │ │ │ @@ -40476,18 +40487,18 @@ │ │ │ │ bad option: │ │ │ │ more than one :INITFORM in ~S │ │ │ │ slot :DOCUMENTATION argument is not a string: ~S │ │ │ │ more than one :DOCUMENTATION in ~S │ │ │ │ unknown slot option: │ │ │ │ malformed condition slot spec: │ │ │ │ Keyword slot name indicates probable syntax error: │ │ │ │ -SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ ill-formed ~S clause, no lambda-list: │ │ │ │ a DEFSETF lambda list │ │ │ │ Ill-formed DEFSETF for ~S │ │ │ │ +SYS:SRC;CODE;EARLY-TIME.LISP │ │ │ │ Quoted type specifier in ~S: ~S │ │ │ │ PPRINT-POP must be lexically inside PPRINT-LOGICAL-BLOCK. │ │ │ │ ~S is not a valid type-specifier │ │ │ │ ~S is not a recognized type specifier │ │ │ │ ~S is not accessible in the ~A package. │ │ │ │ unexporting symbol~P ~{~A~^, ~} │ │ │ │ ~S isn't forced to memory. Something went wrong. │ │ │ │ @@ -40504,21 +40515,23 @@ │ │ │ │ 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 │ │ │ │ removing local nickname ~A for ~A │ │ │ │ ~S has ~D elements, vector length is ~D. │ │ │ │ -Disregard this version requirement. │ │ │ │ -SBCL ~A is too old for this program (version ~{~A~^.~} ~ │ │ │ │ - or later is required). │ │ │ │ Something is wrong; local-alien-info not found: ~S │ │ │ │ SYS:SRC;CODE;DEFPACKAGE.LISP │ │ │ │ SYS:SRC;COMPILER;LTN.LISP │ │ │ │ -UNLOCKED-PACKAGES- │ │ │ │ +IF predicate then [else] │ │ │ │ +If PREDICATE evaluates to true, evaluate THEN and return its values, │ │ │ │ +otherwise evaluate ELSE and return its values. ELSE defaults to NIL. │ │ │ │ +Disregard this version requirement. │ │ │ │ +SBCL ~A is too old for this program (version ~{~A~^.~} ~ │ │ │ │ + or later is required). │ │ │ │ SYS:SRC;**;*.*.* │ │ │ │ SYS:CONTRIB;**;*.*.* │ │ │ │ SYS:OUTPUT;**;*.*.* │ │ │ │ SYS:CONTRIB; │ │ │ │ SYS:OUTPUT; │ │ │ │ ~@<~A does not make sense without ~A.~@:> │ │ │ │ Could not delete directory ~S │ │ │ │ @@ -40526,21 +40539,21 @@ │ │ │ │ ~S is not a policy quality │ │ │ │ ~S cannot be used with displaced arrays. Use ~S instead. │ │ │ │ objects, │ │ │ │ candidates, │ │ │ │ Unknown object type #x~x ~s │ │ │ │ Input is not a proper list of weak pointers. │ │ │ │ Could not stop all threads │ │ │ │ +UNLOCKED-PACKAGES- │ │ │ │ Malformed HASH-FUNCTION: ~S │ │ │ │ Cannot redefine standard hash table test ~S. │ │ │ │ Destructively sort SEQUENCE. PREDICATE should return non-NIL if │ │ │ │ ARG1 is to precede ARG2. │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/op-theory.lisp │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ fmt$8W7X7WSPF4LH │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ REST-ARG │ │ │ │ @@ -40553,107 +40566,103 @@ │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ OBJECT SB-KERNEL0 │ │ │ │ .ANONYMOUS. │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ Substitutes new for subtrees matching old. │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ fmt$HT3TNFMEYD1A │ │ │ │ fmt$CJ29BTKLEFXQ │ │ │ │ fmt$QC7J575R438 │ │ │ │ fmt$PYCMUERAX5D │ │ │ │ fmt$NHTBNRHJ3X7V │ │ │ │ +fmt$X31T5ED1QR9C │ │ │ │ +fmt$Y9UHAULNVMVO │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ VALUE SB-KERNEL@!'< │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL8 │ │ │ │ +VALUE SB-KERNEL@ │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -INSTANCE SB-KERNEL8 │ │ │ │ -VALUE SB-KERNEL@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL8 │ │ │ │ VALUE SB-KERNEL@!'< │ │ │ │ -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. │ │ │ │ -fmt$X31T5ED1QR9C │ │ │ │ -fmt$Y9UHAULNVMVO │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ Return true if OBJECT is an ATOM, and NIL otherwise. │ │ │ │ fmt$T86SVWM7HGVG │ │ │ │ fmt$P16POR9RN5FA │ │ │ │ fmt$7PXJYDX26JJ3 │ │ │ │ fmt$HKQPOI27TKQ8 │ │ │ │ @@ -40667,32 +40676,39 @@ │ │ │ │ fmt$BU8XPNXNETYK │ │ │ │ fmt$GMV7C3WL7AGR │ │ │ │ fmt$ABKDDD1B04LN │ │ │ │ fmt$NG2J3WQJEMM6 │ │ │ │ ,+)'&$#R& │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +NEW-ENVP │ │ │ │ +globaldb │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/eval/eval-ast2.lisp │ │ │ │ +SYS:SRC;CODE;CAS.LISP │ │ │ │ +SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ +Synonym for COMPARE-AND-SWAP. │ │ │ │ +Additionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be also used to │ │ │ │ +define CAS-functions analogously to SETF-functions: │ │ │ │ + (defvar *foo* nil) │ │ │ │ + (defun (cas foo) (old new) │ │ │ │ + (cas (symbol-value '*foo*) old new)) │ │ │ │ +First argument of a CAS function is the expected old value, and the second │ │ │ │ +argument of is the new value. Note that the system provides no automatic │ │ │ │ +atomicity for CAS functions, nor can it verify that they are atomic: it is up │ │ │ │ +to the implementor of a CAS function to ensure its atomicity. │ │ │ │ +EXPERIMENTAL: Interface subject to change. │ │ │ │ REST-ARG │ │ │ │ -globaldb │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP@ │ │ │ │ -NEW-ENVP │ │ │ │ -SYS:SRC;CODE;CAS.LISP │ │ │ │ -SYS:SRC;CODE;SETF-FUNS.LISP │ │ │ │ TIME-LEFT- │ │ │ │ INFO-NUMBER- │ │ │ │ Unsupported on this platform. │ │ │ │ ~S is unsupported on this platform ~ │ │ │ │ (OS, CPU, whatever). │ │ │ │ -N-HASH-TABLE- │ │ │ │ -Not a parser state: ~S │ │ │ │ -Bad size for the ~S type specifier: ~S. │ │ │ │ -malformed ONCE-ONLY binding spec: ~S │ │ │ │ Abort ~A file ~S. │ │ │ │ Ignore error and continue ~A file ~S. │ │ │ │ Retry EVAL of current toplevel form. │ │ │ │ ~&While evaluating the form starting at line ~D, column ~D │ │ │ │ of ~S: │ │ │ │ ~{~S~^, ~} │ │ │ │ ~& ~@[type ~D~]~@[~{~S ~S~}~] = │ │ │ │ @@ -40715,21 +40731,19 @@ │ │ │ │ ~2,'0D:~2,'0D │ │ │ │ ~2,'0D ~:@(~A~) ~D │ │ │ │ ~A: Unrecognized :style keyword value. │ │ │ │ ~D/~D/~D │ │ │ │ ~A: Timezone is not a second (1/3600) multiple. │ │ │ │ ~A: Timezone should be a rational between -24 and 24. │ │ │ │ ~A: Universal-Time should be an integer. │ │ │ │ +N-HASH-TABLE- │ │ │ │ +Not a parser state: ~S │ │ │ │ +Bad size for the ~S type specifier: ~S. │ │ │ │ +malformed ONCE-ONLY binding spec: ~S │ │ │ │ bad option: ~S │ │ │ │ -Bad size for ~S type specifier: ~S. │ │ │ │ -malformed NAMED-LET variable spec: ~S │ │ │ │ -F-METHOD- │ │ │ │ -F-BUFFER- │ │ │ │ -F-INDEX- │ │ │ │ -EOF-VAL- │ │ │ │ not legal as a function name: ~S │ │ │ │ interning ~A │ │ │ │ No such thing as DEBOOTSTRAP-PACKAGE │ │ │ │ deleted package │ │ │ │ ~@<~S can't be a ~A: ~2I~_It has been reset to ~S.~:> │ │ │ │ a VALUES type specifier │ │ │ │ a macro lambda list │ │ │ │ @@ -40753,106 +40767,95 @@ │ │ │ │ wrong number of args to FUNCTION: │ │ │ │ VUUUUUUU │ │ │ │ ~@<~S is a relative pathname. (But we'll try using it anyway.)~@:> │ │ │ │ Cannot resolve foreign symbol: lost *runtime-dlhandle* │ │ │ │ Error opening ~:[runtime~;shared object ~:*~S~]: │ │ │ │ Unix system call getrusage failed: ~A. │ │ │ │ invalid external alien name: ~S │ │ │ │ +SUPPLIED-P-P │ │ │ │ +Bad size for ~S type specifier: ~S. │ │ │ │ +malformed NAMED-LET variable spec: ~S │ │ │ │ +F-METHOD- │ │ │ │ +F-BUFFER- │ │ │ │ +F-INDEX- │ │ │ │ +EOF-VAL- │ │ │ │ +~S is valid only inside ~S. │ │ │ │ +OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ Invalid direction ~S, must be either :INPUT or :OUTPUT │ │ │ │ Cancel the deadline and continue. │ │ │ │ By how many seconds shall the deadline ~ │ │ │ │ be deferred?: │ │ │ │ Defer the deadline for SECONDS more. │ │ │ │ -~S is valid only inside ~S. │ │ │ │ -SUPPLIED-P-P │ │ │ │ -OUTER-ALLOW-WITH-INTERRUPTS- │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ +The type declarations ~// and ~// for ~S conflict. │ │ │ │ Construct an association list from KEYS and DATA (adding to ALIST). │ │ │ │ -hA><853.$ │ │ │ │ }~t>>lxL │ │ │ │ ~_eff~'{ │ │ │ │ zz0|[;A^ │ │ │ │ +hA><853.$ │ │ │ │ @2RG │ │ │ │ PROTO-GENERIC-FUNCTIONH │ │ │ │ SPECIALIZER-NAME8 │ │ │ │ SPECIALIZER-NAME8 │ │ │ │ SPECIALIZER-NAME8*g0 │ │ │ │ -~@ │ │ │ │ -~S ~S #X~8,'0X ~S ~// │ │ │ │ INITARGS@ │ │ │ │ METHOD-LAMBDA` │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ APPLICABLE-METHODSH │ │ │ │ COMMON-LISP │ │ │ │ TYPE-NAME8 │ │ │ │ @@ -40935,51 +40937,52 @@ │ │ │ │ NEW-VALUE │ │ │ │ NEW-VALUE8 │ │ │ │ NEW-VALUE8 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ +~S ~S #X~8,'0X ~S ~// │ │ │ │ +~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ +~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ +~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ +~//, slot:~S, ~:S │ │ │ │ MON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ READTABLE │ │ │ │ COMMON-LISPP │ │ │ │ COMMON-LISP@ │ │ │ │ p zHX7Q' │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ -~@<~:@_~*An error will be signaled at runtime for ~//.~:@> │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a runtime error.~:@> │ │ │ │ -~@<~:@_In future~@[ ~A~] versions ~// will signal a full warning at compile-time.~:@> │ │ │ │ -~:[~*~;~// ~]~{~S ~}~:S │ │ │ │ -~//, slot:~S, ~:S │ │ │ │ |JLG~v<9 │ │ │ │ /-`o:00: │ │ │ │ /-`o:00: │ │ │ │ dr!f7n{\ │ │ │ │ L.,`o:00: │ │ │ │ a0 c:F.D │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ `$"H9It,A │ │ │ │ fmt$DOT6XAOY7ZSR │ │ │ │ COMMON-LISP@ │ │ │ │ +Superclass of all Gray output streams whose element-type │ │ │ │ +is a subtype of character. │ │ │ │ fmt$B0NCY3LJDL4 │ │ │ │ DFUN-INFOP │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$SLHNTOJ2K18F │ │ │ │ -Superclass of all Gray output streams whose element-type │ │ │ │ -is a subtype of character. │ │ │ │ fmt$WJLN8FO1R5OK │ │ │ │ fmt$NX8AZZT9W09R │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$UAHLK5RVUSLD │ │ │ │ NEW-VALUE` │ │ │ │ REST-ARG │ │ │ │ FROM-ENDH │ │ │ │ @@ -41003,19 +41006,19 @@ │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ ITERATOR@ │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ ITERATOR( │ │ │ │ B#HM:y A │ │ │ │ +Element-type: ~// │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -Element-type: ~// │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$FRF53XELDXSD │ │ │ │ fmt$HHUAPATMV50T │ │ │ │ fmt$FB3EVX2NMF2Q │ │ │ │ fmt$4DLLZTG4YNZ7 │ │ │ │ fmt$ND46XQARXQ19 │ │ │ │ fmt$RL1L0WOJUJI1 │ │ │ │ @@ -41166,84 +41169,54 @@ │ │ │ │ `` ( 015 │ │ │ │ ``` ( 0V │ │ │ │ `` ( 0V5 │ │ │ │ ``` ( 0X │ │ │ │ `` ( 0X5 │ │ │ │ ``` ( 0Z │ │ │ │ `` ( 0Z5 │ │ │ │ -When set, avoid calling INVOKE-DEBUGGER recursively when errors occur while │ │ │ │ - executing in the debugger. │ │ │ │ -If the trace indentation exceeds this value, then indentation restarts at │ │ │ │ -the increase in trace indentation at each call level │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ TRUSTEDH │ │ │ │ REST-ARG │ │ │ │ -REST-ARG │ │ │ │ is not specified as 'autoload'. │ │ │ │ resetting bound value of │ │ │ │ get-method-info: no opinfo-table │ │ │ │ specified module │ │ │ │ is inconsistent │ │ │ │ no such view : │ │ │ │ +start setting constructor ordering... │ │ │ │ +REST-ARG │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +OPTIONAL-ARGS │ │ │ │ +If NAME names a compiler-macro in ENV, return the expansion function, else │ │ │ │ +return NIL. Can be set with SETF when ENV is NIL. │ │ │ │ LEAFH g< │ │ │ │ -SYS:SRC;COMPILER;RISCV;PRED.LISP │ │ │ │ MORE-ARG │ │ │ │ NAMESPACE │ │ │ │ COMMON-LISP0 │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ .(M$0hBkh7t │ │ │ │ DOCSTRING0 │ │ │ │ NAME@ g4 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH$` │ │ │ │ SB-INTA$] │ │ │ │ MORE-ARG │ │ │ │ Return a list of the arguments with last cons a dotted pair. │ │ │ │ -N-RESULT(!g< │ │ │ │ -DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)} │ │ │ │ - Define the structure type Name. Instances are created by MAKE-, │ │ │ │ - which takes &KEY arguments allowing initial slot values to the specified. │ │ │ │ - A SETF'able function - is defined for each slot to read and │ │ │ │ - write slot values. -p is a type predicate. │ │ │ │ - Popular DEFSTRUCT options (see manual for others): │ │ │ │ - (:CONSTRUCTOR Name) │ │ │ │ - (:PREDICATE Name) │ │ │ │ - Specify the name for the constructor or predicate. │ │ │ │ - (:CONSTRUCTOR Name Lambda-List) │ │ │ │ - Specify the name and arguments for a BOA constructor │ │ │ │ - (which is more efficient when keyword syntax isn't necessary.) │ │ │ │ - (:INCLUDE Supertype Slot-Spec*) │ │ │ │ - Make this type a subtype of the structure type Supertype. The optional │ │ │ │ - Slot-Specs override inherited slot options. │ │ │ │ - Slot options: │ │ │ │ - :TYPE Type-Spec │ │ │ │ - Asserts that the value of this slot is always of the specified type. │ │ │ │ - :READ-ONLY {T | NIL} │ │ │ │ - If true, no setter function is defined for this slot. │ │ │ │ -DUMMIES( │ │ │ │ -LqI2a-ap │ │ │ │ -COMMON-LISP │ │ │ │ -Return the integer code of CHAR. │ │ │ │ +SYS:SRC;COMPILER;RISCV;PRED.LISP │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/comlib/lex.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/cafeobj/creader.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/tools/help.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/thstuff/eval-apply.lisp │ │ │ │ PN-PARAM- │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/decafe/view.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/primitives/parse-modexp.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/tram/tram.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/decafe/mimport.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/cafeobj/trans-com.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/butils.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-top.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/reader.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/cafein/rengine.lisp │ │ │ │ -start setting constructor ordering... │ │ │ │ invalid value for exec limit: │ │ │ │ unknown term : │ │ │ │ no subterm is specified yet, please `choose' some. │ │ │ │ selected the whole term. │ │ │ │ no such sort │ │ │ │ (cond)]: │ │ │ │ No such operator │ │ │ │ @@ -41254,14 +41227,21 @@ │ │ │ │ sec for parse, │ │ │ │ sec for │ │ │ │ rewrites + │ │ │ │ matches │ │ │ │ memo hits) │ │ │ │ ] contradiction: │ │ │ │ `true = false' can be derived! │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/cafeobj/trans-com.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/butils.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-top.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/reader.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/cafein/rengine.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match-a.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/match-method.lisp │ │ │ │ The list of commands classified as ' │ │ │ │ ========================================================================== │ │ │ │ Sorry, the commands classified as ' │ │ │ │ ' not found. │ │ │ │ System does not know the command class ' │ │ │ │ Type '?cat' for the list of available class names. │ │ │ │ Instanciating an axiom, no such variable │ │ │ │ @@ -41291,34 +41271,37 @@ │ │ │ │ , coarity= │ │ │ │ operator pattern is just _, declaration ignored. │ │ │ │ You can not specify the order with built in sort │ │ │ │ ** binary-res:(prop-res = │ │ │ │ clash = │ │ │ │ Internal error, :def invalid │ │ │ │ Internal error, :def accepted │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match-a.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/match-method.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/boot/builtins.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/gen-rule.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/term-utils.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/version.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/module.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/weight.lisp │ │ │ │ Unknown type of hidden declaration │ │ │ │ , prec = │ │ │ │ over 256 arguments for argument* │ │ │ │ invalid strategy │ │ │ │ for opeator │ │ │ │ , ignored. │ │ │ │ current module has no let binding for " │ │ │ │ unknown option for `show term' : │ │ │ │ resetting weight limit to │ │ │ │ sos size = │ │ │ │ setting flag │ │ │ │ no such flag name │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/boot/builtins.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/gen-rule.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/term-utils.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/version.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/module.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/weight.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match-ac.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/message.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/trs.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/inspect.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/formula.lisp │ │ │ │ __________________________ │ │ │ │ key(type: │ │ │ │ value(type: │ │ │ │ selected rule doesn't exist, │ │ │ │ rule number must be greater than 0. │ │ │ │ >[normalize-quantifiers]: │ │ │ │ ] discharged goal │ │ │ │ @@ -41351,25 +41334,21 @@ │ │ │ │ , rhs-f-r= │ │ │ │ -- lhs-f-r= │ │ │ │ , lhs-v-r= │ │ │ │ -- lhs-mask= │ │ │ │ -- lhs-f-mask= │ │ │ │ -- lhs-r-mask= │ │ │ │ - term = │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match-ac.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/message.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/trs.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/inspect.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/formula.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/decafe/meval.lisp │ │ │ │ Unknown parameter to :show/:describe │ │ │ │ ignoring these selections : │ │ │ │ found variable in subset selection │ │ │ │ ignoring the selection and select whole subterms instead. │ │ │ │ -- result : │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/decafe/meval.lisp │ │ │ │ +GENERAL-LISP-FORM- │ │ │ │ invalid sort reference │ │ │ │ too many args │ │ │ │ sorry, but transitions are not supported yet. │ │ │ │ axiom to formula translation: ignoring axiom │ │ │ │ [Error] Cannot parse as regexp: │ │ │ │ Setting induction variable, no such variable │ │ │ │ in target axiom. │ │ │ │ @@ -41407,30 +41386,31 @@ │ │ │ │ invalid module expression: │ │ │ │ remaining │ │ │ │ internal error, strange sort name │ │ │ │ could not evaluate an argument to `+' : │ │ │ │ could not evaluate plus: │ │ │ │ dependent: param( │ │ │ │ sec. for abstraction) │ │ │ │ -GENERAL-LISP-FORM- │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/bmodule2.lisp │ │ │ │ : no current module is specified! │ │ │ │ -- reading in file : │ │ │ │ -- apply rule: │ │ │ │ (total run time │ │ │ │ ** dump of *clash-pos-literals* │ │ │ │ Internal error, unknown citp command │ │ │ │ binspect: internal error, no module. │ │ │ │ [transfer-operator]: │ │ │ │ ** !! Discarding the current proof... │ │ │ │ Given term is not of sort Bool. │ │ │ │ propositional │ │ │ │ equality │ │ │ │ symmetry │ │ │ │ max literals │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/bmodule2.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/index.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match2.lisp │ │ │ │ continue count must be positive integer, but │ │ │ │ is given. │ │ │ │ invalid args │ │ │ │ - operator: │ │ │ │ but the module name is not simple one: │ │ │ │ the name must be qualified for disambiguation, │ │ │ │ the name must be qualified for disambiguation: │ │ │ │ @@ -41443,20 +41423,21 @@ │ │ │ │ is followed by │ │ │ │ setting parameter │ │ │ │ given value │ │ │ │ is too large, maximum value allowed is │ │ │ │ is too small, minimun value allowed is │ │ │ │ invalid parameter value │ │ │ │ no such parameter name │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/index.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/e-match/match2.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/gen-print.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/clause.lisp │ │ │ │ is missing, proof incomplete. │ │ │ │ invalid rewrite count limit │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/gen-print.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/clause.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/error.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/gen-eval.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/demod.lisp │ │ │ │ The path │ │ │ │ is not in 'libpath'. │ │ │ │ incorrect module expression: │ │ │ │ no target term is given! │ │ │ │ ** run times in seconds ------------------- │ │ │ │ demod time │ │ │ │ forward subsume │ │ │ │ @@ -41482,33 +41463,30 @@ │ │ │ │ ' is given │ │ │ │ memo attribute is now obsolate. │ │ │ │ declaring attributes, could not found unique operator │ │ │ │ illegual id condition : │ │ │ │ adding sort │ │ │ │ :spoiler flag is │ │ │ │ invalid :embed type │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/error.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/gen-eval.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/demod.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/operator.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/axiom.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/describe.lisp │ │ │ │ - source type: │ │ │ │ , target type: │ │ │ │ [Error] source and target must be non-behavioural for `op' map: │ │ │ │ - source │ │ │ │ - target │ │ │ │ [Error] source and target must be behavioural for `bop' map: │ │ │ │ of built-in sort │ │ │ │ Operator mapping is not injective, the declaration │ │ │ │ could not resolve operator target pattern : │ │ │ │ could not resolve source operator pattern : │ │ │ │ -method image is already in module │ │ │ │ `set print fancy { on | off }' is now obsolete. │ │ │ │ please use `set print mode fancy' or `print mode normal'. │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/operator.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/axiom.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/describe.lisp │ │ │ │ importing variable │ │ │ │ , could not find sort │ │ │ │ Invalid variable in substitution: │ │ │ │ Sort mismatch for the substitution │ │ │ │ variable: │ │ │ │ term: │ │ │ │ No parse..: │ │ │ │ @@ -41545,32 +41523,33 @@ │ │ │ │ > back demod: │ │ │ │ > demod: │ │ │ │ - resetting reduced flag ... │ │ │ │ [reduce-term](NF= │ │ │ │ rocessing input : │ │ │ │ adding operator theory │ │ │ │ into module │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/normodexp.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/cafein/cbred.lisp │ │ │ │ -PIGNOSE-FLAG- │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/set.lisp │ │ │ │ No evaluator is defined for command │ │ │ │ Invalid argument to command │ │ │ │ No parser is defined for command │ │ │ │ No such command or declaration keyword ' │ │ │ │ Could not find the goal │ │ │ │ No default target goal. │ │ │ │ unify? = │ │ │ │ one way match? = │ │ │ │ no such operator: │ │ │ │ incorrect module expression, or unknown module: │ │ │ │ no such parameter │ │ │ │ could not evaluate view source module │ │ │ │ error in argument name : no such module │ │ │ │ bad modexp form │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/normodexp.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/cafein/cbred.lisp │ │ │ │ +PIGNOSE-FLAG- │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/set.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/regcheck.lisp │ │ │ │ sort_decl: forms = │ │ │ │ ** dump of *paramod-rules* │ │ │ │ : result info = │ │ │ │ unknown sort │ │ │ │ for variable form │ │ │ │ Static variable │ │ │ │ already used before in the same context │ │ │ │ @@ -41635,18 +41614,15 @@ │ │ │ │ Invalid module expression: │ │ │ │ [reg-sort-included]: assumption failure! │ │ │ │ $$subterm = │ │ │ │ no subterm selection is made by `choose'. │ │ │ │ - tgt = │ │ │ │ recostructing view illegual view: │ │ │ │ ++ selected ( │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/regcheck.lisp │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/thstuff/case.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/module-tree.lisp │ │ │ │ -%CHAOS-AST- │ │ │ │ No current goal. │ │ │ │ for parse, │ │ │ │ rewrites( │ │ │ │ expecting theory, given invalid object: │ │ │ │ operator │ │ │ │ is not a constructor, ignored. │ │ │ │ is already ordered, ignored. │ │ │ │ @@ -41683,21 +41659,23 @@ │ │ │ │ rhs-c-max= │ │ │ │ rhs-c-compat= │ │ │ │ rhs-c-r= │ │ │ │ lhs-f-r= │ │ │ │ lhs-mask= │ │ │ │ lhs-f-mask= │ │ │ │ lhs-r-mask= │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/decafe/modmorph.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/find.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/module-tree.lisp │ │ │ │ +%CHAOS-AST- │ │ │ │ No parser is defined for declaration │ │ │ │ No such declaration ' │ │ │ │ directory " │ │ │ │ " not found. │ │ │ │ inspect: internal error, │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/decafe/modmorph.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/find.lisp │ │ │ │ the operator of the same rank has already been declared: │ │ │ │ unit-conflict: accepted empty clause! │ │ │ │ could not find reverse map of operator symbol │ │ │ │ already on. │ │ │ │ already stop. │ │ │ │ >[neg-normal-form]: │ │ │ │ Invalid submodule number │ │ │ │ @@ -41814,14 +41792,15 @@ │ │ │ │ No rule number or name is specified. │ │ │ │ no such file │ │ │ │ Could not parse │ │ │ │ >*subsume-disjuncts: │ │ │ │ unknown switch │ │ │ │ Sort name │ │ │ │ is reserfed for the system, sorry. │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-engine.lisp │ │ │ │ No context module is specified. │ │ │ │ invalid value for term print depth: │ │ │ │ No proof tree! │ │ │ │ $$term is not bound. │ │ │ │ no module is open. │ │ │ │ could not evaluate modexp │ │ │ │ illegal modexp │ │ │ │ @@ -41844,17 +41823,14 @@ │ │ │ │ qualified by the module expression: │ │ │ │ Redefining module │ │ │ │ is protected! │ │ │ │ You can not redefine system module │ │ │ │ There is no unproved goals. │ │ │ │ you cannot use │ │ │ │ is appeared in FOPL sentence, replacing... │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-engine.lisp │ │ │ │ -PN-CLOCK- │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/modconv.lisp │ │ │ │ >> The following operators have empty arity: │ │ │ │ >> The following operators are detected as redundant, │ │ │ │ due to the above new operators. │ │ │ │ >> The following sorts are empty: │ │ │ │ * starting back unit deletion with │ │ │ │ backsubsumes │ │ │ │ * starting back demodulation with │ │ │ │ @@ -41867,14 +41843,16 @@ │ │ │ │ invalid sort of variable in state equality pattern. │ │ │ │ variables in state equality pattern must be of the same sort. │ │ │ │ state equality pattern must have exactly 2 different variables in it, but │ │ │ │ state equality must be of a term of sort Bool. │ │ │ │ `suchThat' introduces new variable(s). │ │ │ │ Sorts of the source term and the target pattern must be in the same connected component. │ │ │ │ Target pattern: │ │ │ │ +PN-CLOCK- │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/modconv.lisp │ │ │ │ fixing operator renaming .. │ │ │ │ generating error sorts │ │ │ │ [apply-modmorph] : begin ---------------------------- │ │ │ │ - map = │ │ │ │ - module = │ │ │ │ - new module = │ │ │ │ [most-general-method] │ │ │ │ @@ -41921,14 +41899,15 @@ │ │ │ │ : arg-acc-list = │ │ │ │ modexp-update-name: no such module │ │ │ │ illegal show mode │ │ │ │ module is inconsistent and cannot be shown, please redefine it! │ │ │ │ rank of method │ │ │ │ does not allow it to be associative, ignoring `assoc' attribute. │ │ │ │ No goal is specified yet. │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-macro.lisp │ │ │ │ Invalid print mode │ │ │ │ >> The following operators may be required for regularity: │ │ │ │ >> The following sorts may be required for regularity: │ │ │ │ , entries ------------------- │ │ │ │ CafeOBJ> │ │ │ │ is inconsistent due to changes in some of its submodules. │ │ │ │ End[para-into]: │ │ │ │ @@ -41946,15 +41925,14 @@ │ │ │ │ ;;; user defined modules. │ │ │ │ ;;; views. │ │ │ │ [MEL]: max-minorants = │ │ │ │ [MEL]: minimals = │ │ │ │ [MEL]: candidates 1 = │ │ │ │ [MEL]: setting hashed sort │ │ │ │ sort membership test nesting too deep │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/term-parser/parse-macro.lisp │ │ │ │ A module │ │ │ │ is open. │ │ │ │ Try typing '?com element' for the list of available constructs. │ │ │ │ is set as current module. │ │ │ │ You are at top level, no context module is set. │ │ │ │ rules were found for term: │ │ │ │ could not find subterm at pos │ │ │ │ @@ -41968,16 +41946,14 @@ │ │ │ │ - theory │ │ │ │ - coherent is specified │ │ │ │ - constr is specified │ │ │ │ - memo is specified │ │ │ │ - strategy │ │ │ │ - precedence │ │ │ │ - associativity │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/unify.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/eval/eval-ast.lisp │ │ │ │ cannot instantiate builtin rules! │ │ │ │ Illegal variable form: │ │ │ │ Invalid argument to ':ind' command: │ │ │ │ ** PigNose Parameters --------- │ │ │ │ invalid `after' argument : │ │ │ │ invalid `after' agument : │ │ │ │ state(s) to be examined -- │ │ │ │ @@ -41989,14 +41965,17 @@ │ │ │ │ Value = │ │ │ │ has no instance database. │ │ │ │ operator precedence must be a natural number less than │ │ │ │ internal error, could not find │ │ │ │ ** dump of *clash-neg-literals* │ │ │ │ mapping term image, could not find operator image: │ │ │ │ invalid identity term │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/unify.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/eval/eval-ast.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/construct/sort.lisp │ │ │ │ No tactic with the name │ │ │ │ invalid value for print mode │ │ │ │ module is inconsistent and cannt be described │ │ │ │ please redefine it from the scratch. │ │ │ │ {on|off} : │ │ │ │ : │ │ │ │ [Error]: no successful parse │ │ │ │ @@ -42007,16 +41986,14 @@ │ │ │ │ No target goal. │ │ │ │ The name │ │ │ │ is already defined in the current proof context. │ │ │ │ You can not use the name of builtin tactic │ │ │ │ Internal error : no context found for object │ │ │ │ Internal error, could not evaluate modexp │ │ │ │ Invalid context module │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/construct/sort.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/let-over-lambda.lisp │ │ │ │ substitution : │ │ │ │ extra variables : │ │ │ │ No such variable in rule: │ │ │ │ matched with the substitution │ │ │ │ value must be either `cafeobj' or `meta' │ │ │ │ - target = │ │ │ │ - module of sort │ │ │ │ @@ -42034,14 +42011,16 @@ │ │ │ │ require: reading proc is not specified! │ │ │ │ is already imported into │ │ │ │ with the effective mode : │ │ │ │ this conflicts to the new mode : │ │ │ │ confliction in importation mode of common submodule │ │ │ │ already imports with effective mode │ │ │ │ imports with effective mode │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/let-over-lambda.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/eval/chaos-top.lisp │ │ │ │ variation in identity of method │ │ │ │ re setting it to │ │ │ │ directory stack is not so deep. │ │ │ │ No other directory. │ │ │ │ must be │ │ │ │ ' renaming. │ │ │ │ sorry! sort ` │ │ │ │ @@ -42092,17 +42071,16 @@ │ │ │ │ (new) states. │ │ │ │ [state │ │ │ │ from [state │ │ │ │ possible transitions..... │ │ │ │ rule patterns for state │ │ │ │ Arbitrarily taking the │ │ │ │ Taking the │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/eval/chaos-top.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/tools/op-check.lisp │ │ │ │ Invalid depth/state specifier: │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/tools/op-check.lisp │ │ │ │ * kept in │ │ │ │ : weight= │ │ │ │ after proc-gen: │ │ │ │ start[pre-process] │ │ │ │ -- non coherent, sort match fail. │ │ │ │ new-env = │ │ │ │ RHS = │ │ │ │ @@ -42232,42 +42210,69 @@ │ │ │ │ not found in view variable │ │ │ │ -find non-specified method │ │ │ │ -try finding in module │ │ │ │ source = │ │ │ │ target = │ │ │ │ sort-map = │ │ │ │ op-map = │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ dependent: flag( │ │ │ │ expecting parameter context, given invalid object: │ │ │ │ No such discharged sentence with name │ │ │ │ Found more than 1 sentences with name │ │ │ │ unknown associativity declaration │ │ │ │ assoc for operator │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/comlib/print-utils.lisp │ │ │ │ -SYS:SRC;PCL;ENV.LISP │ │ │ │ -AcB.EisN │ │ │ │ -HASH-TABLE │ │ │ │ -COMMON-LISP0 │ │ │ │ -WRITE-PH │ │ │ │ declaring associativity: no such operator │ │ │ │ !! cannot find variable subst │ │ │ │ No step term found for variable │ │ │ │ hypo-v-op: │ │ │ │ No subst given. │ │ │ │ - map pair : │ │ │ │ key : │ │ │ │ val : │ │ │ │ - val = │ │ │ │ is not available in the current context. │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ ** PigNose statistics ------------------+ │ │ │ │ >[expand-macro]: │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/comlib/print-utils.lisp │ │ │ │ +When set, avoid calling INVOKE-DEBUGGER recursively when errors occur while │ │ │ │ + executing in the debugger. │ │ │ │ +If the trace indentation exceeds this value, then indentation restarts at │ │ │ │ +the increase in trace indentation at each call level │ │ │ │ +AcB.EisN │ │ │ │ +HASH-TABLE │ │ │ │ +COMMON-LISP0 │ │ │ │ +WRITE-PH │ │ │ │ +COMMON-LISP │ │ │ │ +YIh$|\.0 │ │ │ │ +N-RESULT(!g< │ │ │ │ +DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)} │ │ │ │ + Define the structure type Name. Instances are created by MAKE-, │ │ │ │ + which takes &KEY arguments allowing initial slot values to the specified. │ │ │ │ + A SETF'able function - is defined for each slot to read and │ │ │ │ + write slot values. -p is a type predicate. │ │ │ │ + Popular DEFSTRUCT options (see manual for others): │ │ │ │ + (:CONSTRUCTOR Name) │ │ │ │ + (:PREDICATE Name) │ │ │ │ + Specify the name for the constructor or predicate. │ │ │ │ + (:CONSTRUCTOR Name Lambda-List) │ │ │ │ + Specify the name and arguments for a BOA constructor │ │ │ │ + (which is more efficient when keyword syntax isn't necessary.) │ │ │ │ + (:INCLUDE Supertype Slot-Spec*) │ │ │ │ + Make this type a subtype of the structure type Supertype. The optional │ │ │ │ + Slot-Specs override inherited slot options. │ │ │ │ + Slot options: │ │ │ │ + :TYPE Type-Spec │ │ │ │ + Asserts that the value of this slot is always of the specified type. │ │ │ │ + :READ-ONLY {T | NIL} │ │ │ │ + If true, no setter function is defined for this slot. │ │ │ │ +SYS:SRC;PCL;ENV.LISP │ │ │ │ No such file │ │ │ │ must be either "at" or "within", but │ │ │ │ is specified │ │ │ │ No pathnames are specified. │ │ │ │ is illegal for sort name. │ │ │ │ ] contradictory assumption: │ │ │ │ ** done restting system. │ │ │ │ @@ -42288,37 +42293,36 @@ │ │ │ │ parsing parameter mapping of │ │ │ │ parsing behavioural operator mapping of │ │ │ │ parsing operator mapping of │ │ │ │ the target term : │ │ │ │ isn't proper in the context : │ │ │ │ please re-`start' with supplying new one! │ │ │ │ >*subsume-conjuncts: │ │ │ │ -] found contradiction: │ │ │ │ -libpath = │ │ │ │ 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. │ │ │ │ +] found contradiction: │ │ │ │ +libpath = │ │ │ │ LET ({(var [value]) | var}*) declaration* form* │ │ │ │ During evaluation of the FORMS, bind the VARS to the result of evaluating the │ │ │ │ VALUE forms. The variables are bound in parallel after all of the VALUES forms │ │ │ │ have been evaluated. │ │ │ │ +LVAR-SINGLE-VALUE-P │ │ │ │ +FUNCTIONAL-LETLIKE-P │ │ │ │ +LqI2a-ap │ │ │ │ COMMON-LISP │ │ │ │ -YIh$|\.0 │ │ │ │ -SYS:SRC;COMPILER;RISCV;CHAR.LISP │ │ │ │ +Return the integer code of CHAR. │ │ │ │ optimize away possible call to FDEFINITION at runtime │ │ │ │ -PATHNAME │ │ │ │ -COMMON-LISP@ │ │ │ │ +SYS:SRC;COMPILER;RISCV;CHAR.LISP │ │ │ │ (PDQE=`9 │ │ │ │ Print a description of OBJECT to STREAM-DESIGNATOR. │ │ │ │ $($0$8$! │ │ │ │ CONDITION │ │ │ │ COMMON-LISP` │ │ │ │ MORE-ARG │ │ │ │ -LVAR-SINGLE-VALUE-P │ │ │ │ -FUNCTIONAL-LETLIKE-P │ │ │ │ COMMON-LISP0 │ │ │ │ INTERVAL@ │ │ │ │ REF20!g4 │ │ │ │ $N{is 3F │ │ │ │ OPTIONAL-ARGS │ │ │ │ Return a floating-point number that has the same sign as │ │ │ │ FLOAT1 and, if FLOAT2 is given, has the same absolute value │ │ │ │ @@ -42339,23 +42343,24 @@ │ │ │ │ Finds the PC for the return from an assembly routine properly. │ │ │ │ For some architectures (such as PPC) this will not be the $LRA │ │ │ │ register. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP@(gp │ │ │ │ DEBUG-FUN0 │ │ │ │ +PATHNAME │ │ │ │ +COMMON-LISP@ │ │ │ │ SYS:SRC;CODE;FILESYS.LISP │ │ │ │ -REST-ARG │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/comlib/string.lisp │ │ │ │ +REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ -DEBUG-SOURCE- │ │ │ │ -SYS:SRC;CODE;STUBS.LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ +DEBUG-SOURCE- │ │ │ │ DEBUG-FUN8 │ │ │ │ BPT-LRA@ │ │ │ │ DEBUG-FUN0 │ │ │ │ FRAME80g4 │ │ │ │ DEBUG-VARH │ │ │ │ ESCAPED8 │ │ │ │ CONDITION │ │ │ │ @@ -42396,34 +42401,33 @@ │ │ │ │ DEBUG-FUN8 │ │ │ │ BREAKPOINT0 │ │ │ │ DEBUG-FUN0 │ │ │ │ DEBUG-VAR │ │ │ │ SB-EXT`&g< │ │ │ │ VARS(>g< │ │ │ │ CODE-LOCATIONS( │ │ │ │ -COMMON-LISP@ │ │ │ │ COMMON-LISP8 │ │ │ │ DEBUG-VAR │ │ │ │ FORM SB-KERNELH │ │ │ │ Evaluate FORM in the lexical context of FRAME's current code location, │ │ │ │ returning the results of the evaluation. │ │ │ │ BREAKPOINTH │ │ │ │ BREAKPOINTS( │ │ │ │ COMMON-LISP9,g4 │ │ │ │ BREAKPOINT0 │ │ │ │ DEBUG-VAR │ │ │ │ BASIC-CODE-LOCATION8 │ │ │ │ CODE-LOCATIONH │ │ │ │ +attempt to multiply define ~A ~S │ │ │ │ DEBUG-FUN │ │ │ │ LOCATION │ │ │ │ OBJ2@"g@ │ │ │ │ COMMON-LISP │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ |R (alien (* (array (signed 8) 10))) │ │ │ │ + (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ + (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ +Establish some local alien variables. Each BINDING is of the form: │ │ │ │ + VAR TYPE [ ALLOCATION ] [ INITIAL-VALUE | EXTERNAL-NAME ] │ │ │ │ + ALLOCATION should be one of: │ │ │ │ + :LOCAL (the default) │ │ │ │ + The alien is allocated on the stack, and has dynamic extent. │ │ │ │ + :EXTERN │ │ │ │ + No alien is allocated, but VAR is established as a local name for │ │ │ │ + the external alien given by EXTERNAL-NAME. │ │ │ │ +Return an Alien pointer to the data addressed by Expr, which must be a call │ │ │ │ + to SLOT or DEREF, or a reference to an Alien variable. │ │ │ │ +CONTEXT0 │ │ │ │ +COMMON-LISP@"g4 │ │ │ │ COMMON-LISP0 │ │ │ │ ]#_}eoEeZ │ │ │ │ COMMON-LISP8 │ │ │ │ ~?1(p$0X │ │ │ │ Returns true if the alien is associated with a lisp-side callback, │ │ │ │ and a secondary return value of true if the callback is still valid. │ │ │ │ Load a shared library / dynamic shared object file / similar foreign │ │ │ │ @@ -42582,17 +42635,14 @@ │ │ │ │ INDICESP │ │ │ │ REST-ARG │ │ │ │ Dereference an Alien pointer or array. If an array, the indices are used │ │ │ │ as the indices of the array element to access. If a pointer, one index can │ │ │ │ optionally be specified, giving the equivalent of C pointer arithmetic. │ │ │ │ COMMON-LISP($g │ │ │ │ Extract SLOT from the Alien STRUCT or UNION ALIEN. May be set with SETF. │ │ │ │ -Input type (~//) and output type (~//) are unrelated? │ │ │ │ -could not find any input routine for ~// │ │ │ │ -~@:_In ~A deprecation since ~@[~A ~]version ~A.~@[ ~//~] │ │ │ │ NEW-ERRNO0 │ │ │ │ Set the C library pseudo-variable named "errno", for obscure syscalls. │ │ │ │ VMTHREAD │ │ │ │ g_G\'\7T │ │ │ │ TIMEOUTP │ │ │ │ +\OZi;=mQ │ │ │ │ SESSION0 │ │ │ │ @@ -42697,64 +42747,14 @@ │ │ │ │ (return-from pop-data nil))) │ │ │ │ (pop *data*))) │ │ │ │ ;; Producer │ │ │ │ (defun push-data (data) │ │ │ │ (with-mutex (*lock*) │ │ │ │ (push data *data*) │ │ │ │ (condition-notify *queue*))) │ │ │ │ -Return T if THREAD is still alive. Note that the return value is │ │ │ │ -potentially stale even before the function returns, as the thread may exit at │ │ │ │ -any time. │ │ │ │ -Name of the thread. Can be assigned to using SETF. A thread name must be │ │ │ │ -a simple-string (not necessarily unique) or NIL. │ │ │ │ -Define NAME as an external alien variable of type TYPE. NAME should │ │ │ │ -be a list of a string holding the alien name and a symbol to use as │ │ │ │ -the Lisp name. If NAME is just a symbol or string, then the other name │ │ │ │ -is guessed from the one supplied. │ │ │ │ -ALIEN-TYPE │ │ │ │ -SB-ALIEN-INTERNALS │ │ │ │ -NAME(Ng@ │ │ │ │ -Access the alien variable named NAME, assuming it is of type TYPE. │ │ │ │ -This is SETFable. │ │ │ │ -Convert the system area pointer SAP to an ALIEN of the specified TYPE (not │ │ │ │ - evaluated.) TYPE must be pointer-like. │ │ │ │ -Return the size of the alien type TYPE. UNITS specifies the units to │ │ │ │ - use and can be either :BITS, :BYTES, or :WORDS. │ │ │ │ -Allocate an alien of type TYPE in foreign heap, and return an alien │ │ │ │ -pointer to it. The allocated memory is not initialized, and may │ │ │ │ -contain garbage. The memory is allocated using malloc(3), so it can be │ │ │ │ -passed to foreign functions which use free(3), or released using │ │ │ │ -FREE-ALIEN. │ │ │ │ -For alien stack allocation, see macro WITH-ALIEN. │ │ │ │ -The TYPE argument is not evaluated. If SIZE is supplied, how it is │ │ │ │ -interpreted depends on TYPE: │ │ │ │ - * When TYPE is a foreign array type, an array of that type is │ │ │ │ - allocated, and a pointer to it is returned. Note that you │ │ │ │ - must use DEREF to first access the array through the pointer. │ │ │ │ - If supplied, SIZE is used as the first dimension for the array. │ │ │ │ - * When TYPE is any other foreign type, then an object for that │ │ │ │ - type is allocated, and a pointer to it is returned. So │ │ │ │ - (make-alien int) returns a (* int). │ │ │ │ - If SIZE is specified, then a block of that many objects is │ │ │ │ - allocated, with the result pointing to the first one. │ │ │ │ -Examples: │ │ │ │ - (defvar *foo* (make-alien (array char 10))) │ │ │ │ - (type-of *foo*) ; => (alien (* (array (signed 8) 10))) │ │ │ │ - (setf (deref (deref *foo*) 0) 10) ; => 10 │ │ │ │ - (make-alien char 12) ; => (alien (* (signed 8))) │ │ │ │ -Establish some local alien variables. Each BINDING is of the form: │ │ │ │ - VAR TYPE [ ALLOCATION ] [ INITIAL-VALUE | EXTERNAL-NAME ] │ │ │ │ - ALLOCATION should be one of: │ │ │ │ - :LOCAL (the default) │ │ │ │ - The alien is allocated on the stack, and has dynamic extent. │ │ │ │ - :EXTERN │ │ │ │ - No alien is allocated, but VAR is established as a local name for │ │ │ │ - the external alien given by EXTERNAL-NAME. │ │ │ │ -Return an Alien pointer to the data addressed by Expr, which must be a call │ │ │ │ - to SLOT or DEREF, or a reference to an Alien variable. │ │ │ │ Insert a barrier in the code stream, preventing some sort of │ │ │ │ reordering. │ │ │ │ KIND should be one of: │ │ │ │ :COMPILER │ │ │ │ Prevent the compiler from reordering memory access across the │ │ │ │ barrier. │ │ │ │ :MEMORY │ │ │ │ @@ -42782,14 +42782,19 @@ │ │ │ │ If current thread is the main thread of the process (see │ │ │ │ MAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as │ │ │ │ terminating the main thread would terminate the entire process. If │ │ │ │ ALLOW-EXIT is true, returning from the main thread is equivalent to │ │ │ │ calling SB-EXT:EXIT with :CODE 0 and :ABORT NIL. │ │ │ │ See also: ABORT-THREAD and SB-EXT:EXIT. │ │ │ │ COMMON-LISP( g< │ │ │ │ +Return T if THREAD is still alive. Note that the return value is │ │ │ │ +potentially stale even before the function returns, as the thread may exit at │ │ │ │ +any time. │ │ │ │ +Name of the thread. Can be assigned to using SETF. A thread name must be │ │ │ │ +a simple-string (not necessarily unique) or NIL. │ │ │ │ SEMAPHORE-NOTIFICATION0 │ │ │ │ Returns T if a WAIT-ON-SEMAPHORE or TRY-SEMAPHORE using │ │ │ │ SEMAPHORE-NOTIFICATION has succeeded since the notification object was created │ │ │ │ or cleared. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ Returns the current count of the semaphore INSTANCE. │ │ │ │ jmi'@nP, │ │ │ │ @@ -42890,19 +42895,19 @@ │ │ │ │ COMMON-LISP │ │ │ │ NAMESPACE │ │ │ │ COMMON-LISP │ │ │ │ FD-STREAM │ │ │ │ #:: syntax. │ │ │ │ COMMON-LISP │ │ │ │ I^@(Y~'6M │ │ │ │ -POSSIBLY-RATIONAL │ │ │ │ -DESCRIPTOR-IDX │ │ │ │ DISPATCH-TABLE │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ CHANGED-P │ │ │ │ Remove any occurrences of escape characters from the string │ │ │ │ because we've already checked for whatever they may have │ │ │ │ protected. │ │ │ │ @@ -43096,16 +43101,16 @@ │ │ │ │ fmt$LKZRPQVMP0RO │ │ │ │ fmt$YFX2UA6FQMD0 │ │ │ │ COMMON-LISP@ │ │ │ │ DIRECTIONH │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISPH │ │ │ │ SB-CN2gh │ │ │ │ -#i'[(R("hEB[ │ │ │ │ MASK`;g< │ │ │ │ +#i'[(R("hEB[ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP8 │ │ │ │ HI3"i~ZO │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ zm (PF`p=@U │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ MdMCxDs.e4g │ │ │ │ @@ -43195,27 +43200,14 @@ │ │ │ │ fmt$1KL7BBTPCFXY │ │ │ │ 5DEGR5%Y$} │ │ │ │ fmt$QXSSWPWLQZAE │ │ │ │ fmt$J8DY08OKZTYD │ │ │ │ fmt$NSUYYLCVJJIR │ │ │ │ $H$0$8$( │ │ │ │ REPLACEMENT-SPEC │ │ │ │ -COMMON-LISP0 │ │ │ │ -COMMON-LISP@ │ │ │ │ -COMPILER-P` │ │ │ │ -CLOSURE SB-KERNEL@ │ │ │ │ -NVALUESM5'X& │ │ │ │ - INDICATORP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP@ │ │ │ │ -SB-CN*gp │ │ │ │ -EXTERNAL-FORMATH │ │ │ │ -Q4Hze62G2` │ │ │ │ -COMMON-LISP) │ │ │ │ -ENTRY-POINTS0 │ │ │ │ ~&Evaluation took: │ │ │ │ ~@< ~@;~// of real time │ │ │ │ ~// of total run time (~@// user, ~@// system) │ │ │ │ ~[[ Real times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ ~;~2*~]~[[ Run times consist of ~// GC time, and ~// non-GC time. ] │ │ │ │ ~;~2*~]~,2F% CPU │ │ │ │ ~@[~:D form~:P interpreted │ │ │ │ @@ -43224,15 +43216,27 @@ │ │ │ │ ~]~@[~:D page fault~:P │ │ │ │ ~]~:D bytes consed │ │ │ │ before it was aborted by a non-local transfer of control. │ │ │ │ ~@:_Derived type: ~// │ │ │ │ ~@:_(~A ~{~S ~}~//) │ │ │ │ ~@:_~:(~A~) type: ~// │ │ │ │ ~#[~;Use ~// instead.~;Use ~// or ~// instead.~:;Use~@{~#[~; or~] ~//~^,~} instead.~] │ │ │ │ -~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ +COMMON-LISP0 │ │ │ │ +COMMON-LISP@ │ │ │ │ +COMPILER-P` │ │ │ │ +CLOSURE SB-KERNEL@ │ │ │ │ +NVALUESM5'X& │ │ │ │ + INDICATORP │ │ │ │ +COMMON-LISP │ │ │ │ +COMMON-LISP@ │ │ │ │ +SB-CN*gp │ │ │ │ +EXTERNAL-FORMATH │ │ │ │ +Q4Hze62G2` │ │ │ │ +COMMON-LISP) │ │ │ │ +ENTRY-POINTS0 │ │ │ │ USPNLIGBA@<;89%db`_]Y,VTRNJGDBA@> │ │ │ │ COMMON-LISPH │ │ │ │ SB-CN6gh │ │ │ │ %0$#4&%('d │ │ │ │ COMMON-LISP8 │ │ │ │ Returns number of complete years since March 1st 2000, and remainder in seconds │ │ │ │ CODE-OBJ0 │ │ │ │ @@ -43262,17 +43266,17 @@ │ │ │ │ CLOSURE SB-KERNEL0 │ │ │ │ IFPOsKlv │ │ │ │ SB-INT) g, │ │ │ │ COMMON-LISPH │ │ │ │ SB-CN*gp │ │ │ │ o7k[vFo%4g │ │ │ │ KEY-VALUEH │ │ │ │ +ELEMENTp │ │ │ │ HJ$dxAF; │ │ │ │ COMMON-LISPP │ │ │ │ -ELEMENTp │ │ │ │ SUB-CHARP │ │ │ │ NEW-VALUE │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP8 │ │ │ │ SB-INT) g, │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP0 │ │ │ │ @@ -43326,21 +43330,21 @@ │ │ │ │ fmt$ILYJ2K7WCBQU │ │ │ │ fmt$U82G6REVR9EL │ │ │ │ EXTERNAL-FORMAT0 │ │ │ │ (PF`p=@U │ │ │ │ REVERSED-ELEMENTS │ │ │ │ SLOT-NAMEP │ │ │ │ REST-ARG │ │ │ │ -Assignment to virtual DISPATCH-TABLES slot not allowed │ │ │ │ COMMON-LISPP │ │ │ │ SECONDSP │ │ │ │ OPTIONAL-ARGS │ │ │ │ EOF-ERROR-P` │ │ │ │ EOF-VALUEP │ │ │ │ COMMON-LISPH │ │ │ │ +Assignment to virtual DISPATCH-TABLES slot not allowed │ │ │ │ NAME@(g< │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ UlPGcZIC │ │ │ │ PATHNAME │ │ │ │ COMMON-LISP0 │ │ │ │ fmt$YZY0XWHFWKIH │ │ │ │ fmt$65M73OLIC19N │ │ │ │ @@ -43397,14 +43401,15 @@ │ │ │ │ SUB-CHAR │ │ │ │ (PF`p=@U │ │ │ │ COMMON-LISPH │ │ │ │ COMMON-LISP │ │ │ │ PRIORITY-QUEUE8 │ │ │ │ Return the item in PRIORITY-QUEUE with the largest key. │ │ │ │ EF-ENTRY │ │ │ │ +SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ fmt$6F3A8JT3YFFL │ │ │ │ fmt$8HXQ8ZGG5XU5 │ │ │ │ fmt$J2SAMAZ49FH5 │ │ │ │ fmt$T9PTSA9SKC4 │ │ │ │ fmt$N8RCNYS1WIGE │ │ │ │ fmt$68MON69VIGHG │ │ │ │ fmt$DP6UOSUZOG0O │ │ │ │ @@ -43414,14 +43419,20 @@ │ │ │ │ fmt$AL990XGVAFKQ │ │ │ │ NAMEX>g8 │ │ │ │ 2;*jF~^D │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP8 │ │ │ │ Test for the ANSI concept "stream associated with a file". │ │ │ │ Return NIL or the underlying FILE-STREAM. │ │ │ │ +~@:_Direct slots:~:{~@:_ ~S~@[~@:_ Type: ~//~]~@[~@:_ Allocation: ~S~]~@[~@:_ Initargs: ~{~S~^, ~}~]~@[~@:_ Initform: ~S~]~@[~@:_ Readers: ~{~S~^, ~}~]~@[~@:_ Writers: ~{~S~^, ~}~]~@[~@:_ Documentation:~@:_ ~@<~@;~A~:>~]~} │ │ │ │ +~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ +~:[This~;~:*~A~] is not a ~< │ │ │ │ +~9T~:;~//:~> │ │ │ │ +~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ +~9T~:;not a ~//.~> │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP@ │ │ │ │ fmt$QSK348MS4FOE │ │ │ │ fmt$6YJHLKOYXEI3 │ │ │ │ SXSTATE@ │ │ │ │ \z,%"ILB │ │ │ │ COMMON-LISP( │ │ │ │ @@ -43429,29 +43440,23 @@ │ │ │ │ IMPORT-LIST │ │ │ │ i5Y 1398L │ │ │ │ fmt$AS6HUZU75IU0 │ │ │ │ Fo%(PFTH │ │ │ │ fmt$RA86W1UCPB9M │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ SB-INT) g, │ │ │ │ -fmt$6QTSHAZOSR3D │ │ │ │ -fmt$OE738YZH05S6 │ │ │ │ -fmt$L0FP0Q6417IX │ │ │ │ -fmt$FVYSFOM3WPSF │ │ │ │ ARRAY-FORM │ │ │ │ OTHER-FORM │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP`?g< │ │ │ │ -~@:_Slots:~:{~@:_ ~S~@:_ Type: ~// ~@[~A~]~@:_ Initform: ~S~} │ │ │ │ -~:[This~;~:*~A~] is not a ~< │ │ │ │ -~9T~:;~//:~> │ │ │ │ -~:[Result~;~:*~A~] is a ~//, ~< │ │ │ │ -~9T~:;not a ~//.~> │ │ │ │ -SYS:SRC;COMPILER;COVERAGE.LISP │ │ │ │ FIRST-CLAUSE`;g< │ │ │ │ +fmt$6QTSHAZOSR3D │ │ │ │ +fmt$OE738YZH05S6 │ │ │ │ +fmt$L0FP0Q6417IX │ │ │ │ +fmt$FVYSFOM3WPSF │ │ │ │ COMMON-LISP8 │ │ │ │ DEFINITION0 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ P2AMO7b}*r+fu │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMPONENT │ │ │ │ CONTEXT8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -PREV-KIND │ │ │ │ -SAW-LAST │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ SUCCESSORSP │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP( │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP0 │ │ │ │ CLEANUP@ │ │ │ │ ANNOTATIONP │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ REST-ARG │ │ │ │ 2>**yP(P │ │ │ │ +DEFINITION-SOURCE-LOCATION- │ │ │ │ +PREV-KIND │ │ │ │ +SAW-LAST │ │ │ │ COMMON-LISP0 │ │ │ │ COMPONENT@&g4 │ │ │ │ SB-ALIENH │ │ │ │ LVAR(1gd │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -DEFINITION-SOURCE-LOCATION- │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ SB-ALIEN │ │ │ │ INTERVAL │ │ │ │ $($0$8$@#g0 │ │ │ │ EXIT-BLOCK( │ │ │ │ MORE-ARG │ │ │ │ @@ -43718,15 +43723,14 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ BIT-ARRAY-1 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -TARGET-ENV │ │ │ │ CONTEXTP │ │ │ │ COMMON-LISP` │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ SB-INT(1g< │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ @@ -43802,16 +43806,16 @@ │ │ │ │ REST-ARG │ │ │ │ >:61.,+)("! │ │ │ │ FIXUP-NOTESP │ │ │ │ RESULT8&g@ │ │ │ │ COMMON-LISP@ │ │ │ │ LEXENV SB-KERNEL0 │ │ │ │ NODE@"g\ │ │ │ │ -~@ │ │ │ │ REST-ARG │ │ │ │ +~@ │ │ │ │ BRPIM G| │ │ │ │ REST-ARG │ │ │ │ %POLICY0 │ │ │ │ DISABLED-PACKAGE-LOCKS SB-KERNEL@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP@ │ │ │ │ HASH-TABLE │ │ │ │ @@ -43820,14 +43824,15 @@ │ │ │ │ ,$I$~4zsg-K │ │ │ │ <*pYc|WUE'Y9 │ │ │ │ DEST-FUN-NAMES │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ +TARGET-ENV │ │ │ │ |tB]{+a/ │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ REST-ARG │ │ │ │ NEW-BLOCK8 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -43858,16 +43863,14 @@ │ │ │ │ Automagically generated boolean attribute creation function. │ │ │ │ See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ ATTRIBUTES │ │ │ │ Automagically generated boolean attribute setter. See │ │ │ │ !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ Automagically generated boolean attribute test function. │ │ │ │ See !DEF-BOOLEAN-ATTRIBUTE. │ │ │ │ -degraded │ │ │ │ -without-hashing │ │ │ │ INDICES0 │ │ │ │ NAMESTRING │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP@ │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP` │ │ │ │ @@ -43964,14 +43967,29 @@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP8 │ │ │ │ EXPANSION@ │ │ │ │ COMMON-LISP0 │ │ │ │ REST-ARG │ │ │ │ RES-TYPEP │ │ │ │ COMMON-LISP │ │ │ │ +Assignment to argument: ~S │ │ │ │ + prevents use of assertion from function type ~A: │ │ │ │ +The result type from ~A: │ │ │ │ +conflicts with the definition's result type: │ │ │ │ +Not a function type: ~// │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +violating package lock on ~// │ │ │ │ +It allows an unknown number of values, consider using │ │ │ │ +Type assertion too complex to check efficiently: │ │ │ │ +It allows a variable number of values, consider using │ │ │ │ +~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ +~@ │ │ │ │ +using the lexical binding of the symbol ~//, not the │ │ │ │ +dynamic binding │ │ │ │ $H$`$P$8.gH │ │ │ │ BIT-ARRAY-1X │ │ │ │ LIVE-LIST` │ │ │ │ Bk7C"/(0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ COMMON-LISP │ │ │ │ @@ -43981,34 +43999,19 @@ │ │ │ │ REST-ARG │ │ │ │ OPTIONAL-ARGS │ │ │ │ _QJPy'MF1 │ │ │ │ +?NWKh@UwV │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -Assignment to argument: ~S │ │ │ │ - prevents use of assertion from function type ~A: │ │ │ │ -The result type from ~A: │ │ │ │ -conflicts with the definition's result type: │ │ │ │ -Not a function type: ~// │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ -violating package lock on ~// │ │ │ │ -It allows an unknown number of values, consider using │ │ │ │ -Type assertion too complex to check efficiently: │ │ │ │ -It allows a variable number of values, consider using │ │ │ │ -~@<~// names a ~A, and cannot be used in ~A.~:@> │ │ │ │ -~@ │ │ │ │ -using the lexical binding of the symbol ~//, not the │ │ │ │ -dynamic binding │ │ │ │ -~@ │ │ │ │ -~@ │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ +degraded │ │ │ │ +without-hashing │ │ │ │ REST-ARG │ │ │ │ SB-ALIEN │ │ │ │ PRIMITIVE-TYPE8 │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ CURRENT` │ │ │ │ e;(dqpyu │ │ │ │ @@ -44053,26 +44056,26 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ FASL-OUTPUTH │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ Zc&U[$(@ │ │ │ │ $($0$8%g0 │ │ │ │ VAR-LOCS │ │ │ │ +N-SIMPLE-FUNS │ │ │ │ +LVAR-KIND │ │ │ │ DERIVED-TYPE( │ │ │ │ DERIVED-VALUES-TYPE( │ │ │ │ LEAF-TYPEH │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ -N-SIMPLE-FUNS │ │ │ │ -LVAR-KIND │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ NODE@/g\ │ │ │ │ >q `%/:E │ │ │ │ @@ -44139,17 +44142,17 @@ │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ $`$0$8$( │ │ │ │ COMMON-LISP │ │ │ │ REST-ARG │ │ │ │ Z=96542/,+)' │ │ │ │ 033cU'3mZ │ │ │ │ +$($0$8$@#g0 │ │ │ │ COMMON-LISP(#g< │ │ │ │ REST-ARG │ │ │ │ -$($0$8$@#g0 │ │ │ │ $($0$`$! │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ FASL-OUTPUT │ │ │ │ REST-ARG │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ @@ -44204,27 +44207,31 @@ │ │ │ │ IR2-BLOCK │ │ │ │ REST-ARG │ │ │ │ 6gfiBb=v; │ │ │ │ NL]YNPa$ │ │ │ │ 'z+ 6 fuM │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ -SUCC0&gx │ │ │ │ FORM SB-KERNELP │ │ │ │ -REST-ARG │ │ │ │ +SUCC0&gx │ │ │ │ SYS:SRC;COMPILER;LTV.LISP │ │ │ │ +REST-ARG │ │ │ │ CONDITION │ │ │ │ COMMON-LISP │ │ │ │ CONSTRAINT( │ │ │ │ ATTRIBUTES@ │ │ │ │ QUALITY-NAME │ │ │ │ REST-ARG │ │ │ │ CTYPE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP │ │ │ │ +~@ │ │ │ │ +~@ │ │ │ │ +undefined ~(~A~): ~// │ │ │ │ +Bad bounding indices ~s, ~s for ~// │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ $($0$8$@$H$P$` │ │ │ │ COMMON-LISP │ │ │ │ FALLBACK │ │ │ │ INDEX-TYPE │ │ │ │ REST-ARG │ │ │ │ @@ -44234,16 +44241,14 @@ │ │ │ │ COMMON-LISP0,g< │ │ │ │ REST-ARG │ │ │ │ INTERVAL │ │ │ │ CONTEXTP │ │ │ │ DEFINITIONS │ │ │ │ REST-ARG │ │ │ │ NS(9G0$L │ │ │ │ -undefined ~(~A~): ~// │ │ │ │ -Bad bounding indices ~s, ~s for ~// │ │ │ │ =]{>jVHri │ │ │ │ FASL-OUTPUT │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPH │ │ │ │ DIVISOR-TYPE │ │ │ │ NUMBER-TYPE │ │ │ │ REST-ARG │ │ │ │ @@ -44323,16 +44328,14 @@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP( │ │ │ │ COMMON-LISP0%g< │ │ │ │ REST-ARG │ │ │ │ ALTERNATIVE-CONSTRAINTS │ │ │ │ COMMON-LISP │ │ │ │ FINAL-PASS-P │ │ │ │ -COMPONENT-LAMBDA │ │ │ │ -COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ NODE0*g4 │ │ │ │ CONSTANT SB-KERNEL │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISPH │ │ │ │ EXPANSIONP │ │ │ │ COMMON-LISP │ │ │ │ $H$P$8$( │ │ │ │ @@ -44364,14 +44367,18 @@ │ │ │ │ GREATER` │ │ │ │ OR-EQUAL8 │ │ │ │ EPHEMERAL8 │ │ │ │ [yYE~Xf]4 │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ REST-ARG │ │ │ │ +COMPONENT-LAMBDA │ │ │ │ +COMBINATION-FUN is not a ref to a nameful leaf │ │ │ │ +TAILP-LVAR │ │ │ │ +ORIGINAL-START │ │ │ │ REST-ARG │ │ │ │ CONTEXT8 │ │ │ │ 1L$(nH+X │ │ │ │ COMMON-LISP8 │ │ │ │ COMMON-LISP@ │ │ │ │ yHB{&o41 │ │ │ │ UNIVERSE │ │ │ │ @@ -44380,16 +44387,14 @@ │ │ │ │ REST-ARG │ │ │ │ COMMON-LISP │ │ │ │ LOAD-TN8 │ │ │ │ (8&I& │ │ │ │ OPTIONAL-ARGS │ │ │ │ SOURCE-LOC0 │ │ │ │ DEPRECATED-NAMES0 │ │ │ │ SITUATIONS │ │ │ │ SOURCE-LOC@ │ │ │ │ $8UT*L{u │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ SC-NUMBER5 │ │ │ │ COMMON-LISP │ │ │ │ POSITION │ │ │ │ COMMON-LISP8 │ │ │ │ -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. │ │ │ │ SOURCE-LOCH │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ START-LABEL@ │ │ │ │ TRAMPOLINE-LABEL0 │ │ │ │ COMMON-LISP8 │ │ │ │ Calls the designated FUNCTION with each frame on the call stack. │ │ │ │ @@ -44580,45 +44581,47 @@ │ │ │ │ SEQUENCE │ │ │ │ COMMON-LISP@ │ │ │ │ Return a sequence of the same elements in reverse order; the argument │ │ │ │ is destroyed. │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP@ │ │ │ │ NEW-VALUEH │ │ │ │ +EARLY-METHOD8-g< │ │ │ │ +SYS:SRC;CODE;STUBS.LISP │ │ │ │ Oversized code component? │ │ │ │ Shadowed asm labels ~S should be renamed not to conflict │ │ │ │ Repeated labels in ASSEMBLE body │ │ │ │ -EARLY-METHOD8-g< │ │ │ │ CLASSES-LIST │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISPP │ │ │ │ NEW-CLASS` │ │ │ │ $($0$8$@ │ │ │ │ DFUN-INFO │ │ │ │ COMMON-LISP │ │ │ │ EARLY-METHOD@&g< │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ |V~%Ry*&O │ │ │ │ -The first argument is a byte specifier. The second is any place form │ │ │ │ -acceptable to SETF. Replace the specified byte of the number in this │ │ │ │ -place with bits from the low-order end of the new value. │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +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. │ │ │ │ ~:@(ARG-FOR-~S-~) │ │ │ │ The byte spec ~S either overlaps another byte spec, or extends past the end. │ │ │ │ There are holes. │ │ │ │ ~W isn't an even multiple of ~W. │ │ │ │ Undefined instruction: ~s in │ │ │ │ Undefined instruction: ~s in~% ~s │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL8 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ @@ -44631,62 +44634,65 @@ │ │ │ │ COMMON-LISP │ │ │ │ $@$`$H$P$($0$8 │ │ │ │ NEW-CLASS │ │ │ │ Takes and expands a type specifier once like MACROEXPAND-1. │ │ │ │ Returns two values: the expansion, and a boolean that is true when │ │ │ │ expansion happened. │ │ │ │ COMMON-LISPP │ │ │ │ +setting the macro-function of ~S │ │ │ │ +~S names a special form. │ │ │ │ +Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ COMMON-LISP8 │ │ │ │ Returns T when PACKAGE is locked, NIL otherwise. Signals an error │ │ │ │ if PACKAGE doesn't designate a valid package. │ │ │ │ Return a new function that returns T whenever FUNCTION returns NIL and │ │ │ │ NIL whenever FUNCTION returns non-NIL. │ │ │ │ -COMMON-LISPH │ │ │ │ - NEW-VALUE │ │ │ │ CHARACTER │ │ │ │ COMMON-LISP │ │ │ │ Return the name (a STRING) for a CHARACTER object. │ │ │ │ +COMMON-LISPH │ │ │ │ + NEW-VALUE │ │ │ │ CHAR-BAG` │ │ │ │ COMMON-LISPP │ │ │ │ +P*[r=^cb │ │ │ │ +INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -P*[r=^cb │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +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. │ │ │ │ fold division by 1 │ │ │ │ -setting the macro-function of ~S │ │ │ │ -~S names a special form. │ │ │ │ -Non-NIL environment argument in SETF of MACRO-FUNCTION ~S: ~S │ │ │ │ +SYS:SRC;CODE;WEAK.LISP │ │ │ │ convert integer division to multiplication │ │ │ │ convert division by 2^k to shift │ │ │ │ -SYS:SRC;CODE;WEAK.LISP │ │ │ │ ARGUMENTS │ │ │ │ GENERIC-FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ +UB~D-BASH-COPY │ │ │ │ RESULT8%' │ │ │ │ MORE-ARG │ │ │ │ Return the sum of its arguments. With no args, returns 0. │ │ │ │ -UB~D-BASH-COPY │ │ │ │ +INSTANCE0 │ │ │ │ When set (the default), evaluations in the debugger's command loop occur │ │ │ │ relative to the current frame's environment without the need of debugger │ │ │ │ forms that explicitly control this kind of evaluation. │ │ │ │ MEMBERS8 │ │ │ │ SB-INT`)g4 │ │ │ │ Set the name of a compiled function object. Return the function. │ │ │ │ +INSTANCE SB-KERNEL@ gD │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ -INSTANCE SB-KERNEL@ gD │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ @@ -44716,41 +44722,35 @@ │ │ │ │ VALUE SB-KERNEL( │ │ │ │ INSTANCE0 │ │ │ │ FORM SB-KERNEL@ │ │ │ │ SIMPLE-FUN SB-KERNEL │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ +COMMON-LISP │ │ │ │ +VALUE-TN │ │ │ │ +TRUSTEDP │ │ │ │ +INSTANCE0 │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL( │ │ │ │ +COMMON-LISP@ │ │ │ │ SYS:SRC;PCL;DEFCLASS.LISP │ │ │ │ SYS:SRC;CODE;NUMBER-DISPATCH.LISP │ │ │ │ SYS:SRC;CODE;LATE-CONDITION.LISP │ │ │ │ OPTIMIZE-DECL │ │ │ │ BEFORE-USES │ │ │ │ -SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ -SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ -#.$V$_*P7 │ │ │ │ automatically-generated makunbound method │ │ │ │ Bogus slot-cell in (CAS SLOT-VALUE): ~S │ │ │ │ Cannot compare-and-swap slot ~S on: ~S │ │ │ │ -The object file ~A is~@ │ │ │ │ - older than the presumed source:~% ~A. │ │ │ │ -load object file │ │ │ │ -load source file │ │ │ │ -attempt to load an empty FASL file: │ │ │ │ -COMMON-LISP │ │ │ │ -VALUE-TN │ │ │ │ -TRUSTEDP │ │ │ │ -INSTANCE0 │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL( │ │ │ │ -COMMON-LISP@ │ │ │ │ +SYS:SRC;CODE;STRING-HASH.LISP │ │ │ │ +SYS:SRC;CODE;MIPSSTROPS.LISP │ │ │ │ +#.$V$_*P7 │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE SB-KERNEL0 │ │ │ │ VALUE SB-KERNEL( │ │ │ │ -bytes_allocated │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ FUNCTION │ │ │ │ COMMON-LISP │ │ │ │ NEW-VALUE │ │ │ │ SB-C0-gX │ │ │ │ FUNCTION │ │ │ │ @@ -44762,40 +44762,46 @@ │ │ │ │ INSTANCE0 │ │ │ │ INSTANCE0 │ │ │ │ NEWVAL("g0 │ │ │ │ COMMON-LISP0 │ │ │ │ HASH-TABLE │ │ │ │ COMMON-LISP0 │ │ │ │ Return the number of entries in the given HASH-TABLE. │ │ │ │ -COMMON-LISPP │ │ │ │ -COMMON-LISPH │ │ │ │ COMMON-LISP8 │ │ │ │ Unlocks PACKAGE and returns T. Has no effect if PACKAGE was already │ │ │ │ unlocked. Signals an error if PACKAGE is not a valid package designator. │ │ │ │ -d ^"{";#X# │ │ │ │ -Form associated with the STEP-CONDITION. │ │ │ │ +COMMON-LISPP │ │ │ │ +COMMON-LISPH │ │ │ │ $H$($0$@ │ │ │ │ CATEGORY │ │ │ │ NEW-VALUE │ │ │ │ +bytes_allocated │ │ │ │ +d ^"{";#X# │ │ │ │ +Form associated with the STEP-CONDITION. │ │ │ │ POSITION │ │ │ │ COMMON-LISP1 │ │ │ │ Return a byte specifier which may be used by other byte functions │ │ │ │ (e.g. LDB). │ │ │ │ -Output a newline, the mostly READable printed representation of OBJECT, and │ │ │ │ - space to the specified STREAM. │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ Given a character count and an optional fill character, makes and returns a │ │ │ │ new string COUNT long filled with the fill character. │ │ │ │ Destructively modify SEQ by reading elements from STREAM. │ │ │ │ That part of SEQ bounded by START and END is destructively modified by │ │ │ │ copying successive elements into it from STREAM. If the end of file │ │ │ │ for STREAM is reached before copying all elements of the subsequence, │ │ │ │ then the extra elements near the end of sequence are not updated, and │ │ │ │ the index of the next element is returned. │ │ │ │ +Output a newline, the mostly READable printed representation of OBJECT, and │ │ │ │ + space to the specified STREAM. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ tmU?1H&I │ │ │ │ +The object file ~A is~@ │ │ │ │ + older than the presumed source:~% ~A. │ │ │ │ +load object file │ │ │ │ +load source file │ │ │ │ +attempt to load an empty FASL file: │ │ │ │ R/(~d7x, │ │ │ │ Make an internal symbol in PACKAGE with the same name as each of the │ │ │ │ specified SYMBOLS. If a symbol with the given name is already present in │ │ │ │ PACKAGE, then the existing symbol is placed in the shadowing symbols list if │ │ │ │ it is not already present. │ │ │ │ Return the symbol named STRING in PACKAGE. If such a symbol is found │ │ │ │ then the second value is :INTERNAL, :EXTERNAL or :INHERITED to indicate │ │ │ │ @@ -44868,22 +44874,20 @@ │ │ │ │ Converts FILENAME-DESIGNATOR into a FILENAME. │ │ │ │ OPTIONAL-ARGS │ │ │ │ Return the home directory of the user as a pathname. If the HOME │ │ │ │ environment variable has been specified, the directory it designates │ │ │ │ is returned; otherwise obtains the home directory from the operating │ │ │ │ system. HOST argument is ignored by SBCL. │ │ │ │ CLEANUP-FUN-6 │ │ │ │ +setting the compiler-macro-function of ~A │ │ │ │ +can't SETF COMPILER-MACRO-FUNCTION when ENV is non-NIL │ │ │ │ Given a SYSTEM, and a (Unix-style relative path) NAME of a file (or directory) of given TYPE, │ │ │ │ return the absolute pathname of a corresponding file under that system's source code pathname. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ -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) │ │ │ │ SB-ALIEN │ │ │ │ $P$($H$= │ │ │ │ ERROR-CODE` │ │ │ │ COMMON-LISPP │ │ │ │ REST-ARG │ │ │ │ Cause an error. ERROR-CODE is the error to cause. │ │ │ │ $($0$`$H │ │ │ │ @@ -44901,20 +44905,33 @@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ SB-ALIEN0 │ │ │ │ WIDETAG@ │ │ │ │ CONTEXTH │ │ │ │ SB-ALIEN(0gH │ │ │ │ TN-OFFSET │ │ │ │ COMMON-LISP0 │ │ │ │ + ~V@<~//~> ~V:D bytes, ~V:D object~:P. │ │ │ │ +: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.~@[ │ │ │ │ +~A is not allowed in ~A: ~// │ │ │ │ +~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ + ~// │ │ │ │ +repeated ~S in lambda list: ~// │ │ │ │ +~S and ~S are mutually exclusive: ~// │ │ │ │ +expected lambda list keyword at ~S in: ~// │ │ │ │ +illegal dotted lambda list: ~// │ │ │ │ +&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ +suspicious ~A ~S in lambda list: ~//. │ │ │ │ COMMON-LISPP │ │ │ │ v:TC4F/tB │ │ │ │ COMMON-LISPP │ │ │ │ SB-ALIEN( │ │ │ │ S6!}k12Q │ │ │ │ -FLAG-TN` g< │ │ │ │ Implements CL:MAP for extended sequences. │ │ │ │ RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:MAP but │ │ │ │ receives a prototype instance of an extended sequence class │ │ │ │ instead of a type specifier. By dispatching on RESULT-PROTOTYPE, │ │ │ │ methods on this generic function specify how extended sequence │ │ │ │ classes act when they are specified as the result type in a CL:MAP │ │ │ │ call. RESULT-PROTOTYPE may not be fully initialized and thus │ │ │ │ @@ -44935,34 +44952,20 @@ │ │ │ │ generic-function │ │ │ │ funcallable-instance │ │ │ │ interpreted function │ │ │ │ compiled closure │ │ │ │ The object is a │ │ │ │ Lambda-list │ │ │ │ Closed over values │ │ │ │ +FLAG-TN` g< │ │ │ │ N-STACK()g< │ │ │ │ Move the TN Reg-Or-Stack into Reg if it isn't already there. │ │ │ │ PRIM-TYPE-NAME` │ │ │ │ )IzDe ~V:D bytes, ~V:D object~:P. │ │ │ │ -: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.~@[ │ │ │ │ -~A is not allowed in ~A: ~// │ │ │ │ -~:[misplaced ~A in lambda list~;~A must appear first in a lambda list~]: │ │ │ │ - ~// │ │ │ │ -repeated ~S in lambda list: ~// │ │ │ │ -~S and ~S are mutually exclusive: ~// │ │ │ │ -expected lambda list keyword at ~S in: ~// │ │ │ │ -illegal dotted lambda list: ~// │ │ │ │ -&OPTIONAL and &KEY found in the same lambda list: ~// │ │ │ │ -suspicious ~A ~S in lambda list: ~//. │ │ │ │ -expecting variable after ~A in: ~// │ │ │ │ $($0$8$@$H │ │ │ │ $($H$0$8 │ │ │ │ COMMON-LISP │ │ │ │ WIDETAG@ │ │ │ │ ARX322'w │ │ │ │ COMMON-LISPP │ │ │ │ CONTENT-LENGTHP │ │ │ │ @@ -44985,37 +44988,37 @@ │ │ │ │ SB-ALIEN │ │ │ │ SB-ALIEN@ │ │ │ │ CONSTANTS( │ │ │ │ COMMON-LISP │ │ │ │ START0#g< │ │ │ │ SB-ALIEN │ │ │ │ COMMON-LISP │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ ARRAY-VAR` │ │ │ │ COMMON-LISP │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ NODE-HASHH │ │ │ │ SO-DATA8 │ │ │ │ COMMON-LISP │ │ │ │ PREDpKg< │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP@ │ │ │ │ COMMON-LISP │ │ │ │ +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). │ │ │ │ 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. │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP@ │ │ │ │ -COMMON-LISP │ │ │ │ W2&NSTV │ │ │ │ NODE-DATA0 │ │ │ │ NODE-KEY@ │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISPH │ │ │ │ @@ -45130,16 +45133,14 @@ │ │ │ │ Case is ignored. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the 1st object in the cadr of a list. │ │ │ │ PACKAGE-DESIGNATOR SB-KERNEL8 │ │ │ │ COMMON-LISP@ │ │ │ │ Decrease the fill pointer by 1 and return the element pointed to by the │ │ │ │ new fill pointer. │ │ │ │ -COMMON-LISPH │ │ │ │ -Return the arc sine of NUMBER. │ │ │ │ COMMON-LISP8 │ │ │ │ iL#76wl< │ │ │ │ The first argument is some location holding a number. This number is │ │ │ │ decremented by the second argument, DELTA, which defaults to 1. │ │ │ │ The first argument is some location holding a number. This number is │ │ │ │ incremented by the second argument, DELTA, which defaults to 1. │ │ │ │ NEW-VAR(=g@ │ │ │ │ @@ -45245,39 +45246,22 @@ │ │ │ │ which are evaluated after the function call, (SB-DEBUG:ARG N) returns │ │ │ │ the N-th value returned by the function. │ │ │ │ .3iwT80mO │ │ │ │ Within the lexical scope of the body forms, MNAME is defined via macrolet │ │ │ │ such that successive invocations of (MNAME) will return the symbols, one by │ │ │ │ one, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be any │ │ │ │ of :INHERITED :EXTERNAL :INTERNAL. │ │ │ │ -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. │ │ │ │ +COMMON-LISPH │ │ │ │ +Return the arc sine of NUMBER. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the 1st object in the cddr of a list. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the cdr of the cadar of a list. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the car of the caddr of a list. │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ -Transfer control to the named TAG in the lexically enclosing TAGBODY. This is │ │ │ │ -constrained to be used only within the dynamic extent of the TAGBODY. │ │ │ │ -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. │ │ │ │ COMMON-LISP` │ │ │ │ Return a new list which is EQUAL to LIST. LIST may be improper. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the cdr of the cdar of a list. │ │ │ │ HOST SB-KERNEL8 │ │ │ │ Return the (logical) host object argument's list of translations. │ │ │ │ Return a string with the long form of the site name, or NIL if not known. │ │ │ │ @@ -45291,14 +45275,30 @@ │ │ │ │ element. If COLON? is NIL (defaults to T), then no parens are printed │ │ │ │ around the output. ATSIGN? is ignored (but allowed so that PPRINT-LINEAR │ │ │ │ can be used with the ~/.../ format directive. │ │ │ │ Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss │ │ │ │ of precision or overflow. │ │ │ │ Given an argument acceptable to STRING, NAME-CHAR returns a character whose │ │ │ │ name is that string, if one exists. Otherwise, NIL is returned. │ │ │ │ +MACROLET ({(name lambda-list form*)}*) body-form* │ │ │ │ +Evaluate the BODY-FORMS in an environment with the specified local macros │ │ │ │ +defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style │ │ │ │ +destructuring lambda list, and the FORMS evaluate to the expansion. │ │ │ │ +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. │ │ │ │ +Transfer control to the named TAG in the lexically enclosing TAGBODY. This is │ │ │ │ +constrained to be used only within the dynamic extent of the TAGBODY. │ │ │ │ +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 new list of elements appearing exactly once in LIST1 and LIST2. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the 4th object in a list or NIL if there is no 4th object. │ │ │ │ Add ITEM to LIST unless it is already a member │ │ │ │ Return the first cons in ALIST whose CAR does not satisfy PREDICATE. │ │ │ │ If KEY is supplied, apply it to the CAR of each cons before testing. │ │ │ │ COMMON-LISP@ │ │ │ │ @@ -45463,16 +45463,17 @@ │ │ │ │ :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, │ │ │ │ :OVERWRITE, :APPEND, :SUPERSEDE or NIL │ │ │ │ :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL │ │ │ │ See the manual for details. │ │ │ │ MORE-ARG │ │ │ │ Return the least common multiple of one or more integers. LCM of no │ │ │ │ arguments is defined to be 1. │ │ │ │ -COMMON-LISP8 │ │ │ │ -Return the 1st object in the caar of a list. │ │ │ │ +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. │ │ │ │ Define a global constant, saying that the value is constant and may be │ │ │ │ compiled into code. If the variable already has a value, and this is not │ │ │ │ EQL to the new value, the code is not portable (undefined behavior). The │ │ │ │ third argument is an optional documentation string for the variable. │ │ │ │ 3NFS!jNL │ │ │ │ Takes any number of SETF-style place expressions. Evaluates all of the │ │ │ │ expressions in turn, then assigns to each place the value of the form to │ │ │ │ @@ -45527,20 +45528,14 @@ │ │ │ │ included in the error report if the assertion fails. │ │ │ │ DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}* │ │ │ │ Executes the FORMs once for each symbol in every package with VAR bound │ │ │ │ to the current symbol. │ │ │ │ TYPECASE Keyform {(Type Form*)}* │ │ │ │ Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ is true. │ │ │ │ -CATCH tag form* │ │ │ │ -Evaluate TAG and instantiate it as a catcher while the body forms are │ │ │ │ -evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic │ │ │ │ -scope of the body, then control will be transferred to the end of the body and │ │ │ │ -the thrown values will be returned. │ │ │ │ -defining ~A as a method combination │ │ │ │ DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* │ │ │ │ Iteration construct. Each Var is initialized sequentially (like LET*) to the │ │ │ │ value of the specified Init form. On subsequent iterations, the Vars are │ │ │ │ sequentially assigned the value of the Step form (if any). The Test is │ │ │ │ evaluated before each evaluation of the body Forms. When the Test is true, │ │ │ │ the Exit-Forms are evaluated as a PROGN, with the result being the value │ │ │ │ of the DO. A block named NIL is established around the entire expansion, │ │ │ │ @@ -45549,14 +45544,19 @@ │ │ │ │ Iteration construct. Each Var is initialized in parallel to the value of the │ │ │ │ specified Init form. On subsequent iterations, the Vars are assigned the │ │ │ │ value of the Step form (if any) in parallel. The Test is evaluated before │ │ │ │ each evaluation of the body Forms. When the Test is true, the Exit-Forms │ │ │ │ are evaluated as a PROGN, with the result being the value of the DO. A block │ │ │ │ named NIL is established around the entire expansion, allowing RETURN to be │ │ │ │ used as an alternate exit mechanism. │ │ │ │ +CATCH tag form* │ │ │ │ +Evaluate TAG and instantiate it as a catcher while the body forms are │ │ │ │ +evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic │ │ │ │ +scope of the body, then control will be transferred to the end of the body and │ │ │ │ +the thrown values will be returned. │ │ │ │ (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. │ │ │ │ SPECSHKg< │ │ │ │ @@ -45589,53 +45589,40 @@ │ │ │ │ *READTABLE* the standard readtable │ │ │ │ SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL │ │ │ │ SB-EXT:*PRINT-VECTOR-LENGTH* NIL │ │ │ │ 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. │ │ │ │ -Return true if STREAM is not closed. A default method is provided │ │ │ │ - by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been │ │ │ │ - called on the stream. │ │ │ │ COMMON-LISPp:g< │ │ │ │ WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body) │ │ │ │ Provides a method of manually looping over the elements of a hash-table. NAME │ │ │ │ is bound to a generator-macro that, within the scope of the invocation, │ │ │ │ returns one or three values. The first value tells whether any objects remain │ │ │ │ in the hash table. When the first value is non-NIL, the second and third │ │ │ │ values are the key and the value of the next object. │ │ │ │ Consequences are undefined if HASH-TABLE is mutated during execution of BODY, │ │ │ │ except for changing or removing elements corresponding to the current key. The │ │ │ │ applies to all threads, not just the current one -- even for synchronized │ │ │ │ hash-tables. If the table may be mutated by another thread during iteration, │ │ │ │ use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR │ │ │ │ -VECTOR-SYM( │ │ │ │ -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. │ │ │ │ +COMMON-LISP8 │ │ │ │ +Return the 1st object in the caar of a list. │ │ │ │ Return the numerator of NUMBER, which must be rational. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the cdr of the cdadr of a list. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the cdr of the caaar of a list. │ │ │ │ Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, │ │ │ │ putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, │ │ │ │ BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is │ │ │ │ created. All the arrays must have the same rank and dimensions. │ │ │ │ +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. │ │ │ │ Given two strings, if the first string is not lexicographically equal │ │ │ │ to the second string, returns the longest common prefix (using char-equal) │ │ │ │ of the two strings. Otherwise, returns (). │ │ │ │ Return T if the arguments are in strictly non-increasing alphabetic order. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the car of the cdadr of a list. │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -45868,37 +45855,52 @@ │ │ │ │ RAW-FORM │ │ │ │ Return the character with the code CODE. │ │ │ │ Return the greatest integer less than or equal to the square root of N. │ │ │ │ Substitute NEW for subtrees matching OLD. │ │ │ │ Return T if the arguments are in strictly decreasing alphabetic order. │ │ │ │ Case is ignored. │ │ │ │ Return the 10th object in a list or NIL if there is no 10th object. │ │ │ │ +defining ~A as a method combination │ │ │ │ Substitute NEW for subtrees of TREE for which TEST is false. │ │ │ │ COMMON-LISP9 │ │ │ │ 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. │ │ │ │ jYkg~&ef │ │ │ │ Destructively return a list with elements which appear but once in LIST1 │ │ │ │ and LIST2. │ │ │ │ Return a sequence of the same kind as SEQUENCE with the same elements │ │ │ │ except that all elements satisfying the PRED are replaced with NEW. │ │ │ │ COMMON-LISP8 │ │ │ │ Return the cdr of the caadr of a list. │ │ │ │ -Perform a bit-wise LOGXOR 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. │ │ │ │ -Pathname matches the wildname template? │ │ │ │ +VECTOR-SYM( │ │ │ │ +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. │ │ │ │ (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. │ │ │ │ Execute FORMS handling ERROR conditions, returning the result of the last │ │ │ │ form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled. │ │ │ │ +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. │ │ │ │ FORM SB-KERNEL │ │ │ │ COMMON-LISP │ │ │ │ CTYPECASE Keyform {(Type Form*)}* │ │ │ │ Evaluates the Forms in the first clause for which TYPEP of Keyform and Type │ │ │ │ is true. If no form is satisfied then a correctable error is signalled. │ │ │ │ DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* │ │ │ │ Executes the FORMs once for each external symbol in the given PACKAGE with │ │ │ │ @@ -45971,26 +45973,35 @@ │ │ │ │ (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. │ │ │ │ LAMBDA-LIST0 │ │ │ │ QUALIFIERS("g< │ │ │ │ +COMMON-LISP@ │ │ │ │ +The argument is a location holding a list. Pops one item off the front │ │ │ │ + of the list and returns it. │ │ │ │ +Using ~A as the class-name argument in ~ │ │ │ │ + (SETF FIND-CLASS) │ │ │ │ +sb_getitimer │ │ │ │ +failed to resolve home directory for Unix uid=~S │ │ │ │ Arrange for FORM to be evaluated at load-time and use the value produced as │ │ │ │ if it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is │ │ │ │ guaranteed to never be modified, so it can be put in read-only storage. │ │ │ │ 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). │ │ │ │ -COMMON-LISP@ │ │ │ │ -The argument is a location holding a list. Pops one item off the front │ │ │ │ - of the list and returns it. │ │ │ │ +can't understand something in the arglist ~S │ │ │ │ #3l~@v${l; │ │ │ │ -COMMON-LISP8 │ │ │ │ +Perform a bit-wise LOGXOR 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. │ │ │ │ +Pathname matches the wildname template? │ │ │ │ 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. │ │ │ │ Return the element of SEQUENCE specified by INDEX. │ │ │ │ Converts a universal-time to decoded time format returning the following │ │ │ │ nine values: second, minute, hour, date, month, year, day of week (0 = │ │ │ │ @@ -46121,14 +46132,16 @@ │ │ │ │ Return NCONC of results. │ │ │ │ INTEGER1P │ │ │ │ RES SB-BIGNUM(C'@& │ │ │ │ Bitwise AND (LOGNOT INTEGER1) with INTEGER2. │ │ │ │ INTEGER1P │ │ │ │ RES SB-BIGNUM(C'@5 │ │ │ │ Bitwise OR INTEGER1 with (LOGNOT INTEGER2). │ │ │ │ +Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ +or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ Return the cosine of NUMBER. │ │ │ │ Return a single integer for the current time of day in universal time │ │ │ │ Write the elements of SEQ bounded by START and END to STREAM. │ │ │ │ COMMON-LISP │ │ │ │ MORE-ARG │ │ │ │ Return T if no two of its arguments are numerically equal, NIL otherwise. │ │ │ │ COMMON-LISP8 │ │ │ │ @@ -46198,15 +46211,15 @@ │ │ │ │ Return the first cons in ALIST whose CAR satisfies PREDICATE. If │ │ │ │ KEY is supplied, apply it to the CAR of each cons before testing. │ │ │ │ This function causes execution to be suspended for SECONDS. SECONDS may be │ │ │ │ any non-negative real number. │ │ │ │ Return the tangent of NUMBER. │ │ │ │ Return the hyperbolic sine of NUMBER. │ │ │ │ Return the sine of NUMBER. │ │ │ │ -Substitute from ALIST into TREE nondestructively. │ │ │ │ +COMMON-LISP8 │ │ │ │ Output OBJECT to STREAM with "#<" prefix, ">" suffix, optionally │ │ │ │ with object-type prefix and object-identity suffix, and executing the │ │ │ │ code in BODY to provide possible further output. │ │ │ │ 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}* │ │ │ │ @@ -46223,71 +46236,14 @@ │ │ │ │ COMMON-LISP0 │ │ │ │ DECLAIM Declaration* │ │ │ │ Do a declaration or declarations for the global environment. │ │ │ │ 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. │ │ │ │ -Return values associated with STEP-VALUES-CONDITION as a list, │ │ │ │ -or the variable value associated with STEP-VARIABLE-CONDITION. │ │ │ │ -sb_getitimer │ │ │ │ -close_current_thread_tlab │ │ │ │ -close_code_region │ │ │ │ -wrapped_environ │ │ │ │ -wifcontinued │ │ │ │ -wifstopped │ │ │ │ -unlockpt │ │ │ │ -wait_for_exec │ │ │ │ -gc_pathfind │ │ │ │ -gc_and_save │ │ │ │ -closedir │ │ │ │ -fdatasync │ │ │ │ -ftruncate │ │ │ │ -truncate │ │ │ │ -setfsuid │ │ │ │ -setreuid │ │ │ │ -setresuid │ │ │ │ -getresgid │ │ │ │ -getresuid │ │ │ │ -setfsgid │ │ │ │ -setregid │ │ │ │ -setresgid │ │ │ │ -sb_posix_after_fork │ │ │ │ -readlink │ │ │ │ -wifexited │ │ │ │ -wexitstatus │ │ │ │ -wifsignaled │ │ │ │ -wtermsig │ │ │ │ -wstopsig │ │ │ │ -mlockall │ │ │ │ -munlockall │ │ │ │ -getpwnam │ │ │ │ -getpwuid │ │ │ │ -getpwent │ │ │ │ -setpwent │ │ │ │ -endpwent │ │ │ │ -getgrnam │ │ │ │ -getgrgid │ │ │ │ -getgrent │ │ │ │ -setgrent │ │ │ │ -endgrent │ │ │ │ -s_isfifo │ │ │ │ -s_issock │ │ │ │ -tcsetattr │ │ │ │ -tcgetattr │ │ │ │ -tcgetsid │ │ │ │ -tcsendbreak │ │ │ │ -cfsetispeed │ │ │ │ -cfsetospeed │ │ │ │ -cfgetispeed │ │ │ │ -cfgetospeed │ │ │ │ -unsetenv │ │ │ │ -closelog │ │ │ │ -failed to resolve home directory for Unix uid=~S │ │ │ │ -Error reading directory entry~@[ from ~S~] │ │ │ │ (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. │ │ │ │ @@ -46298,34 +46254,31 @@ │ │ │ │ is used to return, this can only return if the STORE-VALUE restart is │ │ │ │ invoked. In that case it will store into PLACE and start over. │ │ │ │ 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. │ │ │ │ -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. │ │ │ │ +Substitute from ALIST into TREE nondestructively. │ │ │ │ Return true if Object is a symbol in the "KEYWORD" package. │ │ │ │ COMMON-LISP8&gL │ │ │ │ Return the 6th object in a list or NIL if there is no 6th object. │ │ │ │ {FD@=;753 │ │ │ │ Makes a new pathname from the component arguments. Note that host is │ │ │ │ a host-structure or string. │ │ │ │ -MULTIPLE-VALUE-PROG1 values-form form* │ │ │ │ -Evaluate VALUES-FORM and then the FORMS, but return all the values of │ │ │ │ -VALUES-FORM. │ │ │ │ Return PATHNAME's directory. │ │ │ │ Return the cons in ALIST whose car is equal (by a given test or EQL) to │ │ │ │ the ITEM. │ │ │ │ Return the number of elements in SEQUENCE satisfying PRED(el). │ │ │ │ Read Lisp values from INPUT-STREAM until the next character after a │ │ │ │ value's representation is ENDCHAR, and return the objects as a list. │ │ │ │ Change the CAR of CONS to X and return the CONS. │ │ │ │ +MULTIPLE-VALUE-PROG1 values-form form* │ │ │ │ +Evaluate VALUES-FORM and then the FORMS, but return all the values of │ │ │ │ +VALUES-FORM. │ │ │ │ Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a │ │ │ │ sequence of type RESULT-TYPE using PREDICATE to order the elements. │ │ │ │ Return (NCONC (NREVERSE X) Y). │ │ │ │ If PATHSPEC is a pathname that names an existing file, return │ │ │ │ a pathname that denotes a canonicalized name for the file. If │ │ │ │ pathspec is a stream associated with a file, return a pathname │ │ │ │ that denotes a canonicalized name for the file associated with │ │ │ │ @@ -46706,28 +46659,18 @@ │ │ │ │ Experimental: interface subject to change. │ │ │ │ Construct the full native (name)string form of PATHNAME. For │ │ │ │ file systems whose native conventions allow directories to be │ │ │ │ indicated as files, if AS-FILE is true and the name, type, and │ │ │ │ version components of PATHNAME are all NIL or :UNSPECIFIC, │ │ │ │ construct a string that names the directory according to the file │ │ │ │ system's syntax for files. │ │ │ │ -SUBVERSIONS │ │ │ │ -REST-ARG │ │ │ │ -Asserts that the current SBCL is of version equal to or greater than │ │ │ │ -the version specified in the arguments. A continuable error is signaled │ │ │ │ -otherwise. │ │ │ │ -The arguments specify a sequence of subversion numbers in big endian order. │ │ │ │ -They are compared lexicographically with the runtime version, and versions │ │ │ │ -are treated as though trailed by an unbounded number of 0s. │ │ │ │ -For example, (assert-version->= 1 1 4) asserts that the current SBCL is │ │ │ │ -version 1.1.4[.0.0...] or greater, and (assert-version->= 1) that it is │ │ │ │ -version 1[.0.0...] or greater. │ │ │ │ -Size of the dynamic space in bytes. │ │ │ │ -See if TIMER will still need to be triggered after DELTA seconds │ │ │ │ -from now. For timers with a repeat interval it returns true. │ │ │ │ +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. │ │ │ │ COMMON-LISP │ │ │ │ COMMON-LISP((g< │ │ │ │ ARGUMENT-TYPES` │ │ │ │ RESULT-TYPEp │ │ │ │ SPECIFIER │ │ │ │ Returns an alien-value of alien ftype SPECIFIER, that can be passed to │ │ │ │ an alien function as a pointer to the FUNCTION. If a callback for the given │ │ │ │ @@ -46752,14 +46695,17 @@ │ │ │ │ - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM. │ │ │ │ ATOMIC-DECF of #x-4000000000000000 by one results in #x3FFFFFFFFFFFFFFF │ │ │ │ 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. │ │ │ │ +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. │ │ │ │ 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 │ │ │ │ @@ -46782,16 +46728,14 @@ │ │ │ │ returned and NEW is assigned to the slot. Additionally, the results are │ │ │ │ unspecified if there is an applicable method on either │ │ │ │ SB-MOP:SLOT-VALUE-USING-CLASS, (SETF SB-MOP:SLOT-VALUE-USING-CLASS), or │ │ │ │ SB-MOP:SLOT-BOUNDP-USING-CLASS. │ │ │ │ Additionally, the PLACE can be a anything for which a CAS-function has │ │ │ │ been defined. (See SB-EXT:CAS for more information.) │ │ │ │ Return line# and column# of this macro invocation as multiple values. │ │ │ │ -SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ -SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ COMMON-LISP( │ │ │ │ Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ and assigned to NAME both at compile- and load-time, but only if NAME is not │ │ │ │ already bound. │ │ │ │ Global variables share their values between all threads, and cannot be │ │ │ │ locally bound, declared special, defined as constants, and neither bound │ │ │ │ nor defined as symbol macros. │ │ │ │ @@ -46800,29 +46744,14 @@ │ │ │ │ If TIMEOUT is provided, waits at most approximately TIMEOUT seconds before │ │ │ │ returning NIL. │ │ │ │ If WITH-DEADLINE has been used to provide a global deadline, signals a │ │ │ │ DEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the │ │ │ │ deadline. │ │ │ │ Experimental: subject to change without prior notice. │ │ │ │ Return character position of this macro invocation or NIL if unavailable. │ │ │ │ -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. │ │ │ │ -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. │ │ │ │ Execute the body, asynchronously interrupting it and signalling a TIMEOUT │ │ │ │ condition after at least EXPIRES seconds have passed. │ │ │ │ Note that it is never safe to unwind from an asynchronous condition. Consider: │ │ │ │ (defun call-with-foo (function) │ │ │ │ (let (foo) │ │ │ │ (unwind-protect │ │ │ │ (progn │ │ │ │ @@ -46832,35 +46761,38 @@ │ │ │ │ (release-foo foo))))) │ │ │ │ If TIMEOUT occurs after GET-FOO has executed, but before the assignment, then │ │ │ │ RELEASE-FOO will be missed. While individual sites like this can be made proof │ │ │ │ against asynchronous unwinds, this doesn't solve the fundamental issue, as all │ │ │ │ the frames potentially unwound through need to be proofed, which includes both │ │ │ │ system and application code -- and in essence proofing everything will make │ │ │ │ the system uninterruptible. │ │ │ │ -UNLOCKED-PACKAGES( │ │ │ │ -Unlocks PACKAGES for the dynamic scope of the body. Signals an │ │ │ │ -error if any of PACKAGES is not a valid package designator. │ │ │ │ -Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ -and assigned to NAME at load-time, but only if NAME is not already bound. │ │ │ │ -Attempts to read NAME at compile-time will signal an UNBOUND-VARIABLE error │ │ │ │ -unless it has otherwise been assigned a value. │ │ │ │ -See also DEFGLOBAL which assigns the VALUE at compile-time too. │ │ │ │ +SYS:SRC;CODE;TARGET-UNICODE.LISP │ │ │ │ +SYS:SRC;CODE;TRACEROOT.LISP │ │ │ │ +SUBVERSIONS │ │ │ │ +REST-ARG │ │ │ │ +Asserts that the current SBCL is of version equal to or greater than │ │ │ │ +the version specified in the arguments. A continuable error is signaled │ │ │ │ +otherwise. │ │ │ │ +The arguments specify a sequence of subversion numbers in big endian order. │ │ │ │ +They are compared lexicographically with the runtime version, and versions │ │ │ │ +are treated as though trailed by an unbounded number of 0s. │ │ │ │ +For example, (assert-version->= 1 1 4) asserts that the current SBCL is │ │ │ │ +version 1.1.4[.0.0...] or greater, and (assert-version->= 1) that it is │ │ │ │ +version 1[.0.0...] or greater. │ │ │ │ +Size of the dynamic space in bytes. │ │ │ │ +See if TIMER will still need to be triggered after DELTA seconds │ │ │ │ +from now. For timers with a repeat interval it returns true. │ │ │ │ Return the Unix environment ("man environ") as a list of SIMPLE-STRINGs. │ │ │ │ Return a list of all timers in the system. │ │ │ │ Calls (SB-EXT:EXIT :CODE UNIX-STATUS :ABORT RECKLESSLY-P), │ │ │ │ see documentation for SB-EXT:EXIT. │ │ │ │ Number of times garbage collection is done on GENERATION before │ │ │ │ automatic promotion to the next generation is triggered. Default is 1. Can be │ │ │ │ assigned to using SETF. Available on GENCGC platforms only. │ │ │ │ Experimental: interface subject to change. │ │ │ │ -Specifies that the values returned by FORM conform to the │ │ │ │ -VALUE-TYPE, and causes the compiler to trust this information │ │ │ │ -unconditionally. │ │ │ │ -Consequences are undefined if any result is not of the declared type │ │ │ │ --- typical symptoms including memory corruptions. Use with great │ │ │ │ COMMON-LISP │ │ │ │ Locks PACKAGE and returns T. Has no effect if PACKAGE was already │ │ │ │ locked. Signals an error if PACKAGE is not a valid package designator │ │ │ │ Hints the processor that the current thread is spin-looping. │ │ │ │ Return an octet vector that is STRING encoded according to EXTERNAL-FORMAT. │ │ │ │ If EXTERNAL-FORMAT is given, it must designate an external format. │ │ │ │ If given, START and END must be bounding index designators and │ │ │ │ @@ -46965,14 +46897,19 @@ │ │ │ │ symbolic links are considered file entries. In both cases the pathname used │ │ │ │ for the symbolic link is not fully resolved, but names it as an immediate │ │ │ │ child of DIRECTORY. Defaults to T. │ │ │ │ :ERRORP │ │ │ │ If true, signal an error if DIRECTORY does not exist, cannot be read, etc. │ │ │ │ Defaults to T. │ │ │ │ Experimental: interface subject to change. │ │ │ │ +Specifies that the values returned by FORM conform to the │ │ │ │ +VALUE-TYPE, and causes the compiler to trust this information │ │ │ │ +unconditionally. │ │ │ │ +Consequences are undefined if any result is not of the declared type │ │ │ │ +-- typical symptoms including memory corruptions. Use with great │ │ │ │ TYPE-SPECIFIER │ │ │ │ OPTIONAL-ARGS │ │ │ │ Returns T if TYPE-SPECIFIER is a valid type specifier, otherwise NIL. │ │ │ │ There may be different metrics on what constitutes a "valid type │ │ │ │ specifier" depending on context. If this function does not suit your │ │ │ │ exact need, you may be able to craft a particular solution using a │ │ │ │ combination of DEFINED-TYPE-NAME-P and the TYPEXPAND functions. │ │ │ │ @@ -47124,22 +47061,22 @@ │ │ │ │ READTABLE │ │ │ │ COMMON-LISP0 │ │ │ │ Returns T if READTABLE normalizes symbols to NFKC, and NIL otherwise. │ │ │ │ The READTABLE-NORMALIZATION of the standard readtable is T. │ │ │ │ Cancel TIMER. Once this function returns it is guaranteed that │ │ │ │ TIMER shall not be triggered again and there are no unfinished │ │ │ │ triggers. │ │ │ │ -INSTANCE SB-KERNELH │ │ │ │ -VALUE SB-KERNEL@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ -INSTANCE SB-KERNELH │ │ │ │ -VALUE SB-KERNEL@ │ │ │ │ -INSTANCE SB-KERNEL0 │ │ │ │ -VALUE SB-KERNEL8 │ │ │ │ +UNLOCKED-PACKAGES( │ │ │ │ +Unlocks PACKAGES for the dynamic scope of the body. Signals an │ │ │ │ +error if any of PACKAGES is not a valid package designator. │ │ │ │ +Defines NAME as a global variable that is always bound. VALUE is evaluated │ │ │ │ +and assigned to NAME at load-time, but only if NAME is not already bound. │ │ │ │ +Attempts to read NAME at compile-time will signal an UNBOUND-VARIABLE error │ │ │ │ +unless it has otherwise been assigned a value. │ │ │ │ +See also DEFGLOBAL which assigns the VALUE at compile-time too. │ │ │ │ Atomically increments PLACE by DIFF, and returns the value of PLACE before │ │ │ │ the increment. │ │ │ │ PLACE must access one of the following: │ │ │ │ - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 64) │ │ │ │ or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) │ │ │ │ The type SB-EXT:WORD can be used for these purposes. │ │ │ │ - CAR or CDR (respectively FIRST or REST) of a CONS. │ │ │ │ @@ -47235,73 +47172,138 @@ │ │ │ │ precise source locations in case conditions are signaled during the │ │ │ │ execution of BODY. │ │ │ │ NOTE: This interface is experimental and subject to change. │ │ │ │ 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. │ │ │ │ - NEW-VALUEH │ │ │ │ - NEW-VALUEP │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ +I#!EmI$S │ │ │ │ +INSTANCE SB-KERNELH │ │ │ │ +VALUE SB-KERNEL@ │ │ │ │ /build/reproducible-path/cafeobj-1.6.0/chaos/primitives/print-object.lisp │ │ │ │ +SYS:SRC;PCL;WALK.LISP │ │ │ │ +dummy macro │ │ │ │ +Error reading directory entry~@[ from ~S~] │ │ │ │ +select(2) │ │ │ │ +Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ +Syscall poll(2) failed: ~A │ │ │ │ +sb_setitimer │ │ │ │ +found no match for Unix uid=~S │ │ │ │ +Error closing directory~@[ ~S~] │ │ │ │ +close_current_thread_tlab │ │ │ │ +close_code_region │ │ │ │ +wrapped_environ │ │ │ │ +wifcontinued │ │ │ │ +wifstopped │ │ │ │ +unlockpt │ │ │ │ +wait_for_exec │ │ │ │ +gc_pathfind │ │ │ │ +gc_and_save │ │ │ │ +closedir │ │ │ │ +fdatasync │ │ │ │ +ftruncate │ │ │ │ +truncate │ │ │ │ +setfsuid │ │ │ │ +setreuid │ │ │ │ +setresuid │ │ │ │ +getresgid │ │ │ │ +getresuid │ │ │ │ +setfsgid │ │ │ │ +setregid │ │ │ │ +setresgid │ │ │ │ +sb_posix_after_fork │ │ │ │ +readlink │ │ │ │ +wifexited │ │ │ │ +wexitstatus │ │ │ │ +wifsignaled │ │ │ │ +wtermsig │ │ │ │ +wstopsig │ │ │ │ +mlockall │ │ │ │ +munlockall │ │ │ │ +getpwnam │ │ │ │ +getpwuid │ │ │ │ +getpwent │ │ │ │ +setpwent │ │ │ │ +endpwent │ │ │ │ +getgrnam │ │ │ │ +getgrgid │ │ │ │ +getgrent │ │ │ │ +setgrent │ │ │ │ +endgrent │ │ │ │ +s_isfifo │ │ │ │ +s_issock │ │ │ │ +tcsetattr │ │ │ │ +tcgetattr │ │ │ │ +tcgetsid │ │ │ │ +tcsendbreak │ │ │ │ +cfsetispeed │ │ │ │ +cfsetospeed │ │ │ │ +cfgetispeed │ │ │ │ +cfgetospeed │ │ │ │ +unsetenv │ │ │ │ +closelog │ │ │ │ 1.0.56.55 │ │ │ │ +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. │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ +INSTANCE SB-KERNELH │ │ │ │ +VALUE SB-KERNEL@ │ │ │ │ +INSTANCE SB-KERNEL0 │ │ │ │ +VALUE SB-KERNEL8 │ │ │ │ + NEW-VALUEH │ │ │ │ + NEW-VALUEP │ │ │ │ +encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ +~@<~S of ~S is not a ~S.~@:> │ │ │ │ +~@<~S, in ~S ~S, is not a non-~S atom.~@:> │ │ │ │ +~@<~S of ~S is an improper list.~@:> │ │ │ │ +NEW-INFO │ │ │ │ This is like CL:WRITE-SEQUENCE, but for Gray streams. │ │ │ │ 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. │ │ │ │ -SYS:SRC;PCL;WALK.LISP │ │ │ │ -select(2) │ │ │ │ -Cannot select(2) on ~D: above FD_SETSIZE limit. │ │ │ │ -Syscall poll(2) failed: ~A │ │ │ │ -sb_setitimer │ │ │ │ -found no match for Unix uid=~S │ │ │ │ -Error closing directory~@[ ~S~] │ │ │ │ -can't understand something in the arglist ~S │ │ │ │ -encountered ~S ~_in a place where a DECLARE was not expected │ │ │ │ -dummy macro │ │ │ │ -~@<~S of ~S is not a ~S.~@:> │ │ │ │ -COMMON-LISP │ │ │ │ -COMMON-LISP │ │ │ │ 1.M%b3ft │ │ │ │ FUNCTIONS8 │ │ │ │ ~S: malformed feature specification ~S │ │ │ │ +The default plan class to use when building with ASDF │ │ │ │ How should ASDF react if it encounters a warning when compiling a file? │ │ │ │ Valid values are :error, :warn, and :ignore. │ │ │ │ How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) │ │ │ │ when compiling a file, which includes any non-style-warning warning. │ │ │ │ Valid values are :error, :warn, and :ignore. │ │ │ │ Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling. │ │ │ │ -The default plan class to use when building with ASDF │ │ │ │ loading │ │ │ │ ~@ │ │ │ │ operation. │ │ │ │ operation │ │ │ │ resetting │ │ │ │ configuration. │ │ │ │ ~*~S and ~S arguments not allowed in a nested call to ~3:*~S ~ │ │ │ │ @@ -47578,53 +47591,42 @@ │ │ │ │ SORT-RELATION │ │ │ │ OPTIONAL-ARGS │ │ │ │ } ( 0 @ │ │ │ │ INDENT-CHARP │ │ │ │ COMMON-LISP` │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP8 │ │ │ │ -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: │ │ │ │ ` P 0 `2 │ │ │ │ SORT-NAME8 │ │ │ │ OPTIONAL-ARGS │ │ │ │ -The dimension list is not constant; cannot open code array creation. │ │ │ │ -~S is not a ~S. │ │ │ │ -~@<~S is not a ~S (which is the ~S of ~S).~@:> │ │ │ │ -ELEMENT-TYPE ~s is not a known type │ │ │ │ -ELEMENT-TYPE is not constant. │ │ │ │ -Can't specify :DISPLACED-TO and ~S │ │ │ │ -:DISPLACED-TO potentially used with ~S │ │ │ │ -INDEX-~D │ │ │ │ -$($0$8$@ │ │ │ │ -SB-DISASSEM │ │ │ │ -COMMON-LISP │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ REST-ARG │ │ │ │ +SYS:SRC;PCL;DLISP3.LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ OPTIONAL-ARGS │ │ │ │ -SYS:SRC;PCL;DLISP3.LISP │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/script.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/commands.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/absntax.lisp │ │ │ │ -/build/reproducible-path/cafeobj-1.6.0/thstuff/parse-apply.lisp │ │ │ │ ` ( 0 8Q │ │ │ │ OPTIONAL-ARGS │ │ │ │ SUBNODES@ │ │ │ │ SUBNODES │ │ │ │ RENAMESH │ │ │ │ COMMON-LISP@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ +The dimension list is not constant; cannot open code array creation. │ │ │ │ +~S is not a ~S. │ │ │ │ +~@<~S is not a ~S (which is the ~S of ~S).~@:> │ │ │ │ +ELEMENT-TYPE ~s is not a known type │ │ │ │ +ELEMENT-TYPE is not constant. │ │ │ │ +Can't specify :DISPLACED-TO and ~S │ │ │ │ +:DISPLACED-TO potentially used with ~S │ │ │ │ +INDEX-~D │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/script.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/BigPink/codes/commands.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/chaos/primitives/absntax.lisp │ │ │ │ +/build/reproducible-path/cafeobj-1.6.0/thstuff/parse-apply.lisp │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMON-LISP │ │ │ │ OPTIONAL-ARGS │ │ │ │ FOPL-SENTENCE │ │ │ │ REPORT-ERROR@ │ │ │ │ OPTIONAL-ARGS │ │ │ │ COMMAND@ │ │ │ │ @@ -47862,47 +47864,47 @@ │ │ │ │ ` @ 8 P! │ │ │ │ ` H 0 86 │ │ │ │ I'` ( X ` p │ │ │ │ 0 8 @ H P │ │ │ │ } ( 0 8> │ │ │ │ DO-REPORT │ │ │ │ OPTIONAL-ARGS │ │ │ │ -; puts all repeated terms together in the list, and bashes the array │ │ │ │ - ; (into numbers) in locations corresponding to the duplicate terms. │ │ │ │ - ; returns the newly grouped permutation of list. │ │ │ │ - ; e.g. for input (a b c c c d d e f f) and #(0 0 0 0 0 0 0 0 0), │ │ │ │ - ; this should make the array into #(0 0 3 2 1 2 1 0 2 1). │ │ │ │ -G!BOX8