From 30b2ef895fd416e775b73ab4208e940d04aab223 Mon Sep 17 00:00:00 2001 From: Camm Maguire Date: Thu, 11 Aug 2022 18:16:42 +0100 Subject: [PATCH] TODO: Put a short summary on the line above and replace this paragraph with a longer explanation of this change. Complete the meta-information with other relevant fields (see below for details). To make it easier, the information below has been extracted from the changelog. Adjust it or drop it. gcl (2.6.12-43) unstable; urgency=medium * pathnames1.7 Gbp-Pq: Name pathnames1.9 --- ansi-tests/ansi-aux.lsp | 3 + clcs/sys-proclaim.lisp | 52 +- cmpnew/gcl_cmpmain.lsp | 2 +- cmpnew/gcl_lfun_list.lsp | 2 - cmpnew/sys-proclaim.lisp | 606 +++++----- configure | 2 +- configure.in | 2 +- gcl-tk/socketsl.lisp | 4 - gcl-tk/tkl.lisp | 28 +- h/compprotos.h | 1 + h/lu.h | 17 +- h/object.h | 8 +- h/type.h | 4 +- lsp/gcl_directory.lsp | 10 +- lsp/gcl_iolib.lsp | 61 +- lsp/gcl_namestring.lsp | 2 +- lsp/gcl_predlib.lsp | 2 + lsp/gcl_restart.lsp | 2 +- lsp/gcl_serror.lsp | 8 +- lsp/gcl_top.lsp | 11 +- lsp/gcl_translate_pathname.lsp | 2 +- lsp/sys-proclaim.lisp | 974 +++++++-------- o/fasdump.c | 10 +- o/file.d | 335 +----- o/gbc.c | 1 - o/pathname.d | 5 + o/print.d | 1 - o/read.d | 2 +- o/run_process.c | 12 +- o/sockets.c | 10 - o/string.d | 49 +- o/unixfsys.c | 20 +- pcl/sys-proclaim.lisp | 2056 ++++++++++++++++---------------- 33 files changed, 2088 insertions(+), 2216 deletions(-) diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp index 6f84d2c..cf1a831 100644 --- a/ansi-tests/ansi-aux.lsp +++ b/ansi-tests/ansi-aux.lsp @@ -1635,3 +1635,6 @@ the condition to go uncaught if it cannot be classified." (defmacro expand-in-current-env (macro-form &environment env) (macroexpand macro-form env)) + +(defun typep* (element type) + (not (not (typep element type)))) diff --git a/clcs/sys-proclaim.lisp b/clcs/sys-proclaim.lisp index 1faff63..267e206 100644 --- a/clcs/sys-proclaim.lisp +++ b/clcs/sys-proclaim.lisp @@ -2,30 +2,14 @@ (COMMON-LISP::IN-PACKAGE "CONDITIONS") (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - CONDITIONS::IS-WARNING CONDITIONS::DEFAULT-REPORT - CONDITIONS::IS-CONDITION CONDITIONS::CONDITIONP)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + CONDITIONS::COERCE-TO-FN CONDITIONS::SLOT-SYM)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ARITHMETIC-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CASE-FAILURE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PRINT-NOT-READABLE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (SIMPLE-CONDITION T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ABORT-FAILURE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (FILE-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (END-OF-FILE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))|)) + COMMON-LISP::MAKE-CONDITION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -36,11 +20,27 @@ CONDITIONS::|(PCL::FAST-METHOD MAKE-LOAD-FORM (CONDITION))|)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - CONDITIONS::COERCE-TO-FN CONDITIONS::SLOT-SYM)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) + CONDITIONS::IS-CONDITION CONDITIONS::DEFAULT-REPORT + CONDITIONS::IS-WARNING CONDITIONS::CONDITIONP)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) COMMON-LISP::*) - COMMON-LISP::MAKE-CONDITION)) \ No newline at end of file + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CASE-FAILURE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ABORT-FAILURE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (FILE-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ARITHMETIC-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (END-OF-FILE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (SIMPLE-CONDITION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PRINT-NOT-READABLE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))|)) \ No newline at end of file diff --git a/cmpnew/gcl_cmpmain.lsp b/cmpnew/gcl_cmpmain.lsp index 3955812..4552326 100755 --- a/cmpnew/gcl_cmpmain.lsp +++ b/cmpnew/gcl_cmpmain.lsp @@ -430,7 +430,7 @@ Cannot compile ~a.~%" (si::copy-stream st *standard-output*)) (with-open-file (st hn) (si::copy-stream st *standard-output*)) - (when (eql (aref *objdump* 0) #\/);program found at startup in path + (when *objdump* (safe-system (si::string-concatenate *objdump* (namestring on)))) (mdelete-file cn) (mdelete-file dn) diff --git a/cmpnew/gcl_lfun_list.lsp b/cmpnew/gcl_lfun_list.lsp index e2b1262..4b46f92 100755 --- a/cmpnew/gcl_lfun_list.lsp +++ b/cmpnew/gcl_lfun_list.lsp @@ -43,7 +43,6 @@ (DEFSYSFUN 'RASSOC "Lrassoc" '(T T *) 'T NIL NIL) (DEFSYSFUN 'PPRINT "Lpprint" '(T *) 'T NIL NIL) (DEFSYSFUN 'NSUBST-IF-NOT "Lnsubst_if_not" '(T T T *) 'T NIL NIL) -(DEFSYSFUN 'FILE-POSITION "Lfile_position" '(T *) 'T NIL NIL) (DEFSYSFUN 'STRING< "Lstring_l" '(T T *) 'T NIL NIL) (DEFSYSFUN 'REVERSE "Lreverse" '(T) 'T NIL NIL) (DEFSYSFUN 'STREAMP "Lstreamp" '(T) 'T NIL T) @@ -67,7 +66,6 @@ (DEFSYSFUN 'CONS "Lcons" '(T T) 'T NIL NIL) (DEFSYSFUN 'LIST "Llist" '(*) 'T NIL NIL) (DEFSYSFUN 'USE-PACKAGE "Luse_package" '(T *) 'T NIL NIL) -(DEFSYSFUN 'FILE-LENGTH "Lfile_length" '(T) 'T NIL NIL) (DEFSYSFUN 'MAKE-SYMBOL "Lmake_symbol" '(T) 'T NIL NIL) (DEFSYSFUN 'STRING-RIGHT-TRIM "Lstring_right_trim" '(T T) 'STRING NIL NIL) diff --git a/cmpnew/sys-proclaim.lisp b/cmpnew/sys-proclaim.lisp index 32afb65..5215594 100755 --- a/cmpnew/sys-proclaim.lisp +++ b/cmpnew/sys-proclaim.lisp @@ -1,377 +1,395 @@ (COMMON-LISP::IN-PACKAGE "COMPILER") -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::STRING COMMON-LISP::*) - COMMON-LISP::T) - COMPILER::TS)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - COMPILER::C1MULTIPLE-VALUE-BIND COMPILER::C1VALUES - COMPILER::C1RPLACA COMPILER::FUN-P - COMPILER::FUNCTION-ARG-TYPES COMPILER::C1STRUCTURE-REF - COMPILER::GET-RETURN-TYPE COMPILER::WT-FUNCALL-C - COMPILER::MACRO-DEF-P COMPILER::T1DEFUN COMPILER::C1ASSOC - COMPILER::SET-UP-VAR-CVS COMPILER::C2FUNCTION - COMPILER::C1DM-BAD-KEY COMPILER::ADD-OBJECT - COMPILER::WT-SWITCH-CASE COMPILER::VARARG-P - COMPILER::C1TAGBODY COMPILER::C2GET COMPILER::VAR-REF - COMPILER::SCH-LOCAL-FUN COMPILER::ADD-SYMBOL - COMPILER::TAG-UNWIND-EXIT COMPILER::C1MULTIPLE-VALUE-SETQ - COMPILER::C1PRINC COMPILER::WT-VAR-DECL COMPILER::C1QUOTE - COMPILER::C2RPLACD COMPILER::CHECK-VREF - COMPILER::PUSH-ARGS-LISPCALL COMPILER::C1MAPLIST - COMPILER::ADD-REG1 COMPILER::C1OR COMPILER::WT-SYMBOL-FUNCTION - COMPILER::TAG-P COMPILER::SAFE-SYSTEM COMPILER::C1ECASE - COMPILER::LTVP COMPILER::GET-INCLUDED COMPILER::INFO-P - COMPILER::FUN-INFO COMPILER::C1LOAD-TIME-VALUE - COMPILER::GET-LOCAL-ARG-TYPES COMPILER::BLK-P - COMPILER::BLK-EXIT COMPILER::C2VAR-KIND COMPILER::C2LOCATION - COMPILER::WT1 COMPILER::WT-CCB-VS - COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::BLK-REF-CCB - COMPILER::UNDEFINED-VARIABLE COMPILER::C1MULTIPLE-VALUE-CALL - COMPILER::VAR-LOC COMPILER::C1SETQ COMPILER::C1NTH-CONDITION - COMPILER::C2RPLACA COMPILER::FUN-REF COMPILER::C2VAR - COMPILER::WT-CAR COMPILER::WT-LIST COMPILER::WRITE-BLOCK-OPEN - COMPILER::INFO-VOLATILE COMPILER::GET-LOCAL-RETURN-TYPE - COMPILER::AET-C-TYPE COMPILER::PUSH-ARGS COMPILER::TAG-REF-CLB - COMPILER::BLK-REF COMPILER::VAR-P COMPILER::C1ADD-GLOBALS - COMPILER::T3ORDINARY COMPILER::ADD-OBJECT2 COMPILER::SET-TOP - COMPILER::T1DEFLA COMPILER::C1FUNCTION COMPILER::T3CLINES - COMPILER::T1DEFCFUN COMPILER::C1VREF COMPILER::C1ASH - COMPILER::BLK-NAME COMPILER::WT-CADR COMPILER::WT-DOWN - COMPILER::C1TERPRI COMPILER::C2GETHASH COMPILER::C2GO-CCB - COMPILER::SAVE-FUNOB COMPILER::T2DECLARE COMPILER::FUN-REF-CCB - COMPILER::C1MAPCAR COMPILER::T1DEFMACRO - COMPILER::C2TAGBODY-LOCAL COMPILER::C1STACK-LET - COMPILER::INFO-TYPE COMPILER::T1MACROLET COMPILER::C1LET* - COMPILER::C1RPLACD COMPILER::DECLARATION-TYPE - COMPILER::T1ORDINARY COMPILER::C2EXPR* COMPILER::C1LOCAL-FUN - COMPILER::WT-DATA-PACKAGE-OPERATION - COMPILER::C1BOOLE-CONDITION SYSTEM::UNDEF-COMPILER-MACRO - COMPILER::C2TAGBODY-BODY COMPILER::C1NTHCDR COMPILER::C1VAR - COMPILER::C1MULTIPLE-VALUE-PROG1 COMPILER::C1NTHCDR-CONDITION - COMPILER::CONSTANT-FOLD-P COMPILER::C1UNWIND-PROTECT - COMPILER::PROCLAMATION COMPILER::C1NTH COMPILER::C1RETURN-FROM - COMPILER::INFO-SP-CHANGE COMPILER::C1LENGTH - COMPILER::CMP-MACRO-FUNCTION COMPILER::BLK-REF-CLB - COMPILER::NAME-TO-SD COMPILER::CTOP-WRITE COMPILER::C1MAPCON - COMPILER::C1FUNOB COMPILER::FIX-OPT COMPILER::C1RPLACA-NTHCDR - COMPILER::C1FLET COMPILER::RESULT-TYPE COMPILER::C1CATCH - COMPILER::C2DM-RESERVE-V COMPILER::VAR-NAME - COMPILER::CMP-MACROEXPAND COMPILER::VERIFY-DATA-VECTOR - COMPILER::T1CLINES COMPILER::C1MAPL COMPILER::T1DEFENTRY - COMPILER::TAG-REF-CCB COMPILER::WT-VS - COMPILER::LONG-FLOAT-LOC-P COMPILER::C1MAPCAN - COMPILER::OBJECT-TYPE COMPILER::ADD-ADDRESS - COMPILER::RESET-INFO-TYPE COMPILER::C1BOOLE3 COMPILER::C1MEMQ - COMPILER::C1DEFINE-STRUCTURE COMPILER::TYPE-FILTER - COMPILER::UNWIND-NO-EXIT COMPILER::C1FMLA-CONSTANT - COMPILER::C2DM-RESERVE-VL COMPILER::C1FSET COMPILER::LTVP-EVAL - COMPILER::C1GO COMPILER::WT-VV COMPILER::INFO-CHANGED-ARRAY - COMPILER::C1FUNCALL COMPILER::C2TAGBODY-CCB - COMPILER::TAG-LABEL COMPILER::VAR-KIND COMPILER::WT-VS* - COMPILER::VAR-TYPE COMPILER::C2GO-LOCAL COMPILER::REGISTER - COMPILER::T1PROGN COMPILER::C1BLOCK COMPILER::TAG-SWITCH - COMPILER::VAR-REP-LOC COMPILER::C2BIND - COMPILER::SET-PUSH-CATCH-FRAME COMPILER::COPY-INFO - COMPILER::C1LIST-NTH COMPILER::CONS-TO-LISTA - COMPILER::FUN-LEVEL COMPILER::C1DOWNWARD-FUNCTION - COMPILER::THE-PARAMETER COMPILER::C2VALUES COMPILER::C1LABELS - COMPILER::MAXARGS COMPILER::VAR-REF-CCB COMPILER::MDELETE-FILE - COMPILER::WT-FUNCTION-LINK COMPILER::SAVE-AVMA - COMPILER::VOLATILE COMPILER::ADD-CONSTANT COMPILER::C1APPLY - COMPILER::C1GETHASH COMPILER::FUN-NAME COMPILER::DEFAULT-INIT - COMPILER::CLINK COMPILER::WT-CDR COMPILER::PARSE-CVSPECS - COMPILER::REP-TYPE COMPILER::C2GO-CLB - COMPILER::ARGS-CAUSE-SIDE-EFFECT COMPILER::PUSH-DATA-INCF - COMPILER::SCH-GLOBAL COMPILER::C1STRUCTURE-SET - COMPILER::TAG-NAME COMPILER::INFO-REFERRED-ARRAY - COMPILER::C1EXPR COMPILER::C1GET COMPILER::BLK-VAR - COMPILER::TAG-REF COMPILER::C1MAPC COMPILER::SET-RETURN - COMPILER::SHORT-FLOAT-LOC-P COMPILER::C1DECLARE - COMPILER::WT-DATA1 COMPILER::FLAGS-POS - COMPILER::BLK-VALUE-TO-GO COMPILER::NAME-SD1 - COMPILER::C2DOWNWARD-FUNCTION COMPILER::C1SHARP-COMMA - COMPILER::INLINE-POSSIBLE COMPILER::WT-H1 - COMPILER::FIXNUM-LOC-P COMPILER::C1LET COMPILER::C1IF - COMPILER::C1THE COMPILER::FUNCTION-RETURN-TYPE - COMPILER::GET-ARG-TYPES COMPILER::INLINE-TYPE - COMPILER::FUN-CFUN COMPILER::TAG-VAR COMPILER::CHARACTER-LOC-P - COMPILER::CHECK-DOWNWARD COMPILER::C1PSETQ - COMPILER::INLINE-BOOLE3-STRING COMPILER::C1THROW - COMPILER::FSET-FN-NAME COMPILER::T1DEFINE-STRUCTURE - COMPILER::NEED-TO-SET-VS-POINTERS COMPILER::C1PROGN - COMPILER::C2FUNCALL-AUX COMPILER::C1MACROLET COMPILER::C1AND - COMPILER::WT-VS-BASE COMPILER::ADD-LOOP-REGISTERS - COMPILER::VAR-REGISTER COMPILER::C1PROGV COMPILER::C1SWITCH - COMPILER::C1MEMBER COMPILER::C2TAGBODY-CLB - COMPILER::CMP-MACROEXPAND-1 COMMON-LISP::PROCLAIM - COMPILER::C1ASH-CONDITION COMPILER::C1EVAL-WHEN - COMPILER::C1LOCAL-CLOSURE COMPILER::REPLACE-CONSTANT)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - COMPILER::INLINE-BOOLE3)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - COMPILER::C2DM COMPILER::C1DM-V COMPILER::C1DM-VL - COMPILER::C2RETURN-FROM COMPILER::C2APPLY-OPTIMIZE)) + ((COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::T) + COMPILER::MLIN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - COMPILER::WT-INLINE COMPILER::C2IF COMPILER::C2LABELS - COMPILER::C2FLET)) + ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER + COMMON-LISP::*) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::T) + COMPILER::DASH-TO-UNDERSCORE-INT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - COMPILER::T3DEFUN-AUX)) + ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER + COMMON-LISP::*)) + COMMON-LISP::T) + COMPILER::TS COMPILER::DASH-TO-UNDERSCORE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) - COMPILER::F-TYPE)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + COMPILER::C1NIL COMPILER::WT-DATA-FILE + COMPILER::CLOSE-INLINE-BLOCKS COMPILER::WT-NEXT-VAR-ARG + COMPILER::RESET-TOP COMPILER::VS-PUSH COMPILER::BABOON + COMPILER::GAZONK-NAME COMPILER::PRINT-COMPILER-INFO + COMPILER::ADD-LOAD-TIME-SHARP-COMMA COMPILER::INIT-ENV + COMPILER::PRINT-CURRENT-FORM COMPILER::WT-C-PUSH COMPILER::C1T + COMPILER::WT-FIRST-VAR-ARG COMPILER::CCB-VS-PUSH + COMPILER::INC-INLINE-BLOCKS COMPILER::WT-CVARS + COMPILER::WT-FASD-DATA-FILE COMPILER::WFS-ERROR + COMPILER::WT-DATA-END COMPILER::TAIL-RECURSION-POSSIBLE + COMPILER::CVS-PUSH COMPILER::WT-DATA-BEGIN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::STRING) COMMON-LISP::T) - COMPILER::DASH-TO-UNDERSCORE)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::FIXNUM) + COMPILER::ANALYZE-REGS1 COMPILER::ANALYZE-REGS + COMPILER::PROCLAIMED-ARGD)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - COMPILER::INIT-NAME COMPILER::ADD-INIT COMPILER::C1LAMBDA-EXPR - COMPILER::WT-CVAR COMPILER::C1CASE COMPILER::WT-COMMENT - COMPILER::CMPERR COMPILER::WT-INTEGER-LOC COMPILER::CMPNOTE - COMPILER::FAST-LINK-PROCLAIMED-TYPE-P COMPILER::UNWIND-EXIT - COMPILER::CMPWARN)) + COMPILER::CHECK-FNAME-ARGS COMPILER::COERCE-LOC + COMPILER::TYPE>= COMPILER::C2BIND-LOC + COMPILER::RESULT-TYPE-FROM-ARGS COMPILER::ADD-DEBUG-INFO + COMPILER::MAKE-USER-INIT COMPILER::CO1EQL COMPILER::C2ASSOC!2 + COMPILER::WT-VAR COMPILER::CFAST-WRITE COMPILER::C2STACK-LET + COMPILER::C2DM-BIND-INIT COMPILER::IS-REP-REFERRED + COMPILER::CO1CONS COMPILER::SHIFT<< + COMPILER::C2MULTIPLE-VALUE-SETQ COMPILER::C2CALL-LOCAL + COMPILER::CO1SCHAR COMPILER::C1CONSTANT-VALUE + COMPILER::WT-CHARACTER-VALUE COMPILER::CONVERT-CASE-TO-SWITCH + COMPILER::C2MULTIPLE-VALUE-CALL COMPILER::C2EXPR-TOP + COMPILER::CO1READ-BYTE COMPILER::PRIN1-CMP + COMPILER::STRUCT-TYPE-OPT COMPILER::C1DECL-BODY + COMPILER::COERCE-LOC-STRUCTURE-REF + COMPILER::CO1STRUCTURE-PREDICATE COMPILER::WT-MAKE-DCLOSURE + COMPILER::ARGS-INFO-CHANGED-VARS + COMPILER::C2LIST-NTH-IMMEDIATE COMPILER::CO1LDB + COMPILER::CO1WRITE-BYTE COMPILER::C1PROGN* + COMPILER::CO1CONSTANT-FOLD COMPILER::SET-JUMP-TRUE + COMPILER::C1SETQ1 COMPILER::CO1READ-CHAR COMPILER::C2BIND-INIT + COMPILER::CO1TYPEP COMPILER::WT-FIXNUM-VALUE + COMPILER::MULTIPLE-VALUE-CHECK COMPILER::SHIFT>> + COMPILER::CO1SUBLIS COMPILER::DO-MACRO-EXPANSION + COMPILER::C2UNWIND-PROTECT COMPILER::C2CALL-LAMBDA + COMPILER::C2MEMBER!2 COMPILER::GET-INLINE-LOC + COMPILER::C1LAMBDA-FUN COMPILER::JUMPS-TO-P COMPILER::C1EXPR* + COMPILER::C2SETQ COMPILER::C2APPLY COMPILER::UNWIND-BDS + COMPILER::SET-BDS-BIND COMPILER::NEED-TO-PROTECT + COMPILER::C1FMLA COMPILER::TYPE-AND COMPILER::CMPFIX-ARGS + COMPILER::MAYBE-EVAL COMPILER::C2BLOCK-CLB COMPILER::SET-DBIND + COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY + COMPILER::WT-LONG-FLOAT-VALUE COMPILER::C2DM-BIND-VL + COMPILER::WT-SHORT-FLOAT-VALUE COMPILER::T3SHARP-COMMA + COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES COMPILER::C2CATCH + COMPILER::C2EXPR-TOP* COMPILER::SET-JUMP-FALSE + COMPILER::CO1VECTOR-PUSH COMPILER::WT-V*-MACROS + COMPILER::ARGS-INFO-REFERRED-VARS COMPILER::SET-VS + COMPILER::WT-REQUIREDS COMPILER::C2RETURN-CCB + COMPILER::C2THROW COMPILER::CHECK-END + COMPILER::PUSH-CHANGED-VARS COMPILER::C2BLOCK-CCB + SYSTEM::ADD-DEBUG COMPILER::C2PSETQ COMPILER::C1ARGS + COMPILER::COMPILER-CC COMPILER::INLINE-PROC + COMPILER::CO1WRITE-CHAR COMPILER::COMPILER-DEF-HOOK + COMPILER::CAN-BE-REPLACED COMPILER::C2MULTIPLE-VALUE-PROG1 + COMPILER::C2DM-BIND-LOC COMPILER::ADD-INFO + COMPILER::CO1SPECIAL-FIX-DECL COMPILER::C2LAMBDA-EXPR-WITH-KEY + COMPILER::FAST-READ COMPILER::C2RETURN-CLB + COMPILER::PROCLAIM-VAR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - COMPILER::C2RETURN-LOCAL COMPILER::C2BLOCK-LOCAL - COMPILER::NCONC-FILES COMPILER::C1SYMBOL-FUN COMPILER::C2BLOCK - COMPILER::C1BODY COMPILER::COMPILER-BUILD - COMPILER::C2DECL-BODY COMPILER::WT-INLINE-LOC)) -(COMMON-LISP::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'SYSTEM::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(COMPILER::CMP-ANON COMMON-LISP::COMPILE COMPILER::CMP-TMP-MACRO - COMMON-LISP::DISASSEMBLE)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T (COMMON-LISP::VECTOR COMMON-LISP::T) - COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM - COMMON-LISP::T) - COMMON-LISP::FIXNUM) - COMPILER::BSEARCHLEQ)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T (COMMON-LISP::VECTOR COMMON-LISP::T) - COMMON-LISP::FIXNUM COMMON-LISP::T) - COMMON-LISP::FIXNUM) - COMPILER::PUSH-ARRAY)) + COMPILER::COMPILE-FILE1)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - COMPILER::AND-FORM-TYPE COMPILER::SET-VAR COMPILER::C2LET* - COMPILER::COMPILER-PASS2 COMPILER::ADD-FUNCTION-DECLARATION - COMPILER::BOOLE3 COMPILER::C1MAP-FUNCTIONS - COMPILER::TOO-MANY-ARGS COMPILER::CHECK-FORM-TYPE - COMPILER::C2LET COMPILER::C-FUNCTION-NAME - COMPILER::WT-INLINE-SHORT-FLOAT COMPILER::FIX-DOWN-ARGS - COMPILER::C2PRINC COMPILER::WT-IF-PROCLAIMED - COMPILER::ADD-FAST-LINK COMPILER::C2MULTIPLE-VALUE-BIND - COMPILER::C2MAPCAN COMPILER::CJT COMPILER::CHECK-VDECL - COMPILER::INLINE-TYPE-MATCHES COMPILER::WT-INLINE-LONG-FLOAT - COMPILER::C2GO COMPILER::CAN-BE-REPLACED* COMPILER::MYSUB - COMPILER::ASSIGN-DOWN-VARS COMPILER::C2MAPC - COMPILER::WT-INLINE-INTEGER COMPILER::GET-INLINE-INFO - COMPILER::CJF COMPILER::TOO-FEW-ARGS COMPILER::T3DEFCFUN - COMPILER::CMP-EXPAND-MACRO COMPILER::WT-MAKE-CCLOSURE - COMPILER::C2FUNCALL-SFUN COMPILER::C1DM - COMPILER::WT-INLINE-COND COMPILER::C2TAGBODY - COMPILER::WT-INLINE-CHARACTER COMPILER::C2PROGV - COMPILER::C2MAPCAR COMPILER::C1STRUCTURE-REF1 COMPILER::C2CASE - COMPILER::ADD-FUNCTION-PROCLAMATION - COMPILER::MAKE-INLINE-STRING COMPILER::SUBLIS1-INLINE - COMPILER::WT-INLINE-FIXNUM)) + COMPILER::MAKE-INLINE-STRING COMPILER::GET-INLINE-INFO + COMPILER::C1STRUCTURE-REF1 COMPILER::CJF COMPILER::SET-VAR + COMPILER::CHECK-FORM-TYPE COMPILER::AND-FORM-TYPE + COMPILER::SUBLIS1-INLINE COMPILER::T3DEFCFUN + COMPILER::WT-INLINE-INTEGER COMPILER::C-FUNCTION-NAME + COMPILER::FIX-DOWN-ARGS COMPILER::ASSIGN-DOWN-VARS + COMPILER::WT-INLINE-FIXNUM COMPILER::C2GO COMPILER::CJT + COMPILER::TOO-FEW-ARGS COMPILER::C2PRINC COMPILER::C2CASE + COMPILER::C2LET* COMPILER::BOOLE3 COMPILER::COMPILER-PASS2 + COMPILER::C1DM COMPILER::CHECK-VDECL COMPILER::C2LET + COMPILER::MYSUB COMPILER::CAN-BE-REPLACED* + COMPILER::ADD-FUNCTION-PROCLAMATION COMPILER::WT-IF-PROCLAIMED + COMPILER::C1MAP-FUNCTIONS COMPILER::ADD-FAST-LINK + COMPILER::WT-INLINE-LONG-FLOAT COMPILER::TOO-MANY-ARGS + COMPILER::C2MULTIPLE-VALUE-BIND COMPILER::C2PROGV + COMPILER::WT-INLINE-CHARACTER + COMPILER::ADD-FUNCTION-DECLARATION COMPILER::CMP-EXPAND-MACRO + COMPILER::C2MAPCAR COMPILER::INLINE-TYPE-MATCHES + COMPILER::C2FUNCALL-SFUN COMPILER::WT-MAKE-CCLOSURE + COMPILER::C2MAPCAN COMPILER::C2TAGBODY + COMPILER::WT-INLINE-COND COMPILER::C2MAPC + COMPILER::WT-INLINE-SHORT-FLOAT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMPILER::C2LAMBDA-EXPR COMPILER::C2FUNCALL COMPILER::LINK - COMPILER::INLINE-ARGS)) + COMPILER::T3LOCAL-FUN COMPILER::T3LOCAL-DCFUN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - COMPILER::C2STRUCTURE-REF COMPILER::WT-GLOBAL-ENTRY - COMPILER::T3DEFUN-VARARG COMPILER::T3DEFUN-NORMAL - COMPILER::C2CALL-GLOBAL COMPILER::C1MAKE-VAR - COMPILER::C2CALL-UNKNOWN-GLOBAL COMPILER::C2SWITCH - COMPILER::T3INIT-FUN COMPILER::MY-CALL)) + COMPILER::T3DEFMACRO COMPILER::T3DEFENTRY COMPILER::T2DEFENTRY + COMPILER::DEFSYSFUN COMPILER::T2DEFMACRO)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - COMPILER::DEFSYSFUN COMPILER::T2DEFMACRO COMPILER::T2DEFENTRY - COMPILER::T3DEFMACRO COMPILER::T3DEFENTRY)) + COMPILER::T3DEFUN COMPILER::T3DEFUN-LOCAL-ENTRY + COMPILER::C2STRUCTURE-SET COMPILER::T2DEFUN + COMPILER::C1APPLY-OPTIMIZE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMPILER::T2DEFUN COMPILER::C1APPLY-OPTIMIZE COMPILER::T3DEFUN - COMPILER::C2STRUCTURE-SET COMPILER::T3DEFUN-LOCAL-ENTRY)) + COMPILER::C2LAMBDA-EXPR COMPILER::C2FUNCALL + COMPILER::INLINE-ARGS COMPILER::LINK)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) + COMMON-LISP::T) COMMON-LISP::T) - COMPILER::WT-SIMPLE-CALL COMPILER::GET-OUTPUT-PATHNAME)) + COMPILER::T3INIT-FUN COMPILER::C2STRUCTURE-REF + COMPILER::WT-GLOBAL-ENTRY COMPILER::T3DEFUN-NORMAL + COMPILER::T3DEFUN-VARARG COMPILER::C1MAKE-VAR + COMPILER::C2SWITCH COMPILER::MY-CALL COMPILER::C2CALL-GLOBAL + COMPILER::C2CALL-UNKNOWN-GLOBAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) COMMON-LISP::T) - COMPILER::T3LOCAL-FUN COMPILER::T3LOCAL-DCFUN)) + COMPILER::GET-OUTPUT-PATHNAME COMPILER::WT-SIMPLE-CALL)) +(COMMON-LISP::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(COMPILER::CMP-ANON COMMON-LISP::COMPILE COMPILER::CMP-TMP-MACRO + COMMON-LISP::DISASSEMBLE)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + COMPILER::MAKE-VAR COMPILER::COMPILER-COMMAND + COMPILER::LIST*-INLINE COMMON-LISP::COMPILE-FILE + COMPILER::CS-PUSH COMPILER::MAKE-INFO COMPILER::FCALLN-INLINE + COMPILER::C2FSET COMPILER::MAKE-TAG COMPILER::WT-CLINK + COMPILER::LIST-INLINE COMPILER::MAKE-FUN COMPILER::MAKE-BLK)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - COMPILER::C2PROGN COMPILER::WT-LONG-FLOAT-LOC COMPILER::C2EXPR - COMPILER::WT-FIXNUM-LOC COMPILER::WT-CHARACTER-LOC - COMPILER::C2AND COMPILER::T1EXPR COMPILER::CMP-TOPLEVEL-EVAL - COMPILER::WT-SHORT-FLOAT-LOC COMPILER::C2OR COMPILER::WT-LOC - COMPILER::CMP-EVAL COMPILER::T1EVAL-WHEN COMPILER::SET-LOC - COMPILER::VV-STR COMPILER::WT-TO-STRING)) + COMPILER::T1EVAL-WHEN COMPILER::T1EXPR + COMPILER::WT-CHARACTER-LOC COMPILER::SET-LOC + COMPILER::CMP-TOPLEVEL-EVAL COMPILER::C2PROGN + COMPILER::WT-TO-STRING COMPILER::MEXPAND-DEFTYPE + COMPILER::WT-SHORT-FLOAT-LOC COMPILER::CMP-EVAL + COMPILER::WT-LOC COMPILER::C2AND COMPILER::C2EXPR + COMPILER::WT-LONG-FLOAT-LOC COMPILER::C2OR + COMPILER::WT-FIXNUM-LOC)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - COMPILER::MAKE-FUN COMPILER::MAKE-BLK - COMMON-LISP::COMPILE-FILE COMPILER::FCALLN-INLINE - COMPILER::MAKE-INFO COMPILER::CS-PUSH COMPILER::MAKE-VAR - COMPILER::LIST-INLINE COMPILER::C2FSET COMPILER::WT-CLINK - COMPILER::COMPILER-COMMAND COMPILER::MAKE-TAG - COMPILER::LIST*-INLINE)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) + COMPILER::LTVP-EVAL COMPILER::FSET-FN-NAME COMPILER::C1MAPCON + COMPILER::FUNCTION-ARG-TYPES COMPILER::C1SHARP-COMMA + COMPILER::SAVE-AVMA COMPILER::C2TAGBODY-CCB COMPILER::VAR-LOC + COMPILER::WT-DOWN COMPILER::C1SETQ COMPILER::TAG-REF-CCB + COMPILER::T1DEFINE-STRUCTURE COMPILER::SAVE-FUNOB + COMPILER::C1VAR COMPILER::VV-STR COMPILER::C1RPLACA + COMPILER::INFO-SP-CHANGE COMPILER::BLK-REF-CCB + COMPILER::T1ORDINARY COMPILER::FIXNUM-LOC-P + COMPILER::FUN-REF-CCB COMPILER::C2GET COMPILER::FUN-NAME + COMPILER::FUN-P COMPILER::SCH-GLOBAL COMPILER::C1LET + COMPILER::C2TAGBODY-CLB COMPILER::C1UNWIND-PROTECT + COMPILER::SET-RETURN COMPILER::WT-VAR-DECL + COMPILER::VAR-REGISTER COMPILER::C1DEFINE-STRUCTURE + COMPILER::LTVP COMPILER::INLINE-POSSIBLE COMPILER::CHECK-VREF + COMPILER::TAG-NAME COMPILER::C2DM-RESERVE-VL + COMPILER::VAR-TYPE COMPILER::WT-LIST COMPILER::C1LET* + COMPILER::VARARG-P COMPILER::C1LOAD-TIME-VALUE + COMPILER::C2FUNCALL-AUX COMPILER::INFO-TYPE COMPILER::C1GET + COMPILER::C1NTHCDR-CONDITION COMPILER::C1AND + COMPILER::C1MULTIPLE-VALUE-CALL COMPILER::C1RPLACA-NTHCDR + COMPILER::INFO-VOLATILE COMPILER::INLINE-TYPE + COMPILER::LONG-FLOAT-LOC-P COMPILER::INFO-CHANGED-ARRAY + SYSTEM::UNDEF-COMPILER-MACRO COMPILER::DECL-BODY-SAFETY + COMPILER::TAG-VAR COMPILER::CHARACTER-LOC-P COMPILER::C2BIND + COMPILER::C1DECLARE COMPILER::CONS-TO-LISTA + COMPILER::C1MULTIPLE-VALUE-SETQ COMPILER::NAME-SD1 + COMPILER::BLK-NAME COMPILER::PARSE-CVSPECS COMPILER::C1MAPL + COMPILER::AET-C-TYPE COMPILER::C2VAR COMPILER::COPY-INFO + COMPILER::C1PSETQ COMPILER::C1VREF COMPILER::FUN-REF + COMPILER::WT-H1 COMPILER::T1DEFCFUN COMPILER::T1PROGN + COMPILER::C1EVAL-WHEN COMPILER::FLAGS-POS COMPILER::WT-VS + COMPILER::C2VAR-KIND COMPILER::C1LENGTH + COMPILER::C1MULTIPLE-VALUE-BIND COMPILER::C2LOCATION + COMPILER::C2DM-RESERVE-V COMPILER::C2FUNCTION + COMPILER::WT-SWITCH-CASE COMPILER::C2TAGBODY-LOCAL + COMPILER::CONSTANT-FOLD-P COMPILER::NEED-TO-SET-VS-POINTERS + COMPILER::C1MAPCAN COMPILER::WT-FUNCALL-C COMPILER::WT-CCB-VS + COMPILER::C1RETURN-FROM COMPILER::GET-INCLUDED + COMPILER::C1BLOCK COMPILER::ADD-CONSTANT COMPILER::WT-VS-BASE + COMPILER::C1NTH-CONDITION COMPILER::FUN-LEVEL + COMPILER::UNWIND-NO-EXIT COMMON-LISP::PROCLAIM + COMPILER::C1PRINC COMPILER::C2EXPR* COMPILER::RESULT-TYPE + COMPILER::TAG-REF COMPILER::C1FUNCALL COMPILER::C1PROGN + COMPILER::MAXARGS COMPILER::UNDEFINED-VARIABLE COMPILER::C1THE + COMPILER::CMP-MACROEXPAND COMPILER::C1MAPCAR + COMPILER::DEFAULT-INIT COMPILER::C1STRUCTURE-SET + COMPILER::WT-SYMBOL-FUNCTION COMPILER::T1DEFUN + COMPILER::WT-DATA1 COMPILER::PUSH-DATA-INCF COMPILER::C1IF + COMPILER::C1NTHCDR COMPILER::ADD-SYMBOL + COMPILER::C1MULTIPLE-VALUE-PROG1 COMPILER::BLK-REF + COMPILER::WT-FUNCTION-LINK COMPILER::INFO-P COMPILER::C1FSET + COMPILER::C1PROGV COMPILER::C1ASSOC COMPILER::VAR-REF + COMPILER::ARGS-CAUSE-SIDE-EFFECT COMPILER::MDELETE-FILE + COMPILER::CMP-MACRO-FUNCTION COMPILER::C2DOWNWARD-FUNCTION + COMPILER::C2GO-LOCAL COMPILER::T1DEFLA COMPILER::VAR-REF-CCB + COMPILER::C1FLET COMPILER::C1LIST-NTH + COMPILER::ADD-LOOP-REGISTERS COMPILER::INFO-REFERRED-ARRAY + COMPILER::BLK-VALUE-TO-GO COMPILER::WT-VS* + COMPILER::NAME-TO-SD COMPILER::C1RPLACD + COMPILER::WT-DATA-PACKAGE-OPERATION COMPILER::C1SWITCH + COMPILER::C1CATCH COMPILER::WT-CAR COMPILER::C1MACROLET + COMPILER::OBJECT-TYPE COMPILER::C1MAPC COMPILER::T1CLINES + COMPILER::C1COMPILER-LET COMPILER::CMP-MACROEXPAND-1 + COMPILER::C1TAGBODY COMPILER::C1MAPLIST COMPILER::PUSH-ARGS + COMPILER::T3ORDINARY COMPILER::C1MEMBER COMPILER::T1MACROLET + COMPILER::WT-CDR COMPILER::C1BOOLE3 COMPILER::PROCLAMATION + COMPILER::GET-LOCAL-RETURN-TYPE COMPILER::C1LOCAL-FUN + COMPILER::VAR-KIND COMPILER::WT1 COMPILER::TAG-SWITCH + COMPILER::C1OR COMPILER::C1STRUCTURE-REF + COMPILER::THE-PARAMETER COMPILER::VAR-REP-LOC + COMPILER::DECLARATION-TYPE COMPILER::TAG-P COMPILER::C2GETHASH + COMPILER::C1EXPR COMPILER::REPLACE-CONSTANT COMPILER::C1ECASE + COMPILER::FUN-CFUN COMPILER::SET-TOP COMPILER::TAG-LABEL + COMPILER::C1DM-BAD-KEY COMPILER::C1THROW COMPILER::C2GO-CCB + COMPILER::REP-TYPE COMPILER::C2VALUES + COMPILER::SHORT-FLOAT-LOC-P COMPILER::FUNCTION-RETURN-TYPE + COMPILER::ADD-OBJECT COMPILER::CTOP-WRITE COMPILER::C1MEMQ + COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::C1TERPRI + COMPILER::T1DEFMACRO COMPILER::T3CLINES COMPILER::ADD-REG1 + COMPILER::C1NTH COMPILER::C1ASH COMPILER::C1FMLA-CONSTANT + COMPILER::C2GO-CLB COMPILER::WT-CADR + COMPILER::C1BOOLE-CONDITION COMPILER::CLINK COMPILER::VAR-NAME + COMPILER::PUSH-ARGS-LISPCALL COMPILER::GET-ARG-TYPES + COMPILER::BLK-VAR COMPILER::C1APPLY COMPILER::CHECK-DOWNWARD + COMPILER::C1QUOTE COMPILER::TAG-REF-CLB + COMPILER::GET-LOCAL-ARG-TYPES COMPILER::REGISTER + COMPILER::BLK-P COMPILER::FUN-INFO COMPILER::C2RPLACD + COMPILER::ADD-OBJECT2 COMPILER::C2TAGBODY-BODY + COMPILER::T1DEFENTRY COMPILER::C1FUNCTION + COMPILER::C1DOWNWARD-FUNCTION COMPILER::SAFE-SYSTEM + COMPILER::C1GO COMPILER::BLK-EXIT COMPILER::VERIFY-DATA-VECTOR + COMPILER::C2RPLACA COMPILER::T2DECLARE COMPILER::MACRO-DEF-P + COMPILER::C1LABELS COMPILER::C1GETHASH COMPILER::FIX-OPT + COMPILER::SCH-LOCAL-FUN COMPILER::C1FUNOB + COMPILER::SET-PUSH-CATCH-FRAME COMPILER::GET-RETURN-TYPE + COMPILER::SET-UP-VAR-CVS COMPILER::TAG-UNWIND-EXIT + COMPILER::VAR-P COMPILER::C1ADD-GLOBALS COMPILER::TYPE-FILTER + COMPILER::WT-VV COMPILER::C1ASH-CONDITION COMPILER::VOLATILE + COMPILER::INLINE-BOOLE3-STRING COMPILER::C1LOCAL-CLOSURE + COMPILER::WRITE-BLOCK-OPEN COMPILER::ADD-ADDRESS + COMPILER::RESET-INFO-TYPE COMPILER::C1VALUES + COMPILER::BLK-REF-CLB COMPILER::C1STACK-LET)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) + COMPILER::INLINE-BOOLE3)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION ((COMMON-LISP::VECTOR COMMON-LISP::T)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - COMPILER::COPY-ARRAY)) + COMPILER::MEMOIZED-HASH-EQUAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + COMPILER::WT-INLINE-LOC COMPILER::NCONC-FILES + COMPILER::COMPILER-BUILD COMPILER::C2BLOCK-LOCAL + COMPILER::C2DECL-BODY COMPILER::C1SYMBOL-FUN COMPILER::C2BLOCK + COMPILER::C1BODY COMPILER::C2RETURN-LOCAL)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMPILER::C2EXPR-TOP COMPILER::CO1SUBLIS - COMPILER::C2CALL-LAMBDA COMPILER::GET-INLINE-LOC - COMPILER::CHECK-END COMPILER::C2PSETQ COMPILER::TYPE-AND - COMPILER::TYPE>= COMPILER::C2MULTIPLE-VALUE-PROG1 - COMPILER::CO1SCHAR SYSTEM::ADD-DEBUG COMPILER::C2BLOCK-CCB - COMPILER::C2DM-BIND-VL COMPILER::MAKE-USER-INIT - COMPILER::NEED-TO-PROTECT COMPILER::FAST-READ - COMPILER::RESULT-TYPE-FROM-ARGS COMPILER::C2BIND-INIT - COMPILER::JUMPS-TO-P COMPILER::C2MEMBER!2 - COMPILER::C2CALL-LOCAL COMPILER::C2BLOCK-CLB - COMPILER::ARGS-INFO-CHANGED-VARS COMPILER::INLINE-PROC - COMPILER::C2THROW COMPILER::C1DECL-BODY - COMPILER::WT-MAKE-DCLOSURE COMPILER::CO1WRITE-CHAR - COMPILER::C1SETQ1 COMPILER::SET-JUMP-FALSE COMPILER::CO1CONS - COMPILER::CO1VECTOR-PUSH COMPILER::SET-VS COMPILER::SHIFT>> - COMPILER::COERCE-LOC-STRUCTURE-REF COMPILER::WT-FIXNUM-VALUE - COMPILER::C2CATCH COMPILER::C2RETURN-CCB COMPILER::MAYBE-EVAL - COMPILER::C2ASSOC!2 COMPILER::C2DM-BIND-INIT - COMPILER::C2STACK-LET COMPILER::C2LAMBDA-EXPR-WITH-KEY - COMPILER::ARGS-INFO-REFERRED-VARS - COMPILER::C2MULTIPLE-VALUE-SETQ COMPILER::C1PROGN* - COMPILER::WT-LONG-FLOAT-VALUE COMPILER::C2MULTIPLE-VALUE-CALL - COMPILER::WT-SHORT-FLOAT-VALUE COMPILER::CO1CONSTANT-FOLD - COMPILER::C1CONSTANT-VALUE COMPILER::C1EXPR* - COMPILER::CO1SPECIAL-FIX-DECL COMPILER::C2RETURN-CLB - COMPILER::CMPFIX-ARGS COMPILER::PROCLAIM-VAR COMPILER::C2APPLY - COMPILER::DO-MACRO-EXPANSION COMPILER::CFAST-WRITE - COMPILER::PRIN1-CMP COMPILER::SHIFT<< COMPILER::WT-REQUIREDS - COMPILER::C2EXPR-TOP* COMPILER::UNWIND-BDS - COMPILER::MULTIPLE-VALUE-CHECK COMPILER::COERCE-LOC - COMPILER::STRUCT-TYPE-OPT COMPILER::CO1READ-CHAR - COMPILER::ADD-DEBUG-INFO COMPILER::C2LIST-NTH-IMMEDIATE - COMPILER::WT-VAR COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY - COMPILER::CHECK-FNAME-ARGS COMPILER::CAN-BE-REPLACED - COMPILER::WT-CHARACTER-VALUE COMPILER::C2UNWIND-PROTECT - COMPILER::SET-DBIND COMPILER::T3SHARP-COMMA - COMPILER::IS-REP-REFERRED COMPILER::C1FMLA - COMPILER::WT-V*-MACROS COMPILER::C2DM-BIND-LOC - COMPILER::C2BIND-LOC - COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES - COMPILER::ADD-INFO COMPILER::C2SETQ - COMPILER::PUSH-CHANGED-VARS COMPILER::CO1STRUCTURE-PREDICATE - COMPILER::SET-BDS-BIND COMPILER::SET-JUMP-TRUE - COMPILER::CO1READ-BYTE COMPILER::C1LAMBDA-FUN - COMPILER::CO1TYPEP COMPILER::CONVERT-CASE-TO-SWITCH - COMPILER::COMPILER-DEF-HOOK COMPILER::CO1LDB COMPILER::C1ARGS - COMPILER::CO1WRITE-BYTE COMPILER::CO1EQL - COMPILER::COMPILER-CC)) + COMPILER::C1LAMBDA-EXPR COMPILER::CMPWARN COMPILER::ADD-INIT + COMPILER::UNWIND-EXIT COMPILER::CMPNOTE COMPILER::CMPERR + COMPILER::C1CASE COMPILER::WT-COMMENT COMPILER::INIT-NAME + COMPILER::FAST-LINK-PROCLAIMED-TYPE-P COMPILER::WT-INTEGER-LOC + COMPILER::WT-CVAR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM) COMMON-LISP::T) - COMPILER::MLIN)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + COMPILER::C2IF COMPILER::WT-INLINE COMPILER::C2COMPILER-LET + COMPILER::C2FLET COMPILER::C2LABELS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) COMMON-LISP::*) - COMPILER::COMPILE-FILE1)) + COMPILER::C2RETURN-FROM COMPILER::C2APPLY-OPTIMIZE + COMPILER::C2DM COMPILER::C1DM-V COMPILER::C1DM-VL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - COMPILER::WT-DATA-BEGIN COMPILER::WT-C-PUSH COMPILER::WT-CVARS - COMPILER::C1T COMPILER::CVS-PUSH COMPILER::WT-DATA-FILE - COMPILER::ADD-LOAD-TIME-SHARP-COMMA - COMPILER::CLOSE-INLINE-BLOCKS COMPILER::WT-FASD-DATA-FILE - COMPILER::GAZONK-NAME COMPILER::WFS-ERROR - COMPILER::WT-NEXT-VAR-ARG COMPILER::WT-FIRST-VAR-ARG - COMPILER::C1NIL COMPILER::WT-DATA-END COMPILER::RESET-TOP - COMPILER::TAIL-RECURSION-POSSIBLE - COMPILER::PRINT-COMPILER-INFO COMPILER::CCB-VS-PUSH - COMPILER::BABOON COMPILER::INIT-ENV - COMPILER::PRINT-CURRENT-FORM COMPILER::VS-PUSH - COMPILER::INC-INLINE-BLOCKS)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + COMPILER::T3DEFUN-AUX)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::FIXNUM) + (COMMON-LISP::FUNCTION + ((COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*))) COMMON-LISP::T) - COMPILER::MEMOIZED-HASH-EQUAL)) + COMPILER::COPY-ARRAY)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T + (COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*)) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T) COMMON-LISP::FIXNUM) - COMPILER::PROCLAIMED-ARGD COMPILER::ANALYZE-REGS1 - COMPILER::ANALYZE-REGS)) + COMPILER::BSEARCHLEQ)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::STRING COMMON-LISP::FIXNUM - COMMON-LISP::FIXNUM) - COMMON-LISP::T) - COMPILER::DASH-TO-UNDERSCORE-INT)) \ No newline at end of file + (COMMON-LISP::T + (COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*)) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T) + COMMON-LISP::FIXNUM) + COMPILER::PUSH-ARRAY)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) + COMPILER::F-TYPE)) \ No newline at end of file diff --git a/configure b/configure index 3bab4ae..da90182 100755 --- a/configure +++ b/configure @@ -3980,7 +3980,7 @@ add_args_to_cflags -fsigned-char -pipe \ -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \ -Wno-unused-but-set-variable -Wno-misleading-indentation -add_args_to_ldflags -Wl,-no_pie -no-pie -Wl,-z,lazy +add_args_to_ldflags -no-pie -Wl,-z,lazy { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clang" >&5 $as_echo_n "checking for clang... " >&6; } diff --git a/configure.in b/configure.in index 4c85b6d..bdb3630 100644 --- a/configure.in +++ b/configure.in @@ -264,7 +264,7 @@ add_args_to_cflags -fsigned-char -pipe \ -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \ -Wno-unused-but-set-variable -Wno-misleading-indentation -add_args_to_ldflags -Wl,-no_pie -no-pie -Wl,-z,lazy +add_args_to_ldflags -no-pie -Wl,-z,lazy AC_MSG_CHECKING([for clang]) AC_RUN_IFELSE( diff --git a/gcl-tk/socketsl.lisp b/gcl-tk/socketsl.lisp index 1d6a66a..ba1d2f7 100755 --- a/gcl-tk/socketsl.lisp +++ b/gcl-tk/socketsl.lisp @@ -12,10 +12,6 @@ (defentry our-write (int object int ) (int "our_write_object")) (defentry print-to-string1 (object object object) (object print_to_string1)) -(clines "#define reset_string_input_stream1(strm,string,start,end) reset_string_input_stream(strm,string,fix(start),fix(end))") -(defentry reset-string-input-stream (object object object object) (object "reset_string_input_stream1")) - - ;(clines "#define symbol_value_any(x) ((x)->s.s_dbind)") ;(defentry symbol-value-any (object) (object symbol_value_any)) diff --git a/gcl-tk/tkl.lisp b/gcl-tk/tkl.lisp index 3d4e78e..f8fdee1 100755 --- a/gcl-tk/tkl.lisp +++ b/gcl-tk/tkl.lisp @@ -293,6 +293,9 @@ (let () (send-tcl-cmd *tk-connection* tk-command nil)))) +(defun fsubseq (s &optional (b 0) (e (length s))) + (make-array (- e b) :element-type (array-element-type s) :displaced-to s :displaced-index-offset b :fill-pointer (- e b))) + (defun send-tcl-cmd (c str send-and-wait ) ;(notice-text-variables) (or send-and-wait (setq send-and-wait *send-and-wait*)) @@ -308,7 +311,7 @@ (cond (send-and-wait (if *debugging* - (store-circle *requests* (subseq str #.(length *header*)) + (store-circle *requests* (fsubseq str #.(length *header*)) msg-id)) (store-circle *replies* nil msg-id) (execute-tcl-cmd c str)) @@ -932,7 +935,7 @@ #.(+ 1 (length *header*)) 3)) (values - (subseq str #.(+ 4 (length *header*))) + (fsubseq str #.(+ 4 (length *header*))) (eql (aref str #.(+ 1 (length *header*))) #\0) reply-from (get-circle *requests* reply-from))) @@ -1082,7 +1085,7 @@ (store-circle *replies* (cons success (if (eql (length tk-command) #.(+ 4 (length *header*))) "" - (subseq tk-command #.(+ 4 (length *header*))))) + (fsubseq tk-command #.(+ 4 (length *header*))))) from-id)) (#.(pos m_call *mtypes*) ;; Can play a game of if read-and-act called with request-id: @@ -1114,7 +1117,7 @@ (var (aref *text-variable-locations* lisp-var-id)) (type (get var 'linked-variable-type)) val) - (setq val (coerce-result (subseq tk-command #.(+ 3 (length *header*))) type)) + (setq val (coerce-result (fsubseq tk-command #.(+ 3 (length *header*))) type)) (setf (aref *text-variable-locations* (the fixnum ( + lisp-var-id 1))) val) @@ -1130,7 +1133,9 @@ (let* ((s (car *string-streams*)) (*string-streams* (cdr *string-streams*))) (or s (setq s (make-string-input-stream ""))) - (si::reset-string-input-stream s string start (length string)) + (assert (array-has-fill-pointer-p string)) + (setf (fill-pointer string) start) + (si::c-set-stream-object0 s string) (read s nil nil))) @@ -1196,7 +1201,7 @@ (cond (skipping nil) ((eql brace-level 0) (if (> i beg) - (setq ans (cons (subseq x beg i) ans))) + (setq ans (cons (fsubseq x beg i) ans))) (setq beg (+ i 1)) ))) @@ -1207,12 +1212,12 @@ (setq beg (+ i 1)))) (incf brace-level)) (#\} (cond ((eql brace-level 1) - (setq ans (cons (subseq x beg i) ans)) + (setq ans (cons (fsubseq x beg i) ans)) (setq skipping t))) (incf brace-level -1))))) finally (unless skipping - (setq ans (cons (subseq x beg i) ans))) + (setq ans (cons (fsubseq x beg i) ans))) (return (nreverse ans)) )) @@ -1394,7 +1399,7 @@ (cond (start (pp v no_leading_space) (setq start nil)) (t (pp v normal))) (setf x (cdr x))) - (subseq tk-command #.(length *header*)))) + (fsubseq tk-command #.(length *header*)))) @@ -1409,7 +1414,6 @@ (setq gcltksrv (cond (host "gcltksrv") ((si::getenv "GCL_TK_SERVER")) - ((probe-file (tk-conc si::*lib-directory* "/gcl-tk/gcltksrv"))) ((probe-file (tk-conc si::*lib-directory* "gcl-tk/gcltksrv"))) (t (error "Must setenv GCL_TK_SERVER "))))) (let ((pid (if host -1 (si::getpid))) @@ -1427,9 +1431,9 @@ args ))) (print command) - (cond ((not host) (system command)) + (cond ((not host) (si::system command)) (can-rsh - (system (tk-conc "rsh " host " " command + (si::system (tk-conc "rsh " host " " command " < /dev/null &"))) (t (format t "Waiting for you to invoke GCL_TK_SERVER, on ~a as in: ~s~%" host command ))) diff --git a/h/compprotos.h b/h/compprotos.h index 25d51ba..2de7bbb 100644 --- a/h/compprotos.h +++ b/h/compprotos.h @@ -180,3 +180,4 @@ char *gcl_gets(char *,int); int gcl_puts(const char *); int endp_error(object); object Icall_gen_error_handler(object,object,object,object,ufixnum,...); +object file_stream(object); diff --git a/h/lu.h b/h/lu.h index 201da4f..aa8340b 100644 --- a/h/lu.h +++ b/h/lu.h @@ -271,15 +271,14 @@ struct structure { struct stream { FIRSTWORD; - void *sm_fp; - object sm_object0; - object sm_object1; - int sm_int0; - int sm_int1; - char *sm_buffer; - char sm_mode; - unsigned char sm_flags; - short sm_fd; + void *sm_fp; + object sm_object0; + object sm_object1; + char *sm_buffer; + ufixnum sm_mode:4; + ufixnum sm_flags:6; + ufixnum sm_fd:6; + ufixnum sm_int:LM(16); }; struct random { diff --git a/h/object.h b/h/object.h index 3129b67..8cde395 100755 --- a/h/object.h +++ b/h/object.h @@ -166,18 +166,18 @@ enum aelttype { /* array element type */ /* for any stream that takes writec_char, directly (not two_way or echo) ie. smm_output,smm_io, smm_string_output, smm_socket */ -#define STREAM_FILE_COLUMN(str) ((str)->sm.sm_int1) +#define STREAM_FILE_COLUMN(str) ((str)->sm.sm_int) /* for smm_echo */ -#define ECHO_STREAM_N_UNREAD(strm) ((strm)->sm.sm_int0) +#define ECHO_STREAM_N_UNREAD(strm) ((strm)->sm.sm_int) /* file fd for socket */ #define SOCKET_STREAM_FD(strm) ((strm)->sm.sm_fd) #define SOCKET_STREAM_BUFFER(strm) ((strm)->sm.sm_object1) /* for smm_string_input */ -#define STRING_INPUT_STREAM_NEXT(strm) ((strm)->sm.sm_int0) -#define STRING_INPUT_STREAM_END(strm) ((strm)->sm.sm_int1) +#define STRING_INPUT_STREAM_NEXT(strm) ((strm)->sm.sm_object0->st.st_fillp) +#define STRING_INPUT_STREAM_END(strm) ((strm)->sm.sm_object0->st.st_dim) /* for smm_two_way and smm_echo */ #define STREAM_OUTPUT_STREAM(strm) ((strm)->sm.sm_object1) diff --git a/h/type.h b/h/type.h index dd584bd..1e778d9 100644 --- a/h/type.h +++ b/h/type.h @@ -41,7 +41,6 @@ enum smmode { /* stream mode */ smm_output, /* output */ smm_io, /* input-output */ smm_probe, /* probe */ - smm_file_synonym, /* synonym stream to file_stream */ smm_synonym, /* synonym */ smm_broadcast, /* broadcast */ smm_concatenated, /* concatenated */ @@ -152,5 +151,4 @@ enum smmode { /* stream mode */ #define pathname_string_symbol_streamp(a_) ({enum type _tp=type_of(a_); _tp==t_pathname || _tp == t_string\ || _tp == t_symbol || _tp==t_stream;}) -#define pathname_designatorp(a_) ({object _a=(a_);enum type _tp=type_of(a_);\ - _tp==t_pathname||_tp==t_string||(_tp==t_stream && _a->sm.sm_mode>=smm_input && _a->sm.sm_mode<=smm_file_synonym);}) +#define pathname_designatorp(a_) ({object _a=(a_);enum type _tp=type_of(a_);_tp==t_pathname||_tp==t_string||file_stream(_a)!=Cnil;}) diff --git a/lsp/gcl_directory.lsp b/lsp/gcl_directory.lsp index 2a7142e..a33a1b2 100644 --- a/lsp/gcl_directory.lsp +++ b/lsp/gcl_directory.lsp @@ -74,4 +74,12 @@ (let ((r (with-open-file (s (apply 'string-concatenate "|" #-winnt "which " #+winnt "for %i in (" s #+winnt ".exe) do @echo.%~$PATH:i" nil)) (read-line s nil 'eof)))) - (if (eq r 'eof) s (string-downcase r)))) + (unless (eq r 'eof) + (string-downcase r)))) + +(defun get-path (s &aux + (e (unless (minusp (string-match #v"([^\n\t\r ]+)([\n\t\r ]|$)" s))(match-end 1))) + (w (when e (which (pathname-name (subseq s (match-beginning 1) e)))))) + (when w + (string-concatenate w (subseq s e)))) + diff --git a/lsp/gcl_iolib.lsp b/lsp/gcl_iolib.lsp index 98df8ca..4453e72 100755 --- a/lsp/gcl_iolib.lsp +++ b/lsp/gcl_iolib.lsp @@ -69,7 +69,20 @@ (progn ,@b) (close ,var))))) -(defmacro with-input-from-string ((var string &key index start end) . body) +(defun make-string-input-stream (string &optional (start 0) end) + (declare (optimize (safety 1))) + (check-type string string) + (check-type start seqind) + (check-type end (or null seqind)) + (let ((l (- (or end (length string)) start))) + (make-string-input-stream-int + (make-array l :element-type (array-element-type string) :displaced-to string :displaced-index-offset start :fill-pointer 0) + 0 l))) + +(defun get-string-input-stream-index (stream &aux (s (c-stream-object0 stream))) + (+ (fill-pointer s) (multiple-value-bind (a b) (array-displacement s) b))) + +(defmacro with-input-from-string ((var string &key index (start 0) end) . body) (declare (optimize (safety 1))) (multiple-value-bind (ds b) (find-declarations body) `(let ((,var (make-string-input-stream ,string ,start ,end))) @@ -77,7 +90,8 @@ (unwind-protect (multiple-value-prog1 (progn ,@b) - ,@(when index `((setf ,index (get-string-input-stream-index ,var))))) + ,@(when index + `((setf ,index (get-string-input-stream-index ,var))))) (close ,var))))) (defmacro with-output-to-string ((var &optional string &key element-type) . body) @@ -406,7 +420,7 @@ (defun write-sequence (seq strm &rest r &key (start 0) end - &aux (l (listp seq))(cp (eq (stream-element-type strm) 'character))) + &aux (cp (eq (stream-element-type strm) 'character))) (declare (optimize (safety 1))(dynamic-extent r)) (check-type seq sequence) (check-type strm stream) @@ -443,9 +457,15 @@ if-exists iesp if-does-not-exist idnesp external-format))) (when (typep s 'stream) (c-set-stream-object1 s pf) s))) +(defun load-pathname-exists (z) + (or (probe-file z) + (when *allow-gzipped-file* + (when (probe-file (string-concatenate (namestring z) ".gz")) + z)))) + (defun load-pathname (p print if-does-not-exist external-format &aux (pp (merge-pathnames p)) - (epp (reduce (lambda (y x) (or y (probe-file (translate-pathname x "" p)))) + (epp (reduce (lambda (y x) (or y (load-pathname-exists (translate-pathname x "" p)))) '(#P".o" #P".lsp" #P".lisp" #P"") :initial-value nil)));FIXME newest? (if epp (let* ((*load-pathname* pp)(*load-truename* epp)) @@ -484,3 +504,36 @@ (d pd (cdr pd))) (values ps created))) +(defun file-length (x) + (declare (optimize (safety 1))) + (check-type x (or broadcast-stream file-stream)) + (if (typep x 'broadcast-stream) + (let ((s (broadcast-stream-streams x))) (if s (file-length (car (last s))) 0)) + (multiple-value-bind (tp sz) (stat x) + (declare (ignore tp)) + (/ sz (get-byte-stream-nchars x))))) + +(defun file-position (x &optional (pos :start pos-p)) + (declare (optimize (safety 1))) + (check-type x (or broadcast-stream file-stream string-stream)) + (check-type pos (or (member :start :end) (integer 0))) + (typecase x + (broadcast-stream + (let ((s (car (last (broadcast-stream-streams x))))) + (if s (if pos-p (file-position s pos) (file-position s)) 0))) + (string-stream + (let* ((st (c-stream-object0 x))(l (length st))(d (array-dimension st 0)) + (p (case pos (:start 0) (:end l) (otherwise pos)))) + (if pos-p (when (<= p d) (setf (fill-pointer st) p)) l))) + (otherwise + (let ((n (get-byte-stream-nchars x)) + (p (case pos (:start 0) (:end (file-length x)) (otherwise pos)))) + (if pos-p (when (fseek x (* p n)) p) (/ (ftell x) n)))))) + +(defun file-string-length (strm obj) + (let* ((pos (file-position strm)) + (w (write obj :stream strm :escape nil :readably nil)) + (pos1 (file-position strm)));(break) + (declare (ignore w)) + (file-position strm pos) + (- pos1 pos))) diff --git a/lsp/gcl_namestring.lsp b/lsp/gcl_namestring.lsp index 704b4ac..d575f36 100644 --- a/lsp/gcl_namestring.lsp +++ b/lsp/gcl_namestring.lsp @@ -27,7 +27,7 @@ (declare (optimize (safety 1))) (check-type x pathname-designator) (check-type def pathname-designator) - ,(labels ((new? (k &aux (f (intern (concatenate 'string "PATHNAME-" (string k)) :si))) + ,(labels ((new? (k &aux (f (intern (string-concatenate "PATHNAME-" (string k)) :si))) `(let ((k (,f px))) (unless (equal k (,f pdef)) k)))) `(namestring (make-pathname ,@(mapcan (lambda (x) (list x (new? x))) +pathname-keys+))))) diff --git a/lsp/gcl_predlib.lsp b/lsp/gcl_predlib.lsp index df0dbbf..791b917 100755 --- a/lsp/gcl_predlib.lsp +++ b/lsp/gcl_predlib.lsp @@ -125,6 +125,8 @@ (character . characterp) (package . packagep) (stream . streamp) + (string-input-stream . string-input-stream-p) + (string-output-stream . string-output-stream-p) (file-stream . file-stream-p) (synonym-stream . synonym-stream-p) (broadcast-stream . broadcast-stream-p) diff --git a/lsp/gcl_restart.lsp b/lsp/gcl_restart.lsp index 139debb..0c9aa35 100644 --- a/lsp/gcl_restart.lsp +++ b/lsp/gcl_restart.lsp @@ -73,7 +73,7 @@ &aux rr (report (if (stringp report) `(lambda (s) (write-string ,report s)) report))) (macrolet ((do-setf (x) `(when ,x - (setf (getf rr ,(intern (concatenate 'string (symbol-name x) "-FUNCTION") :keyword)) + (setf (getf rr ,(intern (string-concatenate (symbol-name x) "-FUNCTION") :keyword)) (list 'function ,x))))) (do-setf report) (do-setf interactive) diff --git a/lsp/gcl_serror.lsp b/lsp/gcl_serror.lsp index df4ceda..95f0c9a 100755 --- a/lsp/gcl_serror.lsp +++ b/lsp/gcl_serror.lsp @@ -2,11 +2,11 @@ (in-package :si) (macrolet - ((make-conditionp (condition &aux (n (intern (concatenate 'string (string condition) "P")))) + ((make-conditionp (condition &aux (n (intern (string-concatenate (string condition) "P")))) `(defun ,n (x &aux (z (si-find-class ',condition))) (when z (funcall (setf (symbol-function ',n) (lambda (x) (typep x z))) x)))) - (make-condition-classp (class &aux (n (intern (concatenate 'string (string class) "-CLASS-P")))) + (make-condition-classp (class &aux (n (intern (string-concatenate (string class) "-CLASS-P")))) `(defun ,n (x &aux (s (si-find-class 'standard-class)) (z (si-find-class ',class))) (when (and s z) (funcall (setf (symbol-function ',n) @@ -124,9 +124,9 @@ (defun process-error (datum args &optional (default-type 'simple-error)) (let ((internal (cond ((simple-condition-class-p datum) - (find-symbol (concatenate 'string "INTERNAL-" (string datum)) :conditions)) + (find-symbol (string-concatenate "INTERNAL-" (string datum)) :conditions)) ((condition-class-p datum) - (find-symbol (concatenate 'string "INTERNAL-SIMPLE-" (string datum)) :conditions))))) + (find-symbol (string-concatenate "INTERNAL-SIMPLE-" (string datum)) :conditions))))) (coerce-to-condition (or internal datum) (if internal (list* :function-name *sig-fn-name* args) args) default-type 'process-error))) (defun universal-error-handler (n cp fn cs es &rest args &aux (*sig-fn-name* fn)) diff --git a/lsp/gcl_top.lsp b/lsp/gcl_top.lsp index 1b61ba7..a611971 100755 --- a/lsp/gcl_top.lsp +++ b/lsp/gcl_top.lsp @@ -593,12 +593,11 @@ First directory is checked for first name and all extensions etc." (when (eq (stat x) :directory) (return-from get-temp-dir x)))))) -(defun get-path (s &aux (m (string-match "([^ ]*)( |$)" s))(b (match-beginning 1))(e (match-end 1))) - (string-concatenate (which (pathname-name (subseq s b e))) (subseq s e))) + (defvar *cc* "cc") (defvar *ld* "ld") -(defvar *objdump* "objdump --source ") +(defvar *objdump* nil) (defvar *current-directory* *system-directory*) @@ -608,9 +607,9 @@ First directory is checked for first name and all extensions etc." (declare (fixnum i)) (setq *current-directory* (current-directory-pathname)) (setq *tmp-dir* (get-temp-dir) - *cc* (get-path *cc*) - *ld* (get-path *ld*) - *objdump* (get-path *objdump*)) + *cc* (or (get-path *cc*) *cc*) + *ld* (or (get-path *ld*) *ld*) + *objdump* (get-path "objdump --source ")) (dotimes (j i) (push (argv j) tem)) (setq *command-args* (nreverse tem)) (setq tem *lib-directory*) diff --git a/lsp/gcl_translate_pathname.lsp b/lsp/gcl_translate_pathname.lsp index ace0ce2..1985b1c 100644 --- a/lsp/gcl_translate_pathname.lsp +++ b/lsp/gcl_translate_pathname.lsp @@ -32,7 +32,7 @@ (defun do-repl (x y) (labels ((r (x l &optional (b 0) &aux (f (string-match #v"\\*" x b))) (if (eql f -1) (if (eql b 0) x (subseq x b)) - (concatenate 'string (subseq x b f) (or (car l) "") (r x (cdr l) (1+ f)))))) + (string-concatenate (subseq x b f) (or (car l) "") (r x (cdr l) (1+ f)))))) (r y x))) (defun dir-p (x) (when (consp x) (member (car x) '(:absolute :relative)))) diff --git a/lsp/sys-proclaim.lisp b/lsp/sys-proclaim.lisp index 70040f4..21b6856 100755 --- a/lsp/sys-proclaim.lisp +++ b/lsp/sys-proclaim.lisp @@ -4,229 +4,269 @@ '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER - COMMON-LISP::*) - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::FIXNUM) - SYSTEM::ATOI)) + COMMON-LISP::*)) + COMMON-LISP::T) + SYSTEM::RESET-SYS-PATHS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::OR COMMON-LISP::NULL - COMMON-LISP::HASH-TABLE)) - SYSTEM::CONTEXT-HASH)) + (COMMON-LISP::VECTOR COMMON-LISP::T)) + SYSTEM::CONTEXT-VEC)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST SYSTEM::PARSE-DEFMACRO)) + ((COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::T) + SYSTEM::PUSH-CONTEXT SYSTEM::GET-CONTEXT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - COMMON-LISP::SUBTYPEP COMMON-LISP::REDUCE - SLOOP::FIND-IN-ORDERED-LIST SYSTEM::PARSE-BODY - COMMON-LISP::STABLE-SORT COMMON-LISP::SORT)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + SLOOP::PARSE-LOOP-DO ANSI-LOOP::LOOP-WHEN-IT-VARIABLE + SYSTEM::GET-INDEX-NODE SLOOP::LOOP-PEEK + ANSI-LOOP::LOOP-POP-SOURCE SYSTEM::STEP-READ-LINE + SYSTEM::SET-UP-TOP-LEVEL SLOOP::LOOP-POP SYSTEM::SET-ENV + SYSTEM::DBL COMMON-LISP::TYPE-ERROR SYSTEM::INSPECT-INDENT + SLOOP::PARSE-LOOP-COLLECT SYSTEM::CLEANUP + SYSTEM::DEFAULT-SYSTEM-BANNER + SYSTEM::CURRENT-DIRECTORY-PATHNAME ANSI-LOOP::LOOP-DO-WITH + SYSTEM::INIT-BREAK-POINTS SYSTEM::TEST-ERROR + SYSTEM::GET-SIG-FN-NAME SLOOP::PARSE-ONE-WHEN-CLAUSE + ANSI-LOOP::LOOP-DO-DO SYSTEM::READ-EVALUATED-FORM + SYSTEM::INSPECT-INDENT-1 ANSI-LOOP::LOOP-DO-NAMED + SLOOP::PARSE-LOOP-FOR SYSTEM::ALL-TRACE-DECLARATIONS + ANSI-LOOP::LOOP-GET-FORM ANSI-LOOP::LOOP-BIND-BLOCK + SLOOP::PARSE-LOOP-WHEN SYSTEM::TOP-LEVEL + SYSTEM::DM-TOO-FEW-ARGUMENTS SYSTEM::KCL-TOP-RESTARTS + SYSTEM::DEFAULT-INFO-HOTLIST SYSTEM::SHOW-RESTARTS + SYSTEM::DM-TOO-MANY-ARGUMENTS SYSTEM::SETUP-LINEINFO + SYSTEM::GET-TEMP-DIR ANSI-LOOP::LOOP-ITERATION-DRIVER + SLOOP::PARSE-LOOP1 SLOOP::LOOP-UN-POP + ANSI-LOOP::LOOP-DO-FINALLY SYSTEM::INSPECT-READ-LINE + ANSI-LOOP::LOOP-CONTEXT SYSTEM::SET-CURRENT + ANSI-LOOP::LOOP-DO-REPEAT SYSTEM::ILLEGAL-BOA + COMMON-LISP::LISP-IMPLEMENTATION-VERSION + ANSI-LOOP::LOOP-DO-RETURN ANSI-LOOP::LOOP-DO-INITIALLY + ANSI-LOOP::LOOP-GET-PROGN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - SYSTEM::SHARP-+-READER SYSTEM::SHARP---READER - SYSTEM::SHARP-S-READER ANSI-LOOP::LOOP-GET-COLLECTION-INFO - SYSTEM::VERIFY-KEYWORDS SYSTEM::LIST-MERGE-SORT - SYSTEM::RESTART-PRINT SYSTEM::READ-INSPECT-COMMAND)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + COMMON-LISP::HASH-TABLE) + SYSTEM::CONTEXT-SPICE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - SYSTEM::TRACE-CALL)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::OR COMMON-LISP::NULL + COMMON-LISP::HASH-TABLE)) + SYSTEM::CONTEXT-HASH)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::*) - SYSTEM::EXPAND-WILD-DIRECTORY SYSTEM::MASET)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::FIXNUM) + ANSI-LOOP::DUPLICATABLE-CODE-P SYSTEM::RELATIVE-LINE + SYSTEM::LENEL SYSTEM::GET-NODE-INDEX SYSTEM::FASLINK + SYSTEM::THE-END)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - SYSTEM::MME3)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + SLOOP::IN-PACKAGE-SLOOP-MAP SLOOP::DESETQ1 + COMMON-LISP::LOGANDC2 ANSI-LOOP::MAKE-LOOP-MINIMAX + COMMON-LISP::WRITE-BYTE SYSTEM::MATCH-DIMENSIONS + SLOOP::IN-CAREFULLY-SLOOP-FOR SLOOP::SUM-SLOOP-COLLECT + SYSTEM::DOT-DIR-P SLOOP::IN-FRINGE-SLOOP-MAP + SLOOP::COLLATE-SLOOP-COLLECT ANSI-LOOP::LOOP-TMEMBER + FPE::READ-OPERANDS SYSTEM::IN-INTERVAL-P SYSTEM::SUBSTRINGP + FPE::PAREN-READER ANSI-LOOP::HIDE-VARIABLE-REFERENCES + SYSTEM::QUOTATION-READER SYSTEM::ALL-MATCHES SYSTEM::GET-MATCH + SYSTEM::ADD-FILE ANSI-LOOP::LOOP-DO-ALWAYS SLOOP::THE-TYPE + SYSTEM::?PUSH SYSTEM::INCREMENT-CURSOR + SYSTEM::CHECK-SEQ-START-END SLOOP::MAKE-VALUE + SLOOP::THEREIS-SLOOP-COLLECT ANSI-LOOP::LOOP-DO-WHILE + COMMON-LISP::COERCE ANSI-LOOP::LOOP-TEQUAL + ANSI-LOOP::LOOP-DECLARE-VARIABLE COMMON-LISP::LOGNAND + COMMON-LISP::LOGORC1 SYSTEM::BREAK-STEP-NEXT + SLOOP::LOGXOR-SLOOP-COLLECT COMMON-LISP::LOGNOR + COMPILER::COMPILER-DEF-HOOK ANSI-LOOP::LOOP-TASSOC + SYSTEM::GET-LINE-OF-FORM SLOOP::MAXIMIZE-SLOOP-COLLECT + ANSI-LOOP::LOOP-DO-IF SYSTEM::SETF-EXPAND SYSTEM::DM-V + SYSTEM::ITERATE-OVER-BKPTS COMMON-LISP::NTHCDR + SYSTEM::CONDITION-PASS SYSTEM::DISPLAY-COMPILED-ENV + COMMON-LISP::LDB-TEST ANSI-LOOP::LOOP-MAYBE-BIND-FORM + SYSTEM::SUPER-GO SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS + FPE::RF SYSTEM::SUB-INTERVAL-P SYSTEM::LEFT-PARENTHESIS-READER + COMMON-LISP::FILE-STRING-LENGTH SYSTEM::OBJLT SYSTEM::MSUB + SYSTEM::COERCE-TO-STRING SYSTEM::SAFE-EVAL + SYSTEM::SET-PATH-STREAM-NAME SYSTEM::SET-BACK + ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION COMMON-LISP::LOGTEST + SYSTEM::*BREAK-POINTS* SLOOP::=-SLOOP-FOR + SLOOP::MINIMIZE-SLOOP-COLLECT SYSTEM::KEYWORD-SUPPLIED-P + SLOOP::COUNT-SLOOP-COLLECT FPE::%-READER COMMON-LISP::LOGORC2 + SYSTEM::SEQUENCE-CURSOR SYSTEM::LOOKUP-KEYWORD + COMMON-LISP::BYTE SYSTEM::PARSE-SLOT-DESCRIPTION + COMMON-LISP::LOGANDC1 SYSTEM::DM-NTH-CDR FPE::0-READER + SLOOP::L-EQUAL SYSTEM::LIST-DELQ SYSTEM::DM-NTH + COMMON-LISP::LDB SYSTEM::SETF-HELPER + SLOOP::NEVER-SLOOP-COLLECT SLOOP::PARSE-LOOP-MAP + COMMON-LISP::NTH SYSTEM::BREAK-STEP-INTO + SYSTEM::GET-INFO-CHOICES SLOOP::IN-TABLE-SLOOP-MAP + SYSTEM::GET-NODES COMMON-LISP::VECTOR-PUSH + COMMON-LISP::PATHNAME-MATCH-P SYSTEM::DBL-UP + ANSI-LOOP::LOOP-LOOKUP-KEYWORD FPE::READ-INSTRUCTION + SLOOP::ALWAYS-SLOOP-COLLECT SYSTEM::SET-DIR SYSTEM::INFO-AUX + SYSTEM::DISPLAY-ENV COMMON-LISP::DOCUMENTATION + SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - SYSTEM::PUSH-OPTIONAL-BINDING)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) - SYSTEM::MAKE-KEYWORD)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - SYSTEM::QUICK-SORT)) + COMMON-LISP::APROPOS ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE + COMMON-LISP::FFLOOR SYSTEM::PRINT-DOC SYSTEM::INFO + SYSTEM::PARSE-BODY-HEADER COMMON-LISP::INVOKE-RESTART + SYSTEM::BREAK-FUNCTION SYSTEM::SHOW-INFO COMMON-LISP::FROUND + COMMON-LISP::GET-SETF-EXPANSION COMMON-LISP::PARSE-NAMESTRING + SYSTEM::APROPOS-DOC COMMON-LISP::ENSURE-DIRECTORIES-EXIST + COMMON-LISP::USE-VALUE COMMON-LISP::READ-FROM-STRING + COMMON-LISP::FTRUNCATE COMMON-LISP::STORE-VALUE + SYSTEM::STEPPER SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE + COMMON-LISP::APROPOS-LIST COMMON-LISP::FCEILING + COMMON-LISP::WRITE-TO-STRING + COMMON-LISP::DECODE-UNIVERSAL-TIME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::BIGNTHCDR)) + SYSTEM::SETF-EXPAND-1 SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS + SYSTEM::WARN-VERSION ANSI-LOOP::LOOP-TRANSLATE + ANSI-LOOP::LOOP-FOR-IN ANSI-LOOP::PRINT-LOOP-UNIVERSE + ANSI-LOOP::LOOP-STANDARD-EXPANSION + ANSI-LOOP::LOOP-ANSI-FOR-EQUALS SYSTEM::DM-VL + SYSTEM::SHARP-A-READER COMMON-LISP::DEPOSIT-FIELD + SYSTEM::RESTART-CASE-EXPRESSION-CONDITION + SYSTEM::APPLY-DISPLAY-FUN ANSI-LOOP::HIDE-VARIABLE-REFERENCE + SYSTEM::FLOATING-POINT-ERROR SYSTEM::GET-SLOT-POS + ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE + SYSTEM::MAKE-BREAK-POINT SYSTEM::SHARP-V-READER + SYSTEM::TO-REGEXP-OR-NAMESTRING ANSI-LOOP::LOOP-FOR-ON + SYSTEM::SHARP-U-READER ANSI-LOOP::LOOP-SUM-COLLECTION + SYSTEM::SHARP-P-READER SYSTEM::MAKE-T-TYPE + ANSI-LOOP::LOOP-FOR-ACROSS SYSTEM::MFR SYSTEM::RECURSE-DIR + SYSTEM::PATHNAME-PARSE ANSI-LOOP::LOOP-FOR-BEING + COMMON-LISP::DPB SYSTEM::SHARP-DQ-READER + SYSTEM::CHECK-TRACE-ARGS SYSTEM::DEFMACRO* + SYSTEM::CHECK-S-DATA FPE::REF)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMMON-LISP::EVERY COMMON-LISP::SET-DIFFERENCE - SYSTEM::VECTOR-PUSH-STRING SYSTEM::PROCESS-ERROR - COMMON-LISP::POSITION-IF-NOT COMMON-LISP::FIND-IF - SLOOP::LOOP-ADD-BINDING COMMON-LISP::BIT-ORC1 - COMMON-LISP::READ-SEQUENCE SYSTEM::INTERNAL-COUNT-IF - COMMON-LISP::COUNT COMMON-LISP::MISMATCH - COMMON-LISP::ADJUST-ARRAY COMMON-LISP::INTERSECTION - COMMON-LISP::UNION COMMON-LISP::DELETE-IF-NOT - COMMON-LISP::NINTERSECTION COMMON-LISP::BIT-ANDC1 - COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::TYPEP - COMMON-LISP::NUNION COMMON-LISP::WRITE-SEQUENCE - COMMON-LISP::VECTOR-PUSH-EXTEND COMMON-LISP::REMOVE - COMMON-LISP::BIT-IOR SLOOP::PARSE-LOOP-MACRO - COMMON-LISP::SEARCH COMMON-LISP::SUBSETP - COMMON-LISP::SET-EXCLUSIVE-OR SYSTEM::WREADDIR - COMMON-LISP::POSITION-IF COMMON-LISP::DELETE - COMMON-LISP::BIT-EQV COMMON-LISP::BIT-ANDC2 - COMMON-LISP::BIT-AND COMMON-LISP::NSET-EXCLUSIVE-OR - SLOOP::IN-ARRAY-SLOOP-FOR ANSI-LOOP::LOOP-CHECK-DATA-TYPE - COMMON-LISP::POSITION COMMON-LISP::MAKE-SEQUENCE - COMMON-LISP::NOTEVERY COMMON-LISP::MAP-INTO - COMMON-LISP::REPLACE COMMON-LISP::NSET-DIFFERENCE + SYSTEM::FIND-IHS COMMON-LISP::NSET-DIFFERENCE + COMMON-LISP::BIT-NAND SYSTEM::BREAK-CALL + COMMON-LISP::COUNT-IF-NOT COMMON-LISP::DELETE + SYSTEM::INTERNAL-COUNT COMMON-LISP::BIT-ORC1 + COMMON-LISP::DELETE-IF COMMON-LISP::BIT-ANDC1 + SYSTEM::VECTOR-PUSH-STRING COMMON-LISP::MISMATCH + COMMON-LISP::NOTEVERY SYSTEM::PROCESS-ERROR COMMON-LISP::TYPEP + COMMON-LISP::BIT-IOR COMMON-LISP::BIT-EQV + COMMON-LISP::COUNT-IF COMMON-LISP::REMOVE-IF + COMMON-LISP::EVERY COMMON-LISP::POSITION-IF-NOT + COMMON-LISP::ADJUST-ARRAY COMMON-LISP::VECTOR-PUSH-EXTEND + SYSTEM::INTERNAL-COUNT-IF-NOT COMMON-LISP::COUNT + COMMON-LISP::DELETE-IF-NOT COMMON-LISP::NINTERSECTION COMMON-LISP::FIND-IF-NOT COMMON-LISP::BIT-ORC2 - COMMON-LISP::DELETE-IF COMMON-LISP::CERROR - COMMON-LISP::BIT-XOR COMMON-LISP::FIND COMMON-LISP::FILL - SYSTEM::INTERNAL-COUNT-IF-NOT COMMON-LISP::REMOVE-IF - COMMON-LISP::BIT-NAND COMMON-LISP::BIT-NOR COMMON-LISP::SOME - COMMON-LISP::COUNT-IF SYSTEM::BREAK-CALL - COMMON-LISP::COUNT-IF-NOT SYSTEM::FIND-IHS COMMON-LISP::NOTANY - SYSTEM::INTERNAL-COUNT)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - SYSTEM::PATHNAME-PARSE ANSI-LOOP::LOOP-TRANSLATE - SYSTEM::CHECK-S-DATA SYSTEM::MFR FPE::REF - ANSI-LOOP::LOOP-STANDARD-EXPANSION ANSI-LOOP::LOOP-FOR-ON - ANSI-LOOP::LOOP-SUM-COLLECTION SYSTEM::SHARP-DQ-READER - COMMON-LISP::DPB SYSTEM::CHECK-TRACE-ARGS - SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS SYSTEM::RECURSE-DIR - SYSTEM::SHARP-U-READER SYSTEM::FLOATING-POINT-ERROR - ANSI-LOOP::LOOP-FOR-IN ANSI-LOOP::HIDE-VARIABLE-REFERENCE - SYSTEM::GET-SLOT-POS SYSTEM::APPLY-DISPLAY-FUN - SYSTEM::RESTART-CASE-EXPRESSION-CONDITION - SYSTEM::MAKE-BREAK-POINT SYSTEM::TO-REGEXP-OR-NAMESTRING - COMMON-LISP::DEPOSIT-FIELD SYSTEM::SHARP-V-READER - SYSTEM::MAKE-T-TYPE ANSI-LOOP::LOOP-FOR-ACROSS - ANSI-LOOP::LOOP-ANSI-FOR-EQUALS ANSI-LOOP::PRINT-LOOP-UNIVERSE - ANSI-LOOP::LOOP-FOR-BEING SYSTEM::SHARP-P-READER SYSTEM::DM-VL - SYSTEM::SHARP-A-READER ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE - SYSTEM::DEFMACRO* SYSTEM::SETF-EXPAND-1 SYSTEM::WARN-VERSION)) + COMMON-LISP::SUBSETP COMMON-LISP::SOME SYSTEM::WREADDIR + COMMON-LISP::SET-DIFFERENCE COMMON-LISP::UNION + COMMON-LISP::BIT-XOR SLOOP::PARSE-LOOP-MACRO + COMMON-LISP::REPLACE COMMON-LISP::REMOVE + SLOOP::LOOP-ADD-BINDING COMMON-LISP::BIT-ANDC2 + COMMON-LISP::READ-SEQUENCE COMMON-LISP::CERROR + COMMON-LISP::INTERSECTION COMMON-LISP::POSITION-IF + ANSI-LOOP::LOOP-CHECK-DATA-TYPE SYSTEM::INTERNAL-COUNT-IF + COMMON-LISP::NUNION COMMON-LISP::WRITE-SEQUENCE + COMMON-LISP::MAP-INTO COMMON-LISP::MAKE-SEQUENCE + COMMON-LISP::SET-EXCLUSIVE-OR SLOOP::IN-ARRAY-SLOOP-FOR + COMMON-LISP::FIND-IF COMMON-LISP::SEARCH COMMON-LISP::FILL + COMMON-LISP::FIND COMMON-LISP::NOTANY + COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::BIT-NOR + COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::POSITION + COMMON-LISP::BIT-AND)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) + COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::MME2 COMMON-LISP::NSUBSTITUTE SYSTEM::MATCH-COMPONENT - SYSTEM::COMPLETE-PROP SYSTEM::WALK-DIR - COMMON-LISP::TRANSLATE-PATHNAME ANSI-LOOP::ADD-LOOP-PATH - SYSTEM::DIR-PARSE ANSI-LOOP::LOOP-MAKE-VARIABLE - COMMON-LISP::SUBSTITUTE-IF COMMON-LISP::NSUBSTITUTE-IF - SYSTEM::PUSH-LET-BINDING COMMON-LISP::SUBSTITUTE - ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH COMMON-LISP::MAP - COMMON-LISP::SUBSTITUTE-IF-NOT COMMON-LISP::NSUBSTITUTE-IF-NOT - ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH - SLOOP::LOOP-DECLARE-BINDING - ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH - SYSTEM::CHECK-TYPE-SYMBOL)) + SYSTEM::FIND-LINE-IN-FUN ANSI-LOOP::LOOP-FOR-ARITHMETIC + SYSTEM::EXPAND-RANGE SYSTEM::MAYBE-BREAK SYSTEM::MINMAX + SLOOP::FIRST-USE-SLOOP-FOR SLOOP::FIRST-SLOOP-FOR + SYSTEM::SETF-STRUCTURE-ACCESS SYSTEM::DO-BREAK-LEVEL + SYSTEM::CALL-TEST SYSTEM::ELEMENT SYSTEM::LOAD-PATHNAME + SYSTEM::COERCE-TO-CONDITION SYSTEM::ELSUB)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - SYSTEM::SHARP-EQ-READER SYSTEM::SHARP-SHARP-READER)) + SLOOP::DEF-LOOP-INTERNAL COMMON-LISP::MERGE + SYSTEM::PRINT-STACK-FRAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) COMMON-LISP::T) - SYSTEM::ELSUB SLOOP::FIRST-USE-SLOOP-FOR - SLOOP::FIRST-SLOOP-FOR SYSTEM::SETF-STRUCTURE-ACCESS - SYSTEM::FIND-LINE-IN-FUN SYSTEM::COERCE-TO-CONDITION - ANSI-LOOP::LOOP-FOR-ARITHMETIC SYSTEM::MAYBE-BREAK - SYSTEM::ELEMENT SYSTEM::DO-BREAK-LEVEL SYSTEM::CALL-TEST)) + COMMON-LISP::ENCODE-UNIVERSAL-TIME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) + COMMON-LISP::*) COMMON-LISP::T) - ANSI-LOOP::LOOP-SEQUENCER)) + ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH + SYSTEM::COMPLETE-PROP SYSTEM::CHECK-TYPE-SYMBOL + COMMON-LISP::NSUBSTITUTE + ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH COMMON-LISP::SUBSTITUTE + COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::NSUBSTITUTE-IF + COMMON-LISP::MAP SLOOP::LOOP-DECLARE-BINDING SYSTEM::WALK-DIR + SYSTEM::MATCH-COMPONENT ANSI-LOOP::LOOP-MAKE-VARIABLE + ANSI-LOOP::ADD-LOOP-PATH COMMON-LISP::SUBSTITUTE-IF + COMMON-LISP::NSUBSTITUTE-IF-NOT SYSTEM::MME2 + ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH + COMMON-LISP::SUBSTITUTE-IF-NOT SYSTEM::PUSH-LET-BINDING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::T COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - SYSTEM::MAKE-CONSTRUCTOR SYSTEM::MAKE-PREDICATE)) + SYSTEM::SHARP-SHARP-READER SYSTEM::SHARP-EQ-READER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::PUSH-SUB-LIST-BINDING SYSTEM::DO-ARG-COUNT-ERROR)) + SYSTEM::DO-ARG-COUNT-ERROR SYSTEM::PUSH-SUB-LIST-BINDING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SLOOP::DEF-LOOP-INTERNAL COMMON-LISP::MERGE - SYSTEM::PRINT-STACK-FRAME)) + SYSTEM::MAKE-CONSTRUCTOR SYSTEM::MAKE-PREDICATE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) COMMON-LISP::T) - COMMON-LISP::ENCODE-UNIVERSAL-TIME)) + ANSI-LOOP::LOOP-SEQUENCER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -234,43 +274,50 @@ COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) SYSTEM::UNIVERSAL-ERROR-HANDLER)) +(COMMON-LISP::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(SYSTEM::SI-FIND-CLASS SYSTEM::WARNINGP SYSTEM::SI-CLASS-OF + SYSTEM::CONDITION-CLASS-P SYSTEM::UNTRACE-ONE + SYSTEM::MAKE-ACCESS-FUNCTION SYSTEM::SIMPLE-CONDITION-CLASS-P + SYSTEM::CONDITIONP SYSTEM::AUTOLOAD + SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::SI-CLASSP + FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS SYSTEM::TRACE-ONE + SYSTEM::AUTOLOAD-MACRO SYSTEM::DEFINE-STRUCTURE + SYSTEM::SI-CLASS-NAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - COMMON-LISP::MERGE-PATHNAMES - COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME ANSI-LOOP::LOOP-ERROR - COMMON-LISP::WILD-PATHNAME-P SLOOP::LOOP-ADD-TEMPS - SYSTEM::FILE-SEARCH SYSTEM::INFO-SEARCH - COMMON-LISP::PATHNAME-VERSION COMMON-LISP::WARN SYSTEM::MGSUB - COMMON-LISP::ARRAY-ROW-MAJOR-INDEX - COMMON-LISP::REMOVE-DUPLICATES COMMON-LISP::PATHNAME-NAME - COMMON-LISP::BIT COMMON-LISP::FIND-RESTART SYSTEM::TO-REGEXP - SYSTEM::PROCESS-SOME-ARGS COMMON-LISP::ERROR - COMMON-LISP::REQUIRE COMMON-LISP::OPEN - COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE SLOOP::ADD-FROM-DATA - SYSTEM::BREAK-LEVEL SYSTEM::LIST-MATCHES - COMMON-LISP::DELETE-DUPLICATES ANSI-LOOP::LOOP-WARN - COMMON-LISP::PATHNAME-DEVICE COMMON-LISP::LOAD - COMMON-LISP::PATHNAME-HOST COMMON-LISP::SBIT SYSTEM::NLOAD - COMMON-LISP::BIT-NOT COMMON-LISP::ENOUGH-NAMESTRING - COMMON-LISP::SIGNAL COMMON-LISP::ARRAY-IN-BOUNDS-P - COMMON-LISP::PATHNAME-TYPE SYSTEM::FILE-TO-STRING - SYSTEM::LOGICAL-PATHNAME-PARSE SYSTEM::NTH-STACK-FRAME - ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES SYSTEM::MGLIST - COMMON-LISP::DIRECTORY SYSTEM::BAD-SEQ-LIMIT - COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::READ-BYTE - SYSTEM::LINK-EXPAND COMMON-LISP::CONCATENATE - COMMON-LISP::MAKE-ARRAY)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) + SYSTEM::INSTREAM-NAME ANSI-LOOP::LOOP-LIST-STEP + COMMON-LISP::PRIN1-TO-STRING ANSI-LOOP::NAMED-VARIABLE + SYSTEM::WAITING SYSTEM::FIND-DECLARATIONS COMMON-LISP::INSPECT + SYSTEM::END-WAITING SYSTEM::BREAK-GO SYSTEM::INFO-SUBFILE + COMMON-LISP::INVOKE-RESTART-INTERACTIVELY + ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES SYSTEM::INSPECT-OBJECT + SYSTEM::BREAK-LEVEL-INVOKE-RESTART SYSTEM::EXPAND-RANGES + SYSTEM::GET-&ENVIRONMENT COMMON-LISP::DESCRIBE + COMMON-LISP::PRINC-TO-STRING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - SYSTEM::NEWLINE SYSTEM::LIST-TOGGLE-CASE - COMMON-LISP::RENAME-FILE ANSI-LOOP::ESTIMATE-CODE-SIZE - SYSTEM::SOURCE-PORTION SYSTEM::RESTART-REPORT SYSTEM::DO-REPL - SYSTEM::FIND-DOC ANSI-LOOP::ESTIMATE-CODE-SIZE-1 - SYSTEM::NEW-SEMI-COLON-READER)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + COMMON-LISP::ABORT ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE + SYSTEM::MAKE-S-DATA ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL + ANSI-LOOP::MAKE-LOOP-PATH SYSTEM::CURRENT-STEP-FUN SYSTEM::LOC + SYSTEM::DBL-READ SYSTEM::MAKE-RESTART + SYSTEM::TRANSFORM-KEYWORDS COMMON-LISP::Y-OR-N-P + SYSTEM::NEXT-MATCH COMMON-LISP::COMPUTE-RESTARTS + SLOOP::PARSE-LOOP-WITH COMMON-LISP::VECTOR SYSTEM::STEP-NEXT + ANSI-LOOP::MAKE-LOOP-COLLECTOR + COMMON-LISP::USER-HOMEDIR-PATHNAME SLOOP::PARSE-LOOP-DECLARE + COMMON-LISP::YES-OR-NO-P SYSTEM::STEP-INTO + SYSTEM::MAKE-CONTEXT SYSTEM::BREAK-LOCALS + SYSTEM::DESCRIBE-ENVIRONMENT COMMON-LISP::DRIBBLE + ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL SYSTEM::MAYBE-CLEAR-INPUT + COMMON-LISP::BREAK ANSI-LOOP::LOOP-GENTEMP + ANSI-LOOP::MAKE-LOOP-UNIVERSE SYSTEM::MAKE-INSTREAM + COMMON-LISP::MAKE-PATHNAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -278,74 +325,6 @@ 9223372036854775807)) COMMON-LISP::FIXNUM) FPE::FE-ENABLE SYSTEM::DBL-WHAT-FRAME)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - SYSTEM::INFO SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE - COMMON-LISP::FTRUNCATE COMMON-LISP::USE-VALUE - COMMON-LISP::INVOKE-RESTART COMMON-LISP::WRITE-TO-STRING - COMMON-LISP::FCEILING COMMON-LISP::FROUND - COMMON-LISP::READ-FROM-STRING COMMON-LISP::FFLOOR - SYSTEM::PARSE-BODY-HEADER SYSTEM::BREAK-FUNCTION - SYSTEM::APROPOS-DOC COMMON-LISP::APROPOS - COMMON-LISP::APROPOS-LIST - ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE - COMMON-LISP::GET-SETF-EXPANSION SYSTEM::PRINT-DOC - COMMON-LISP::PARSE-NAMESTRING - COMMON-LISP::ENSURE-DIRECTORIES-EXIST - COMMON-LISP::DECODE-UNIVERSAL-TIME SYSTEM::SHOW-INFO - COMMON-LISP::STORE-VALUE SYSTEM::STEPPER)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - COMMON-LISP::VECTOR-PUSH SYSTEM::DM-NTH COMMON-LISP::LOGORC1 - SLOOP::L-EQUAL SLOOP::NEVER-SLOOP-COLLECT - COMMON-LISP::LDB-TEST COMMON-LISP::LDB COMMON-LISP::LOGORC2 - SLOOP::COUNT-SLOOP-COLLECT SLOOP::MAXIMIZE-SLOOP-COLLECT - SYSTEM::ALL-MATCHES ANSI-LOOP::LOOP-TMEMBER SLOOP::THE-TYPE - SYSTEM::?PUSH SYSTEM::INCREMENT-CURSOR SYSTEM::SET-DIR - SYSTEM::DM-NTH-CDR SYSTEM::IN-INTERVAL-P SLOOP::MAKE-VALUE - SYSTEM::DBL-UP COMMON-LISP::COERCE SYSTEM::MATCH-DIMENSIONS - COMMON-LISP::LOGNAND SLOOP::=-SLOOP-FOR - SYSTEM::KEYWORD-SUPPLIED-P SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS - SYSTEM::LEFT-PARENTHESIS-READER - ANSI-LOOP::LOOP-MAYBE-BIND-FORM SYSTEM::COERCE-TO-STRING - SYSTEM::ADD-FILE SLOOP::PARSE-LOOP-MAP COMMON-LISP::LOGNOR - SYSTEM::MSUB SYSTEM::SET-BACK SYSTEM::SUPER-GO - SYSTEM::SUBSTRINGP ANSI-LOOP::LOOP-TEQUAL - ANSI-LOOP::LOOP-DO-WHILE SYSTEM::GET-LINE-OF-FORM - FPE::READ-INSTRUCTION SYSTEM::SUB-INTERVAL-P - SYSTEM::CHECK-SEQ-START-END SYSTEM::*BREAK-POINTS* - ANSI-LOOP::MAKE-LOOP-MINIMAX SLOOP::IN-PACKAGE-SLOOP-MAP - SYSTEM::DM-V SYSTEM::INFO-AUX - ANSI-LOOP::HIDE-VARIABLE-REFERENCES - SLOOP::COLLATE-SLOOP-COLLECT COMMON-LISP::PATHNAME-MATCH-P - SYSTEM::SET-PATH-STREAM-NAME SLOOP::SUM-SLOOP-COLLECT - ANSI-LOOP::LOOP-LOOKUP-KEYWORD - ANSI-LOOP::LOOP-DECLARE-VARIABLE SYSTEM::BREAK-STEP-NEXT - FPE::RF SLOOP::IN-TABLE-SLOOP-MAP SYSTEM::OBJLT - FPE::READ-OPERANDS SYSTEM::BREAK-STEP-INTO COMMON-LISP::BYTE - SYSTEM::SEQUENCE-CURSOR SYSTEM::LIST-DELQ - SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS - SYSTEM::CONDITION-PASS SYSTEM::SETF-HELPER FPE::0-READER - SYSTEM::DISPLAY-COMPILED-ENV COMMON-LISP::NTH - COMPILER::COMPILER-DEF-HOOK SYSTEM::DOT-DIR-P - COMMON-LISP::LOGTEST SYSTEM::QUOTATION-READER - SYSTEM::ITERATE-OVER-BKPTS COMMON-LISP::LOGANDC1 - SLOOP::ALWAYS-SLOOP-COLLECT SLOOP::DESETQ1 - SYSTEM::GET-INFO-CHOICES COMMON-LISP::WRITE-BYTE - ANSI-LOOP::LOOP-DO-IF ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION - ANSI-LOOP::LOOP-TASSOC SLOOP::IN-CAREFULLY-SLOOP-FOR - COMMON-LISP::DOCUMENTATION FPE::PAREN-READER SYSTEM::GET-NODES - SYSTEM::PARSE-SLOT-DESCRIPTION SLOOP::IN-FRINGE-SLOOP-MAP - SYSTEM::SAFE-EVAL SYSTEM::DISPLAY-ENV FPE::%-READER - SLOOP::THEREIS-SLOOP-COLLECT SYSTEM::LOOKUP-KEYWORD - COMMON-LISP::LOGANDC2 COMMON-LISP::NTHCDR - SLOOP::MINIMIZE-SLOOP-COLLECT SYSTEM::GET-MATCH - SYSTEM::SETF-EXPAND SLOOP::LOGXOR-SLOOP-COLLECT - ANSI-LOOP::LOOP-DO-ALWAYS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -357,263 +336,300 @@ SYSTEM::ROUND-UP)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - COMMON-LISP::Y-OR-N-P COMMON-LISP::YES-OR-NO-P - COMMON-LISP::DRIBBLE COMMON-LISP::VECTOR SYSTEM::NEXT-MATCH - SYSTEM::MAKE-S-DATA SYSTEM::LOC SYSTEM::BREAK-LOCALS - SLOOP::PARSE-LOOP-WITH COMMON-LISP::USER-HOMEDIR-PATHNAME - SYSTEM::STEP-INTO SYSTEM::MAYBE-CLEAR-INPUT - ANSI-LOOP::MAKE-LOOP-PATH SYSTEM::STEP-NEXT - ANSI-LOOP::LOOP-GENTEMP COMMON-LISP::COMPUTE-RESTARTS - SYSTEM::CURRENT-STEP-FUN SYSTEM::MAKE-INSTREAM - ANSI-LOOP::MAKE-LOOP-COLLECTOR SYSTEM::MAKE-RESTART - SYSTEM::DESCRIBE-ENVIRONMENT SYSTEM::TRANSFORM-KEYWORDS - COMMON-LISP::ABORT ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE - ANSI-LOOP::MAKE-LOOP-UNIVERSE SLOOP::PARSE-LOOP-DECLARE - COMMON-LISP::BREAK ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL - SYSTEM::MAKE-CONTEXT SYSTEM::DBL-READ - COMMON-LISP::MAKE-PATHNAME - ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES SYSTEM::BREAK-GO - COMMON-LISP::FILE-AUTHOR SYSTEM::ENSURE-DIR-STRING - SYSTEM::INFO-SUBFILE COMMON-LISP::DESCRIBE SYSTEM::END-WAITING - COMMON-LISP::PRIN1-TO-STRING SYSTEM::FIND-DECLARATIONS - COMMON-LISP::INSPECT ANSI-LOOP::NAMED-VARIABLE - SYSTEM::GET-&ENVIRONMENT SYSTEM::INSPECT-OBJECT - COMMON-LISP::PRINC-TO-STRING ANSI-LOOP::LOOP-LIST-STEP - SYSTEM::INSTREAM-NAME SYSTEM::BREAK-LEVEL-INVOKE-RESTART - SYSTEM::WAITING COMMON-LISP::INVOKE-RESTART-INTERACTIVELY)) + (COMMON-LISP::FUNCTION + ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER + COMMON-LISP::*) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::FIXNUM) + SYSTEM::ATOI)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::IHS-NOT-INTERPRETED-ENV COMMON-LISP::NINTH - SYSTEM::FIND-KCL-TOP-RESTART COMMON-LISP::TRUENAME - SYSTEM::DIRECTORY-LIST-CHECK SYSTEM::REAL-ASINH - SYSTEM::SHOW-ENVIRONMENT SYSTEM::PRINT-FRS - SYSTEM::REWRITE-RESTART-CASE-CLAUSE - COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM - ANSI-LOOP::LOOP-COLLECTOR-DATA SLOOP::POINTER-FOR-COLLECT - SYSTEM::MLP SYSTEM::WILD-PATH-ELEMENT-P SYSTEM::LNP - ANSI-LOOP::LOOP-MINIMAX-OPERATIONS SYSTEM::FRS-KIND - SYSTEM::BKPT-FILE COMMON-LISP::FIFTH - ANSI-LOOP::LOOP-COLLECTOR-P ANSI-LOOP::LOOP-UNIVERSE-ANSI - ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS SYSTEM::IDESCRIBE - ANSI-LOOP::LOOP-CONSTANTP - ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS COMMON-LISP::PROBE-FILE - ANSI-LOOP::LOOP-UNIVERSE-P COMMON-LISP::SINH SYSTEM::RESTART-P - SYSTEM::S-DATA-DOCUMENTATION + SYSTEM::REGEXP-CONV SYSTEM::DIR-CONJ SYSTEM::DIR-P + ANSI-LOOP::LOOP-LIST-COLLECTION COMMON-LISP::COSH + SYSTEM::GET-BYTE-STREAM-NCHARS SYSTEM::INSPECT-CONS + SYSTEM::KNOWN-TYPE-P SYSTEM::LNP COMMON-LISP::SEVENTH + SYSTEM::BKPT-FUNCTION SYSTEM::WILD-DIR-ELEMENT-P + COMMON-LISP::COMPILER-MACRO-FUNCTION + ANSI-LOOP::LOOP-HACK-ITERATION COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM - SYSTEM::FIND-DOCUMENTATION SYSTEM::INFO-GET-FILE - SLOOP::PARSE-NO-BODY COMMON-LISP::FILE-NAMESTRING - COMMON-LISP::COMPILER-MACRO-FUNCTION SYSTEM::PROCESS-ARGS - ANSI-LOOP::LOOP-COLLECTOR-DTYPE COMMON-LISP::PHASE - SYSTEM::MAKE-FRAME SYSTEM::INSTREAM-STREAM - ANSI-LOOP::LOOP-COLLECTOR-HISTORY SYSTEM::FIX-LOAD-PATH - SYSTEM::COMPUTING-ARGS-P - ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE COMMON-LISP::TENTH - ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE SYSTEM::WILD-NAMESTRING-P - SYSTEM::BEST-ARRAY-ELEMENT-TYPE SYSTEM::DM-BAD-KEY - SYSTEM::TERMINAL-INTERRUPT SYSTEM::REGEXP-CONV - COMMON-LISP::FILE-WRITE-DATE SLOOP::PARSE-LOOP - ANSI-LOOP::LOOP-CONSTRUCT-RETURN SYSTEM::DWIM + SYSTEM::DIRECTORY-LIST-CHECK COMMON-LISP::FILE-WRITE-DATE + SYSTEM::NORMALIZE-TYPE COMMON-LISP::EIGHTH SYSTEM::TOGGLE-CASE + SYSTEM::SHOW-ENVIRONMENT + COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM SYSTEM::GET-PATH + COMMON-LISP::ASINH SYSTEM::FIND-KCL-TOP-RESTART + SYSTEM::RESTART-P SYSTEM::EVAL-FEATURE SYSTEM::ALOAD + COMMON-LISP::PHASE SLOOP::SUBSTITUTE-SLOOP-BODY + COMMON-LISP::ASIN SYSTEM::NODES-FROM-INDEX + SYSTEM::MAKE-DEFPACKAGE-FORM ANSI-LOOP::LOOP-COLLECTOR-DTYPE + SYSTEM::LOGICAL-PATHNAMEP SYSTEM::INSPECT-VECTOR ANSI-LOOP::LOOP-UNIVERSE-TYPE-KEYWORDS - SLOOP::RETURN-SLOOP-MACRO SLOOP::AVERAGING-SLOOP-MACRO - SYSTEM::S-DATA-NAME SYSTEM::CHECK-TRACE-SPEC - SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE SLOOP::TRANSLATE-NAME - SYSTEM::ADD-TO-HOTLIST SYSTEM::S-DATA-CONC-NAME - ANSI-LOOP::LOOP-MINIMAX-TYPE SYSTEM::PRINT-IHS - SYSTEM::DBL-RPL-LOOP SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY - SYSTEM::INSPECT-CONS SYSTEM::INSTREAM-STREAM-NAME - SYSTEM::S-DATA-P SYSTEM::EVAL-FEATURE - COMMON-LISP::ARRAY-DIMENSIONS SYSTEM::IHS-VISIBLE - ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE - SYSTEM::CHECK-DECLARATIONS COMMON-LISP::TANH - ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS - COMMON-LISP::COMPILE-FILE-PATHNAME SYSTEM::INSPECT-PACKAGE - SLOOP::LOOP-LET-BINDINGS COMMON-LISP::CIS SYSTEM::SETUP-INFO - SYSTEM::NORMALIZE-TYPE ANSI-LOOP::LOOP-PSEUDO-BODY - SYSTEM::PATH-STREAM-NAME SYSTEM::INFO-GET-TAGS FPE::ST-LOOKUP - SYSTEM::BREAK-BACKWARD-SEARCH-STACK - ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE SYSTEM::SIMPLE-ARRAY-P - SYSTEM::S-DATA-TYPE COMMON-LISP::CONCATENATED-STREAM-STREAMS - SYSTEM::INSPECT-CHARACTER ANSI-LOOP::DESTRUCTURING-SIZE - SYSTEM::GET-BYTE-STREAM-NCHARS ANSI-LOOP::LOOP-PATH-P - COMMON-LISP::FIRST COMMON-LISP::SECOND - COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM - SYSTEM::MAKE-DEFPACKAGE-FORM SYSTEM::INSPECT-SYMBOL - SYSTEM::INSPECT-VECTOR - COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS - SYSTEM::RESTART-INTERACTIVE-FUNCTION SYSTEM::INSPECT-STRING - SYSTEM::DIR-P ANSI-LOOP::LOOP-COLLECTOR-CLASS - SYSTEM::S-DATA-CONSTRUCTORS SYSTEM::NODES-FROM-INDEX - SYSTEM::VERSION-PARSE SYSTEM::BKPT-FILE-LINE COMMON-LISP::ABS - SYSTEM::IHS-FNAME ANSI-LOOP::LOOP-MAKE-PSETQ - SYSTEM::LEAP-YEAR-P ANSI-LOOP::LOOP-EMIT-FINAL-VALUE - SYSTEM::GET-PATH SYSTEM::ALOAD SYSTEM::DM-KEY-NOT-ALLOWED - SYSTEM::MAKE-KCL-TOP-RESTART SYSTEM::S-DATA-SLOT-DESCRIPTIONS - COMMON-LISP::VECTOR-POP ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS - ANSI-LOOP::LOOP-PATH-USER-DATA SYSTEM::S-DATA-SLOT-POSITION - COMMON-LISP::BROADCAST-STREAM-STREAMS - SYSTEM::LOGICAL-PATHNAMEP SYSTEM::BREAK-FORWARD-SEARCH-STACK - SLOOP::SLOOP-SLOOP-MACRO COMMON-LISP::SIGNUM - SYSTEM::RESET-TRACE-DECLARATIONS SYSTEM::CONTEXT-P - SYSTEM::S-DATA-FROZEN SYSTEM::NUMBER-OF-DAYS-FROM-1900 - SYSTEM::S-DATA-STATICP ANSI-LOOP::LOOP-PATH-FUNCTION - SYSTEM::KNOWN-TYPE-P COMMON-LISP::PROVIDE SYSTEM::PNL1 - ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD - SYSTEM::COERCE-SLASH-TERMINATED COMMON-LISP::LOGICAL-PATHNAME - SYSTEM::DIR-CONJ SYSTEM::BKPT-FORM - SYSTEM::LOGICAL-PATHNAME-HOST-P SYSTEM::INSPECT-STRUCTURE - ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED - COMMON-LISP::FIND-ALL-SYMBOLS + SYSTEM::RESTART-REPORT-FUNCTION SYSTEM::IHS-VISIBLE + SLOOP::LOOP-COLLECT-KEYWORD-P ANSI-LOOP::LOOP-TYPED-INIT + COMMON-LISP::VECTOR-POP SYSTEM::UNIQUE-ID ANSI-LOOP::LOOP-UNIVERSE-ITERATION-KEYWORDS - ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED + SYSTEM::SIMPLE-ARRAY-P COMMON-LISP::ACOS SYSTEM::DBL-EVAL + SYSTEM::INSPECT-STRING SYSTEM::MLP + SYSTEM::INSTREAM-STREAM-NAME SYSTEM::WILD-NAMESTRING-P + ANSI-LOOP::LOOP-PATH-FUNCTION + SYSTEM::GET-STRING-INPUT-STREAM-INDEX + ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE SYSTEM::SEQTYPE + ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS + SYSTEM::BEST-ARRAY-ELEMENT-TYPE + ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA SYSTEM::S-DATA-FROZEN + SYSTEM::S-DATA-DOCUMENTATION SYSTEM::DWIM COMMON-LISP::SIGNUM + SYSTEM::FIND-DOCUMENTATION ANSI-LOOP::LOOP-COLLECTOR-HISTORY + ANSI-LOOP::LOOP-MAKE-PSETQ FPE::GREF SYSTEM::S-DATA-OFFSET + SYSTEM::WILD-PATH-ELEMENT-P SYSTEM::INSTREAM-P + COMMON-LISP::DIRECTORY-NAMESTRING SYSTEM::INSPECT-ARRAY + COMMON-LISP::ARRAY-DIMENSIONS + ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS ANSI-LOOP::LOOP-MINIMAX-P + SLOOP::RETURN-SLOOP-MACRO SYSTEM::WALK-THROUGH + SYSTEM::NEXT-STACK-FRAME SYSTEM::S-DATA-NAME COMMON-LISP::TANH + SYSTEM::BREAK-BACKWARD-SEARCH-STACK COMMON-LISP::TENTH + SYSTEM::INFO-NODE-FROM-POSITION FPE::ST-LOOKUP + COMMON-LISP::RESTART-NAME SYSTEM::S-DATA-TYPE + SYSTEM::BKPT-FILE-LINE COMMON-LISP::FIND-ALL-SYMBOLS + COMMON-LISP::FIFTH SLOOP::LOOP-LET-BINDINGS + COMMON-LISP::ECHO-STREAM-INPUT-STREAM + ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED + COMMON-LISP::PROBE-FILE SYSTEM::MAKE-FRAME + SYSTEM::IHS-NOT-INTERPRETED-ENV SYSTEM::SEARCH-STACK + COMMON-LISP::COMPILE-FILE-PATHNAME + SYSTEM::PRINT-SYMBOL-APROPOS COMMON-LISP::LOGNOT + SYSTEM::INFO-GET-TAGS SYSTEM::SHORT-NAME + ANSI-LOOP::LOOP-MINIMAX-TYPE COMMON-LISP::SIXTH + COMMON-LISP::SECOND ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS + COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM + SYSTEM::S-DATA-INCLUDES SYSTEM::RESTART-INTERACTIVE-FUNCTION + SLOOP::TRANSLATE-NAME SYSTEM::PATCH-SHARP COMMON-LISP::ABS + ANSI-LOOP::LOOP-CONSTANTP SYSTEM::LEAP-YEAR-P + ANSI-LOOP::LOOP-UNIVERSE-ANSI ANSI-LOOP::LOOP-EMIT-BODY + COMMON-LISP::HOST-NAMESTRING COMMON-LISP::FIRST + SYSTEM::INSERT-BREAK-POINT + COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS + COMMON-LISP::DELETE-FILE ANSI-LOOP::LOOP-PSEUDO-BODY + SYSTEM::GET-NEXT-VISIBLE-FUN SYSTEM::S-DATA-HAS-HOLES + ANSI-LOOP::LOOP-COLLECTOR-NAME COMMON-LISP::FOURTH + SYSTEM::BKPT-FILE SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY + SYSTEM::INSTREAM-STREAM SYSTEM::PNL1 SYSTEM::IHS-FNAME + SYSTEM::S-DATA-SLOT-POSITION SLOOP::PARSE-LOOP + SYSTEM::CHECK-TRACE-SPEC SYSTEM::S-DATA-CONSTRUCTORS + SYSTEM::S-DATA-STATICP SYSTEM::CONTEXT-P COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS - SYSTEM::TRACE-ONE-PREPROCESS COMMON-LISP::CONSTANTLY - COMMON-LISP::ACOS SYSTEM::S-DATA-OFFSET COMMON-LISP::ASINH - SYSTEM::SHORT-NAME SYSTEM::S-DATA-INCLUDED SYSTEM::DBL-EVAL - SYSTEM::BKPT-FUNCTION SYSTEM::INSPECT-NUMBER - SYSTEM::GET-INSTREAM SYSTEM::SHOW-BREAK-POINT FPE::LOOKUP - SYSTEM::NEXT-STACK-FRAME SYSTEM::INSPECT-ARRAY - SYSTEM::S-DATA-RAW ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA - SYSTEM::RESTART-REPORT-FUNCTION SYSTEM::TOGGLE-CASE - SYSTEM::NODE-OFFSET SYSTEM::INSTREAM-P - ANSI-LOOP::LOOP-PATH-NAMES SYSTEM::FREEZE-DEFSTRUCT - COMMON-LISP::SEVENTH SYSTEM::SEARCH-STACK COMMON-LISP::SIXTH - ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS FPE::GREF - FPE::XMM-LOOKUP COMMON-LISP::HOST-NAMESTRING - ANSI-LOOP::LOOP-TYPED-INIT + SYSTEM::INFO-GET-FILE COMMON-LISP::COMPLEMENT + SYSTEM::INSPECT-NUMBER SYSTEM::RESET-TRACE-DECLARATIONS + ANSI-LOOP::LOOP-PATH-P SLOOP::REPEAT-SLOOP-MACRO SYSTEM::DO-F + SYSTEM::INSPECT-PACKAGE SYSTEM::PATH-STREAM-NAME + SYSTEM::GET-INSTREAM COMMON-LISP::BYTE-SIZE + SYSTEM::RESTART-FUNCTION FPE::LOOKUP SYSTEM::S-DATA-CONC-NAME + COMMON-LISP::PROVIDE SYSTEM::S-DATA-NAMED SYSTEM::PRINT-FRS + ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE SYSTEM::NODE-OFFSET + ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE SYSTEM::PRINT-IHS + ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS COMMON-LISP::TRUENAME + SYSTEM::BREAK-FORWARD-SEARCH-STACK + COMMON-LISP::CONCATENATED-STREAM-STREAMS SYSTEM::VERSION-PARSE + SYSTEM::INSPECT-CHARACTER SYSTEM::LOGICAL-PATHNAME-HOST-P + SYSTEM::DM-BAD-KEY SYSTEM::EXPAND-HOME-DIR + ANSI-LOOP::LOOP-PATH-USER-DATA + ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS SYSTEM::INSPECT-SYMBOL + COMMON-LISP::INVOKE-DEBUGGER SYSTEM::LOGICAL-PATHNAME-DESIGNATOR-P - ANSI-LOOP::LOOP-DO-THEREIS COMMON-LISP::EIGHTH - SYSTEM::UNIQUE-ID COMMON-LISP::THIRD - COMMON-LISP::BYTE-POSITION COMMON-LISP::SYNONYM-STREAM-SYMBOL - SYSTEM::PATCH-SHARP SYSTEM::PRINT-SYMBOL-APROPOS - COMMON-LISP::LOGNOT SLOOP::REPEAT-SLOOP-MACRO - COMMON-LISP::FOURTH SLOOP::SUBSTITUTE-SLOOP-BODY - COMMON-LISP::ATANH SLOOP::LOOP-COLLECT-KEYWORD-P - SYSTEM::SEQTYPE SYSTEM::RE-QUOTE-STRING COMMON-LISP::ISQRT - SYSTEM::DO-F SYSTEM::S-DATA-HAS-HOLES - ANSI-LOOP::LOOP-HACK-ITERATION ANSI-LOOP::LOOP-COLLECTOR-NAME - COMMON-LISP::RESTART-NAME COMMON-LISP::DIRECTORY-NAMESTRING - ANSI-LOOP::LOOP-EMIT-BODY COMMON-LISP::ACOSH - SYSTEM::RESTART-FUNCTION SYSTEM::INFO-NODE-FROM-POSITION - COMMON-LISP::ASIN ANSI-LOOP::LOOP-LIST-COLLECTION - SYSTEM::S-DATA-INCLUDES SYSTEM::GET-NEXT-VISIBLE-FUN - COMMON-LISP::BYTE-SIZE COMMON-LISP::PATHNAME - ANSI-LOOP::LOOP-MINIMAX-P SLOOP::PARSE-LOOP-INITIALLY - COMMON-LISP::COSH SYSTEM::EXPAND-HOME-DIR - COMMON-LISP::ECHO-STREAM-INPUT-STREAM - SYSTEM::INSERT-BREAK-POINT SYSTEM::RESTART-TEST-FUNCTION - SYSTEM::S-DATA-PRINT-FUNCTION SYSTEM::WILD-DIR-ELEMENT-P - SYSTEM::S-DATA-NAMED COMMON-LISP::INVOKE-DEBUGGER - COMMON-LISP::NAMESTRING ANSI-LOOP::LOOP-MAKE-DESETQ - COMMON-LISP::COMPLEMENT SYSTEM::WALK-THROUGH - COMMON-LISP::RATIONAL ANSI-LOOP::LOOP-MAXMIN-COLLECTION - COMMON-LISP::DELETE-FILE ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS)) + COMMON-LISP::BYTE-POSITION COMMON-LISP::ISQRT COMMON-LISP::CIS + ANSI-LOOP::LOOP-COLLECTOR-CLASS + COMMON-LISP::SYNONYM-STREAM-SYMBOL ANSI-LOOP::LOOP-PATH-NAMES + SYSTEM::RE-QUOTE-STRING SYSTEM::INSPECT-STRUCTURE + COMMON-LISP::RATIONAL FPE::XMM-LOOKUP + SYSTEM::REWRITE-RESTART-CASE-CLAUSE + SYSTEM::S-DATA-PRINT-FUNCTION + SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE SLOOP::SLOOP-SLOOP-MACRO + COMMON-LISP::NAMESTRING SYSTEM::ENSURE-DIR-STRING + COMMON-LISP::CONSTANTLY SLOOP::PARSE-LOOP-INITIALLY + SYSTEM::S-DATA-RAW SYSTEM::ADD-TO-HOTLIST SYSTEM::FRS-KIND + ANSI-LOOP::LOOP-MAXMIN-COLLECTION + ANSI-LOOP::LOOP-COLLECTOR-DATA SYSTEM::PROCESS-ARGS + SYSTEM::COERCE-SLASH-TERMINATED SYSTEM::MAKE-KCL-TOP-RESTART + COMMON-LISP::ATANH ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD + COMMON-LISP::SINH ANSI-LOOP::LOOP-UNIVERSE-P + ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED + SYSTEM::S-DATA-INCLUDED COMMON-LISP::STREAM-EXTERNAL-FORMAT + SYSTEM::COMPUTING-ARGS-P SYSTEM::REAL-ASINH + ANSI-LOOP::LOOP-CONSTRUCT-RETURN + SYSTEM::S-DATA-SLOT-DESCRIPTIONS SYSTEM::FIX-LOAD-PATH + SYSTEM::CHECK-DECLARATIONS + ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS + SLOOP::POINTER-FOR-COLLECT COMMON-LISP::LOGICAL-PATHNAME + SYSTEM::CHDIR SYSTEM::IDESCRIBE + ANSI-LOOP::LOOP-MINIMAX-OPERATIONS COMMON-LISP::ACOSH + COMMON-LISP::NINTH ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE + ANSI-LOOP::LOOP-COLLECTOR-P SYSTEM::S-DATA-P SYSTEM::BKPT-FORM + COMMON-LISP::FILE-NAMESTRING SYSTEM::TERMINAL-INTERRUPT + SYSTEM::SETUP-INFO SLOOP::PARSE-NO-BODY + SYSTEM::DM-KEY-NOT-ALLOWED ANSI-LOOP::LOOP-EMIT-FINAL-VALUE + SYSTEM::FREEZE-DEFSTRUCT SYSTEM::DBL-RPL-LOOP + SYSTEM::TRACE-ONE-PREPROCESS + COMMON-LISP::BROADCAST-STREAM-STREAMS COMMON-LISP::THIRD + SLOOP::AVERAGING-SLOOP-MACRO SYSTEM::SHOW-BREAK-POINT + COMMON-LISP::PATHNAME ANSI-LOOP::LOOP-DO-THEREIS + COMMON-LISP::FILE-AUTHOR ANSI-LOOP::LOOP-MAKE-DESETQ + SYSTEM::NC SYSTEM::NUMBER-OF-DAYS-FROM-1900 + SYSTEM::RESTART-TEST-FUNCTION SYSTEM::WHICH + ANSI-LOOP::DESTRUCTURING-SIZE COMMON-LISP::FILE-LENGTH)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - SYSTEM::BREAK-QUIT SYSTEM::BREAK-BDS SYSTEM::DBL-BACKTRACE - SYSTEM::BREAK-LOCAL SYSTEM::INFO-ERROR - SYSTEM::SHOW-BREAK-VARIABLES SYSTEM::BREAK-VS - COMMON-LISP::CONTINUE COMMON-LISP::MUFFLE-WARNING - SYSTEM::IHS-BACKTRACE ANSI-LOOP::LOOP-OPTIONAL-TYPE - SYSTEM::BREAK-PREVIOUS SYSTEM::BREAK-NEXT)) + SYSTEM::BREAK-VS ANSI-LOOP::LOOP-OPTIONAL-TYPE + SYSTEM::BREAK-BDS SYSTEM::IHS-BACKTRACE SYSTEM::INFO-ERROR + SYSTEM::BREAK-LOCAL SYSTEM::SHOW-BREAK-VARIABLES + COMMON-LISP::MUFFLE-WARNING SYSTEM::BREAK-PREVIOUS + SYSTEM::BREAK-QUIT SYSTEM::DBL-BACKTRACE COMMON-LISP::CONTINUE + SYSTEM::BREAK-NEXT)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) + SYSTEM::MAKE-KEYWORD)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - COMMON-LISP::T) + (COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::SMALLNTHCDR)) + SYSTEM::QUICK-SORT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - COMMON-LISP::HASH-TABLE) - SYSTEM::CONTEXT-SPICE)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + SYSTEM::BIGNTHCDR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) - SYSTEM::S-DATA-SIZE FPE::REG-LOOKUP SYSTEM::INSTREAM-LINE - SYSTEM::S-DATA-LENGTH SYSTEM::THE-START)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + COMMON-LISP::FIND-RESTART COMMON-LISP::PATHNAME-HOST + SYSTEM::LINK-EXPAND COMMON-LISP::CONCATENATE COMMON-LISP::WARN + COMMON-LISP::FILE-POSITION ANSI-LOOP::LOOP-WARN + COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::SBIT + COMMON-LISP::BIT ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES + COMMON-LISP::PATHNAME-TYPE COMMON-LISP::MAKE-ARRAY + ANSI-LOOP::LOOP-ERROR COMMON-LISP::DIRECTORY SYSTEM::DIR-PARSE + COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME + SYSTEM::NTH-STACK-FRAME COMMON-LISP::REQUIRE COMMON-LISP::LOAD + SYSTEM::MGLIST COMMON-LISP::DELETE-DUPLICATES + COMMON-LISP::PATHNAME-VERSION COMMON-LISP::ENOUGH-NAMESTRING + SYSTEM::BAD-SEQ-LIMIT COMMON-LISP::REMOVE-DUPLICATES + COMMON-LISP::PATHNAME-NAME + COMMON-LISP::MAKE-STRING-INPUT-STREAM SLOOP::LOOP-ADD-TEMPS + SYSTEM::NLOAD SYSTEM::LIST-MATCHES + COMMON-LISP::ARRAY-ROW-MAJOR-INDEX + COMMON-LISP::ARRAY-IN-BOUNDS-P SYSTEM::BREAK-LEVEL + SYSTEM::PROCESS-SOME-ARGS SYSTEM::TO-REGEXP + COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE COMMON-LISP::OPEN + SYSTEM::FILE-SEARCH COMMON-LISP::READ-BYTE + SYSTEM::FILE-TO-STRING SLOOP::ADD-FROM-DATA COMMON-LISP::ERROR + COMMON-LISP::SIGNAL SYSTEM::MGSUB COMMON-LISP::WILD-PATHNAME-P + COMMON-LISP::PATHNAME-DEVICE SYSTEM::LOGICAL-PATHNAME-PARSE + COMMON-LISP::MERGE-PATHNAMES SYSTEM::INFO-SEARCH + COMMON-LISP::BIT-NOT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T) - SYSTEM::MATCH-BEGINNING SYSTEM::MATCH-END)) -(COMMON-LISP::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(SYSTEM::CONDITION-CLASS-P SYSTEM::WARNINGP SYSTEM::SI-CLASS-OF - SYSTEM::SI-FIND-CLASS SYSTEM::DEFINE-STRUCTURE - FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS - SYSTEM::SIMPLE-CONDITION-CLASS-P SYSTEM::AUTOLOAD - SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::SI-CLASS-NAME - SYSTEM::TRACE-ONE SYSTEM::MAKE-ACCESS-FUNCTION - SYSTEM::UNTRACE-ONE SYSTEM::SI-CLASSP SYSTEM::CONDITIONP - SYSTEM::AUTOLOAD-MACRO)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + ANSI-LOOP::ESTIMATE-CODE-SIZE-1 SYSTEM::DO-REPL + SYSTEM::SOURCE-PORTION SYSTEM::RESTART-REPORT + SYSTEM::NEW-SEMI-COLON-READER SYSTEM::FIND-DOC + ANSI-LOOP::ESTIMATE-CODE-SIZE SYSTEM::NEWLINE + COMMON-LISP::RENAME-FILE SYSTEM::LIST-TOGGLE-CASE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::T) - SYSTEM::GET-CONTEXT SYSTEM::PUSH-CONTEXT)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + COMMON-LISP::REDUCE COMMON-LISP::STABLE-SORT + SYSTEM::PARSE-BODY SLOOP::FIND-IN-ORDERED-LIST + COMMON-LISP::SUBTYPEP COMMON-LISP::SORT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::FIXNUM) - SYSTEM::RELATIVE-LINE SYSTEM::LENEL SYSTEM::THE-END - ANSI-LOOP::DUPLICATABLE-CODE-P SYSTEM::FASLINK - SYSTEM::GET-NODE-INDEX)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + SYSTEM::LIST-MERGE-SORT ANSI-LOOP::LOOP-GET-COLLECTION-INFO + SYSTEM::SHARP---READER SYSTEM::SHARP-S-READER + SYSTEM::VERIFY-KEYWORDS SYSTEM::RESTART-PRINT + SYSTEM::SHARP-+-READER SYSTEM::READ-INSPECT-COMMAND)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - SLOOP::PARSE-ONE-WHEN-CLAUSE ANSI-LOOP::LOOP-DO-FINALLY - SLOOP::LOOP-PEEK ANSI-LOOP::LOOP-DO-INITIALLY SLOOP::LOOP-POP - ANSI-LOOP::LOOP-GET-PROGN SYSTEM::KCL-TOP-RESTARTS - SYSTEM::INSPECT-READ-LINE SLOOP::PARSE-LOOP-WHEN - ANSI-LOOP::LOOP-GET-FORM SYSTEM::DEFAULT-SYSTEM-BANNER - SYSTEM::SET-UP-TOP-LEVEL SYSTEM::GET-INDEX-NODE - ANSI-LOOP::LOOP-DO-DO ANSI-LOOP::LOOP-WHEN-IT-VARIABLE - SYSTEM::SETUP-LINEINFO COMMON-LISP::TYPE-ERROR - SYSTEM::READ-EVALUATED-FORM SYSTEM::INSPECT-INDENT-1 - SLOOP::LOOP-UN-POP SLOOP::PARSE-LOOP-DO - ANSI-LOOP::LOOP-DO-WITH SYSTEM::INSPECT-INDENT - SYSTEM::GET-TEMP-DIR ANSI-LOOP::LOOP-ITERATION-DRIVER - SYSTEM::WINE-TMP-REDIRECT SLOOP::PARSE-LOOP-COLLECT - SYSTEM::DEFAULT-INFO-HOTLIST SLOOP::PARSE-LOOP1 - SYSTEM::CLEANUP ANSI-LOOP::LOOP-DO-NAMED SYSTEM::DBL - SYSTEM::ALL-TRACE-DECLARATIONS SYSTEM::TEST-ERROR - ANSI-LOOP::LOOP-BIND-BLOCK ANSI-LOOP::LOOP-DO-REPEAT - SYSTEM::ILLEGAL-BOA SYSTEM::SET-ENV SYSTEM::SET-CURRENT - SYSTEM::INIT-BREAK-POINTS SYSTEM::GET-SIG-FN-NAME - ANSI-LOOP::LOOP-DO-RETURN ANSI-LOOP::LOOP-CONTEXT - SYSTEM::SHOW-RESTARTS SYSTEM::STEP-READ-LINE - SLOOP::PARSE-LOOP-FOR SYSTEM::DM-TOO-MANY-ARGUMENTS - COMMON-LISP::LISP-IMPLEMENTATION-VERSION SYSTEM::TOP-LEVEL - ANSI-LOOP::LOOP-POP-SOURCE SYSTEM::DM-TOO-FEW-ARGUMENTS)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + SYSTEM::PUSH-OPTIONAL-BINDING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER - COMMON-LISP::*)) - COMMON-LISP::T) - SYSTEM::RESET-SYS-PATHS)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::*) + SYSTEM::TRACE-CALL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::VECTOR COMMON-LISP::T)) - SYSTEM::CONTEXT-VEC)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::*) + SYSTEM::MASET)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + SYSTEM::EXPAND-WILD-DIRECTORY)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + SYSTEM::PARSE-DEFMACRO SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::*) + SYSTEM::MME3)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + ((COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T) + COMMON-LISP::T) + SYSTEM::SMALLNTHCDR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) - SYSTEM::BREAK-HELP SYSTEM::BREAK-MESSAGE - SYSTEM::SIMPLE-BACKTRACE ANSI-LOOP::LOOP-DO-FOR - SYSTEM::BREAK-CURRENT SYSTEM::GCL-TOP-LEVEL - SYSTEM::BREAK-RESUME)) \ No newline at end of file + SYSTEM::GCL-TOP-LEVEL SYSTEM::BREAK-MESSAGE + SYSTEM::BREAK-RESUME SYSTEM::SIMPLE-BACKTRACE + SYSTEM::BREAK-HELP ANSI-LOOP::LOOP-DO-FOR + SYSTEM::BREAK-CURRENT)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) + SYSTEM::S-DATA-LENGTH SYSTEM::THE-START SYSTEM::INSTREAM-LINE + SYSTEM::S-DATA-SIZE FPE::REG-LOOKUP)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T) + SYSTEM::MATCH-BEGINNING SYSTEM::MATCH-END)) \ No newline at end of file diff --git a/o/fasdump.c b/o/fasdump.c index 01f3221..2ee5ec8 100755 --- a/o/fasdump.c +++ b/o/fasdump.c @@ -598,7 +598,7 @@ DEFUN_NEW("OPEN-FASD",object,fSopen_fasd,SI,4,4,NONE,OO,OO,OO,OO,(object stream, if(tabl==Cnil) tabl=funcall_cfun(Lmake_hash_table,2,sKtest,sLeq); else check_type(tabl,t_hashtable);} - check_type(str,t_stream); + massert(str==stream); result=alloc_simple_vector(sizeof(struct fasd)/sizeof(int),aet_object); array_allocself(result,1,Cnil); {struct fasd *fd= (struct fasd *)result->v.v_self; @@ -608,7 +608,7 @@ DEFUN_NEW("OPEN-FASD",object,fSopen_fasd,SI,4,4,NONE,OO,OO,OO,OO,(object stream, fd->eof=eof; fd->index=small_fixnum(0); fd->package=symbol_value(sLApackageA); - fd->filepos = make_fixnum(file_position(stream)); + fd->filepos = make_fixnum(ftell(stream->sm.sm_fp)); SETUP_FASD_IN(fd); if (direction==sKoutput){ @@ -649,13 +649,13 @@ DEFUN_NEW("CLOSE-FASD",object,fSclose_fasd,SI,1,1,NONE,OO,OO,OO,OO,(object ar)," {clrhash(fd->table); SETUP_FASD_IN(fd); PUT_OP(d_end_of_file); - {int i = file_position(fd->stream); + {int i = ftell(fd->stream->sm.sm_fp); if(type_of(fd->filepos) == t_fixnum) - { file_position_set(fd->stream,fix(fd->filepos) +2); + { fseek(fd->stream->sm.sm_fp,fix(fd->filepos)+2,SEEK_SET); /* record the length of array needed to read the indices */ PUT4(fix(fd->index)); /* move back to where we were */ - file_position_set(fd->stream,i); + fseek(fd->stream->sm.sm_fp,i,SEEK_SET); }} } diff --git a/o/file.d b/o/file.d index 2d51488..29e5643 100755 --- a/o/file.d +++ b/o/file.d @@ -167,7 +167,6 @@ BEGIN: case smm_probe: return(FALSE); - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -224,7 +223,6 @@ BEGIN: case smm_probe: return(FALSE); - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -272,7 +270,6 @@ BEGIN: case smm_socket: return (sLcharacter); - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -440,7 +437,7 @@ open_stream(object fn,enum smmode smm, object if_exists, object if_does_not_exis x->sm.sm_buffer = 0; x->sm.sm_object0 = sLcharacter; x->sm.sm_object1 = vs_head; - x->sm.sm_int0 = x->sm.sm_int1 = 0; + x->sm.sm_int = 0; x->sm.sm_flags=0; vs_push(x); @@ -522,8 +519,6 @@ DEFUN_NEW("OPEN-STREAM-P",object,fLopen_stream_p,LISP,1,1,NONE,OO,OO,OO,OO,(obje void close_stream(object strm) { - object x; - if (FFN(fLopen_stream_p)(strm)==Cnil) return; @@ -569,24 +564,15 @@ close_stream(object strm) { strm->sm.sm_fd = -1; break; - case smm_file_synonym: case smm_synonym: - strm = symbol_value(strm->sm.sm_object0); - if (type_of(strm) != t_stream) - TYPE_ERROR(strm,sLstream); - close_stream(strm); break; case smm_broadcast: case smm_concatenated: - for (x = strm->sm.sm_object0; !endp(x); x = x->c.c_cdr) - close_stream(x->c.c_car); break; case smm_two_way: case smm_echo: - close_stream(STREAM_INPUT_STREAM(strm)); - close_stream(STREAM_OUTPUT_STREAM(strm)); break; case smm_string_input: @@ -616,7 +602,6 @@ DEFUN_NEW("INTERACTIVE-STREAM-P",object,fLinteractive_stream_p,LISP,1,1,NONE,OO, return Ct; return Cnil; break; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -656,7 +641,7 @@ object istrm, ostrm; strm->sm.sm_buffer = 0; STREAM_INPUT_STREAM(strm) = istrm; STREAM_OUTPUT_STREAM(strm) = ostrm; - strm->sm.sm_int0 = strm->sm.sm_int1 = 0; + strm->sm.sm_int = 0; strm->sm.sm_flags=0; return(strm); } @@ -672,24 +657,30 @@ object istrm, ostrm; return(strm); } -object -make_string_input_stream(strng, istart, iend) -object strng; -int istart, iend; -{ - object strm; +DEFUN_NEW("MAKE-STRING-INPUT-STREAM-INT",object,fSmake_string_input_stream_int,SI,3,3,NONE,OO,II,OO,OO, + (object strng,fixnum istart,fixnum iend),"") { + + object strm; + + strm = alloc_object(t_stream); + strm->sm.sm_mode = (short)smm_string_input; + strm->sm.sm_fp = NULL; + strm->sm.sm_buffer = 0; + STRING_STREAM_STRING(strm) = strng; + strm->sm.sm_object1 = OBJNULL; + STRING_INPUT_STREAM_NEXT(strm)= istart; + STRING_INPUT_STREAM_END(strm)= iend; + strm->sm.sm_flags=0; + + RETURN1(strm); - strm = alloc_object(t_stream); - strm->sm.sm_mode = (short)smm_string_input; - strm->sm.sm_fp = NULL; - strm->sm.sm_buffer = 0; - STRING_STREAM_STRING(strm) = strng; - strm->sm.sm_object1 = OBJNULL; - STRING_INPUT_STREAM_NEXT(strm)= istart; - STRING_INPUT_STREAM_END(strm)= iend; - strm->sm.sm_flags=0; - return(strm); } +#ifdef STATIC_FUNCTION_POINTERS +object +fSmake_string_input_stream_int(object x,fixnum y,fixnum z) { + return FFN(fSmake_string_input_stream_int)(x,y,z); +} +#endif DEFUN_NEW("STRING-INPUT-STREAM-P",object,fSstring_input_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") { return type_of(x)==t_stream && x->sm.sm_mode == (short)smm_string_input ? Ct : Cnil; @@ -722,7 +713,7 @@ int line_length; strm->sm.sm_buffer = 0; STRING_STREAM_STRING(strm) = strng; strm->sm.sm_object1 = OBJNULL; - strm->sm.sm_int0 = STREAM_FILE_COLUMN(strm) = 0; + strm->sm.sm_int = 0; strm->sm.sm_flags=0; vs_reset; return(strm); @@ -777,7 +768,6 @@ BEGIN: /* strm->sm.sm_int0++; */ return(c==EOF ? c : (c&0377)); - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -880,7 +870,6 @@ BEGIN: /* --strm->sm.sm_int0; */ /* use ftell now for position */ break; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -982,7 +971,6 @@ BEGIN: break; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -1093,7 +1081,6 @@ BEGIN: #endif closed_stream(strm); break; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -1182,7 +1169,6 @@ BEGIN: case smm_probe: return(FALSE); - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); check_stream(strm); @@ -1308,7 +1294,6 @@ BEGIN: #endif return TRUE; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -1344,136 +1329,6 @@ BEGIN: } } -int -file_position(strm) -object strm; -{ -BEGIN: - switch (strm->sm.sm_mode) { - case smm_input: - case smm_output: - case smm_io: - /* return(strm->sm.sm_int0); */ - if (strm->sm.sm_fp == NULL) - closed_stream(strm); - return(ftell(strm->sm.sm_fp)); - case smm_socket: - return -1; - - - case smm_string_output: - return(STRING_STREAM_STRING(strm)->st.st_fillp); - - case smm_file_synonym: - case smm_synonym: - strm = symbol_value(strm->sm.sm_object0); - if (type_of(strm) != t_stream) - FEwrong_type_argument(sLstream, strm); - goto BEGIN; - - case smm_probe: - case smm_broadcast: - case smm_concatenated: - case smm_two_way: - case smm_echo: - case smm_string_input: - return(-1); - - default: - error("illegal stream mode"); - return(-1); - } -} - -int -file_position_set(strm, disp) -object strm; -int disp; -{ -BEGIN: - switch (strm->sm.sm_mode) { - case smm_socket: - return -1; - case smm_input: - case smm_output: - case smm_io: - - if (fseek(strm->sm.sm_fp, disp, 0) < 0) - return(-1); - /* strm->sm.sm_int0 = disp; */ - return(0); - - case smm_string_output: - if (disp < STRING_STREAM_STRING(strm)->st.st_fillp) { - STRING_STREAM_STRING(strm)->st.st_fillp = disp; - /* strm->sm.sm_int0 = disp; */ - } else { - disp -= STRING_STREAM_STRING(strm)->st.st_fillp; - while (disp-- > 0) - writec_stream(' ', strm); - } - return(0); - - case smm_file_synonym: - case smm_synonym: - strm = symbol_value(strm->sm.sm_object0); - if (type_of(strm) != t_stream) - FEwrong_type_argument(sLstream, strm); - goto BEGIN; - - case smm_probe: - case smm_broadcast: - case smm_concatenated: - case smm_two_way: - case smm_echo: - case smm_string_input: - return(-1); - - default: - error("illegal stream mode"); - return(-1); - } -} - -static int -file_length(strm) -object strm; -{ -BEGIN: - switch (strm->sm.sm_mode) { - case smm_input: - case smm_output: - case smm_io: - - if (strm->sm.sm_fp == NULL) - closed_stream(strm); - return(file_len(strm->sm.sm_fp)); - - - - case smm_file_synonym: - case smm_synonym: - strm = symbol_value(strm->sm.sm_object0); - if (type_of(strm) != t_stream) - FEwrong_type_argument(sLstream, strm); - goto BEGIN; - - case smm_socket: - case smm_probe: - case smm_broadcast: - case smm_concatenated: - case smm_two_way: - case smm_echo: - case smm_string_input: - case smm_string_output: - return(-1); - - default: - error("illegal stream mode"); - return(-1); - } -} - int file_column(object strm) { int i; @@ -1491,7 +1346,6 @@ BEGIN: case smm_two_way: strm=STREAM_OUTPUT_STREAM(strm); goto BEGIN; - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -1558,22 +1412,6 @@ load(const char *s) { -static int -file_synonym_stream_p(object x) { - switch(x->sm.sm_mode) { - case smm_input: - case smm_output: - case smm_io: - case smm_probe: - case smm_file_synonym: - return 1; - case smm_synonym: - return file_synonym_stream_p(x->sm.sm_object0->s.s_dbind); - default: - return 0; - } -} - LFD(Lmake_synonym_stream)() { object x; @@ -1581,12 +1419,12 @@ LFD(Lmake_synonym_stream)() check_arg(1); check_type_sym(&vs_base[0]); x = alloc_object(t_stream); - x->sm.sm_mode = file_synonym_stream_p(vs_base[0]) ? (short)smm_file_synonym : (short)smm_synonym; + x->sm.sm_mode = (short)smm_synonym; x->sm.sm_fp = NULL; x->sm.sm_buffer = 0; x->sm.sm_object0 = vs_base[0]; x->sm.sm_object1 = OBJNULL; - x->sm.sm_int0 = x->sm.sm_int1 = 0; + x->sm.sm_int = 0; x->sm.sm_flags=0; vs_base[0] = x; } @@ -1610,7 +1448,7 @@ LFD(Lmake_broadcast_stream)() x->sm.sm_buffer = 0; x->sm.sm_object0 = vs_base[0]; x->sm.sm_object1 = OBJNULL; - x->sm.sm_int0 = x->sm.sm_int1 = 0; + x->sm.sm_int = 0; x->sm.sm_flags=0; vs_base[0] = x; } @@ -1634,7 +1472,7 @@ LFD(Lmake_concatenated_stream)() x->sm.sm_buffer = 0; x->sm.sm_object0 = vs_base[0]; x->sm.sm_object1 = OBJNULL; - x->sm.sm_int0 = x->sm.sm_int1 = 0; + x->sm.sm_int = 0; x->sm.sm_flags=0; vs_base[0] = x; } @@ -1667,32 +1505,6 @@ LFD(Lmake_echo_stream)() vs_popp; } -@(static defun make_string_input_stream (strng &o istart iend) - int s, e; -@ - check_type_string(&strng); - if (istart == Cnil) - s = 0; - else if (type_of(istart) != t_fixnum) - goto E; - else - s = fix(istart); - if (iend == Cnil) - e = strng->st.st_fillp; - else if (type_of(iend) != t_fixnum) - goto E; - else - e = fix(iend); - if (s < 0 || e > strng->st.st_fillp || s > e) - goto E; - @(return `make_string_input_stream(strng, s, e)`) - -E: - FEerror("~S and ~S are illegal as :START and :END~%\ -for the string ~S.", - 3, istart, iend, strng); -@) - @(static defun make_string_output_stream (&k element_type) @ element_type=Cnil;/*FIXME*/ @@ -1724,12 +1536,29 @@ LFD(siLoutput_stream_string)() vs_base[0] = vs_base[0]->sm.sm_object0; } +object +file_stream(object x) { + if (type_of(x)==t_stream) + switch(x->sm.sm_mode) { + case smm_input: + case smm_output: + case smm_io: + case smm_probe: + return x; + case smm_synonym: + return file_stream(x->sm.sm_object0->s.s_dbind); + default: + break; + } + return Cnil; +} + DEFUN_NEW("FILE-STREAM-P",object,fSfile_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") { - RETURN1(type_of(x)==t_stream && file_synonym_stream_p(x) ? Ct : Cnil); + RETURN1(file_stream(x)!=Cnil ? Ct : Cnil); } DEFUN_NEW("SYNONYM-STREAM-P",object,fSsynonym_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") { - RETURN1(type_of(x)==t_stream && (x->sm.sm_mode==smm_file_synonym || x->sm.sm_mode==smm_synonym) ? Ct : Cnil); + RETURN1(type_of(x)==t_stream && x->sm.sm_mode==smm_synonym ? Ct : Cnil); } DEFUN_NEW("TERMINAL-INPUT-STREAM-P",object,fSterminal_input_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") { @@ -1802,43 +1631,6 @@ LFD(Lstream_element_type)() @) -@(defun file_position (file_stream &o position) - int i=0; -@ - check_type_stream(&file_stream); - if (position == Cnil) { - i = file_position(file_stream); - if (i < 0) - @(return Cnil) - @(return `make_fixnum(i)`) - } else { - if (position == sKstart) - i = 0; - else if (position == sKend) - i = file_length(file_stream); - else if (type_of(position) != t_fixnum || - (i = fix((position))) < 0) - FEerror("~S is an illegal file position~%\ -for the file-stream ~S.", - 2, position, file_stream); - if (file_position_set(file_stream, i) < 0) - @(return Cnil) - @(return Ct) - } -@) - -LFD(Lfile_length)() -{ - int i; - - check_arg(1); - check_type_stream(&vs_base[0]); - i = file_length(vs_base[0]); - if (i < 0) - vs_base[0] = Cnil; - else - vs_base[0] = make_fixnum(i); -} object sLAload_pathnameA; DEFVAR("*COLLECT-BINARY-MODULES*",sSAcollect_binary_modulesA,SI,sLnil,""); @@ -1911,17 +1703,6 @@ DEFUN_NEW("LOAD-FASL",object,fSload_fasl,SI,2,2,NONE,OO,OO,OO,OO,(object fasl_fi } -static void -FFN(siLget_string_input_stream_index)() -{ - check_arg(1); - check_type_stream(&vs_base[0]); - if ((enum smmode)vs_base[0]->sm.sm_mode != smm_string_input) - FEerror("~S is not a string-input stream.", 1, vs_base[0]); - vs_base[0] = make_fixnum(STRING_INPUT_STREAM_NEXT(vs_base[0])); -} - - LFD(siLmake_string_output_stream_from_string)() { object strng, strm; @@ -2042,7 +1823,6 @@ int out; if (type_of(strm) != t_stream) FEwrong_type_argument(sLstream, strm); switch (strm->sm.sm_mode){ - case smm_file_synonym: case smm_synonym: strm = symbol_value(strm->sm.sm_object0); if (type_of(strm) != t_stream) @@ -2203,7 +1983,7 @@ object async; x->sm.sm_buffer = 0; x->sm.sm_object0 = list(3,server,host,port); x->sm.sm_object1 = 0; - x->sm.sm_int0 = x->sm.sm_int1 = 0; + x->sm.sm_int = 0; x->sm.sm_flags=0; SOCKET_STREAM_FD(x)= fd; SET_STREAM_FLAG(x,mode,1); @@ -2466,8 +2246,7 @@ gcl_init_file(void) #ifdef UNIX = make_simple_string("stdin"); #endif - standard_input->sm.sm_int0 = 0; /* unused */ - standard_input->sm.sm_int1 = 0; /* unused */ + standard_input->sm.sm_int = 0; /* unused */ standard_input->sm.sm_flags=0; standard_output = alloc_object(t_stream); @@ -2479,8 +2258,7 @@ gcl_init_file(void) #ifdef UNIX = make_simple_string("stdout"); #endif - standard_output->sm.sm_int0 = 0; /* unused */ - STREAM_FILE_COLUMN(standard_output) = 0; + standard_output->sm.sm_int = 0; /* unused */ standard_output->sm.sm_flags=0; terminal_io = standard @@ -2488,12 +2266,12 @@ gcl_init_file(void) enter_mark_origin(&terminal_io); x = alloc_object(t_stream); - x->sm.sm_mode = (short)smm_file_synonym; + x->sm.sm_mode = (short)smm_synonym; x->sm.sm_fp = NULL; x->sm.sm_buffer = 0; x->sm.sm_object0 = sLAterminal_ioA; x->sm.sm_object1 = OBJNULL; - x->sm.sm_int0 = x->sm.sm_int1 = 0; /* unused */ + x->sm.sm_int = 0; /* unused */ x->sm.sm_flags=0; standard_io = x; enter_mark_origin(&standard_io); @@ -2561,8 +2339,6 @@ gcl_init_file_function() Lmake_concatenated_stream); make_function("MAKE-TWO-WAY-STREAM", Lmake_two_way_stream); make_function("MAKE-ECHO-STREAM", Lmake_echo_stream); - make_function("MAKE-STRING-INPUT-STREAM", - Lmake_string_input_stream); make_function("MAKE-STRING-OUTPUT-STREAM", Lmake_string_output_stream); make_function("GET-OUTPUT-STREAM-STRING", @@ -2581,11 +2357,6 @@ gcl_init_file_function() make_function("STREAM-ELEMENT-TYPE", Lstream_element_type); make_function("CLOSE", Lclose); - make_function("FILE-POSITION", Lfile_position); - make_function("FILE-LENGTH", Lfile_length); - - make_si_function("GET-STRING-INPUT-STREAM-INDEX", - siLget_string_input_stream_index); make_si_function("MAKE-STRING-OUTPUT-STREAM-FROM-STRING", siLmake_string_output_stream_from_string); make_si_function("COPY-STREAM", siLcopy_stream); diff --git a/o/gbc.c b/o/gbc.c index dd2f5a0..df0e990 100755 --- a/o/gbc.c +++ b/o/gbc.c @@ -627,7 +627,6 @@ mark_object1(object x) { } break; - case smm_file_synonym: case smm_synonym: mark_object(x->sm.sm_object0); break; diff --git a/o/pathname.d b/o/pathname.d index b236d78..3c75882 100755 --- a/o/pathname.d +++ b/o/pathname.d @@ -83,6 +83,11 @@ DEFUN_NEW("C-STREAM-OBJECT1",object,fSc_stream_object1,SI,1,1,NONE,OO,OO,OO,OO,( RETURN1(x->sm.sm_object1); } +DEFUN_NEW("C-SET-STREAM-OBJECT0",object,fSc_set_stream_object0,SI,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") { + x->sm.sm_object0=y; + RETURN1(x); +} + DEFUN_NEW("C-SET-STREAM-OBJECT1",object,fSc_set_stream_object1,SI,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") { x->sm.sm_object1=y; RETURN1(x); diff --git a/o/print.d b/o/print.d index 9f256d3..e5fe774 100755 --- a/o/print.d +++ b/o/print.d @@ -1260,7 +1260,6 @@ int level; write_ch('>'); break; - case smm_file_synonym: case smm_synonym: write_str("#sm.sm_object0, level); diff --git a/o/read.d b/o/read.d index 00c9822..7c8e231 100755 --- a/o/read.d +++ b/o/read.d @@ -2204,7 +2204,7 @@ object x; object in; vs_mark; - in = make_string_input_stream(x, 0, x->st.st_fillp); + in = fSmake_string_input_stream_int(x, 0, x->st.st_fillp); vs_push(in); preserving_whitespace_flag = FALSE; detect_eos_flag = FALSE; diff --git a/o/run_process.c b/o/run_process.c index 288d6de..6c4243d 100755 --- a/o/run_process.c +++ b/o/run_process.c @@ -434,7 +434,7 @@ enum smmode smm; stream->sm.sm_object0 = sLcharacter; stream->sm.sm_object1 = host_l; - stream->sm.sm_int0 = stream->sm.sm_int1 = 0; + stream->sm.sm_int = 0; stream->sm.sm_flags=0; vs_push(stream); setup_stream_buffer(stream); @@ -503,8 +503,7 @@ make_socket_pair() stream_in->sm.sm_mode = smm_input; stream_in->sm.sm_fp = fp1; stream_in->sm.sm_buffer = 0; - stream_in->sm.sm_int0 = sockets_in[1]; - stream_in->sm.sm_int1 = 0; + stream_in->sm.sm_int = sockets_in[1]; stream_in->sm.sm_object0=stream_in->sm.sm_object1=OBJNULL; stream_in->sm.sm_flags = 0; stream_out = (object) alloc_object(t_stream); @@ -513,8 +512,7 @@ make_socket_pair() stream_out->sm.sm_buffer = 0; setup_stream_buffer(stream_in); setup_stream_buffer(stream_out); - stream_out->sm.sm_int0 = sockets_out[1]; - stream_out->sm.sm_int1 = 0; + stream_out->sm.sm_int = sockets_out[1]; stream_out->sm.sm_flags = 0; stream_out->sm.sm_object0=stream_out->sm.sm_object1=OBJNULL; stream = make_two_way_stream(stream_in, stream_out); @@ -538,8 +536,8 @@ char **argv; int fdout; if (istream->sm.sm_fp == NULL || ostream->sm.sm_fp == NULL) FEerror("Cannot spawn process with given stream", 0); - fdin = istream->sm.sm_int0; - fdout = ostream->sm.sm_int0; + fdin = istream->sm.sm_int; + fdout = ostream->sm.sm_int; if (pfork() == 0) { /* the child --- replace standard in and out with descriptors given */ close(0); diff --git a/o/sockets.c b/o/sockets.c index 512771d..a388857 100755 --- a/o/sockets.c +++ b/o/sockets.c @@ -518,16 +518,6 @@ DEFUN_NEW("SET-SIGIO-FOR-FD",object,fSset_sigio_for_fd,SI,1,1,NONE,OI,OO,OO,OO,( } -DEFUN_NEW("RESET-STRING-INPUT-STREAM",object,fSreset_string_input_stream,SI,4,4,NONE,OO,OI,IO,OO,(object strm,object string,fixnum start,fixnum end), - "Reuse a string output STREAM by setting its output to STRING \ -and positioning the ouput/input to start at START and end at END") - -{ strm->sm.sm_object0 = string; - strm->sm.sm_int0 = start; - strm->sm.sm_int1 = end; - return strm; -} - DEFUN_NEW("CHECK-STATE-INPUT",object,fScheck_state_input,SI,2,2,NONE,OO,IO,OO,OO,(object osfd,fixnum timeout), "") { diff --git a/o/string.d b/o/string.d index c262b17..4c76c71 100755 --- a/o/string.d +++ b/o/string.d @@ -564,28 +564,33 @@ LFD(Lnstring_capitalize)() { casefun = char_capitalize; FFN(Lnstring_case)(); } @(return `coerce_to_string(x)`) @) -static void -FFN(siLstring_concatenate)() -{ - int narg, i, l, m; - object *v; +DEFUN_NEW("STRING-CONCATENATE",object,fLstring_concatenate,SI,0,63,NONE,OO,OO,OO,OO,(object first,...),"") { + + fixnum i,l,m,narg=VFUN_NARGS; + object x; + va_list ap; + + va_start(ap,first); + vs_base=vs_top; + for (l=i=0;ist.st_fillp; + } + va_end(ap); + + { + object *p; + BEGIN_NO_INTERRUPT; + x=alloc_simple_string(l); + (x)->st.st_self = alloc_relblock(l); + for (l=0,p=vs_base;pst.st_fillp)>=0;p++,l+=m) + memcpy(x->st.st_self+l,(*p)->st.st_self,m); + END_NO_INTERRUPT; + + } + + RETURN1(x); - narg = vs_top - vs_base; - for (i = 0, l = 0; i < narg; i++) { - vs_base[i] = coerce_to_string(vs_base[i]); - l += vs_base[i]->st.st_fillp; - } - v = vs_top; - {BEGIN_NO_INTERRUPT; - vs_push(alloc_simple_string(l)); - (*v)->st.st_self = alloc_relblock(l); - for (i = 0, l = 0; i < narg; i++) - for (m = 0; m < vs_base[i]->st.st_fillp; m++) - (*v)->st.st_self[l++] - = vs_base[i]->st.st_self[m]; - vs_base[0] = *v; - vs_top = vs_base + 1; - END_NO_INTERRUPT;} } void @@ -628,6 +633,4 @@ gcl_init_string_function() make_function("NSTRING-CAPITALIZE", Lnstring_capitalize); make_function("STRING", Lstring); - make_si_function("STRING-CONCATENATE", - siLstring_concatenate); } diff --git a/o/unixfsys.c b/o/unixfsys.c index 32e8ebe..ccf6ae6 100755 --- a/o/unixfsys.c +++ b/o/unixfsys.c @@ -55,7 +55,7 @@ get_string(object x) { case smm_probe: case smm_io: return get_string(x->sm.sm_object1); - case smm_file_synonym: + case smm_synonym: return get_string(x->sm.sm_object0->s.s_dbind); } } @@ -169,24 +169,6 @@ DEF_ORDINARY("DIRECTORY",sKdirectory,KEYWORD,""); DEF_ORDINARY("LINK",sKlink,KEYWORD,""); DEF_ORDINARY("FILE",sKfile,KEYWORD,""); -object -file_stream(object x) { - if (type_of(x)==t_stream) - switch(x->sm.sm_mode) { - case smm_input: - case smm_output: - case smm_io: - case smm_probe: - return x; - case smm_synonym: - return file_stream(x->sm.sm_object0->s.s_dbind); - default: - break; - } - return Cnil; -} - - DEFUNM_NEW("STAT",object,fSstat,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") { struct stat ss; diff --git a/pcl/sys-proclaim.lisp b/pcl/sys-proclaim.lisp index 2e1b703..b36825f 100644 --- a/pcl/sys-proclaim.lisp +++ b/pcl/sys-proclaim.lisp @@ -2,673 +2,402 @@ (COMMON-LISP::IN-PACKAGE "PCL") (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FUNCTION) - PCL::CACHE-LIMIT-FN PCL::FAST-METHOD-CALL-FUNCTION - PCL::METHOD-CALL-FUNCTION)) + (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM COMMON-LISP::T) + COMMON-LISP::T) + PCL::%CCLOSURE-ENV-NTHCDR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - PCL::DISPATCH-DFUN-INFO PCL::DEFAULT-METHOD-ONLY-DFUN-INFO - PCL::MAKE-CACHE PCL::BOOTSTRAP-BUILT-IN-CLASSES - PCL::RENEW-SYS-FILES PCL::SHOW-EMF-CALL-TRACE PCL::MAKE-CPD - PCL::BOOTSTRAP-META-BRAID PCL::CACHES-TO-ALLOCATE - PCL::LIST-ALL-DFUNS PCL::INITIAL-DISPATCH-DFUN-INFO - PCL::INITIAL-DFUN-INFO PCL::%%ALLOCATE-INSTANCE--CLASS - PCL::MAKE-ARG-INFO PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2 - PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS - PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::IN-THE-COMPILER-P - PCL::SHOW-DFUN-CONSTRUCTORS PCL::NO-METHODS-DFUN-INFO - PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST - PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1 - PCL::STRUCTURE-FUNCTIONS-EXIST-P)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::FIXNUM) + PCL::GET-WRAPPER-CACHE-NUMBER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) PCL::FIELD-TYPE) - PCL::CACHE-FIELD)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + PCL::NON-NEGATIVE-FIXNUM) + PCL::CACHE-NLINES PCL::CACHE-MASK PCL::CACHE-SIZE + PCL::CACHE-MAX-LOCATION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::SIMPLE-VECTOR) PCL::CACHE-VECTOR)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::INTEGER 1 256)) - PCL::CACHE-LINE-SIZE)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::INTEGER 1 255)) - PCL::CACHE-NKEYS)) -(COMMON-LISP::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'SYSTEM::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(PCL::REDEFINE-FUNCTION PCL::DO-STANDARD-DEFSETF-1 - PCL::FDEFINE-CAREFULLY PCL::TRACE-METHOD-INTERNAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) - PCL::SYMBOL-APPEND)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL - PCL::GENERIC-CLOBBERS-FUNCTION PCL::STRUCTURE-SLOTD-TYPE - WALKER::GET-WALKER-TEMPLATE PCL::COMPILE-LAMBDA-UNCOMPILED - PCL::EXTRACT-LAMBDA-LIST PCL::DEFAULT-METHOD-ONLY-P - PCL::DISPATCH-CACHE PCL::STRUCTURE-SLOTD-NAME - PCL::FAST-METHOD-CALL-P PCL::SFUN-P - PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST - PCL::EARLY-CLASS-DEFINITION PCL::CONSTANT-SYMBOL-P - PCL::ARG-INFO-LAMBDA-LIST WALKER::ENV-LEXICAL-VARIABLES - PCL::INTERN-EQL-SPECIALIZER PCL::PARSE-SPECIALIZERS - PCL::%STD-INSTANCE-WRAPPER PCL::UPDATE-ALL-C-A-M-GF-INFO - PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION - PCL::STORE-FGEN PCL::COMPUTE-MCASE-PARAMETERS - PCL::INTERNED-SYMBOL-P PCL::MAKE-CALL-METHODS - PCL::USE-CACHING-DFUN-P PCL::LEGAL-CLASS-NAME-P - WALKER::VARIABLE-GLOBALLY-SPECIAL-P PCL::FUNCTION-RETURNING-T - PCL::METHOD-FUNCTION-METHOD PCL::GET-BUILT-IN-CLASS-SYMBOL - PCL::DEFAULT-STRUCTURE-TYPE PCL::GF-DFUN-INFO PCL::CACHING-P - PCL::FREE-CACHE-VECTOR PCL::ONE-CLASS-CACHE - PCL::DEFAULT-TEST-CONVERTER PCL::UNDEFMETHOD-1 - PCL::MAKE-INITFUNCTION PCL::GET-CACHE-VECTOR - PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::GF-INFO-FAST-MF-P - PCL::ECD-SOURCE PCL::INITIAL-P PCL::ARG-INFO-APPLYP - PCL::ARG-INFO-KEYWORDS - PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION - PCL::CACHING-DFUN-COST PCL::INITIAL-DISPATCH-P PCL::EVAL-FORM - PCL::MAKE-CONSTANT-FUNCTION PCL::FUNCTION-RETURNING-NIL - PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::FGEN-GENSYMS - PCL::EXPAND-SHORT-DEFCOMBIN WALKER::ENV-LOCK - PCL::INITIALIZE-INFO-CACHED-CONSTANTS - PCL::INITIALIZE-INFO-WRAPPER - PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME PCL::TWO-CLASS-INDEX - PCL::ONE-INDEX-ACCESSOR-TYPE - PCL::EARLY-COLLECT-DEFAULT-INITARGS WALKER::ENV-WALK-FORM - PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS PCL::MAKE-FUNCTION-INLINE - PCL::FLUSH-CACHE-VECTOR-INTERNAL - PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION - PCL::FGEN-GENERATOR PCL::CONSTANT-VALUE-P - PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION - PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::SLOT-BOUNDP-SYMBOL - PCL::ARG-INFO-NUMBER-OPTIONAL - PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::GET-PV-CELL-FOR-CLASS - PCL::CHECKING-FUNCTION PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P - PCL::INITIAL-DISPATCH-CACHE PCL::STRUCTURE-SVUC-METHOD - PCL::NO-METHODS-CACHE PCL::GF-DFUN-CACHE PCL::%CCLOSURE-ENV - PCL::CONSTANT-VALUE-CACHE PCL::BUILT-IN-WRAPPER-OF - PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P - PCL::EARLY-COLLECT-CPL COMMON-LISP::CLASS-OF - PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL PCL::SYMBOL-PKG-NAME - PCL::GDEFINITION - PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION - PCL::ACCESSOR-DFUN-INFO-CACHE PCL::EXTRACT-SPECIALIZER-NAMES - PCL::CHECK-WRAPPER-VALIDITY PCL::MAKE-INITIAL-DFUN - PCL::WRAPPER-FIELD PCL::EARLY-SLOT-DEFINITION-LOCATION - PCL::EARLY-GF-P PCL::GF-INFO-STATIC-C-A-M-EMF PCL::LOOKUP-FGEN - PCL::MAKE-PV-TYPE-DECLARATION - PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS - PCL::EARLY-METHOD-CLASS - PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION - WALKER::ENV-DECLARATIONS PCL::ALLOCATE-CACHE-VECTOR - PCL::FUNCTION-PRETTY-ARGLIST - PCL::EARLY-CLASS-DIRECT-SUBCLASSES - PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P - PCL::MAKE-CLASS-EQ-PREDICATE PCL::ECD-OTHER-INITARGS - PCL::GBOUNDP PCL::METHOD-FUNCTION-PV-TABLE - WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE - PCL::MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::FIND-CYCLE-REASONS PCL::FGEN-TEST - PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD PCL::FREE-CACHE - PCL::TYPE-CLASS PCL::INITIAL-CACHE - PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS - PCL::STRUCTURE-SLOTD-WRITER-FUNCTION - PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION - PCL::EARLY-COLLECT-SLOTS PCL::LIST-DFUN - PCL::EXPAND-MAKE-INSTANCE-FORM PCL::N-N-CACHE - PCL::MAKE-TYPE-PREDICATE PCL::INTERN-FUNCTION-NAME - PCL::GET-MAKE-INSTANCE-FUNCTIONS WALKER::ENV-WALK-FUNCTION - PCL::TWO-CLASS-CACHE PCL::MAKE-CALLS-TYPE-DECLARATION - PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION - PCL::INITIALIZE-INFO-KEY PCL::GF-LAMBDA-LIST - ITERATE::VARIABLES-FROM-LET PCL::COMPUTE-CLASS-SLOTS - PCL::DFUN-ARG-SYMBOL PCL::CHECKING-P PCL::ARG-INFO-P - PCL::INITIALIZE-INFO-CACHED-RI-VALID-P PCL::CHECKING-CACHE - PCL::METHOD-FUNCTION-PLIST PCL::STRUCTURE-OBJECT-P - PCL::ARG-INFO-PRECEDENCE PCL::ONE-CLASS-INDEX - PCL::STD-INSTANCE-P PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST - PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::EARLY-SLOT-DEFINITION-NAME PCL::UNPARSE-SPECIALIZERS - PCL::STRUCTURE-TYPE-P PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE - PCL::PV-TABLEP PCL::CLASS-FROM-TYPE - PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::STRUCTURE-TYPE - PCL::MAKE-EQL-PREDICATE PCL::TWO-CLASS-ACCESSOR-TYPE - PCL::DEFAULT-STRUCTURE-INSTANCE-P - PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME - PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE PCL::GFS-OF-TYPE - PCL::DEFAULT-STRUCTUREP PCL::EARLY-CLASS-NAME-OF - PCL::%STD-INSTANCE-SLOTS PCL::ONE-INDEX-INDEX PCL::WRAPPER-OF - PCL::ARG-INFO-VALID-P PCL::KEYWORD-SPEC-NAME - PCL::METHOD-CALL-P PCL::SHOW-DFUN-COSTS PCL::DFUN-INFO-CACHE - PCL::DEFAULT-CONSTANT-CONVERTER ITERATE::SEQUENCE-ACCESSOR - PCL::COUNT-DFUN PCL::EXPAND-LONG-DEFCOMBIN - PCL::CACHING-DFUN-INFO PCL::INITIALIZE-INFO-CACHED-VALID-P - PCL::FAST-INSTANCE-BOUNDP-P PCL::ARG-INFO-METATYPES - PCL::EXTRACT-PARAMETERS PCL::GF-INFO-C-A-M-EMF-STD-P - PCL::FINAL-ACCESSOR-DFUN-TYPE PCL::GMAKUNBOUND - PCL::FAST-METHOD-CALL-ARG-INFO PCL::COMPUTE-LINE-SIZE - PCL::ONE-INDEX-CACHE PCL::NO-METHODS-P - PCL::COMPUTE-STD-CPL-PHASE-2 - PCL::COMPLICATED-INSTANCE-CREATION-METHOD - PCL::MAKE-PERMUTATION-VECTOR PCL::CONSTANT-VALUE-DFUN-INFO - PCL::TWO-CLASS-WRAPPER1 PCL::MAP-ALL-GENERIC-FUNCTIONS - PCL::CLASS-PREDICATE SYSTEM::%STRUCTURE-NAME - PCL::RESET-CLASS-INITIALIZE-INFO - PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::EARLY-CLASS-NAME - PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::SLOT-READER-SYMBOL - PCL::ARG-INFO-NKEYS PCL::METHOD-CALL-CALL-METHOD-ARGS - PCL::CCLOSUREP PCL::DEFAULT-METHOD-ONLY-CACHE - PCL::NEXT-WRAPPER-FIELD PCL::SLOT-WRITER-SYMBOL - PCL::ACCESSOR-DFUN-INFO-P - PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::EXTRACT-REQUIRED-PARAMETERS PCL::FORMAT-CYCLE-REASONS - PCL::UNENCAPSULATED-FDEFINITION - PCL::GET-BUILT-IN-WRAPPER-SYMBOL PCL::ONE-CLASS-P - PCL::ECD-METACLASS PCL::METHOD-LL->GENERIC-FUNCTION-LL - PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES PCL::ONE-INDEX-P - PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST - PCL::ECD-CANONICAL-SLOTS - PCL::METHOD-FUNCTION-NEEDS-NEXT-METHODS-P - PCL::INITIALIZE-INFO-CACHED-NEW-KEYS - PCL::STRUCTURE-SLOTD-READER-FUNCTION - PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST - PCL::DISPATCH-P PCL::LIST-LARGE-CACHE - PCL::FAST-METHOD-CALL-PV-CELL PCL::GET-MAKE-INSTANCE-FUNCTION - PCL::DNET-METHODS-P PCL::STRUCTURE-SLOTD-INIT-FORM - PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::ONE-CLASS-ACCESSOR-TYPE - PCL::RESET-INITIALIZE-INFO PCL::STANDARD-SVUC-METHOD - PCL::DEFAULT-CONSTANTP PCL::UPDATE-C-A-M-GF-INFO - PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::EARLY-CLASS-SLOTS - PCL::CPD-SUPERS PCL::FGEN-GENERATOR-LAMBDA - PCL::ECD-SUPERCLASS-NAMES PCL::ECD-CLASS-NAME PCL::SETFBOUNDP - PCL::GET-SETF-FUNCTION-NAME PCL::DFUN-INFO-P - PCL::SLOT-VECTOR-SYMBOL PCL::INITIALIZE-INFO-P - PCL::TWO-CLASS-P PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE - PCL::COPY-CACHE PCL::MAKE-PV-TABLE-TYPE-DECLARATION - PCL::SORT-CALLS PCL::STRUCTURE-SLOT-BOUNDP PCL::%FBOUNDP - PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::UPDATE-GF-INFO - PCL::WRAPPER-FOR-STRUCTURE PCL::FUNCALLABLE-INSTANCE-P - PCL::CPD-CLASS PCL::EARLY-METHOD-STANDARD-ACCESSOR-P - PCL::SORT-SLOTS PCL::CANONICAL-SLOT-NAME - PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION - PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::%SYMBOL-FUNCTION - PCL::EARLY-METHOD-LAMBDA-LIST PCL::ONE-INDEX-DFUN-INFO-INDEX - PCL::N-N-ACCESSOR-TYPE PCL::CACHING-CACHE - PCL::EARLY-CLASS-SLOTDS PCL::ONE-INDEX-DFUN-INFO-P - SYSTEM::%COMPILED-FUNCTION-NAME - PCL::BOOTSTRAP-CLASS-PREDICATES PCL::NET-TEST-CONVERTER - PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS PCL::TWO-CLASS-WRAPPER0 - PCL::MAP-SPECIALIZERS PCL::EARLY-GF-NAME PCL::N-N-P - PCL::FGEN-SYSTEM PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P - PCL::UPDATE-GFS-OF-CLASS PCL::ONE-CLASS-WRAPPER0 - PCL::CPD-AFTER - PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION - PCL::CACHE-P PCL::EARLY-METHOD-QUALIFIERS PCL::CHECK-CACHE - PCL::FORCE-CACHE-FLUSHES PCL::CACHE-OWNER - PCL::COMPILE-LAMBDA-DEFERRED PCL::ARG-INFO-KEY/REST-P)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - COMMON-LISP::INVALID-METHOD-ERROR PCL::LIST-LARGE-CACHES - PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::UNTRACE-METHOD - COMMON-LISP::METHOD-COMBINATION-ERROR)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::ACCESSOR-VALUES-INTERNAL + PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION + PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| + PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN + PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| + PCL::CHECK-METHOD-ARG-INFO + PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| + PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION + PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| + PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION + PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P + ITERATE::WALK-GATHERING-BODY + PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER + PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| + PCL::SLOT-BOUNDP-USING-CLASS-DFUN WALKER::WALK-FORM-INTERNAL + PCL::LOAD-LONG-DEFCOMBIN PCL::MAKE-FINAL-CACHING-DFUN + PCL::EMIT-READER/WRITER + PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION + PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS + PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| + PCL::EMIT-READER/WRITER-FUNCTION PCL::ACCESSOR-VALUES1 + PCL::GENERATING-LISP PCL::GET-CLASS-SLOT-VALUE-1 + PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::CACHE-MISS-VALUES + WALKER::WALK-LET-IF + PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| + PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| + PCL::CHECKING-MISS ITERATE::EXPAND-INTO-LET + PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION + PCL::CONSTANT-VALUE-MISS ITERATE::RENAME-VARIABLES + PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| + PCL::SET-SLOT-VALUE + PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| + PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| + PCL::CONVERT-METHODS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - PCL::NON-NEGATIVE-FIXNUM) - PCL::CACHE-MAX-LOCATION PCL::CACHE-NLINES PCL::CACHE-SIZE - PCL::CACHE-MASK)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| + PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| + PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| + PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| + PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| + PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| + PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| + PCL::ADD-METHOD-DECLARATIONS + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| + PCL::WALK-METHOD-LAMBDA + PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION - ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::ADD-DIRECT-SUBCLASSES - PCL::PROCLAIM-DEFMETHOD PCL::UPDATE-INITIALIZE-INFO-INTERNAL - PCL::RAISE-METATYPE PCL::CLASS-CAN-PRECEDE-P - WALKER::VARIABLE-SPECIAL-P PCL::GF-MAKE-FUNCTION-FROM-EMF - PCL::|SETF PCL METHOD-FUNCTION-PLIST| - PCL::SET-FUNCTION-PRETTY-ARGLIST - PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS - PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST - PCL::DEAL-WITH-ARGUMENTS-OPTION WALKER::NOTE-DECLARATION - PCL::MAKE-CLASS-PREDICATE PCL::VALUE-FOR-CACHING - PCL::EMIT-1-NIL-DLAP PCL::MAKE-CAXR PCL::SYMBOL-LESSP - PCL::GET-KEY-ARG1 PCL::ADD-FORMS - PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION - PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER - PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::N-N-DFUN-INFO - PCL::CANONICALIZE-SLOT-SPECIFICATION - PCL::REDIRECT-EARLY-FUNCTION-INTERNAL - PCL::UPDATE-STD-OR-STR-METHODS PCL::%SET-CCLOSURE-ENV - PCL::QUALIFIER-CHECK-RUNTIME - PCL::MAKE-STD-READER-METHOD-FUNCTION - PCL::ADD-SLOT-ACCESSORS PCL::ADD-TO-CVECTOR - PCL::COMPUTE-LAYOUT PCL::DESTRUCTURE-INTERNAL - PCL::SUPERCLASSES-COMPATIBLE-P - PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION ITERATE::MV-SETQ - PCL::COMPUTE-STD-CPL PCL::SET-METHODS PCL::CHECKING-DFUN-INFO - ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::SWAP-WRAPPERS-AND-SLOTS - PCL::CANONICALIZE-DEFCLASS-OPTION PCL::MAKE-CDXR - PCL::PRINTING-RANDOM-THING-INTERNAL COMMON-LISP::ADD-METHOD - PCL::STANDARD-INSTANCE-ACCESS - SYSTEM::%SET-COMPILED-FUNCTION-NAME PCL::FIND-SLOT-DEFINITION - PCL::CLASS-MIGHT-PRECEDE-P - PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION PCL::SAUT-NOT-EQL - PCL::SET-WRAPPER PCL::SET-STANDARD-SVUC-METHOD - PCL::SAUT-NOT-PROTOTYPE PCL::ACCESSOR-MISS-FUNCTION - PCL::NO-SLOT PCL::REMTAIL PCL::PV-WRAPPERS-FROM-ALL-ARGS - PCL::UPDATE-CLASS PCL::AUGMENT-TYPE PCL::MAKE-EARLY-ACCESSOR - PCL::MAKE-PLIST PCL::MEC-ALL-CLASSES-INTERNAL - PCL::MAKE-STD-WRITER-METHOD-FUNCTION - PCL::PARSE-QUALIFIER-PATTERN PCL::MEMF-CONSTANT-CONVERTER - PCL::|SETF PCL FIND-CLASS-PREDICATE| - PCL::MAKE-UNORDERED-METHODS-EMF WALKER::ENVIRONMENT-FUNCTION - PCL::MEC-ALL-CLASS-LISTS PCL::SAUT-NOT-CLASS-EQ - PCL::DO-SATISFIES-DEFTYPE PCL::SET-STRUCTURE-SVUC-METHOD - PCL::MAKE-DLAP-LAMBDA-LIST PCL::METHOD-FUNCTION-RETURNING-T - PCL::COMPUTE-CALLS PCL::REMOVE-SLOT-ACCESSORS - PCL::UPDATE-ALL-PV-TABLE-CACHES PCL::MAKE-DFUN-LAMBDA-LIST - WALKER::NOTE-LEXICAL-BINDING PCL::REMOVE-DIRECT-SUBCLASSES - PCL::MAP-PV-TABLE-REFERENCES-OF PCL::COMPUTE-CONSTANTS - PCL::METHOD-FUNCTION-RETURNING-NIL PCL::METHODS-CONVERTER - PCL::PV-TABLE-LOOKUP PCL::DESCRIBE-PACKAGE - COMMON-LISP::SLOT-EXISTS-P PCL::MAKE-PV-TABLE-INTERNAL - PCL::SAUT-NOT-CLASS PCL::|SETF PCL FIND-CLASS| - PCL::UPDATE-INITS PCL::UPDATE-CPL - PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION - PCL::COMPUTE-PV WALKER::VARIABLE-LEXICAL-P - PCL::PROCLAIM-DEFGENERIC PCL::MAKE-DFUN-ARG-LIST - PCL::GET-KEY-ARG COMMON-LISP::REMOVE-METHOD - PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::VARIABLE-CLASS - PCL::UPDATE-SLOTS PCL::SYMBOL-OR-CONS-LESSP - PCL::MEC-ALL-CLASSES PCL::LIST-EQ - PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION - WALKER::WALK-REPEAT-EVAL WALKER::ENVIRONMENT-MACRO - WALKER::VARIABLE-SYMBOL-MACRO-P - PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST - PCL::BOOTSTRAP-SLOT-INDEX PCL::PLIST-VALUE - PCL::CHANGE-CLASS-INTERNAL PCL::NET-CONSTANT-CONVERTER - PCL::|SETF PCL GDEFINITION| PCL::FIND-STANDARD-II-METHOD)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::*) + PCL::GET-ACCESSOR-METHOD-FUNCTION + PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| + PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN + PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| + PCL::GENERATE-DISCRIMINATION-NET + PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| + PCL::LOAD-SHORT-DEFCOMBIN + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| + PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| + PCL::REAL-MAKE-METHOD-LAMBDA PCL::SET-CLASS-SLOT-VALUE-1 + PCL::BOOTSTRAP-ACCESSOR-DEFINITION + PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| + PCL::ACCESSOR-MISS PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))| + PCL::ACCESSOR-VALUES + PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))| + PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| + PCL::EMIT-CHECKING-OR-CACHING-FUNCTION + PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION + PCL::MAKE-FINAL-CHECKING-DFUN + PCL::MAKE-SHARED-INITIALIZE-FORM-LIST + PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| + PCL::EMIT-CHECKING-OR-CACHING + PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))| + PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| + PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| + PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN + PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION + PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| + PCL::ORDER-SPECIALIZERS + PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - WALKER::WALK-FORM PCL::MAKE-INSTANCE-1 - PCL::EXTRACT-DECLARATIONS PCL::GET-FUNCTION - WALKER::MACROEXPAND-ALL PCL::ALLOCATE-STRUCTURE-INSTANCE - PCL::MAKE-FINAL-DFUN-INTERNAL PCL::GET-METHOD-FUNCTION - PCL::COERCE-TO-CLASS PCL::MAP-ALL-CLASSES PCL::ENSURE-CLASS - PCL::PARSE-METHOD-OR-SPEC COMMON-LISP::ENSURE-GENERIC-FUNCTION - PCL::MAKE-CACHING-DFUN PCL::GET-FUNCTION1 - PCL::GET-DFUN-CONSTRUCTOR PCL::MAKE-CONSTANT-VALUE-DFUN - PCL::MAKE-METHOD-FUNCTION-INTERNAL PCL::COMPILE-LAMBDA - PCL::PARSE-SPECIALIZED-LAMBDA-LIST PCL::DISPATCH-DFUN-COST - PCL::MAKE-METHOD-LAMBDA-INTERNAL)) + PCL::MAKE-N-N-ACCESSOR-DFUN + PCL::GET-SIMPLE-INITIALIZATION-FUNCTION + PCL::MAKE-FINAL-ACCESSOR-DFUN + PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ACCESSOR-TABLE + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-CHECKING-DFUN + PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS + PCL::MAKE-DEFAULT-INITARGS-FORM-LIST PCL::REAL-ADD-METHOD + PCL::SLOT-VALUE-OR-DEFAULT PCL::LOAD-DEFGENERIC PCL::CPL-ERROR + WALKER::NESTED-WALK-FORM PCL::TYPES-FROM-ARGUMENTS + PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) - PCL::MAKE-CLASS-PREDICATE-NAME PCL::MAKE-KEYWORD)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION + PCL::GENERATE-DISCRIMINATION-NET-INTERNAL + PCL::CACHE-MISS-VALUES-INTERNAL + PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::DO-SHORT-METHOD-COMBINATION PCL::MEMF-CODE-CONVERTER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - PCL::FIND-CLASS-FROM-CELL PCL::GET-METHOD-FUNCTION-PV-CELL - PCL::PROBE-CACHE PCL::NAMED-OBJECT-PRINT-FUNCTION - PCL::PRECOMPUTE-EFFECTIVE-METHODS - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE - PCL::GET-EFFECTIVE-METHOD-FUNCTION1 PCL::MAKE-EMF-FROM-METHOD - PCL::EMIT-MISS PCL::REAL-ENSURE-GF-USING-CLASS--NULL - PCL::RECORD-DEFINITION WALKER::CONVERT-MACRO-TO-LAMBDA - PCL::INITIALIZE-INFO PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION - PCL::METHOD-FUNCTION-GET PCL::FIND-CLASS-PREDICATE-FROM-CELL - PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS - PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::GET-DECLARATION - PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION - PCL::MAP-CACHE)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::*) + PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN WALKER::WALK-DECLARATIONS + PCL::GET-SECONDARY-DISPATCH-FUNCTION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))| - PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| - WALKER::WALK-PROG/PROG* - PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| - WALKER::WALK-BINDINGS-2 - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| - WALKER::WALK-DO/DO* - PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - PCL::|(FAST-METHOD DOCUMENTATION (T))| - PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))| - PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| - PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| - PCL::INITIALIZE-INSTANCE-SIMPLE PCL::BOOTSTRAP-SET-SLOT - PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| - PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))| - PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| - PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| - PCL::FILL-CACHE-P - PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| - PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))| - PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| - PCL::OPTIMIZE-WRITER PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL - PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 - PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| - PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| - PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| - PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| - PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| - PCL::ADJUST-CACHE - PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR - PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| - PCL::MEMF-TEST-CONVERTER - PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| - WALKER::WALK-TEMPLATE PCL::TWO-CLASS-DFUN-INFO - PCL::EXPAND-CACHE - PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| - PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| - PCL::GET-WRAPPERS-FROM-CLASSES - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - PCL::LOAD-PRECOMPILED-IIS-ENTRY - PCL::|(FAST-METHOD PRINT-OBJECT (T T))| - PCL::EXPAND-SYMBOL-MACROLET-INTERNAL - PCL::MAYBE-EXPAND-ACCESSOR-FORM - PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY - PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| - PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| - PCL::EXPAND-DEFCLASS - PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| - WALKER::WALK-LET/LET* PCL::MAKE-DISPATCH-LAMBDA - PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| - PCL::OPTIMIZE-READER - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| - PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|)) + COMMON-LISP::*) + PCL::|(FAST-METHOD SLOT-MISSING (T T T T))| + PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))| + ITERATE::ITERATE-TRANSFORM-BODY)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::OPTIMIZE-SET-SLOT-VALUE - PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| - PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| - PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| - PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| - PCL::PRINT-CACHE WALKER::WALK-UNEXPECTED-DECLARE - ITERATE::OPTIMIZE-ITERATE-FORM - PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| - WALKER::WALK-MULTIPLE-VALUE-SETQ PCL::FIRST-FORM-TO-LISP - PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| - WALKER::WALK-LABELS - PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))| - PCL::ONE-CLASS-DFUN-INFO PCL::GET-FUNCTION-GENERATOR - WALKER::RELIST-INTERNAL PCL::NOTE-PV-TABLE-REFERENCE - WALKER::WALK-LAMBDA PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS - PCL::ONE-INDEX-DFUN-INFO PCL::MAP-ALL-ORDERS - PCL::OPTIMIZE-GF-CALL-INTERNAL PCL::COMPUTE-PRECEDENCE - WALKER::WALK-DO PCL::PRINT-STD-INSTANCE - PCL::OBSOLETE-INSTANCE-TRAP PCL::SORT-APPLICABLE-METHODS - PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - PCL::EMIT-GREATER-THAN-1-DLAP - PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - WALKER::WALK-FLET - PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| - PCL::|SETF PCL PLIST-VALUE| WALKER::WALK-PROG* - WALKER::VARIABLE-DECLARATION - PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| - PCL::SKIP-FAST-SLOT-ACCESS-P PCL::SET-FUNCTION-NAME-1 - WALKER::WALK-MACROLET PCL::CAN-OPTIMIZE-ACCESS - WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL - PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| - PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| - PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| - PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P - PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| - PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| - PCL::EMIT-BOUNDP-CHECK PCL::|SETF PCL METHOD-FUNCTION-GET| - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| - PCL::MAKE-METHOD-SPEC PCL::FLUSH-CACHE-TRAP WALKER::WALK-IF - PCL::OPTIMIZE-SLOT-BOUNDP - PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD - WALKER::WALK-MULTIPLE-VALUE-BIND - ITERATE::RENAME-AND-CAPTURE-VARIABLES WALKER::WALK-LET* - WALKER::WALK-DO* - PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| - PCL::INVALIDATE-WRAPPER - PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| - PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| - PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION - ITERATE::SIMPLE-EXPAND-GATHERING-FORM PCL::ENTRY-IN-CACHE-P - WALKER::WALK-LOCALLY PCL::OPTIMIZE-SLOT-VALUE - PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL - PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| - PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| - PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| - PCL::TRACE-EMF-CALL-INTERNAL WALKER::WALK-SYMBOL-MACROLET - PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| - PCL::CONVERT-TABLE - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| - PCL::INITIALIZE-INTERNAL-SLOT-GFS* - PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))| - PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| - PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| - PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| - PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| - WALKER::WALK-SETQ PCL::EXPAND-DEFGENERIC - PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| - ITERATE::OPTIMIZE-GATHERING-FORM PCL::FIX-SLOT-ACCESSORS - PCL::EMIT-SLOT-READ-FORM WALKER::WALK-PROG - PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| - WALKER::WALK-NAMED-LAMBDA PCL::GET-NEW-FUNCTION-GENERATOR - PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| - WALKER::WALK-TAGBODY - PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| - WALKER::WALK-COMPILER-LET PCL::DECLARE-STRUCTURE - WALKER::WALK-LET ITERATE::VARIABLE-SAME-P - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| - PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL - PCL::COMPUTE-EFFECTIVE-METHOD PCL::SORT-METHODS - WALKER::WALK-TAGBODY-1 - PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| - PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| - PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| - PCL::MAKE-TOP-LEVEL-FORM - PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| - WALKER::RECONS)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + ITERATE::RENAME-LET-BINDINGS + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::UPDATE-SLOTS-IN-PV PCL::MAKE-INSTANCE-FUNCTION-COMPLEX - PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL - PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| - PCL::MAKE-INSTANCE-FUNCTION-SIMPLE - PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| - PCL::COMPUTE-PV-SLOT PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 - PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))| - PCL::OPTIMIZE-INSTANCE-ACCESS - PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| - PCL::REAL-MAKE-METHOD-INITARGS-FORM - PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))| - PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| - PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL - PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS - PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))| - PCL::MAKE-PARAMETER-REFERENCES - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| - PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::OPTIMIZE-ACCESSOR-CALL - WALKER::WALK-TEMPLATE-HANDLE-REPEAT WALKER::WALK-BINDINGS-1 - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| - PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1 - PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::MAKE-FGEN - PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| - PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| - PCL::OPTIMIZE-GENERIC-FUNCTION-CALL - PCL::LOAD-FUNCTION-GENERATOR PCL::MAKE-EMF-CACHE - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| - PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::EXPAND-EMF-CALL-METHOD)) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::*) + PCL::REAL-MAKE-A-METHOD)) +(COMMON-LISP::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(PCL::REDEFINE-FUNCTION PCL::DO-STANDARD-DEFSETF-1 + PCL::TRACE-METHOD-INTERNAL PCL::FDEFINE-CAREFULLY)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) + PCL::ANALYZE-LAMBDA-LIST PCL::GET-DISPATCH-FUNCTION + PCL::PARSE-DEFMETHOD PCL::MAKE-DISPATCH-DFUN + PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-ONE-INDEX-READERS + PCL::METHOD-PROTOTYPE-FOR-GF PCL::EMIT-ONE-CLASS-READER + PCL::GENERIC-FUNCTION-NAME-P PCL::DEFAULT-CODE-CONVERTER + PCL::CLASS-EQ-TYPE PCL::CONVERT-TO-SYSTEM-TYPE + PCL::COMPILE-IIS-FUNCTIONS PCL::EMIT-CONSTANT-VALUE + PCL::GET-GENERIC-FUNCTION-INFO PCL::EARLY-METHOD-FUNCTION + PCL::FIND-STRUCTURE-CLASS PCL::PCL-DESCRIBE + PCL::NET-CODE-CONVERTER PCL::PARSE-METHOD-GROUP-SPECIFIER + PCL::TYPE-FROM-SPECIALIZER PCL::EMIT-TWO-CLASS-WRITER + PCL::COMPUTE-APPLICABLE-METHODS-EMF PCL::EMIT-ONE-CLASS-WRITER + PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA + PCL::SPECIALIZER-FROM-TYPE PCL::EARLY-COLLECT-INHERITANCE + PCL::EMIT-TWO-CLASS-READER PCL::FIND-WRAPPER + PCL::*NORMALIZE-TYPE PCL::EMIT-ONE-INDEX-WRITERS + PCL::STRUCTURE-WRAPPER PCL::MAKE-FINAL-DISPATCH-DFUN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::T) - PCL::EXPAND-DEFMETHOD PCL::LOAD-DEFMETHOD-INTERNAL)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + PCL::|__si::MAKE-INITIAL| PCL::|__si::MAKE-ARG-INFO| + PCL::STRING-APPEND PCL::|__si::MAKE-ONE-INDEX| + PCL::MAKE-INITIALIZE-INFO PCL::MAKE-FAST-METHOD-CALL + PCL::|__si::MAKE-STD-INSTANCE| + PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| + PCL::|__si::MAKE-CONSTANT-VALUE| PCL::|__si::MAKE-N-N| + PCL::FIX-EARLY-GENERIC-FUNCTIONS PCL::INTERN-PV-TABLE + PCL::FALSE PCL::|__si::MAKE-DFUN-INFO| + PCL::|__si::MAKE-CACHING| PCL::MAKE-PV-TABLE + PCL::MAKE-METHOD-CALL PCL::TRUE PCL::MAKE-PROGN + PCL::|__si::MAKE-CACHE| + PCL::|STRUCTURE-OBJECT class constructor| + PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| + PCL::|__si::MAKE-NO-METHODS| PCL::|__si::MAKE-ONE-CLASS| + PCL::|__si::MAKE-PV-TABLE| PCL::PV-WRAPPERS-FROM-PV-ARGS + WALKER::UNBOUND-LEXICAL-FUNCTION PCL::|__si::MAKE-TWO-CLASS| + PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| + PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| + PCL::MAKE-FAST-INSTANCE-BOUNDP + PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::USE-PACKAGE-PCL + PCL::|__si::MAKE-CHECKING| PCL::|__si::MAKE-INITIAL-DISPATCH| + PCL::|__si::MAKE-DISPATCH|)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::T) - PCL::FILL-CACHE PCL::CAN-OPTIMIZE-ACCESS1 PCL::MAKE-EMF-CALL - PCL::EMIT-FETCH-WRAPPER PCL::CHECK-INITARGS-2-LIST - PCL::GET-METHOD PCL::CHECK-INITARGS-2-PLIST - PCL::CHECK-INITARGS-1 PCL::REAL-GET-METHOD - WALKER::WALK-ARGLIST)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FUNCTION) + PCL::METHOD-CALL-FUNCTION PCL::FAST-METHOD-CALL-FUNCTION + PCL::CACHE-LIMIT-FN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN) + PCL::CACHE-VALUEP)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::T) - PCL::LOAD-DEFMETHOD PCL::MAKE-DEFMETHOD-FORM - PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::INTEGER 1 255)) + PCL::CACHE-NKEYS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::SET-ARG-INFO1 PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION - PCL::LOAD-DEFCLASS PCL::REAL-LOAD-DEFCLASS - PCL::OPTIMIZE-GF-CALL WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 - PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::INTEGER 1 256)) + PCL::CACHE-LINE-SIZE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - PCL::EMIT-DLAP PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) + PCL::SYMBOL-APPEND)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - PCL::EARLY-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE - PCL::REAL-ADD-NAMED-METHOD)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::*)) + PCL::SORT-APPLICABLE-METHODS PCL::SORT-METHODS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - PCL::BOOTSTRAP-INITIALIZE-CLASS)) + PCL::COMPUTE-CALLS PCL::SET-STRUCTURE-SVUC-METHOD + PCL::UPDATE-STD-OR-STR-METHODS PCL::SET-METHODS + WALKER::NOTE-LEXICAL-BINDING + ITERATE::SIMPLE-EXPAND-ITERATE-FORM + PCL::|SETF PCL METHOD-FUNCTION-PLIST| PCL::SAUT-NOT-PROTOTYPE + PCL::VALUE-FOR-CACHING PCL::PROCLAIM-DEFMETHOD + PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST + PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION PCL::METHODS-CONVERTER + PCL::DEAL-WITH-ARGUMENTS-OPTION + PCL::UPDATE-ALL-PV-TABLE-CACHES + PCL::MAP-PV-TABLE-REFERENCES-OF PCL::UPDATE-CLASS + PCL::FIND-STANDARD-II-METHOD + PCL::METHOD-FUNCTION-RETURNING-NIL + PCL::REDIRECT-EARLY-FUNCTION-INTERNAL PCL::UPDATE-CPL + PCL::QUALIFIER-CHECK-RUNTIME PCL::COMPUTE-STD-CPL + PCL::COMPUTE-CONSTANTS PCL::ADD-FORMS PCL::AUGMENT-TYPE + PCL::MEMF-CONSTANT-CONVERTER PCL::SWAP-WRAPPERS-AND-SLOTS + PCL::SET-WRAPPER PCL::GET-KEY-ARG PCL::MAKE-PLIST + PCL::MAKE-PV-TABLE-INTERNAL ITERATE::EXTRACT-SPECIAL-BINDINGS + PCL::SAUT-NOT-EQL WALKER::VARIABLE-SYMBOL-MACRO-P + PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION + PCL::SET-FUNCTION-PRETTY-ARGLIST + PCL::GF-MAKE-FUNCTION-FROM-EMF PCL::FIND-SLOT-DEFINITION + PCL::SET-STANDARD-SVUC-METHOD PCL::ADD-TO-CVECTOR + PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS COMMON-LISP::REMOVE-METHOD + PCL::CHECKING-DFUN-INFO PCL::PARSE-QUALIFIER-PATTERN + PCL::%SET-CCLOSURE-ENV PCL::MAKE-CDXR + PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS + PCL::NET-CONSTANT-CONVERTER PCL::|SETF PCL FIND-CLASS| + PCL::METHOD-FUNCTION-RETURNING-T PCL::CHANGE-CLASS-INTERNAL + PCL::MAKE-DFUN-ARG-LIST PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER + PCL::MAKE-STD-WRITER-METHOD-FUNCTION ITERATE::MV-SETQ + PCL::MAKE-EARLY-ACCESSOR PCL::GET-KEY-ARG1 + PCL::ADD-DIRECT-SUBCLASSES PCL::DO-SATISFIES-DEFTYPE + PCL::N-N-DFUN-INFO PCL::CLASSES-HAVE-COMMON-SUBCLASS-P + PCL::SAUT-NOT-CLASS PCL::CANONICALIZE-DEFCLASS-OPTION + PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST + WALKER::VARIABLE-LEXICAL-P WALKER::ENVIRONMENT-FUNCTION + PCL::PV-TABLE-LOOKUP PCL::DESTRUCTURE-INTERNAL + PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION + PCL::REMOVE-SLOT-ACCESSORS + PCL::|SETF PCL FIND-CLASS-PREDICATE| + PCL::|SETF PCL GDEFINITION| PCL::MAKE-DFUN-LAMBDA-LIST + PCL::CANONICALIZE-SLOT-SPECIFICATION WALKER::WALK-REPEAT-EVAL + PCL::STANDARD-INSTANCE-ACCESS + PCL::PRINTING-RANDOM-THING-INTERNAL PCL::REMTAIL + PCL::ACCESSOR-MISS-FUNCTION PCL::COMPUTE-LAYOUT + PCL::CLASS-MIGHT-PRECEDE-P + PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION + SYSTEM::%SET-COMPILED-FUNCTION-NAME PCL::PLIST-VALUE + PCL::MAKE-CAXR PCL::MAKE-DLAP-LAMBDA-LIST + PCL::MAKE-STD-READER-METHOD-FUNCTION WALKER::ENVIRONMENT-MACRO + PCL::UPDATE-SLOTS PCL::VARIABLE-CLASS + PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION PCL::LIST-EQ + PCL::ADD-SLOT-ACCESSORS PCL::SAUT-NOT-CLASS-EQ PCL::COMPUTE-PV + PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::UPDATE-INITS + PCL::MEC-ALL-CLASS-LISTS PCL::RAISE-METATYPE + WALKER::NOTE-DECLARATION PCL::EMIT-1-NIL-DLAP + PCL::BOOTSTRAP-SLOT-INDEX PCL::SUPERCLASSES-COMPATIBLE-P + PCL::MEC-ALL-CLASSES-INTERNAL COMMON-LISP::SLOT-EXISTS-P + PCL::DESCRIBE-PACKAGE PCL::NO-SLOT PCL::PROCLAIM-DEFGENERIC + COMMON-LISP::ADD-METHOD PCL::MAKE-UNORDERED-METHODS-EMF + PCL::MEC-ALL-CLASSES PCL::SYMBOL-OR-CONS-LESSP + PCL::UPDATE-INITIALIZE-INFO-INTERNAL PCL::CLASS-CAN-PRECEDE-P + PCL::SYMBOL-LESSP PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION + PCL::MAKE-CLASS-PREDICATE WALKER::VARIABLE-SPECIAL-P + PCL::REMOVE-DIRECT-SUBCLASSES)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::FIXNUM) - COMMON-LISP::T) - PCL::COMPUTE-STD-CPL-PHASE-3)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + PCL::MAKE-METHOD-FUNCTION-INTERNAL + PCL::MAKE-FINAL-DFUN-INTERNAL WALKER::MACROEXPAND-ALL + COMMON-LISP::ENSURE-GENERIC-FUNCTION + PCL::MAKE-METHOD-LAMBDA-INTERNAL PCL::MAKE-CONSTANT-VALUE-DFUN + PCL::GET-FUNCTION PCL::EXTRACT-DECLARATIONS + PCL::COERCE-TO-CLASS PCL::PARSE-METHOD-OR-SPEC + PCL::DISPATCH-DFUN-COST PCL::PARSE-SPECIALIZED-LAMBDA-LIST + PCL::MAP-ALL-CLASSES PCL::COMPILE-LAMBDA PCL::ENSURE-CLASS + PCL::GET-METHOD-FUNCTION WALKER::WALK-FORM + PCL::ALLOCATE-STRUCTURE-INSTANCE PCL::GET-FUNCTION1 + PCL::MAKE-CACHING-DFUN PCL::MAKE-INSTANCE-1 + PCL::GET-DFUN-CONSTRUCTOR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::FIXNUM) - COMMON-LISP::T) - PCL::FILL-CACHE-FROM-CACHE-P PCL::GET-CACHE)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T)) + PCL::MAKE-CLASS-PREDICATE-NAME PCL::MAKE-KEYWORD)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::LIST) - PCL::PV-TABLE-CALL-LIST PCL::CACHE-OVERFLOW - PCL::PV-TABLE-SLOT-NAME-LISTS)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::VECTOR COMMON-LISP::CHARACTER + COMMON-LISP::*)) + PCL::CAPITALIZE-WORDS)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1 PCL::SHOW-EMF-CALL-TRACE + PCL::CACHES-TO-ALLOCATE PCL::MAKE-CACHE + PCL::SHOW-FREE-CACHE-VECTORS PCL::MAKE-ARG-INFO + PCL::NO-METHODS-DFUN-INFO PCL::STRUCTURE-FUNCTIONS-EXIST-P + PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST + PCL::BOOTSTRAP-BUILT-IN-CLASSES + PCL::%%ALLOCATE-INSTANCE--CLASS PCL::DISPATCH-DFUN-INFO + PCL::INITIAL-DISPATCH-DFUN-INFO PCL::BOOTSTRAP-META-BRAID + PCL::UPDATE-DISPATCH-DFUNS PCL::LIST-ALL-DFUNS + PCL::DEFAULT-METHOD-ONLY-DFUN-INFO PCL::RENEW-SYS-FILES + PCL::IN-THE-COMPILER-P PCL::GET-EFFECTIVE-METHOD-GENSYM + PCL::MAKE-CPD PCL::INITIAL-DFUN-INFO + PCL::SHOW-DFUN-CONSTRUCTORS + PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::FIXNUM) + PCL::ZERO)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::COMPUTE-CACHE-PARAMETERS)) + (COMMON-LISP::T COMMON-LISP::STREAM COMMON-LISP::T) + COMMON-LISP::T) + PCL::PRINT-DFUN-INFO)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -677,107 +406,86 @@ PCL::FIND-FREE-CACHE-LINE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN) - PCL::CACHE-VALUEP)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::COMPUTE-CACHE-PARAMETERS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - PCL::DEFAULT-CODE-CONVERTER PCL::EMIT-IN-CHECKING-CACHE-P - PCL::METHOD-PROTOTYPE-FOR-GF PCL::EMIT-TWO-CLASS-WRITER - PCL::PARSE-METHOD-GROUP-SPECIFIER PCL::EMIT-ONE-CLASS-WRITER - PCL::EMIT-ONE-INDEX-WRITERS PCL::FIND-STRUCTURE-CLASS - PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::MAKE-DISPATCH-DFUN - PCL::COMPUTE-APPLICABLE-METHODS-EMF PCL::EARLY-METHOD-FUNCTION - PCL::NET-CODE-CONVERTER PCL::GET-DISPATCH-FUNCTION - PCL::STRUCTURE-WRAPPER PCL::FIND-WRAPPER PCL::CLASS-EQ-TYPE - PCL::TYPE-FROM-SPECIALIZER PCL::SPECIALIZER-FROM-TYPE - PCL::PCL-DESCRIBE PCL::PARSE-DEFMETHOD - PCL::ANALYZE-LAMBDA-LIST PCL::EMIT-ONE-CLASS-READER - PCL::EARLY-COLLECT-INHERITANCE PCL::GET-GENERIC-FUNCTION-INFO - PCL::COMPILE-IIS-FUNCTIONS PCL::EMIT-CONSTANT-VALUE - PCL::EMIT-ONE-INDEX-READERS PCL::GENERIC-FUNCTION-NAME-P - PCL::CONVERT-TO-SYSTEM-TYPE PCL::MAKE-FINAL-DISPATCH-DFUN - PCL::EMIT-TWO-CLASS-READER PCL::*NORMALIZE-TYPE)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) + PCL::COUNT-ALL-DFUNS PCL::EMIT-N-N-WRITERS + PCL::EMIT-N-N-READERS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| - PCL::MAKE-FAST-INSTANCE-BOUNDP PCL::MAKE-INITIALIZE-INFO - PCL::|STRUCTURE-OBJECT class constructor| - PCL::|__si::MAKE-CACHE| PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| - PCL::TRUE PCL::|__si::MAKE-PV-TABLE| - PCL::|__si::MAKE-ONE-INDEX| WALKER::UNBOUND-LEXICAL-FUNCTION - PCL::|__si::MAKE-CHECKING| PCL::MAKE-PV-TABLE - PCL::|__si::MAKE-NO-METHODS| PCL::MAKE-METHOD-CALL - PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::USE-PACKAGE-PCL - PCL::INTERN-PV-TABLE PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| - PCL::|__si::MAKE-DISPATCH| - PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| - PCL::|__si::MAKE-ARG-INFO| PCL::FIX-EARLY-GENERIC-FUNCTIONS - PCL::ZERO PCL::MAKE-PROGN PCL::|__si::MAKE-INITIAL| - PCL::|__si::MAKE-ONE-CLASS| PCL::|__si::MAKE-DFUN-INFO| - PCL::|__si::MAKE-CONSTANT-VALUE| - PCL::|__si::MAKE-STD-INSTANCE| PCL::PV-WRAPPERS-FROM-PV-ARGS - PCL::|__si::MAKE-TWO-CLASS| PCL::|__si::MAKE-N-N| - PCL::|__si::MAKE-CACHING| PCL::FALSE PCL::STRING-APPEND - PCL::|__si::MAKE-INITIAL-DISPATCH| PCL::MAKE-FAST-METHOD-CALL)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + PCL::MAKE-FINAL-DFUN PCL::SET-ARG-INFO PCL::TRACE-METHOD + PCL::MAKE-SPECIALIZABLE WALKER::WALKER-ENVIRONMENT-BIND-1 + ITERATE::FUNCTION-LAMBDA-P COMMON-LISP::FIND-CLASS + PCL::MAKE-WRAPPER PCL::UPDATE-DFUN + PCL::MAKE-TYPE-PREDICATE-NAME PCL::PV-TABLE-LOOKUP-PV-ARGS + PCL::USE-CONSTANT-VALUE-DFUN-P WALKER::RELIST + PCL::MAKE-EARLY-GF PCL::INITIALIZE-METHOD-FUNCTION + PCL::FIND-CLASS-CELL PCL::USE-DISPATCH-DFUN-P + PCL::FIND-CLASS-PREDICATE PCL::ALLOCATE-STANDARD-INSTANCE + PCL::INITIALIZE-INTERNAL-SLOT-GFS ITERATE::MAYBE-WARN + PCL::ALLOCATE-FUNCALLABLE-INSTANCE + PCL::EARLY-METHOD-SPECIALIZERS WALKER::RELIST* PCL::SET-DFUN)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::SLOT-UNBOUND-INTERNAL ITERATE::PARSE-DECLARATIONS + PCL::EMIT-CACHING PCL::COMPUTE-STD-CPL-PHASE-1 + PCL::INITIAL-DFUN PCL::INSURE-DFUN PCL::EMIT-CHECKING + PCL::COMPUTE-TEST PCL::COMPUTE-CODE PCL::MAKE-DIRECT-SLOTD + PCL::SAUT-CLASS COMMON-LISP::SLOT-MAKUNBOUND + PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::INVOKE-EMF + PCL::*SUBTYPEP PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P + PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES + PCL::REAL-REMOVE-METHOD PCL::SAUT-PROTOTYPE + PCL::MUTATE-SLOTS-AND-CALLS PCL::FIND-SUPERCLASS-CHAIN + COMMON-LISP::SLOT-BOUNDP PCL::FORM-LIST-TO-LISP + PCL::CPL-INCONSISTENT-ERROR PCL::EMIT-DEFAULT-ONLY-FUNCTION + PCL::ENSURE-CLASS-VALUES PCL::CHECK-INITARGS-VALUES + PCL::SAUT-EQL PCL::SPLIT-DECLARATIONS + PCL::UPDATE-SLOT-VALUE-GF-INFO PCL::SAUT-AND + PCL::SLOT-NAME-LISTS-FROM-SLOTS + PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::EMIT-DEFAULT-ONLY + PCL::SAUT-NOT PCL::SAUT-CLASS-EQ COMMON-LISP::SLOT-VALUE + PCL::DESTRUCTURE PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P + PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL + PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SDFUN-FOR-CACHING + PCL::SET-FUNCTION-NAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) - PCL::ARG-INFO-NUMBER-REQUIRED PCL::PV-TABLE-PV-SIZE - PCL::CACHE-COUNT PCL::PV-CACHE-LIMIT-FN PCL::CHECKING-LIMIT-FN - PCL::CACHING-LIMIT-FN PCL::N-N-ACCESSORS-LIMIT-FN - PCL::DEFAULT-LIMIT-FN PCL::EARLY-CLASS-SIZE PCL::CPD-COUNT - PCL::ONE-INDEX-LIMIT-FN PCL::FAST-INSTANCE-BOUNDP-INDEX)) + PCL::ARG-INFO-NUMBER-REQUIRED PCL::CACHING-LIMIT-FN + PCL::PV-CACHE-LIMIT-FN PCL::ONE-INDEX-LIMIT-FN + PCL::PV-TABLE-PV-SIZE PCL::CACHE-COUNT PCL::DEFAULT-LIMIT-FN + PCL::CPD-COUNT PCL::CHECKING-LIMIT-FN + PCL::N-N-ACCESSORS-LIMIT-FN PCL::EARLY-CLASS-SIZE + PCL::FAST-INSTANCE-BOUNDP-INDEX)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T) PCL::POWER-OF-TWO-CEILING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*) COMMON-LISP::T) - PCL::MAKE-TYPE-PREDICATE-NAME PCL::MAKE-FINAL-DFUN - PCL::CAPITALIZE-WORDS PCL::SET-DFUN ITERATE::MAYBE-WARN - PCL::MAKE-EARLY-GF PCL::USE-DISPATCH-DFUN-P WALKER::RELIST - PCL::MAKE-SPECIALIZABLE PCL::PV-TABLE-LOOKUP-PV-ARGS - PCL::ALLOCATE-STANDARD-INSTANCE - PCL::ALLOCATE-FUNCALLABLE-INSTANCE - PCL::USE-CONSTANT-VALUE-DFUN-P ITERATE::FUNCTION-LAMBDA-P - PCL::UPDATE-DFUN PCL::SET-ARG-INFO - PCL::EARLY-METHOD-SPECIALIZERS PCL::MAKE-WRAPPER - PCL::FIND-CLASS-CELL WALKER::WALKER-ENVIRONMENT-BIND-1 - PCL::TRACE-METHOD WALKER::RELIST* COMMON-LISP::FIND-CLASS - PCL::INITIALIZE-INTERNAL-SLOT-GFS PCL::FIND-CLASS-PREDICATE - PCL::INITIALIZE-METHOD-FUNCTION)) + PCL::GET-CACHE-FROM-CACHE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::SAUT-NOT PCL::INVOKE-EMF PCL::SAUT-PROTOTYPE - PCL::COMPUTE-CODE ITERATE::PARSE-DECLARATIONS - PCL::SDFUN-FOR-CACHING - PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES - PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL - PCL::SLOT-NAME-LISTS-FROM-SLOTS PCL::DESTRUCTURE - PCL::SPLIT-DECLARATIONS PCL::MAKE-DIRECT-SLOTD - PCL::FORM-LIST-TO-LISP PCL::EMIT-CHECKING - PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::COMPUTE-TEST - PCL::SET-FUNCTION-NAME COMMON-LISP::SLOT-BOUNDP PCL::SAUT-AND - PCL::EMIT-CACHING PCL::INITIAL-DFUN - COMMON-LISP::SLOT-MAKUNBOUND COMMON-LISP::SLOT-VALUE - PCL::UPDATE-SLOT-VALUE-GF-INFO - PCL::CLASS-APPLICABLE-USING-CLASS-P - PCL::CPL-INCONSISTENT-ERROR PCL::*SUBTYPEP - PCL::SLOT-UNBOUND-INTERNAL - PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P - PCL::CHECK-INITARGS-VALUES PCL::ENSURE-CLASS-VALUES - PCL::SAUT-EQL PCL::REAL-REMOVE-METHOD PCL::EMIT-DEFAULT-ONLY - PCL::INSURE-DFUN PCL::EMIT-DEFAULT-ONLY-FUNCTION - PCL::MUTATE-SLOTS-AND-CALLS PCL::FIND-SUPERCLASS-CHAIN - PCL::SAUT-CLASS PCL::MAKE-INSTANCE-FUNCTION-TRAP - PCL::SAUT-CLASS-EQ PCL::COMPUTE-STD-CPL-PHASE-1 - PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM COMMON-LISP::T) + COMMON-LISP::FIXNUM) + PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) PCL::FIELD-TYPE) + PCL::CACHE-FIELD)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) @@ -787,212 +495,533 @@ '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::T) + PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| + WALKER::WALK-TEMPLATE PCL::|(FAST-METHOD PRINT-OBJECT (T T))| + WALKER::WALK-DO/DO* PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR + PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))| + WALKER::WALK-LET/LET* + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| + PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE + PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| + PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| + PCL::INITIALIZE-INSTANCE-SIMPLE + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| + PCL::EXPAND-SYMBOL-MACROLET-INTERNAL + PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| + PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| + PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| + PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| + PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| + PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| + PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| + PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| + PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| + PCL::MAKE-DISPATCH-LAMBDA + PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| + PCL::EXPAND-DEFCLASS + PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| + PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| + PCL::OPTIMIZE-WRITER + PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| + PCL::|(FAST-METHOD DOCUMENTATION (T))| + PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| + PCL::OPTIMIZE-READER WALKER::WALK-PROG/PROG* + PCL::BOOTSTRAP-SET-SLOT + PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + PCL::TWO-CLASS-DFUN-INFO + PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))| + PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| + PCL::ADJUST-CACHE + PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| + PCL::EXPAND-CACHE + PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| + PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| + PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))| + PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| + PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| + PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| + PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| + PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| + PCL::GET-WRAPPERS-FROM-CLASSES + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| + PCL::MAYBE-EXPAND-ACCESSOR-FORM WALKER::WALK-BINDINGS-2 + PCL::FILL-CACHE-P PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL + PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))| + PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| + PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::MEMF-TEST-CONVERTER + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + PCL::REAL-ADD-NAMED-METHOD PCL::EARLY-ADD-NAMED-METHOD + PCL::FILL-DFUN-CACHE)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + PCL::OBSOLETE-INSTANCE-TRAP + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| + WALKER::WALK-TAGBODY + PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| + PCL::ENTRY-IN-CACHE-P WALKER::WALK-COMPILER-LET + PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| + PCL::NOTE-PV-TABLE-REFERENCE PCL::COMPUTE-EFFECTIVE-METHOD + PCL::MAKE-DFUN-CALL PCL::|SETF PCL PLIST-VALUE| + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| + PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| + PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| + PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + WALKER::WALK-UNEXPECTED-DECLARE + PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL + PCL::SKIP-FAST-SLOT-ACCESS-P PCL::SET-FUNCTION-NAME-1 + WALKER::WALK-DO PCL::EMIT-1-T-DLAP PCL::PRINT-STD-INSTANCE + PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| + WALKER::WALK-LAMBDA PCL::MAKE-METHOD-SPEC + PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))| + PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| + PCL::OPTIMIZE-SET-SLOT-VALUE + PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::EXPAND-DEFGENERIC WALKER::VARIABLE-DECLARATION + ITERATE::RENAME-AND-CAPTURE-VARIABLES + PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| + PCL::MAP-ALL-ORDERS + PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| + PCL::DECLARE-STRUCTURE WALKER::WALK-PROG + PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| + PCL::OPTIMIZE-SLOT-VALUE WALKER::WALK-MULTIPLE-VALUE-BIND + PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| + PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD WALKER::WALK-LOCALLY + PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| + WALKER::WALK-DO* + PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| + PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::EMIT-BOUNDP-CHECK WALKER::RECONS + PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| + PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| + WALKER::WALK-LET* WALKER::WALK-TAGBODY-1 PCL::FLUSH-CACHE-TRAP + WALKER::WALK-FLET + PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| + PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| + PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| + PCL::PRINT-CACHE + PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| + PCL::INVALIDATE-WRAPPER PCL::GET-NEW-FUNCTION-GENERATOR + ITERATE::OPTIMIZE-ITERATE-FORM WALKER::RELIST-INTERNAL + PCL::CAN-OPTIMIZE-ACCESS PCL::MAKE-TOP-LEVEL-FORM + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| + WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::WALK-LABELS + PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| + PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| + PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| + WALKER::WALK-SETQ WALKER::WALK-LET + PCL::|SETF PCL METHOD-FUNCTION-GET| WALKER::WALK-IF + PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| + ITERATE::SIMPLE-EXPAND-GATHERING-FORM + PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| + WALKER::WALK-NAMED-LAMBDA PCL::FIRST-FORM-TO-LISP + PCL::ONE-CLASS-DFUN-INFO + WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL + PCL::EMIT-GREATER-THAN-1-DLAP PCL::CONVERT-TABLE + PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| + PCL::INITIALIZE-INTERNAL-SLOT-GFS* + ITERATE::OPTIMIZE-GATHERING-FORM + PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))| + PCL::OPTIMIZE-SLOT-BOUNDP + PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| + PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| + PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS + WALKER::WALK-SYMBOL-MACROLET ITERATE::VARIABLE-SAME-P + PCL::EMIT-SLOT-READ-FORM + PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P + PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| + PCL::GET-FUNCTION-GENERATOR + PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION + PCL::FIX-SLOT-ACCESSORS + PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + PCL::OPTIMIZE-GF-CALL-INTERNAL + PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| + PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| + PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| + PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| + PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| + PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + WALKER::WALK-PROG* PCL::ONE-INDEX-DFUN-INFO + PCL::COMPUTE-PRECEDENCE PCL::TRACE-EMF-CALL-INTERNAL + WALKER::WALK-MACROLET)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - WALKER::WALK-DECLARATIONS PCL::GET-SECONDARY-DISPATCH-FUNCTION - PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) + COMMON-LISP::T) + PCL::MAKE-DEFMETHOD-FORM-INTERNAL PCL::LOAD-DEFMETHOD + PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - PCL::MAKE-SHARED-INITIALIZE-FORM-LIST PCL::ACCESSOR-MISS - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| - PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| - PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| - PCL::SET-CLASS-SLOT-VALUE-1 - PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| - PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))| - PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION - PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN - PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| - PCL::EMIT-CHECKING-OR-CACHING-FUNCTION - PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN - PCL::LOAD-SHORT-DEFCOMBIN PCL::EMIT-CHECKING-OR-CACHING - PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))| - PCL::MAKE-FINAL-CHECKING-DFUN - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| - PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| - PCL::ACCESSOR-VALUES - PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| - PCL::REAL-MAKE-METHOD-LAMBDA - PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))| - PCL::GET-ACCESSOR-METHOD-FUNCTION - PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| - PCL::ORDER-SPECIALIZERS - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| - PCL::GENERATE-DISCRIMINATION-NET - PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| - PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| - PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN - PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))| - PCL::BOOTSTRAP-ACCESSOR-DEFINITION - PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + PCL::GET-EFFECTIVE-METHOD-FUNCTION1 + PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS + PCL::MAKE-EMF-FROM-METHOD + PCL::REAL-ENSURE-GF-USING-CLASS--NULL PCL::PROBE-CACHE + PCL::MAP-CACHE PCL::GET-DECLARATION + PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION + WALKER::CONVERT-MACRO-TO-LAMBDA + PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION PCL::EMIT-MISS + PCL::GET-METHOD-FUNCTION-PV-CELL PCL::METHOD-FUNCTION-GET + PCL::FIND-CLASS-FROM-CELL PCL::RECORD-DEFINITION + PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 + PCL::FIND-CLASS-PREDICATE-FROM-CELL + PCL::NAMED-OBJECT-PRINT-FUNCTION + PCL::PRECOMPUTE-EFFECTIVE-METHODS PCL::INITIALIZE-INFO + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION - PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION - PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| - PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| - PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| - PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION - PCL::CONVERT-METHODS WALKER::WALK-LET-IF - PCL::EMIT-READER/WRITER-FUNCTION PCL::ACCESSOR-VALUES-INTERNAL - PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| - PCL::LOAD-LONG-DEFCOMBIN PCL::CHECK-METHOD-ARG-INFO - PCL::ACCESSOR-VALUES1 - PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| - PCL::GENERATING-LISP PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN - WALKER::WALK-FORM-INTERNAL PCL::CONSTANT-VALUE-MISS - PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS - PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| - PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::CHECKING-MISS - PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| - PCL::EMIT-READER/WRITER ITERATE::EXPAND-INTO-LET - PCL::GET-CLASS-SLOT-VALUE-1 - PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION - PCL::MAKE-FINAL-CACHING-DFUN - PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| - PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| - PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| - PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P PCL::SET-SLOT-VALUE - PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER - ITERATE::RENAME-VARIABLES - PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| - PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| - ITERATE::WALK-GATHERING-BODY PCL::CACHE-MISS-VALUES - PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION - PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| + PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 + PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL + PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1 PCL::MAKE-EMF-CACHE + PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| + PCL::MAKE-FGEN + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| + PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS + PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| + PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::OPTIMIZE-ACCESSOR-CALL + PCL::MAKE-INSTANCE-FUNCTION-COMPLEX PCL::UPDATE-SLOTS-IN-PV + PCL::COMPUTE-PV-SLOT + PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))| + PCL::OPTIMIZE-INSTANCE-ACCESS + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| + PCL::MAKE-INSTANCE-FUNCTION-SIMPLE + PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + PCL::OPTIMIZE-GENERIC-FUNCTION-CALL + PCL::LOAD-FUNCTION-GENERATOR WALKER::WALK-BINDINGS-1 + PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| + PCL::REAL-MAKE-METHOD-INITARGS-FORM + PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| + PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| + WALKER::WALK-TEMPLATE-HANDLE-REPEAT + PCL::MAKE-PARAMETER-REFERENCES + PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| + PCL::EXPAND-EMF-CALL-METHOD + PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| + PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| + PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::DO-SHORT-METHOD-COMBINATION PCL::MEMF-CODE-CONVERTER - PCL::GENERATE-DISCRIMINATION-NET-INTERNAL - PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION - PCL::CACHE-MISS-VALUES-INTERNAL)) + COMMON-LISP::*) + COMMON-LISP::T) + PCL::GET-METHOD WALKER::WALK-ARGLIST PCL::REAL-GET-METHOD + PCL::EMIT-FETCH-WRAPPER PCL::CHECK-INITARGS-2-LIST + PCL::FILL-CACHE PCL::CHECK-INITARGS-2-PLIST PCL::MAKE-EMF-CALL + PCL::CHECK-INITARGS-1 PCL::CAN-OPTIMIZE-ACCESS1)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| - PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| - PCL::ADD-METHOD-DECLARATIONS - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| - PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| - PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| - PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| - PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| - PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::WALK-METHOD-LAMBDA - PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|)) + COMMON-LISP::T) + PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::*) - PCL::REAL-MAKE-A-METHOD)) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + PCL::REAL-LOAD-DEFCLASS PCL::LOAD-DEFCLASS PCL::SET-ARG-INFO1 + PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION PCL::EMIT-SLOT-ACCESS + WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 PCL::OPTIMIZE-GF-CALL + PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + PCL::MAKE-EARLY-CLASS-DEFINITION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - PCL::MAKE-DEFAULT-INITARGS-FORM-LIST - PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS - PCL::SLOT-VALUE-OR-DEFAULT - PCL::GET-SIMPLE-INITIALIZATION-FUNCTION PCL::REAL-ADD-METHOD - PCL::LOAD-DEFGENERIC PCL::CPL-ERROR - PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MAKE-N-N-ACCESSOR-DFUN - PCL::TYPES-FROM-ARGUMENTS PCL::MAKE-ACCESSOR-TABLE - PCL::MAKE-CHECKING-DFUN WALKER::NESTED-WALK-FORM - PCL::GET-EFFECTIVE-METHOD-FUNCTION - PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::FIXNUM) + COMMON-LISP::T) + PCL::GET-CACHE PCL::FILL-CACHE-FROM-CACHE-P)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - ITERATE::ITERATE-TRANSFORM-BODY - PCL::|(FAST-METHOD SLOT-MISSING (T T T T))| - PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|)) + (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*) + COMMON-LISP::FIXNUM) + PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1 - ITERATE::RENAME-LET-BINDINGS)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) + PCL::EVAL-FORM PCL::EARLY-CLASS-NAME-OF PCL::DFUN-INFO-CACHE + PCL::MAKE-CONSTANT-FUNCTION PCL::EXPAND-SHORT-DEFCOMBIN + PCL::COPY-CACHE PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES + PCL::MAKE-INITIAL-DFUN PCL::ECD-METACLASS + PCL::EXTRACT-SPECIALIZER-NAMES PCL::GBOUNDP + PCL::GET-SETF-FUNCTION-NAME PCL::USE-CACHING-DFUN-P + PCL::INITIALIZE-INFO-CACHED-CONSTANTS + PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS COMMON-LISP::CLASS-OF + PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION + PCL::ARG-INFO-KEY/REST-P PCL::METHOD-CALL-CALL-METHOD-ARGS + PCL::FGEN-GENSYMS PCL::EARLY-CLASS-PRECEDENCE-LIST + PCL::EARLY-SLOT-DEFINITION-LOCATION + PCL::EXPAND-MAKE-INSTANCE-FORM PCL::INTERN-EQL-SPECIALIZER + PCL::METHOD-FUNCTION-METHOD PCL::FGEN-GENERATOR-LAMBDA + PCL::SLOT-READER-SYMBOL PCL::CACHING-P + PCL::EARLY-METHOD-QUALIFIERS + PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::KEYWORD-SPEC-NAME + PCL::ONE-INDEX-P PCL::COMPLICATED-INSTANCE-CREATION-METHOD + PCL::DFUN-ARG-SYMBOL PCL::N-N-CACHE + PCL::ONE-INDEX-DFUN-INFO-INDEX PCL::INITIAL-DISPATCH-CACHE + PCL::CPD-CLASS PCL::FAST-METHOD-CALL-ARG-INFO + PCL::MAKE-PV-TYPE-DECLARATION PCL::COMPUTE-STD-CPL-PHASE-2 + PCL::GET-BUILT-IN-CLASS-SYMBOL + PCL::INITIALIZE-INFO-CACHED-RI-VALID-P + PCL::UPDATE-GFS-OF-CLASS PCL::STRUCTURE-SVUC-METHOD + PCL::SLOT-BOUNDP-SYMBOL PCL::FGEN-SYSTEM + PCL::FIND-CYCLE-REASONS ITERATE::SEQUENCE-ACCESSOR + PCL::GF-INFO-C-A-M-EMF-STD-P PCL::STRUCTURE-TYPE-P + PCL::TWO-CLASS-CACHE PCL::METHOD-LL->GENERIC-FUNCTION-LL + PCL::ONE-CLASS-ACCESSOR-TYPE PCL::WRAPPER-FOR-STRUCTURE + PCL::ACCESSOR-DFUN-INFO-CACHE PCL::%SYMBOL-FUNCTION + PCL::STRUCTURE-TYPE PCL::NET-TEST-CONVERTER + PCL::CONSTANT-SYMBOL-P PCL::GMAKUNBOUND PCL::INITIAL-P + PCL::GF-DFUN-CACHE PCL::STRUCTURE-SLOTD-TYPE + PCL::%STD-INSTANCE-WRAPPER PCL::INITIALIZE-INFO-P + PCL::CACHING-DFUN-INFO + PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::FAST-METHOD-CALL-P PCL::GF-DFUN-INFO + PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::ECD-CLASS-NAME + PCL::MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION + PCL::STD-INSTANCE-P PCL::EXTRACT-PARAMETERS + WALKER::GET-WALKER-TEMPLATE PCL::SYMBOL-PKG-NAME + PCL::CCLOSUREP PCL::LOOKUP-FGEN PCL::CPD-SUPERS + PCL::ARG-INFO-KEYWORDS PCL::DISPATCH-P + PCL::INITIALIZE-INFO-CACHED-NEW-KEYS + PCL::MAKE-CALLS-TYPE-DECLARATION PCL::INITIALIZE-INFO-WRAPPER + PCL::%FBOUNDP PCL::DEFAULT-STRUCTURE-INSTANCE-P + WALKER::ENV-WALK-FORM PCL::EARLY-CLASS-DEFINITION + PCL::SORT-CALLS PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME + PCL::DISPATCH-CACHE PCL::INITIALIZE-INFO-KEY + PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION + PCL::ARG-INFO-METATYPES PCL::GF-LAMBDA-LIST + WALKER::ENV-LEXICAL-VARIABLES PCL::ACCESSOR-DFUN-INFO-P + PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::COMPUTE-LINE-SIZE + PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION + PCL::FORCE-CACHE-FLUSHES PCL::TWO-CLASS-P PCL::DFUN-INFO-P + PCL::MAP-SPECIALIZERS PCL::MAKE-PERMUTATION-VECTOR + WALKER::ENV-LOCK PCL::CPD-AFTER PCL::EARLY-CLASS-SLOTS + PCL::GET-PV-CELL-FOR-CLASS PCL::ARG-INFO-P + PCL::EXTRACT-REQUIRED-PARAMETERS + PCL::STRUCTURE-SLOTD-READER-FUNCTION PCL::COMPUTE-CLASS-SLOTS + PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS + PCL::TWO-CLASS-WRAPPER0 + PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::COMPILE-LAMBDA-UNCOMPILED PCL::EARLY-CLASS-NAME + PCL::SFUN-P PCL::EXTRACT-LAMBDA-LIST PCL::UNDEFMETHOD-1 + PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE PCL::WRAPPER-OF + PCL::ARG-INFO-LAMBDA-LIST PCL::LIST-DFUN + PCL::NEXT-WRAPPER-FIELD PCL::CHECK-WRAPPER-VALIDITY + PCL::STRUCTURE-SLOTD-NAME PCL::BUILT-IN-WRAPPER-OF + PCL::GET-MAKE-INSTANCE-FUNCTIONS + PCL::GENERIC-CLOBBERS-FUNCTION PCL::NO-METHODS-P + PCL::CONSTANT-VALUE-P WALKER::ENV-WALK-FUNCTION + PCL::INITIAL-CACHE PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD + PCL::MAKE-CLASS-EQ-PREDICATE + PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS + PCL::FUNCTION-PRETTY-ARGLIST + PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST PCL::TYPE-CLASS + PCL::CHECK-CACHE PCL::STANDARD-SVUC-METHOD + PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL PCL::GF-INFO-FAST-MF-P + PCL::STRUCTURE-SLOTD-WRITER-FUNCTION + PCL::BOOTSTRAP-CLASS-PREDICATES PCL::DEFAULT-METHOD-ONLY-CACHE + PCL::GET-CACHE-VECTOR PCL::SLOT-WRITER-SYMBOL + PCL::FGEN-GENERATOR PCL::DNET-METHODS-P + PCL::DEFAULT-STRUCTURE-TYPE + PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST + PCL::N-N-ACCESSOR-TYPE + PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST + WALKER::ENV-DECLARATIONS WALKER::VARIABLE-GLOBALLY-SPECIAL-P + PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-DFUN-INFO-CACHE + PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::EARLY-CLASS-SLOTDS + PCL::CANONICAL-SLOT-NAME PCL::EARLY-COLLECT-CPL + PCL::RESET-CLASS-INITIALIZE-INFO-1 + PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::ONE-INDEX-CACHE + PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION + PCL::MAKE-TYPE-PREDICATE PCL::FREE-CACHE + ITERATE::VARIABLES-FROM-LET + PCL::EARLY-METHOD-STANDARD-ACCESSOR-P + PCL::DEFAULT-CONSTANT-CONVERTER PCL::CLASS-PREDICATE + PCL::CHECKING-CACHE PCL::ARG-INFO-PRECEDENCE + PCL::METHOD-FUNCTION-NEEDS-NEXT-METHODS-P + PCL::DEFAULT-METHOD-ONLY-P + PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P + PCL::STRUCTURE-SLOT-BOUNDP PCL::ONE-INDEX-ACCESSOR-TYPE + PCL::TWO-CLASS-ACCESSOR-TYPE + PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::METHOD-CALL-P + PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::CONSTANT-VALUE-DFUN-INFO + PCL::COMPILE-LAMBDA-DEFERRED PCL::SETFBOUNDP + PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P + PCL::PV-TABLEP PCL::STRUCTURE-OBJECT-P PCL::TWO-CLASS-INDEX + PCL::METHOD-FUNCTION-PV-TABLE PCL::ECD-OTHER-INITARGS + WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE + PCL::EARLY-GF-P PCL::STRUCTURE-SLOTD-INIT-FORM + PCL::FUNCALLABLE-INSTANCE-P PCL::CHECKING-FUNCTION + PCL::FUNCTION-RETURNING-NIL PCL::FUNCTION-RETURNING-T + PCL::UPDATE-C-A-M-GF-INFO PCL::COUNT-DFUN + PCL::UNPARSE-SPECIALIZERS PCL::CACHE-OWNER + PCL::EARLY-METHOD-CLASS + PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION + PCL::EARLY-SLOT-DEFINITION-NAME + PCL::GET-MAKE-INSTANCE-FUNCTION + PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME + PCL::ECD-SUPERCLASS-NAMES PCL::GFS-OF-TYPE PCL::SORT-SLOTS + PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS + PCL::COMPUTE-MCASE-PARAMETERS PCL::METHOD-FUNCTION-PLIST + PCL::ARG-INFO-NKEYS PCL::FINAL-ACCESSOR-DFUN-TYPE + PCL::EARLY-COLLECT-SLOTS PCL::EARLY-METHOD-LAMBDA-LIST + PCL::FAST-INSTANCE-BOUNDP-P PCL::GDEFINITION + PCL::%CCLOSURE-ENV SYSTEM::%COMPILED-FUNCTION-NAME + PCL::RESET-INITIALIZE-INFO PCL::ARG-INFO-NUMBER-OPTIONAL + PCL::RESET-CLASS-INITIALIZE-INFO + PCL::INITIALIZE-INFO-CACHED-VALID-P PCL::INTERNED-SYMBOL-P + PCL::EARLY-GF-NAME PCL::FGEN-TEST PCL::MAKE-INITFUNCTION + PCL::MAP-ALL-GENERIC-FUNCTIONS PCL::SHOW-DFUN-COSTS + PCL::CLASS-FROM-TYPE PCL::EXPAND-LONG-DEFCOMBIN + PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION + PCL::FREE-CACHE-VECTOR PCL::%STD-INSTANCE-SLOTS + PCL::ALLOCATE-CACHE-VECTOR PCL::ONE-CLASS-P + PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::SLOT-VECTOR-SYMBOL + PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION + PCL::ONE-CLASS-WRAPPER0 PCL::N-N-P + PCL::UPDATE-ALL-C-A-M-GF-INFO PCL::CHECKING-P + PCL::TWO-CLASS-WRAPPER1 PCL::PARSE-SPECIALIZERS + PCL::FORMAT-CYCLE-REASONS PCL::FLUSH-CACHE-VECTOR-INTERNAL + PCL::UNENCAPSULATED-FDEFINITION PCL::ONE-CLASS-INDEX + PCL::DEFAULT-CONSTANTP PCL::UPDATE-GF-INFO + PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE + PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST + PCL::MAKE-EQL-PREDICATE PCL::ARG-INFO-VALID-P + PCL::CACHING-CACHE PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION + PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL + PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION + PCL::MAKE-FUNCTION-INLINE PCL::STORE-FGEN + PCL::LIST-LARGE-CACHE PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P + PCL::ARG-INFO-APPLYP SYSTEM::%STRUCTURE-NAME + PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::ECD-SOURCE + PCL::EARLY-CLASS-DIRECT-SUBCLASSES + PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::DEFAULT-TEST-CONVERTER + PCL::MAKE-CALL-METHODS PCL::GET-BUILT-IN-WRAPPER-SYMBOL + PCL::GF-INFO-STATIC-C-A-M-EMF PCL::DEFAULT-STRUCTUREP + PCL::CONSTANT-VALUE-CACHE PCL::INITIAL-DISPATCH-P + PCL::ECD-CANONICAL-SLOTS PCL::WRAPPER-FIELD + PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE PCL::ONE-CLASS-CACHE + PCL::CACHING-DFUN-COST PCL::LEGAL-CLASS-NAME-P + PCL::INTERN-FUNCTION-NAME PCL::FAST-METHOD-CALL-PV-CELL + PCL::CACHE-P PCL::ONE-INDEX-DFUN-INFO-P + PCL::MAKE-PV-TABLE-TYPE-DECLARATION PCL::NO-METHODS-CACHE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM COMMON-LISP::T) - COMMON-LISP::FIXNUM) - PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) + PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::UNTRACE-METHOD + COMMON-LISP::METHOD-COMBINATION-ERROR + COMMON-LISP::INVALID-METHOD-ERROR PCL::LIST-LARGE-CACHES)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION - PCL::GET-CACHE-FROM-CACHE)) + PCL::EMIT-DLAP PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM COMMON-LISP::T) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - PCL::%CCLOSURE-ENV-NTHCDR)) + PCL::COMPUTE-STD-CPL-PHASE-3)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::STREAM COMMON-LISP::T) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) COMMON-LISP::T) - PCL::PRINT-DFUN-INFO)) + PCL::EXPAND-DEFMETHOD PCL::LOAD-DEFMETHOD-INTERNAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) - PCL::COUNT-ALL-DFUNS PCL::EMIT-N-N-WRITERS - PCL::EMIT-N-N-READERS)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::T) + PCL::BOOTSTRAP-INITIALIZE-CLASS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::FIXNUM) - PCL::GET-WRAPPER-CACHE-NUMBER)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::LIST) + PCL::PV-TABLE-CALL-LIST PCL::CACHE-OVERFLOW + PCL::PV-TABLE-SLOT-NAME-LISTS)) (IN-PACKAGE "PCL") -(DOLIST (V '(|(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| - |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-METHODS)| +(DOLIST (V '(|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-METHODS)| |(FAST-WRITER-METHOD SLOT-OBJECT SLOTS)| |(FAST-WRITER-METHOD SLOT-CLASS SLOTS)| |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SLOTS)| |(FAST-WRITER-METHOD SLOT-CLASS DIRECT-SLOTS)| + |(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| |(FAST-WRITER-METHOD SLOT-OBJECT METHODS)| |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHODS)| |(FAST-WRITER-METHOD SLOT-OBJECT OPTIONS)| @@ -1034,17 +1063,16 @@ COMPATIBLE-META-CLASS-CHANGE-P |(FAST-READER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)| |(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)| - |(BOUNDP READER-FUNCTION)| TRACE-METHOD-INTERNAL - |(BOUNDP PREDICATE-NAME)| |(BOUNDP READERS)| - UPDATE-GF-DFUN |(BOUNDP CLASS-PRECEDENCE-LIST)| + |(BOUNDP READER-FUNCTION)| |(BOUNDP PREDICATE-NAME)| + |(BOUNDP READERS)| UPDATE-GF-DFUN + |(BOUNDP CLASS-PRECEDENCE-LIST)| |(BOUNDP ACCESSOR-FLAGS)| |(BOUNDP LOCATION)| |(BOUNDP DOCUMENTATION)| SPECIALIZER-OBJECT |(BOUNDP INCOMPATIBLE-SUPERCLASS-LIST)| ACCESSOR-METHOD-SLOT-NAME |(BOUNDP SPECIALIZERS)| |(BOUNDP IDENTITY-WITH-ONE-ARGUMENT)| |(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)| - REDEFINE-FUNCTION SPECIALIZER-CLASS - |(BOUNDP PRETTY-ARGLIST)| + SPECIALIZER-CLASS |(BOUNDP PRETTY-ARGLIST)| |PCL::PCL-CLASS class predicate| |PCL::STD-CLASS class predicate| |(BOUNDP DEFSTRUCT-FORM)| @@ -1082,104 +1110,104 @@ |(BOUNDP OPTIONS)| |(WRITER METHOD)| |PCL::DEPENDENT-UPDATE-MIXIN class predicate| GENERIC-FUNCTION-PRETTY-ARGLIST |(WRITER SOURCE)| + |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| - |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| |(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| + |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| |(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))| - |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| - |(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| - |(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| |(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| - |(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| |(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))| + |(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| |(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))| + |(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| + |(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| MAKE-BOUNDP-METHOD-FUNCTION |(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))| |(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))| |PCL::METAOBJECT class predicate| - |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| + |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| + |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| + |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| + |(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| |(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| + |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| |(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| + |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| + |(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| - |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| - |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| - |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| - |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| + |(FAST-METHOD CHANGE-CLASS (T SYMBOL))| + |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| |(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| |(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - |(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| |(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| - |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| - |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| - |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| - |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| - |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| - |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| - |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| - |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| - |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| - |(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| |(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| - |(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD CHANGE-CLASS (T SYMBOL))| |(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| + |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| |(FAST-METHOD MAKE-INSTANCE (SYMBOL))| + |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| - |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| - |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| - |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| - |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| - |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| - |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| - |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| + |(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SPECIALIZER-CLASS (CLASS))| + |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| + |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| + |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| |(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| + |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| + |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| |(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| - |(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| + |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| - |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| - |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| - |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| - |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| - |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| |(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| - |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| - |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| - |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD SPECIALIZER-CLASS (CLASS))| - |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| - |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| - |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| + |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| |(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| - |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| - |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| - |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| - |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| - |(FAST-METHOD MAKE-INSTANCE (CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| - |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| - |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| + |(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| + |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| |(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| + |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| + |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| + |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| + |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| + |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| + |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| + |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| + |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| |(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| |(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| + |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| + |(FAST-METHOD MAKE-INSTANCE (CLASS))| |(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| - |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| + |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| + |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| + |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| + |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| CLASS-PREDICATE-NAME |PCL::STRUCTURE-SLOT-DEFINITION class predicate| |PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate| @@ -1205,8 +1233,8 @@ |(WRITER PREDICATE-NAME)| |(WRITER READERS)| |(READER WRITER-FUNCTION)| |(READER INITFUNCTION)| INITIALIZE-INTERNAL-SLOT-FUNCTIONS - |SETF PCL SLOT-DEFINITION-TYPE| |(READER WRITERS)| - |(WRITER CLASS-PRECEDENCE-LIST)| + |SETF PCL SLOT-DEFINITION-TYPE| + |(WRITER CLASS-PRECEDENCE-LIST)| |(READER WRITERS)| |(WRITER ACCESSOR-FLAGS)| |(READER INITFORM)| METHOD-COMBINATION-P |(WRITER LOCATION)| |(WRITER DOCUMENTATION)| @@ -1220,11 +1248,11 @@ |(READER ALLOCATION)| |(WRITER SPECIALIZERS)| |(CALL REAL-ENSURE-GF-USING-CLASS--NULL)| |(WRITER IDENTITY-WITH-ONE-ARGUMENT)| - |(SETF METHOD-GENERIC-FUNCTION)| - |(WRITER PRETTY-ARGLIST)| LEGAL-SPECIALIZERS-P - |SETF PCL OBJECT-PLIST| |(WRITER DEFSTRUCT-FORM)| - |(READER FUNCTION)| |(READER GENERIC-FUNCTION)| - |(READER LAMBDA-LIST)| |(READER SLOT-DEFINITION)| + |(SETF METHOD-GENERIC-FUNCTION)| LEGAL-SPECIALIZERS-P + |(WRITER PRETTY-ARGLIST)| |SETF PCL OBJECT-PLIST| + |(WRITER DEFSTRUCT-FORM)| |(READER FUNCTION)| + |(READER GENERIC-FUNCTION)| |(READER LAMBDA-LIST)| + |(READER SLOT-DEFINITION)| |PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate| |SETF PCL SLOT-DEFINITION-INITFORM| |SETF PCL CLASS-DEFSTRUCT-FORM| @@ -1245,16 +1273,17 @@ |SETF PCL SLOT-DEFINITION-ALLOCATION| |SETF PCL SLOT-DEFINITION-INITFUNCTION| |(WRITER SLOT-NAME)| |(BOUNDP NAME)| - |(READER FAST-FUNCTION)| |(WRITER ALLOCATION)| + |(WRITER ALLOCATION)| |(READER FAST-FUNCTION)| |(READER METHOD-CLASS)| |(SETF OBJECT-PLIST)| |(READER INTERNAL-WRITER-FUNCTION)| |(READER INTERNAL-READER-FUNCTION)| |(READER METHOD-COMBINATION)| METHOD-COMBINATION-OPTIONS |(READER DIRECT-SLOTS)| |(READER DIRECT-METHODS)| - |SETF PCL SLOT-DEFINITION-READERS| |(WRITER FUNCTION)| - |(WRITER GENERIC-FUNCTION)| |(READER BOUNDP-FUNCTION)| - |SETF PCL DOCUMENTATION| |(READER DIRECT-SUBCLASSES)| + |SETF PCL SLOT-DEFINITION-READERS| + |(READER BOUNDP-FUNCTION)| |(WRITER FUNCTION)| + |(WRITER GENERIC-FUNCTION)| |SETF PCL DOCUMENTATION| + |(READER DIRECT-SUBCLASSES)| |(READER DIRECT-SUPERCLASSES)| |(WRITER LAMBDA-LIST)| FUNCALLABLE-STANDARD-CLASS-P |(FAST-WRITER-METHOD SLOT-OBJECT METHOD)| @@ -1265,7 +1294,7 @@ |SETF PCL SLOT-VALUE-USING-CLASS| |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)| |(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION DEFSTRUCT-ACCESSOR-SYMBOL)| - |(WRITER PROTOTYPE)| |(BOUNDP TYPE)| |(BOUNDP OBJECT)| + |(WRITER PROTOTYPE)| |(BOUNDP OBJECT)| |(BOUNDP TYPE)| CLASS-CAN-PRECEDE-LIST |SETF PCL CLASS-DIRECT-SLOTS| |SETF PCL CLASS-SLOTS| SLOT-ACCESSOR-FUNCTION |(BOUNDP PLIST)| @@ -1280,11 +1309,11 @@ |(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)| |PCL::PLIST-MIXIN class predicate| |(WRITER FAST-FUNCTION)| |(WRITER METHOD-CLASS)| - |(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)| GET-METHOD + |(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)| |(WRITER INTERNAL-WRITER-FUNCTION)| |(WRITER INTERNAL-READER-FUNCTION)| - |(WRITER METHOD-COMBINATION)| |(WRITER DIRECT-SLOTS)| - |(WRITER DIRECT-METHODS)| + |(WRITER METHOD-COMBINATION)| GET-METHOD + |(WRITER DIRECT-SLOTS)| |(WRITER DIRECT-METHODS)| |(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)| |(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)| |(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)| @@ -1354,18 +1383,18 @@ |(FAST-READER-METHOD SLOT-DEFINITION READERS)| |(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)| |(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)| + |(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)| + |(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)| |(FAST-READER-METHOD SPECIALIZER TYPE)| |(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)| |(FAST-READER-METHOD PCL-CLASS PROTOTYPE)| - |(FAST-READER-METHOD SLOT-DEFINITION TYPE)| - |(FAST-READER-METHOD SLOT-OBJECT TYPE)| - |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)| - |(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)| - |(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)| |(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)| |(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)| |(FAST-READER-METHOD SLOT-OBJECT OBJECT)| |(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)| + |(FAST-READER-METHOD SLOT-DEFINITION TYPE)| + |(FAST-READER-METHOD SLOT-OBJECT TYPE)| + |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)| |(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)| |(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)| |(FAST-READER-METHOD SLOT-OBJECT INITFORM)| @@ -1387,11 +1416,11 @@ |(FAST-READER-METHOD SLOT-CLASS SLOTS)| |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)| |(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)| + |(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| |(FAST-READER-METHOD SLOT-OBJECT METHODS)| |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)| |(FAST-READER-METHOD SLOT-OBJECT OPTIONS)| |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION OPTIONS)| - |(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| |(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)| |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)| @@ -1429,8 +1458,8 @@ |(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)| - |(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)| |(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)| + |(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)| |(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)| |(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)| |(SETF SLOT-VALUE-USING-CLASS)| @@ -1456,10 +1485,10 @@ |(SETF SLOT-DEFINITION-TYPE)| |(SETF SLOT-DEFINITION-INITFORM)| |(BOUNDP INITIALIZE-INFO)| - |(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)| + |(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| |(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)| |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| @@ -1468,94 +1497,95 @@ |(BOUNDP INITARGS)| LONG-METHOD-COMBINATION-FUNCTION GENERIC-FUNCTION-P |PCL::SLOT-DEFINITION class predicate| |(READER NAME)| - |(READER CLASS)| |(FAST-METHOD SLOT-UNBOUND (T T T))| - |(FAST-METHOD (SETF DOCUMENTATION) (T T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| - |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| - |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| - |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| + |(READER CLASS)| + |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| + |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| + |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| + |(FAST-METHOD DESCRIBE-OBJECT (T T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| + |(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| + |(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| + |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| + |(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| |(FAST-METHOD REMOVE-NAMED-METHOD (T T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| + |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| - |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| - |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| |(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| - |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| + |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| + |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| |(FAST-METHOD PRINT-OBJECT (CLASS T))| - |(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| |(FAST-METHOD PRINT-OBJECT (T T))| - |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| - |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| + |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| |(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| |(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - |(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| - |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| - |(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| - |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| - |(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| - |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| - |(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| + |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| + |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| - |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| + |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| - |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| + |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| + |(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| + |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| |(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| - |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| |(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| - |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| + |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| + |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| + |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| + |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| |(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| + |(FAST-METHOD (SETF DOCUMENTATION) (T T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| + |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| + |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| |(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| - |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| + |(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))| |(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| - |(FAST-METHOD DESCRIBE-OBJECT (T T))| - |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| - |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| - |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| - |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| - |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD SLOT-UNBOUND (T T T))| |(FAST-METHOD SLOT-MISSING (T T T T))| - |(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))| - LEGAL-SLOT-NAME-P |(READER TYPE)| |(READER OBJECT)| + |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| + |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| + LEGAL-SLOT-NAME-P |(READER OBJECT)| |(READER TYPE)| CLASS-WRAPPER |(READER PLIST)| |(FAST-METHOD CLASS-PREDICATE-NAME (T))| |(FAST-METHOD DOCUMENTATION (T))| |(FAST-METHOD NO-APPLICABLE-METHOD (T))| |(READER SLOTS)| |(WRITER NAME)| DEFINITION-SOURCE |PCL::SLOT-OBJECT class predicate| DEFAULT-INITARGS - |(WRITER CLASS)| CLASS-SLOT-VALUE |(WRITER TYPE)| - |(WRITER OBJECT)| + |(WRITER CLASS)| CLASS-SLOT-VALUE |(WRITER OBJECT)| + |(WRITER TYPE)| |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))| |(WRITER PLIST)| |(WRITER SLOTS)| |PCL::DOCUMENTATION-MIXIN class predicate| @@ -1595,10 +1625,10 @@ |COMMON-LISP::STANDARD-OBJECT class predicate| |COMMON-LISP::BUILT-IN-CLASS class predicate| |SETF PCL CLASS-SLOT-VALUE| |(SETF CLASS-SLOTS)| - |(SETF CLASS-DIRECT-SLOTS)| DO-STANDARD-DEFSETF-1 - |(READER OPERATOR)| |(CALL REAL-GET-METHOD)| - |(CALL REAL-REMOVE-METHOD)| |(CALL REAL-ADD-METHOD)| - |(READER ARG-INFO)| METHOD-COMBINATION-TYPE + |(SETF CLASS-DIRECT-SLOTS)| |(READER OPERATOR)| + |(CALL REAL-GET-METHOD)| |(CALL REAL-REMOVE-METHOD)| + |(CALL REAL-ADD-METHOD)| |(READER ARG-INFO)| + METHOD-COMBINATION-TYPE |(READER DEFSTRUCT-CONSTRUCTOR)| |(INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)| |(READER INITIALIZE-INFO)| |(WRITER WRAPPER)| @@ -1607,8 +1637,8 @@ |(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)| COMPUTE-SLOT-ACCESSOR-INFO |(READER INITARGS)| |(WRITER CLASS-EQ-SPECIALIZER)| - STANDARD-BOUNDP-METHOD-P FDEFINE-CAREFULLY - |(SETF DOCUMENTATION)| RAW-INSTANCE-ALLOCATOR + STANDARD-BOUNDP-METHOD-P |(SETF DOCUMENTATION)| + RAW-INSTANCE-ALLOCATOR |SETF PCL SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL| |SETF PCL CLASS-INITIALIZE-INFO| |(WRITER OPERATOR)| |(WRITER ARG-INFO)| @@ -1621,8 +1651,9 @@ METHOD-COMBINATION-DOCUMENTATION |SETF PCL SLOT-DEFINITION-INITARGS| REMOVE-BOUNDP-METHOD ADD-NAMED-METHOD + |(WRITER INITARGS)| |SETF PCL CLASS-DEFSTRUCT-CONSTRUCTOR| - |(WRITER INITARGS)| |(BOUNDP METHOD)| + |(BOUNDP METHOD)| |(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)| |(FAST-WRITER-METHOD CLASS NAME)| |(FAST-WRITER-METHOD SLOT-DEFINITION NAME)| @@ -1668,11 +1699,11 @@ |(FAST-WRITER-METHOD SLOT-OBJECT READERS)| |(FAST-WRITER-METHOD SLOT-DEFINITION READERS)| |(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)| + |(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)| |(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)| + |(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)| |(FAST-WRITER-METHOD SLOT-DEFINITION TYPE)| |(FAST-WRITER-METHOD SLOT-OBJECT TYPE)| - |(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)| - |(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)| REMOVE-NAMED-METHOD |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)| |(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)| @@ -1725,6 +1756,5 @@ ENSURE-CLASS-USING-CLASS NO-APPLICABLE-METHOD SLOT-DEFINITION-WRITERS COMPUTE-APPLICABLE-METHODS-USING-CLASSES - CLASS-PRECEDENCE-LIST DISASSEMBLE DESCRIBE-OBJECT - COMPILE)) - (SETF (GET V 'SYSTEM::PROCLAIMED-CLOSURE) T)) + CLASS-PRECEDENCE-LIST DESCRIBE-OBJECT)) + (SETF (GET V 'COMPILER::PROCLAIMED-CLOSURE) T)) -- 2.30.2