From a8b3b36f283dfbb399aa8fc9bffc14de891aeaff Mon Sep 17 00:00:00 2001 From: Camm Maguire Date: Sun, 13 Nov 2022 12:55:14 +0000 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-125) unstable; urgency=medium * Version_2.6.13pre125 Gbp-Pq: Name Version_2_6_13pre125 --- clcs/sys-proclaim.lisp | 46 +- cmpnew/gcl_cmpmain.lsp | 11 +- cmpnew/gcl_cmptop.lsp | 1 + cmpnew/gcl_lfun_list.lsp | 2 +- cmpnew/sys-proclaim.lisp | 644 ++++++----- configure | 4 + configure.in | 2 + git.tag | 2 + h/amd64-linux.h | 2 + h/gclincl.h.in | 3 + h/notcomp.h | 3 + h/object.h | 3 +- h/protoize.h | 10 +- lsp/gcl_mislib.lsp | 11 +- lsp/gcl_predlib.lsp | 1 + lsp/sys-proclaim.lisp | 1089 ++++++++++--------- o/alloc.c | 16 +- o/cfun.c | 10 + o/cmac.c | 14 +- o/hash.d | 153 ++- o/main.c | 4 + o/num_co.c | 43 +- o/num_comp.c | 8 +- o/package.d | 389 ++++--- o/sfaslcoff.c | 2 +- o/sfaslelf.c | 37 +- o/sfaslmacho.c | 2 +- o/unixfsys.c | 19 +- pcl/sys-proclaim.lisp | 2233 +++++++++++++++++++------------------- unixport/makefile | 2 + unixport/sys_init.lsp.in | 1 + 31 files changed, 2586 insertions(+), 2181 deletions(-) create mode 100644 git.tag diff --git a/clcs/sys-proclaim.lisp b/clcs/sys-proclaim.lisp index 4ee08ca..e9893e3 100644 --- a/clcs/sys-proclaim.lisp +++ b/clcs/sys-proclaim.lisp @@ -4,45 +4,45 @@ '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - COMMON-LISP::DEFINE-CONDITION COMMON-LISP::HANDLER-CASE - COMMON-LISP::IGNORE-ERRORS COMMON-LISP::HANDLER-BIND - CONDITIONS::SLOT-SYM CONDITIONS::COERCE-TO-FN)) + COMMON-LISP::HANDLER-BIND COMMON-LISP::DEFINE-CONDITION + COMMON-LISP::HANDLER-CASE COMMON-LISP::IGNORE-ERRORS + CONDITIONS::COERCE-TO-FN CONDITIONS::SLOT-SYM)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) COMMON-LISP::MAKE-CONDITION)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::T) - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CONDITION T))| - 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 COMMON-LISP::T) COMMON-LISP::*) - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION 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 (PRINT-NOT-READABLE T))| CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CASE-FAILURE T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))| CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ABORT-FAILURE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PRINT-NOT-READABLE T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))| CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ARITHMETIC-ERROR T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (END-OF-FILE T))| CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (SIMPLE-CONDITION T))| - CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))|)) + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))|)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::T) + CONDITIONS::|(PCL::FAST-METHOD MAKE-LOAD-FORM (CONDITION))| + CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CONDITION T))|)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - CONDITIONS::CONDITIONP CONDITIONS::DEFAULT-REPORT - CONDITIONS::IS-CONDITION CONDITIONS::IS-WARNING)) \ No newline at end of file + CONDITIONS::CONDITIONP CONDITIONS::IS-CONDITION + CONDITIONS::IS-WARNING CONDITIONS::DEFAULT-REPORT)) \ No newline at end of file diff --git a/cmpnew/gcl_cmpmain.lsp b/cmpnew/gcl_cmpmain.lsp index 7fc76a1..7ebe20f 100755 --- a/cmpnew/gcl_cmpmain.lsp +++ b/cmpnew/gcl_cmpmain.lsp @@ -90,8 +90,10 @@ (defvar *default-h-file* nil) (defvar *default-data-file* nil) (defvar *default-prof-p* nil) +#+large-memory-model(defvar *default-large-memory-model-p* nil) (defvar *keep-gaz* nil) (defvar *prof-p* nil) +#+large-memory-model(defvar *large-memory-model-p* nil) ;; (list section-length split-file-names next-section-start-file-position) ;; Many c compilers cannot handle the large C files resulting from large lisp files. @@ -153,11 +155,13 @@ (c-debug nil) (system-p *default-system-p*) (prof-p *default-prof-p*) + #+large-memory-model(large-memory-model-p *default-large-memory-model-p*) (print nil) (load nil) &aux (*standard-output* *standard-output*) (*prof-p* prof-p) + #+large-memory-model(*large-memory-model-p* large-memory-model-p) (output-file (pathname output-file)) (*error-output* *error-output*) (*compiler-in-use* *compiler-in-use*) @@ -480,7 +484,10 @@ Cannot compile ~a.~%" (setq na (namestring (make-pathname :name name :type (pathname-type(first args))))) (format nil "~a ~a -I~a ~a ~a -c ~a -o ~a ~a" - (if *prof-p* (remove-flag "-fomit-frame-pointer" *cc*) *cc*) + (concatenate 'string + (if *prof-p* (remove-flag "-fomit-frame-pointer" *cc*) *cc*) + #+large-memory-model(if *large-memory-model-p* " -mcmodel=large " "") + #-large-memory-model "") (if *prof-p* " -pg " "") (concatenate 'string si::*system-directory* "../h") (if (and (boundp '*c-debug*) *c-debug*) " -g " "") @@ -536,6 +543,8 @@ Cannot compile ~a.~%" )) + #+large-memory-model(when *large-memory-model-p* (mark-as-large-memory-model o-pathname)) + #+dont_need (let ((cname (pathname-name c-pathname)) (odir (pathname-directory o-pathname)) diff --git a/cmpnew/gcl_cmptop.lsp b/cmpnew/gcl_cmptop.lsp index 2e78814..e020d83 100755 --- a/cmpnew/gcl_cmptop.lsp +++ b/cmpnew/gcl_cmptop.lsp @@ -99,6 +99,7 @@ ;;; Package operations. (si:putprop 'in-package t 'eval-at-compile) +(si:putprop 'si::in-package-internal t 'eval-at-compile) ;;; Pass 1 top-levels. diff --git a/cmpnew/gcl_lfun_list.lsp b/cmpnew/gcl_lfun_list.lsp index 23c2627..86c134b 100755 --- a/cmpnew/gcl_lfun_list.lsp +++ b/cmpnew/gcl_lfun_list.lsp @@ -366,7 +366,7 @@ (DEFSYSFUN 'FMAKUNBOUND "Lfmakunbound" '(T) 'T NIL NIL) (DEFSYSFUN 'SLEEP "Lsleep" '(T) 'T NIL NIL) (DEFSYSFUN 'PACKAGE-NAME "Lpackage_name" '(T) 'T NIL NIL) -(DEFSYSFUN 'FIND-PACKAGE "Lfind_package" '(T) 'T NIL NIL) +;(DEFSYSFUN 'FIND-PACKAGE "Lfind_package" '(T) 'T NIL NIL) (DEFSYSFUN 'ASSOC "Lassoc" '(T T *) 'T NIL NIL) (DEFSYSFUN 'SET-CHAR-BIT "Lset_char_bit" '(T T T) 'CHARACTER NIL NIL) (DEFSYSFUN 'FLOOR "Lfloor" '(T *) '(VALUES T T) NIL NIL) diff --git a/cmpnew/sys-proclaim.lisp b/cmpnew/sys-proclaim.lisp index f081220..89be8e4 100755 --- a/cmpnew/sys-proclaim.lisp +++ b/cmpnew/sys-proclaim.lisp @@ -2,178 +2,159 @@ (COMMON-LISP::IN-PACKAGE "COMPILER") (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - COMPILER::CMPERR COMPILER::CMPWARN COMPILER::WT-CVAR - COMPILER::ADD-INIT COMPILER::INIT-NAME - COMPILER::FAST-LINK-PROCLAIMED-TYPE-P COMPILER::C1CASE - COMPILER::WT-INTEGER-LOC COMPILER::CMPNOTE - COMPILER::UNWIND-EXIT COMPILER::WT-COMMENT - COMPILER::C1LAMBDA-EXPR)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) + COMPILER::WT-CHARACTER-LOC COMPILER::T1EXPR COMPILER::C2PROGN + COMPILER::WT-TO-STRING COMPILER::CMP-EVAL + COMPILER::WT-FIXNUM-LOC COMPILER::T1EVAL-WHEN + COMPILER::MEXPAND-DEFTYPE COMPILER::SET-LOC COMPILER::C2OR + COMPILER::C2AND COMPILER::WT-LOC COMPILER::CMP-TOPLEVEL-EVAL + COMPILER::WT-LONG-FLOAT-LOC COMPILER::WT-SHORT-FLOAT-LOC + COMPILER::C2EXPR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - COMPILER::C2RETURN-LOCAL COMPILER::WT-INLINE-LOC - COMPILER::C1SYMBOL-FUN COMPILER::C2DECL-BODY - COMPILER::COMPILER-BUILD COMPILER::NCONC-FILES - COMPILER::C2BLOCK COMPILER::C1BODY COMPILER::C2BLOCK-LOCAL)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + COMPILER::MAKE-VAR COMPILER::C2FSET COMPILER::CS-PUSH + COMPILER::MAKE-FUN COMPILER::LIST-INLINE COMPILER::WT-CLINK + COMPILER::FCALLN-INLINE COMPILER::MAKE-INFO COMPILER::MAKE-TAG + COMPILER::LIST*-INLINE COMPILER::MAKE-BLK + COMPILER::COMPILER-COMMAND)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T + (COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*)) (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::T) - COMPILER::MEMOIZED-HASH-EQUAL)) + 9223372036854775807) + COMMON-LISP::T) + COMMON-LISP::FIXNUM) + COMPILER::PUSH-ARRAY)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) - COMPILER::MAKE-INIT-STRING)) + (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::BSEARCHLEQ)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - ((COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::T) - COMPILER::MLIN)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + COMPILER::WT-FIRST-VAR-ARG COMPILER::CLOSE-INLINE-BLOCKS + COMPILER::WT-DATA-END COMPILER::CCB-VS-PUSH + COMPILER::INC-INLINE-BLOCKS COMPILER::CVS-PUSH COMPILER::C1NIL + COMPILER::MACRO-ENV COMPILER::WT-C-PUSH + COMPILER::TAIL-RECURSION-POSSIBLE COMPILER::VS-PUSH + COMPILER::WT-CVARS COMPILER::RESET-TOP COMPILER::WT-DATA-BEGIN + COMPILER::WFS-ERROR COMPILER::PRINT-CURRENT-FORM + COMPILER::INIT-ENV COMPILER::BABOON COMPILER::WT-NEXT-VAR-ARG + COMPILER::GAZONK-NAME COMPILER::ADD-LOAD-TIME-SHARP-COMMA + COMPILER::WT-DATA-FILE COMPILER::PRINT-COMPILER-INFO + COMPILER::C1T)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::FIXNUM) - COMPILER::PROCLAIMED-ARGD COMPILER::ANALYZE-REGS - COMPILER::ANALYZE-REGS1)) + COMMON-LISP::T) + COMPILER::GET-INLINE-LOC SYSTEM::ADD-DEBUG COMPILER::FAST-READ + COMPILER::WT-GO COMPILER::MAKE-USER-INIT COMPILER::C2THROW + COMPILER::C2MULTIPLE-VALUE-PROG1 COMPILER::NEXT-CFUN + COMPILER::TYPE>= COMPILER::C2DM-BIND-INIT + COMPILER::NCONC-FILES COMPILER::DO-CHANGED COMPILER::BASE-USED + COMPILER::COERCE-LOC COMPILER::NEXT-LABEL* + COMPILER::PUSH-CHANGED COMPILER::C2DM-BIND-VL + COMPILER::WT-FIXNUM-VALUE COMPILER::TYPE-AND + COMPILER::CAN-BE-REPLACED SYSTEM::DEFINE-INLINE-FUNCTION + COMPILER::CONVERT-CASE-TO-SWITCH COMPILER::SET-BDS-BIND + COMPILER::NEED-TO-PROTECT COMPILER::COMPILER-BUILD + COMPILER::SAFE-COMPILE COMPILER::C2EXPR-TOP* + COMPILER::IS-REFERRED COMPILER::C1FMLA COMPILER::CK-SPEC + COMPILER::CO1WRITE-BYTE COMPILER::CO1CONSTANT-FOLD + COMPILER::WT-SHORT-FLOAT-VALUE COMPILER::CO1TYPEP + COMPILER::BIGNUM-EXPANSION-STORAGE COMPILER::C1CONSTANT-VALUE + COMPILER::CHANGED-LENGTH COMPILER::UNWIND-BDS + COMPILER::DOTIMES** COMPILER::CO1CONS + COMPILER::CO1STRUCTURE-PREDICATE COMPILER::DO-REFERRED + COMPILER::C2ASSOC!2 COMPILER::NEXT-LABEL + COMPILER::C2CALL-LAMBDA COMPILER::C1PROGN* COMPILER::FLAG-P + COMPILER::CFAST-WRITE COMPILER::T23EXPR + COMPILER::C2MULTIPLE-VALUE-SETQ COMPILER::CO1VECTOR-PUSH + COMPILER::WT-LABEL COMPILER::C2CATCH + COMPILER::CHECK-FNAME-ARGS COMPILER::SET-DBIND + COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY COMPILER::SET-VS + COMPILER::C1DECL-BODY COMPILER::C1ARGS + COMPILER::C2LIST-NTH-IMMEDIATE COMPILER::C2RETURN-CCB + COMPILER::IN-ARRAY COMMON-LISP::DEFINE-COMPILER-MACRO + COMPILER::C2APPLY COMPILER::CO1WRITE-CHAR + COMPILER::C2DM-BIND-LOC COMPILER::WT-NL + COMPILER::WT-LONG-FLOAT-VALUE COMPILER::CO1READ-BYTE + COMPILER::REMOVE-FLAG COMPILER::CO1LDB COMPILER::WT-VAR + COMPILER::COERCE-LOC-STRUCTURE-REF COMPILER::PUSH-CHANGED-VARS + COMPILER::C2PSETQ COMPILER::SHIFT>> COMPILER::PROCLAIM-VAR + COMPILER::IS-CHANGED COMPILER::ADD-DEBUG-INFO + COMPILER::CO1SUBLIS COMPILER::WT-CHARACTER-VALUE + COMPILER::C2EXPR-TOP COMPILER::WT-REQUIREDS COMPILER::DOTIMES* + COMPILER::PRIN1-CMP COMPILER::PUSH-CHANGED-WITH-START + COMPILER::DOLIST* COMPILER::C2BLOCK-CLB COMPILER::CMPCK + COMPILER::PUSH-REFERRED-WITH-START COMPILER::INLINE-PROC + COMPILER::CK-VL COMPILER::C1EXPR* COMPILER::WT-H + COMPILER::STRUCT-TYPE-OPT COMPILER::C2UNWIND-PROTECT + COMPILER::ARGS-INFO-CHANGED-VARS + COMPILER::C2LAMBDA-EXPR-WITH-KEY COMPILER::SET-JUMP-TRUE + COMPILER::WT-MAKE-DCLOSURE COMPILER::WT-NL1 COMPILER::CO1SCHAR + COMPILER::JUMPS-TO-P COMPILER::DOLIST** + COMPILER::COMPILER-DEF-HOOK COMPILER::NEXT-CMACRO + COMPILER::C2MEMBER!2 COMPILER::RESULT-TYPE-FROM-ARGS + COMPILER::CO1EQL COMPILER::C2CALL-LOCAL + COMPILER::SET-JUMP-FALSE COMPILER::C2MULTIPLE-VALUE-CALL + COMPILER::C2BIND-LOC COMPILER::C1SETQ1 COMPILER::CO1READ-CHAR + COMPILER::REFERRED-LENGTH COMPILER::C2STACK-LET COMPILER::WT + COMPILER::CMPFIX-ARGS COMPILER::NEXT-CVAR + COMPILER::ARGS-INFO-REFERRED-VARS + COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES SYSTEM::SWITCH + COMPILER::COMPILER-CC COMPILER::FLAGS COMPILER::T3SHARP-COMMA + COMPILER::C2SETQ COMPILER::C2RETURN-CLB COMPILER::C1LAMBDA-FUN + COMPILER::C2BLOCK-CCB COMPILER::IS-REP-REFERRED + COMPILER::MAYBE-WT-C2DM-BIND-VL COMPILER::WT-V*-MACROS + SYSTEM::SWITCH-FINISH COMPILER::STACK-LET COMPILER::SHIFT<< + COMPILER::DO-ARRAY COMPILER::MULTIPLE-VALUE-CHECK + COMPILER::DOWNWARD-FUNCTION COMPILER::EQL-NOT-NIL + COMPILER::ADD-INFO COMPILER::MAYBE-EVAL COMPILER::MIA + COMPILER::PUSH-REFERRED COMPILER::C2BIND-INIT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - COMPILER::DECL-BODY-SAFETY COMPILER::C2FUNCTION - COMPILER::C1PROGN COMPILER::C1MAPCAR COMPILER::C1FLET - COMPILER::C1EXPR COMPILER::C1LET COMPILER::ADD-OBJECT - COMPILER::C1LABELS COMPILER::C1FMLA-CONSTANT COMPILER::C1ECASE - COMPILER::C1LENGTH COMPILER::C1APPLY COMPILER::THE-PARAMETER - COMPILER::C1TAGBODY COMPILER::T3CLINES - COMPILER::VERIFY-DATA-VECTOR COMPILER::VAR-KIND - COMPILER::INLINE-TYPE COMPILER::C1MULTIPLE-VALUE-CALL - COMPILER::C2GET COMPILER::ADD-CONSTANT COMPILER::T1DEFMACRO - COMPILER::C2EXPR* COMPILER::TAG-UNWIND-EXIT - COMPILER::CHECK-DOWNWARD COMPILER::WT-CADR - COMPILER::CHARACTER-LOC-P COMPILER::C1DECLARE - COMPILER::AET-C-TYPE COMPILER::C1QUOTE COMPILER::CHECK-VREF - COMPILER::VAR-LOC COMPILER::INLINE-POSSIBLE COMPILER::SET-TOP - COMPILER::T1ORDINARY COMPILER::BLK-VAR COMPILER::SAVE-AVMA - COMPILER::C1VREF COMPILER::WT-VV COMPILER::C2GO-LOCAL - COMPILER::C1MEMBER COMPILER::LTVP-EVAL COMPILER::VV-STR - COMPILER::TAG-REF-CLB COMPILER::T2DECLARE - COMPILER::CMP-MACROEXPAND-1 COMPILER::T1DEFINE-STRUCTURE - COMPILER::T1DEFENTRY COMPILER::ADD-OBJECT2 COMPILER::FUN-LEVEL - COMPILER::VAR-P COMPILER::WT-DATA-PACKAGE-OPERATION - COMPILER::PUSH-ARGS-LISPCALL COMPILER::C1PSETQ COMPILER::C1OR - COMPILER::C1LOCAL-FUN COMPILER::WT-VS-BASE - COMPILER::DEFAULT-INIT COMPILER::C1MAPCON COMPILER::C1GO - COMPILER::INFO-REFERRED-ARRAY COMPILER::BLK-REF - COMPILER::T1DEFLA COMPILER::INFO-CHANGED-ARRAY - COMPILER::WT-VAR-DECL COMPILER::UNWIND-NO-EXIT - COMPILER::BLK-VALUE-TO-GO COMPILER::C2GO-CLB - COMPILER::FUNCTION-ARG-TYPES COMPILER::C1MAPC - COMPILER::C2DOWNWARD-FUNCTION COMPILER::CMP-MACRO-FUNCTION - COMPILER::C1SHARP-COMMA COMPILER::ADD-ADDRESS - COMPILER::GET-LOCAL-RETURN-TYPE COMPILER::T1DEFUN - COMPILER::C1ADD-GLOBALS COMPILER::C2DM-RESERVE-V - COMPILER::C1ASH COMPILER::C1STACK-LET - COMPILER::WT-SYMBOL-FUNCTION COMPILER::C2TAGBODY-CLB - COMPILER::C1MAPLIST COMPILER::PUSH-DATA-INCF - COMPILER::C2TAGBODY-LOCAL COMPILER::C1FSET COMPILER::WT1 - COMPILER::VAR-REF-CCB COMPILER::INFO-P COMPILER::C1ASSOC - COMPILER::C2GETHASH COMPILER::C1RPLACD COMPILER::C1EVAL-WHEN - COMPILER::REP-TYPE COMPILER::C1FUNOB COMPILER::BLK-REF-CLB - COMPILER::WT-VS* COMPILER::C1GET COMPILER::SCH-LOCAL-FUN - COMPILER::SET-PUSH-CATCH-FRAME COMPILER::C1BOOLE3 - COMPILER::BLK-EXIT COMPILER::T1DEFCFUN COMPILER::GET-ARG-TYPES - COMPILER::WRITE-BLOCK-OPEN COMPILER::C1COMPILER-LET - COMPILER::ADD-LOOP-REGISTERS COMPILER::INLINE-BOOLE3-STRING - COMPILER::C1LOAD-TIME-VALUE COMPILER::VAR-TYPE - COMPILER::REGISTER COMPILER::RESET-INFO-TYPE - COMPILER::C1UNWIND-PROTECT COMPILER::C1IF - COMPILER::SHORT-FLOAT-LOC-P COMPILER::C1VAR - COMPILER::WT-FUNCALL-C COMPILER::C1THE COMPILER::FIX-OPT - COMPILER::UNDEFINED-VARIABLE COMPILER::C2RPLACD - COMPILER::C1BOOLE-CONDITION COMPILER::C1NTH COMPILER::VARARG-P - COMPILER::OBJECT-TYPE COMPILER::VOLATILE COMPILER::FUN-P - COMPILER::VAR-REF COMPILER::C1DEFINE-STRUCTURE - COMPILER::MAXARGS COMPILER::LONG-FLOAT-LOC-P - COMPILER::REPLACE-CONSTANT COMPILER::C2TAGBODY-BODY - COMPILER::TAG-P COMPILER::C1RETURN-FROM COMPILER::WT-VS - COMPILER::ARGS-CAUSE-SIDE-EFFECT COMPILER::C1LIST-NTH - COMPILER::FSET-FN-NAME COMPILER::SAVE-FUNOB COMPILER::C1BLOCK - COMPILER::C1AND COMPILER::C2TAGBODY-CCB COMPILER::GET-INCLUDED - COMPILER::TAG-REF COMPILER::NEED-TO-SET-VS-POINTERS - COMPILER::C1VALUES COMPILER::BLK-P COMPILER::COPY-INFO - COMPILER::WT-CAR COMPILER::FUN-CFUN - COMPILER::C1MULTIPLE-VALUE-PROG1 SYSTEM::UNDEF-COMPILER-MACRO - COMPILER::C1DM-BAD-KEY COMPILER::FUN-REF COMPILER::NAME-SD1 - COMPILER::MDELETE-FILE COMPILER::SAFE-SYSTEM - COMPILER::WT-DATA2 COMPILER::WT-CDR COMPILER::C2GO-CCB - COMPILER::C1ASH-CONDITION COMPILER::C1RPLACA - COMPILER::WT-DATA1 COMPILER::C1RPLACA-NTHCDR - COMPILER::NAME-TO-SD COMPILER::WT-LIST - COMPILER::CMP-MACROEXPAND COMPILER::WT-SWITCH-CASE - COMPILER::GET-LOCAL-ARG-TYPES COMPILER::SET-UP-VAR-CVS - COMPILER::WT-FASD-ELEMENT COMPILER::RESULT-TYPE - COMPILER::C1SWITCH COMPILER::FIXNUM-LOC-P - COMPILER::C1NTHCDR-CONDITION COMPILER::TAG-VAR - COMPILER::C1NTHCDR COMPILER::CLINK COMPILER::LTVP - COMPILER::C1LET* COMPILER::TAG-NAME COMPILER::C1FUNCALL - COMPILER::C2RPLACA COMPILER::MACRO-DEF-P - COMPILER::C1STRUCTURE-REF COMPILER::GET-RETURN-TYPE - COMPILER::C1DOWNWARD-FUNCTION COMPILER::T1CLINES - COMPILER::TYPE-FILTER COMPILER::C1FUNCTION - COMPILER::CONS-TO-LISTA COMPILER::C1NTH-CONDITION - COMPILER::FUN-NAME COMPILER::PROCLAMATION COMPILER::VAR-NAME - COMPILER::WT-CCB-VS COMPILER::FLAGS-POS COMPILER::C1CATCH - COMPILER::CTOP-WRITE COMPILER::TAG-LABEL COMPILER::C1MEMQ - COMPILER::C1GETHASH COMPILER::TAG-REF-CCB COMPILER::TAG-SWITCH - COMPILER::C2BIND COMPILER::VERIFY-DATUM COMPILER::C1MAPCAN - COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::C1TERPRI - COMPILER::FUN-REF-CCB COMMON-LISP::PROCLAIM - COMPILER::INFO-VOLATILE COMPILER::T3ORDINARY - COMPILER::C2LOCATION COMPILER::BLK-NAME - COMPILER::C1STRUCTURE-SET COMPILER::C2VAR - COMPILER::C1LOCAL-CLOSURE COMPILER::C1MACROLET - COMPILER::WT-FUNCTION-LINK COMPILER::C2VALUES - COMPILER::T1MACROLET COMPILER::C1MULTIPLE-VALUE-BIND - COMPILER::C2FUNCALL-AUX COMPILER::C1MULTIPLE-VALUE-SETQ - COMPILER::PUSH-ARGS COMPILER::BLK-REF-CCB COMPILER::C1SETQ - COMPILER::ADD-SYMBOL COMPILER::C2VAR-KIND COMPILER::C1THROW - COMPILER::DECLARATION-TYPE COMPILER::C1PROGV - COMPILER::INFO-TYPE COMPILER::CONSTANT-FOLD-P - COMPILER::C1PRINC COMPILER::WT-DOWN COMPILER::SCH-GLOBAL - COMPILER::T1PROGN COMPILER::INFO-SP-CHANGE - COMPILER::C2DM-RESERVE-VL COMPILER::C1MAPL - COMPILER::FUNCTION-RETURN-TYPE COMPILER::ADD-REG1 - COMPILER::PARSE-CVSPECS COMPILER::FUN-INFO - COMPILER::VAR-REGISTER COMPILER::SET-RETURN COMPILER::WT-H1 - COMPILER::VAR-REP-LOC)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + COMPILER::COMPILE-FILE1 COMMON-LISP::COMPILE-FILE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - COMPILER::INLINE-BOOLE3)) + (COMMON-LISP::FUNCTION + ((COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*))) + COMMON-LISP::T) + COMPILER::COPY-ARRAY)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - COMPILER::C2LABELS COMPILER::C2FLET COMPILER::C2IF - COMPILER::WT-INLINE COMPILER::C2COMPILER-LET)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::FIXNUM) + COMPILER::PROCLAIMED-ARGD COMPILER::ANALYZE-REGS + COMPILER::ANALYZE-REGS1)) +(COMMON-LISP::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(COMMON-LISP::DISASSEMBLE COMMON-LISP::COMPILE COMPILER::CMP-ANON + COMPILER::CMP-TMP-MACRO)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::*) - COMPILER::C1DM-V COMPILER::C1DM-VL COMPILER::C2APPLY-OPTIMIZE - COMPILER::C2RETURN-FROM COMPILER::C2DM)) + COMPILER::C1DM-VL COMPILER::C2RETURN-FROM COMPILER::C2DM + COMPILER::C1DM-V COMPILER::C2APPLY-OPTIMIZE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -182,114 +163,34 @@ COMPILER::T3DEFUN-AUX)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM) - COMPILER::F-TYPE)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - COMPILER::C2RETURN-CCB - COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES - COMPILER::DO-CHANGED COMPILER::CO1STRUCTURE-PREDICATE - COMPILER::RESULT-TYPE-FROM-ARGS COMPILER::CMPFIX-ARGS - COMPILER::T3SHARP-COMMA COMPILER::FLAGS - COMPILER::CO1WRITE-BYTE COMPILER::CHECK-FNAME-ARGS - COMPILER::C2ASSOC!2 COMPILER::CK-SPEC - COMPILER::COERCE-LOC-STRUCTURE-REF COMPILER::ADD-DEBUG-INFO - COMPILER::C2LAMBDA-EXPR-WITH-KEY COMPILER::PRIN1-CMP - COMPILER::PUSH-CHANGED-VARS COMPILER::SHIFT>> - COMPILER::ARGS-INFO-REFERRED-VARS - COMPILER::C2MULTIPLE-VALUE-CALL - COMPILER::ARGS-INFO-CHANGED-VARS COMPILER::CO1SCHAR - COMPILER::NEXT-CVAR COMPILER::C2RETURN-CLB - COMPILER::CO1WRITE-CHAR COMPILER::SET-VS SYSTEM::SWITCH - COMPILER::FLAG-P COMPILER::DO-ARRAY COMPILER::INLINE-PROC - COMPILER::CO1CONS COMPILER::C2EXPR-TOP - COMPILER::CHANGED-LENGTH COMPILER::C2MULTIPLE-VALUE-PROG1 - COMPILER::REMOVE-FLAG COMPILER::CO1SUBLIS COMPILER::ADD-INFO - COMPILER::C2BIND-INIT COMPILER::C2DM-BIND-VL COMPILER::C1FMLA - COMPILER::C2CATCH COMPILER::WT-MAKE-DCLOSURE - COMPILER::UNWIND-BDS COMPILER::IS-REP-REFERRED - COMPILER::WT-LONG-FLOAT-VALUE COMPILER::WT-GO - COMPILER::FAST-READ COMPILER::WT COMPILER::SAFE-COMPILE - COMPILER::WT-H COMPILER::STRUCT-TYPE-OPT - COMPILER::REFERRED-LENGTH COMPILER::TYPE-AND COMPILER::C2THROW - COMPILER::NEED-TO-PROTECT COMPILER::COERCE-LOC - COMPILER::TYPE>= COMPILER::WT-NL1 COMPILER::CHECK-END - COMPILER::C2BLOCK-CCB COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY - COMPILER::SET-BDS-BIND COMPILER::C2DM-BIND-INIT - COMPILER::CAN-BE-REPLACED COMPILER::MAYBE-EVAL - COMPILER::WT-VAR COMPILER::WT-REQUIREDS - COMPILER::CONVERT-CASE-TO-SWITCH COMPILER::CO1TYPEP - COMPILER::C1DECL-BODY COMPILER::DOWNWARD-FUNCTION - COMPILER::MULTIPLE-VALUE-CHECK COMPILER::NEXT-CFUN - SYSTEM::SWITCH-FINISH COMPILER::CO1READ-CHAR - COMPILER::COMPILER-CC COMPILER::C1PROGN* - COMPILER::C1LAMBDA-FUN COMPILER::MAKE-USER-INIT - COMPILER::SHIFT<< COMPILER::C1ARGS COMPILER::CK-VL - COMPILER::T23EXPR COMPILER::IS-CHANGED COMPILER::PUSH-REFERRED - COMPILER::WT-CHARACTER-VALUE - COMPILER::PUSH-REFERRED-WITH-START COMPILER::NEXT-LABEL* - COMPILER::CMPCK COMPILER::C2DM-BIND-LOC - COMPILER::WT-SHORT-FLOAT-VALUE - COMPILER::PUSH-CHANGED-WITH-START COMPILER::C2EXPR-TOP* - COMPILER::DOLIST* COMPILER::WT-LABEL COMPILER::PUSH-CHANGED - COMPILER::BASE-USED COMPILER::CO1VECTOR-PUSH - COMPILER::WT-V*-MACROS COMPILER::CO1CONSTANT-FOLD - COMPILER::WT-FIXNUM-VALUE COMPILER::C2BLOCK-CLB - SYSTEM::DEFINE-INLINE-FUNCTION COMPILER::SET-JUMP-TRUE - COMPILER::C2BIND-LOC COMPILER::IN-ARRAY - COMPILER::SET-JUMP-FALSE COMPILER::PROCLAIM-VAR - COMMON-LISP::DEFINE-COMPILER-MACRO COMPILER::C1CONSTANT-VALUE - COMPILER::COMPILER-DEF-HOOK COMPILER::CO1READ-BYTE - COMPILER::MAYBE-WT-C2DM-BIND-VL COMPILER::IS-REFERRED - COMPILER::DOTIMES** SYSTEM::ADD-DEBUG COMPILER::DO-REFERRED - COMPILER::NEXT-LABEL COMPILER::C2CALL-LAMBDA COMPILER::C2APPLY - COMPILER::C1EXPR* COMPILER::C2SETQ COMPILER::MIA - COMPILER::C2PSETQ COMPILER::C1SETQ1 - COMPILER::C2LIST-NTH-IMMEDIATE COMPILER::WT-NL - COMPILER::CO1EQL COMPILER::CFAST-WRITE COMPILER::CO1LDB - COMPILER::EQL-NOT-NIL COMPILER::JUMPS-TO-P - COMPILER::C2CALL-LOCAL COMPILER::BIGNUM-EXPANSION-STORAGE - COMPILER::STACK-LET COMPILER::C2MULTIPLE-VALUE-SETQ - COMPILER::C2MEMBER!2 COMPILER::C2UNWIND-PROTECT - COMPILER::DOLIST** COMPILER::SET-DBIND COMPILER::DOTIMES* - COMPILER::NEXT-CMACRO COMPILER::GET-INLINE-LOC - COMPILER::C2STACK-LET)) -(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::*) - COMPILER::COMPILE-FILE1)) + COMPILER::C2IF COMPILER::WT-INLINE COMPILER::C2FLET + COMPILER::C2LABELS COMPILER::C2COMPILER-LET)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (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::BSEARCHLEQ)) + ((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::ARRAY COMMON-LISP::T (COMMON-LISP::*)) - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807) - COMMON-LISP::T) - COMMON-LISP::FIXNUM) - COMPILER::PUSH-ARRAY)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + COMPILER::C2BLOCK-LOCAL COMPILER::C1SYMBOL-FUN + COMPILER::WT-INLINE-LOC COMPILER::C2RETURN-LOCAL + COMPILER::C2BLOCK COMPILER::C2DECL-BODY COMPILER::C1BODY)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER - COMMON-LISP::*)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMPILER::TS COMPILER::DASH-TO-UNDERSCORE)) + COMPILER::WT-COMMENT COMPILER::INIT-NAME COMPILER::ADD-INIT + COMPILER::CMPWARN COMPILER::FAST-LINK-PROCLAIMED-TYPE-P + COMPILER::UNWIND-EXIT COMPILER::CMPNOTE COMPILER::C1CASE + COMPILER::WT-INTEGER-LOC COMPILER::C1LAMBDA-EXPR + COMPILER::WT-CVAR COMPILER::CMPERR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -303,121 +204,208 @@ COMPILER::DASH-TO-UNDERSCORE-INT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - COMPILER::VS-PUSH COMPILER::WFS-ERROR COMPILER::MACRO-ENV - COMPILER::C1T COMPILER::WT-CVARS COMPILER::WT-DATA-END - COMPILER::GAZONK-NAME COMPILER::INIT-ENV - COMPILER::ADD-LOAD-TIME-SHARP-COMMA COMPILER::CCB-VS-PUSH - COMPILER::WT-DATA-FILE COMPILER::WT-FASD-DATA-FILE - COMPILER::INC-INLINE-BLOCKS COMPILER::PRINT-CURRENT-FORM - COMPILER::CLOSE-INLINE-BLOCKS COMPILER::WT-DATA-BEGIN - COMPILER::BABOON COMPILER::WT-C-PUSH COMPILER::WT-NEXT-VAR-ARG - COMPILER::WT-FIRST-VAR-ARG COMPILER::CVS-PUSH - COMPILER::TAIL-RECURSION-POSSIBLE COMPILER::RESET-TOP - COMPILER::C1NIL COMPILER::PRINT-COMPILER-INFO)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::T) + COMPILER::WT-GLOBAL-ENTRY COMPILER::MY-CALL + COMPILER::C2CALL-GLOBAL COMPILER::C1MAKE-VAR + COMPILER::T3DEFUN-VARARG COMPILER::C2SWITCH + COMPILER::C2CALL-UNKNOWN-GLOBAL COMPILER::C2STRUCTURE-REF + COMPILER::T3DEFUN-NORMAL COMPILER::WT-IF-PROCLAIMED)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::ARRAY 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::COPY-ARRAY)) + COMPILER::T3LOCAL-FUN COMPILER::T2DEFUN + COMPILER::T3LOCAL-DCFUN COMPILER::T3DEFUN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - COMPILER::T1EXPR COMPILER::WT-TO-STRING COMPILER::C2OR - COMPILER::WT-LOC COMPILER::SET-LOC COMPILER::MEXPAND-DEFTYPE - COMPILER::C2EXPR COMPILER::C2PROGN COMPILER::C2AND - COMPILER::WT-SHORT-FLOAT-LOC COMPILER::WT-CHARACTER-LOC - COMPILER::CMP-EVAL COMPILER::T1EVAL-WHEN - COMPILER::WT-LONG-FLOAT-LOC COMPILER::CMP-TOPLEVEL-EVAL - COMPILER::WT-FIXNUM-LOC)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + COMPILER::MYSUB COMPILER::WT-INLINE-INTEGER COMPILER::C2MAPC + COMPILER::WT-INLINE-LONG-FLOAT COMPILER::C2PROGV + COMPILER::CHECK-VDECL COMPILER::AND-FORM-TYPE + COMPILER::WT-INLINE-CHARACTER COMPILER::C2MAPCAR + COMPILER::MAKE-INLINE-STRING COMPILER::C-FUNCTION-NAME + COMPILER::WT-INLINE-COND COMPILER::ADD-FUNCTION-DECLARATION + COMPILER::T3DEFCFUN COMPILER::C2MAPCAN COMPILER::C1DM + COMPILER::ASSIGN-DOWN-VARS COMPILER::CJT COMPILER::SET-VAR + COMPILER::COMPILER-PASS2 COMPILER::TOO-FEW-ARGS + COMPILER::C2MULTIPLE-VALUE-BIND COMPILER::C2GO + COMPILER::C2FUNCALL-SFUN COMPILER::C2PRINC + COMPILER::WT-INLINE-SHORT-FLOAT COMPILER::C1STRUCTURE-REF1 + COMPILER::GET-INLINE-INFO COMPILER::CAN-BE-REPLACED* + COMPILER::CJF COMPILER::ADD-FUNCTION-PROCLAMATION + COMPILER::C2LET* COMPILER::C2TAGBODY + COMPILER::CMP-EXPAND-MACRO COMPILER::CHECK-FORM-TYPE + COMPILER::C2LET COMPILER::C2CASE COMPILER::WT-MAKE-CCLOSURE + COMPILER::TOO-MANY-ARGS COMPILER::BOOLE3 + COMPILER::SUBLIS1-INLINE COMPILER::WT-INLINE-FIXNUM + COMPILER::FIX-DOWN-ARGS COMPILER::C1MAP-FUNCTIONS + COMPILER::INLINE-TYPE-MATCHES COMPILER::ADD-FAST-LINK)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - COMPILER::FCALLN-INLINE COMPILER::CS-PUSH COMPILER::WT-CLINK - COMPILER::COMPILER-COMMAND COMPILER::MAKE-INFO - COMPILER::T2PROGN COMPILER::MAKE-TAG COMPILER::C2FSET - COMPILER::MAKE-BLK COMPILER::LIST-INLINE - COMMON-LISP::COMPILE-FILE COMPILER::MAKE-FUN - COMPILER::MAKE-VAR COMPILER::T3PROGN COMPILER::LIST*-INLINE)) -(COMMON-LISP::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(COMMON-LISP::COMPILE COMMON-LISP::DISASSEMBLE COMPILER::CMP-ANON - COMPILER::CMP-TMP-MACRO)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + COMPILER::C2LAMBDA-EXPR COMPILER::INLINE-ARGS + COMPILER::C2FUNCALL COMPILER::LINK)) (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) - COMPILER::T3DEFUN-VARARG COMPILER::T3DEFUN-NORMAL - COMPILER::C2CALL-GLOBAL COMPILER::C2SWITCH COMPILER::MY-CALL - COMPILER::C1MAKE-VAR COMPILER::WT-IF-PROCLAIMED - COMPILER::C2STRUCTURE-REF COMPILER::C2CALL-UNKNOWN-GLOBAL - COMPILER::WT-GLOBAL-ENTRY)) + COMPILER::C2STRUCTURE-SET COMPILER::T3INIT-FUN + COMPILER::C1APPLY-OPTIMIZE COMPILER::T3DEFUN-LOCAL-ENTRY)) (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) - COMPILER::T2DEFENTRY COMPILER::T3DEFENTRY COMPILER::DEFSYSFUN)) + COMPILER::T2DEFENTRY COMPILER::DEFSYSFUN COMPILER::T3DEFENTRY)) (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) - COMPILER::C2PROGV COMPILER::WT-INLINE-COND COMPILER::C2TAGBODY - COMPILER::CAN-BE-REPLACED* COMPILER::WT-INLINE-FIXNUM - COMPILER::MAKE-INLINE-STRING COMPILER::WT-INLINE-SHORT-FLOAT - COMPILER::C2LET* COMPILER::ADD-FAST-LINK - COMPILER::C1STRUCTURE-REF1 COMPILER::GET-INLINE-INFO - COMPILER::CHECK-FORM-TYPE COMPILER::C2MAPCAN - COMPILER::FIX-DOWN-ARGS COMPILER::CMP-EXPAND-MACRO - COMPILER::SUBLIS1-INLINE COMPILER::ADD-FUNCTION-PROCLAMATION - COMPILER::ADD-FUNCTION-DECLARATION COMPILER::SET-VAR - COMPILER::BOOLE3 COMPILER::CJF COMPILER::C2PRINC - COMPILER::INLINE-TYPE-MATCHES COMPILER::C1MAP-FUNCTIONS - COMPILER::C1DM COMPILER::WT-INLINE-CHARACTER - COMPILER::WT-MAKE-CCLOSURE COMPILER::TOO-MANY-ARGS - COMPILER::COMPILER-PASS2 COMPILER::WT-INLINE-INTEGER - COMPILER::T3DEFCFUN COMPILER::MYSUB - COMPILER::WT-INLINE-LONG-FLOAT COMPILER::TOO-FEW-ARGS - COMPILER::CHECK-VDECL COMPILER::C2GO COMPILER::C2LET - COMPILER::ASSIGN-DOWN-VARS COMPILER::C2CASE - COMPILER::C2FUNCALL-SFUN COMPILER::AND-FORM-TYPE - COMPILER::C-FUNCTION-NAME COMPILER::C2MAPCAR COMPILER::CJT - COMPILER::C2MULTIPLE-VALUE-BIND COMPILER::C2MAPC)) + COMPILER::GET-OUTPUT-PATHNAME COMPILER::WT-SIMPLE-CALL)) (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::INTEGER -9223372036854775808 + 9223372036854775807) + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - COMPILER::C1APPLY-OPTIMIZE COMPILER::T3DEFUN-LOCAL-ENTRY - COMPILER::T3INIT-FUN COMPILER::C2STRUCTURE-SET)) + COMPILER::MLIN)) (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 + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - COMPILER::T3DEFUN COMPILER::T2DEFUN COMPILER::T3LOCAL-FUN - COMPILER::T3LOCAL-DCFUN)) + COMPILER::MEMOIZED-HASH-EQUAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - COMPILER::C2LAMBDA-EXPR COMPILER::C2FUNCALL COMPILER::LINK - COMPILER::INLINE-ARGS)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) + COMPILER::C1PSETQ COMPILER::ADD-LOOP-REGISTERS + COMPILER::FSET-FN-NAME COMPILER::CMP-MACRO-FUNCTION + COMPILER::C1PROGN COMPILER::C1SHARP-COMMA COMPILER::C1PRINC + COMPILER::C1EXPR COMPILER::CONS-TO-LISTA + COMPILER::RESET-INFO-TYPE COMPILER::WT-VS* + COMPILER::FUNCTION-RETURN-TYPE COMPILER::C2DM-RESERVE-VL + COMPILER::C1APPLY COMPILER::GET-INCLUDED COMPILER::BLK-REF-CCB + COMPILER::C1MACROLET COMPILER::ADD-OBJECT + COMPILER::C1ASH-CONDITION COMPILER::FUN-REF COMPILER::T1DEFLA + COMPILER::C1NTHCDR COMPILER::C1FUNCTION COMPILER::PROCLAMATION + COMPILER::C2FUNCALL-AUX COMPILER::MAXARGS + COMPILER::INFO-VOLATILE COMPILER::C1ASSOC COMPILER::C1MAPLIST + COMPILER::CLINK COMPILER::C1BOOLE-CONDITION COMPILER::C1VAR + COMPILER::VERIFY-DATUM COMPILER::C1OR + COMPILER::FUNCTION-ARG-TYPES COMPILER::C2FUNCTION + COMPILER::INLINE-POSSIBLE COMPILER::C2GO-LOCAL + COMPILER::C1COMPILER-LET COMPILER::NAME-SD1 COMPILER::C1LET + COMPILER::C1MULTIPLE-VALUE-BIND COMPILER::C1LOCAL-FUN + COMPILER::CHARACTER-LOC-P COMPILER::VARARG-P + COMPILER::FIXNUM-LOC-P COMPILER::SAVE-FUNOB COMPILER::BLK-VAR + COMPILER::C1STACK-LET COMPILER::C1FUNCALL + COMPILER::INFO-SP-CHANGE COMPILER::T1DEFINE-STRUCTURE + COMPILER::C1THROW COMPILER::T2PROGN COMPILER::GET-ARG-TYPES + COMMON-LISP::PROCLAIM COMPILER::C2LOCATION COMPILER::C1IF + COMPILER::CHECK-DOWNWARD COMPILER::TAG-REF-CCB + COMPILER::C1MEMBER COMPILER::VAR-REP-LOC COMPILER::VV-STR + COMPILER::C1RETURN-FROM COMPILER::SET-PUSH-CATCH-FRAME + COMPILER::C2TAGBODY-LOCAL COMPILER::C1MAPC COMPILER::C1LET* + COMPILER::WT1 COMPILER::C1PROGV COMPILER::C2TAGBODY-BODY + COMPILER::C1TERPRI COMPILER::FUN-INFO COMPILER::C1EVAL-WHEN + COMPILER::WT-CDR COMPILER::WT-VAR-DECL COMPILER::C1RPLACA + COMPILER::REPLACE-CONSTANT COMPILER::SET-TOP + COMPILER::OBJECT-TYPE COMPILER::C1TAGBODY COMPILER::T1ORDINARY + COMPILER::WT-VS-BASE COMPILER::CONSTANT-FOLD-P + COMPILER::C1RPLACD COMPILER::C1DOWNWARD-FUNCTION + COMPILER::TYPE-FILTER COMPILER::T3PROGN + COMPILER::C1LOCAL-CLOSURE COMPILER::C2RPLACD + COMPILER::TAG-UNWIND-EXIT COMPILER::PUSH-DATA-INCF + COMPILER::VAR-REF-CCB COMPILER::INFO-P + COMPILER::WT-SYMBOL-FUNCTION COMPILER::TAG-VAR + COMPILER::T1DEFMACRO COMPILER::CTOP-WRITE COMPILER::C1MAPCON + COMPILER::C1FUNOB COMPILER::C2BIND COMPILER::ADD-SYMBOL + COMPILER::SET-RETURN COMPILER::WT-CAR COMPILER::NAME-TO-SD + COMPILER::ADD-ADDRESS COMPILER::C2GETHASH COMPILER::C1FLET + COMPILER::C2TAGBODY-CLB COMPILER::C2VAR COMPILER::ADD-OBJECT2 + COMPILER::BLK-REF COMPILER::INLINE-TYPE COMPILER::C2RPLACA + COMPILER::C2GO-CCB COMPILER::WT-FUNCTION-LINK + COMPILER::T1DEFENTRY COMPILER::C1NTH COMPILER::COPY-INFO + COMPILER::WT-FASD-ELEMENT COMPILER::C1STRUCTURE-REF + COMPILER::LTVP-EVAL COMPILER::VAR-NAME COMPILER::C1BOOLE3 + COMPILER::C1STRUCTURE-SET COMPILER::WT-VS + COMPILER::INFO-CHANGED-ARRAY COMPILER::MACRO-DEF-P + COMPILER::TAG-P COMPILER::VAR-TYPE COMPILER::SHORT-FLOAT-LOC-P + COMPILER::AET-C-TYPE COMPILER::BLK-VALUE-TO-GO COMPILER::C1GET + COMPILER::C1AND COMPILER::C1SETQ COMPILER::C1LOAD-TIME-VALUE + COMPILER::C1ECASE COMPILER::C1MAPCAN COMPILER::T1DEFUN + COMPILER::C1DEFINE-STRUCTURE COMPILER::C1ASH + COMPILER::C1NTHCDR-CONDITION COMPILER::BLK-EXIT + COMPILER::FUN-P COMPILER::C1LABELS COMPILER::LONG-FLOAT-LOC-P + COMPILER::C1SWITCH COMPILER::T1CLINES + COMPILER::GET-RETURN-TYPE COMPILER::C1DM-BAD-KEY + COMPILER::T1PROGN COMPILER::C1QUOTE COMPILER::WT-SWITCH-CASE + COMPILER::FUN-LEVEL COMPILER::DECLARATION-TYPE + COMPILER::PARSE-CVSPECS COMPILER::WT-DATA1 COMPILER::REGISTER + COMPILER::C1FMLA-CONSTANT COMPILER::C1DECLARE COMPILER::VAR-P + COMPILER::ADD-REG1 COMPILER::C1UNWIND-PROTECT + COMPILER::C2VAR-KIND COMPILER::BLK-P COMPILER::INFO-TYPE + COMPILER::THE-PARAMETER COMPILER::C2VALUES + COMPILER::WRITE-BLOCK-OPEN COMPILER::C1NTH-CONDITION + COMPILER::C1MAPCAR COMPILER::VAR-LOC COMPILER::SCH-GLOBAL + COMPILER::WT-H1 COMPILER::SAVE-AVMA COMPILER::C1BLOCK + SYSTEM::UNDEF-COMPILER-MACRO COMPILER::C1MULTIPLE-VALUE-PROG1 + COMPILER::SAFE-SYSTEM COMPILER::DEFAULT-INIT + COMPILER::T3ORDINARY COMPILER::CMP-MACROEXPAND-1 + COMPILER::FUN-REF-CCB COMPILER::TAG-REF-CLB + COMPILER::C2DOWNWARD-FUNCTION COMPILER::C1THE + COMPILER::CHECK-VREF COMPILER::ARGS-CAUSE-SIDE-EFFECT + COMPILER::C1ADD-GLOBALS COMPILER::WT-LIST + COMPILER::SET-UP-VAR-CVS COMPILER::T1DEFCFUN + COMPILER::INLINE-BOOLE3-STRING COMPILER::FIX-OPT + COMPILER::VAR-REGISTER COMPILER::TAG-REF COMPILER::T2DECLARE + COMPILER::DECL-BODY-SAFETY COMPILER::C1VREF + COMPILER::C2DM-RESERVE-V COMPILER::BLK-NAME + COMPILER::C1RPLACA-NTHCDR COMPILER::VOLATILE + COMPILER::PUSH-ARGS COMPILER::C1FSET COMPILER::FLAGS-POS + COMPILER::TAG-LABEL COMPILER::C1MEMQ COMPILER::C1CATCH + COMPILER::GET-LOCAL-RETURN-TYPE COMPILER::WT-DATA2 + COMPILER::PUSH-ARGS-LISPCALL COMPILER::FUN-NAME + COMPILER::C2TAGBODY-CCB COMPILER::C2GET + COMPILER::INFO-REFERRED-ARRAY + COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::T1MACROLET + COMPILER::T3CLINES COMPILER::SCH-LOCAL-FUN COMPILER::C1LENGTH + COMPILER::WT-DOWN COMPILER::WT-FUNCALL-C COMPILER::RESULT-TYPE + COMPILER::MDELETE-FILE COMPILER::ADD-CONSTANT + COMPILER::C1VALUES COMPILER::C1GETHASH + COMPILER::CMP-MACROEXPAND COMPILER::FUN-CFUN COMPILER::C1MAPL + COMPILER::UNWIND-NO-EXIT COMPILER::BLK-REF-CLB COMPILER::WT-VV + COMPILER::VAR-KIND COMPILER::TAG-SWITCH COMPILER::WT-CCB-VS + COMPILER::REP-TYPE COMPILER::UNDEFINED-VARIABLE + COMPILER::C1MULTIPLE-VALUE-SETQ COMPILER::C2GO-CLB + COMPILER::NEED-TO-SET-VS-POINTERS COMPILER::LTVP + COMPILER::GET-LOCAL-ARG-TYPES COMPILER::COMPILE-ORDINARY-P + COMPILER::C1LIST-NTH COMPILER::C1GO + COMPILER::C1MULTIPLE-VALUE-CALL COMPILER::C2EXPR* + COMPILER::VAR-REF COMPILER::WT-CADR COMPILER::TAG-NAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::T) - COMPILER::WT-SIMPLE-CALL COMPILER::GET-OUTPUT-PATHNAME)) \ No newline at end of file + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) + COMPILER::INLINE-BOOLE3)) +(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 aaa2a4e..fdd6fa0 100755 --- a/configure +++ b/configure @@ -7720,6 +7720,10 @@ then : enableval=$enable_ansi; if test "$enable_ansi" = "no" ; then SYSTEM=gcl CLSTANDARD=CLtL1 + else + +printf "%s\n" "#define ANSI_COMMON_LISP 1" >>confdefs.h + fi fi diff --git a/configure.in b/configure.in index da6b6c8..e81c78f 100644 --- a/configure.in +++ b/configure.in @@ -1542,6 +1542,8 @@ AC_ARG_ENABLE([ansi],[ --enable-ansi builds a large gcl aiming for ansi complia [if test "$enable_ansi" = "no" ; then SYSTEM=gcl CLSTANDARD=CLtL1 + else + AC_DEFINE([ANSI_COMMON_LISP],[1],[ANSI compliant image]) fi]) FLISP="saved_$SYSTEM" diff --git a/git.tag b/git.tag new file mode 100644 index 0000000..76d0cd4 --- /dev/null +++ b/git.tag @@ -0,0 +1,2 @@ +"Version_2_6_13pre125" + diff --git a/h/amd64-linux.h b/h/amd64-linux.h index c7272e1..7892592 100644 --- a/h/amd64-linux.h +++ b/h/amd64-linux.h @@ -22,3 +22,5 @@ #define RELOC_H "elf64_i386_reloc.h" #define MAX_CODE_ADDRESS (1L<<31)/*large memory model broken gcc 4.8*/ +#define MAX_DEFAULT_MEMORY_MODEL_CODE_ADDRESS (1UL<<31) +#define LARGE_MEMORY_MODEL /*working -mcmodel=large giving unrestricted code load addresses*/ diff --git a/h/gclincl.h.in b/h/gclincl.h.in index 4686d4e..989258f 100644 --- a/h/gclincl.h.in +++ b/h/gclincl.h.in @@ -9,6 +9,9 @@ /* punt guess for no randomize value */ #undef ADDR_NO_RANDOMIZE +/* ANSI compliant image */ +#undef ANSI_COMMON_LISP + /* binding stack size */ #undef BDSSIZE diff --git a/h/notcomp.h b/h/notcomp.h index c6f05c5..1b8a3f8 100755 --- a/h/notcomp.h +++ b/h/notcomp.h @@ -83,6 +83,7 @@ void old(void) \ #undef FFD #undef STATD #undef make_function +#undef make_macro_function #undef make_si_function #undef make_si_sfun #undef make_special_form @@ -91,6 +92,7 @@ void old(void) \ #define LFD(a_) static void FFN(a_) (); void a_ () { FFN(a_)();} static void FFN(a_) #define FFD(a_) static void FFN(a_) (object); void a_ (object x) { FFN(a_)(x);} static void FFN(a_) #define make_function(a_,b_) make_function_internal(a_,FFN(b_)) +#define make_macro_function(a_,b_) make_macro_internal(a_,FFN(b_)) #define make_si_function(a_,b_) make_si_function_internal(a_,FFN(b_)) #define make_special_form(a_,b_) make_special_form_internal(a_,FFN(b_)) #define make_si_special_form(a_,b_) make_si_special_form_internal(a_,FFN(b_)) @@ -101,6 +103,7 @@ void old(void) \ #define LFD(a_) void a_ #define FFD(a_) void a_ #define make_function(a_,b_) make_function_internal(a_,b_) +#define make_macro_function(a_,b_) make_macro_internal(a_,b_) #define make_si_function(a_,b_) make_si_function_internal(a_,b_) #define make_special_form(a_,b_) make_special_form_internal(a_,b_) #define make_si_special_form(a_,b_) make_si_special_form_internal(a_,b_) diff --git a/h/object.h b/h/object.h index 7231467..9d3bfac 100755 --- a/h/object.h +++ b/h/object.h @@ -124,7 +124,8 @@ EXTER struct package *pack_pointer; /* package pointer */ enum httest { /* hash table key test function */ htt_eq, /* eq */ htt_eql, /* eql */ - htt_equal /* equal */ + htt_equal, /* equal */ + htt_equalp /* equalp */ }; enum aelttype { /* array element type */ diff --git a/h/protoize.h b/h/protoize.h index 4c85532..0da4c4a 100644 --- a/h/protoize.h +++ b/h/protoize.h @@ -120,6 +120,7 @@ struct key {short n,allow_other_keys; /* cfun.c:221:OF */ extern object fSmf (object name, object addr); /* (name, addr) object name; object addr; */ /* cfun.c:269:OF */ extern object fSmm (object name, object addr); /* (name, addr) object name; object addr; */ /* cfun.c:283:OF */ extern object make_function_internal (char *s, void(*f)()); /* (s, f) char *s; int (*f)(); */ +/* cfun.c:283:OF */ extern object make_macro_internal (char *s, void(*f)()); /* (s, f) char *s; int (*f)(); */ /* cfun.c:299:OF */ extern object make_si_sfun_internal (char *s, object (*f)(), int argd); /* (s, f, argd) char *s; int (*f)(); int argd; */ /* cfun.c:322:OF */ extern object make_si_function_internal (char *s, void (*f) ()); /* (s, f) char *s; int (*f)(); */ /* cfun.c:341:OF */ extern object make_special_form_internal (char *s, void (*f)()); /* (s, f) char *s; int (*f)(); */ @@ -203,6 +204,7 @@ typedef int (*FUNC)(); /* eval.c:739:OF */ extern void super_funcall (object fun); /* (fun) object fun; */ /* eval.c:752:OF */ extern void super_funcall_no_event (object fun); /* (fun) object fun; */ /* eval.c:936:OF */ extern object Ieval (object form); /* (form) object form; */ +#define Ieval1(x) Ieval(x) /*FIXME*/ /* eval.c:944:OF */ extern void eval (object form); /* (form) object form; */ /* eval.c:1189:OF */ extern void Leval (void); /* () */ /* eval.c:1191:OF */ extern object fLeval (object x0); /* (x0) object x0; */ @@ -1759,6 +1761,9 @@ gcl_isnormal_double(double); int gcl_isnormal_float(float); +int +gcl_isnan(object); + object find_init_name1(char *,unsigned); @@ -1808,6 +1813,9 @@ find_init_string(const char *); void * get_mmap(FILE *,void **); +void * +get_mmap_shared(FILE *,void **); + int un_mmap(void *,void *); @@ -1928,7 +1936,7 @@ void maybe_set_hole_from_maxpages(void); void * -alloc_code_space(size_t); +alloc_code_space(size_t,ufixnum); object fSmake_vector1_2(fixnum,fixnum,object,object); diff --git a/lsp/gcl_mislib.lsp b/lsp/gcl_mislib.lsp index 730ce8c..7ea572f 100755 --- a/lsp/gcl_mislib.lsp +++ b/lsp/gcl_mislib.lsp @@ -129,11 +129,11 @@ (dolist (l '(:unexec :bfd :readline :xgcl)) (when (member l *features*) (push l gpled-modules))) - (format nil "GCL (GNU Common Lisp) ~a.~a.~a ~a ~a ~a~%~a~%~a ~a~%~a~%~a~%~%~a~%" - *gcl-major-version* *gcl-minor-version* *gcl-extra-version* + (format nil "GCL (GNU Common Lisp) ~a.~a.~a ~a ~a ~a git: ~a~%~a~%~a ~a~%~a~%~a~%~%~a~%" + *gcl-major-version* *gcl-minor-version* *gcl-extra-version* *gcl-release-date* (if (member :ansi-cl *features*) "ANSI" "CLtL1") (if (member :gprof *features*) "profiling" "") - *gcl-release-date* + *gcl-git-tag* "Source License: LGPL(gcl,gmp), GPL(unexec,bfd,xgcl)" "Binary License: " (if gpled-modules (format nil "GPL due to GPL'ed components: ~a" gpled-modules) @@ -143,10 +143,11 @@ "Use (help) to get some basic information on how to use GCL."))) (defun lisp-implementation-version nil - (format nil "GCL ~a.~a.~a" + (format nil "GCL ~a.~a.~a git tag ~a" *gcl-major-version* *gcl-minor-version* - *gcl-extra-version*)) + *gcl-extra-version* + *gcl-git-tag*)) (defun objlt (x y) (declare (object x y)) diff --git a/lsp/gcl_predlib.lsp b/lsp/gcl_predlib.lsp index 6026f8d..c1e2c09 100755 --- a/lsp/gcl_predlib.lsp +++ b/lsp/gcl_predlib.lsp @@ -824,6 +824,7 @@ (defvar *gcl-extra-version* nil) (defvar *gcl-minor-version* nil) (defvar *gcl-major-version* nil) +(defvar *gcl-git-tag* nil) (defvar *gcl-release-date* nil) (defun warn-version (majvers minvers extvers) diff --git a/lsp/sys-proclaim.lisp b/lsp/sys-proclaim.lisp index 071abb6..c5e4ca8 100755 --- a/lsp/sys-proclaim.lisp +++ b/lsp/sys-proclaim.lisp @@ -2,338 +2,271 @@ (COMMON-LISP::IN-PACKAGE "SYSTEM") (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::T) COMMON-LISP::T) - SYSTEM::NORMALIZE-TYPE SYSTEM::PNL1 - ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS SYSTEM::DM-BAD-KEY - SYSTEM::S-DATA-INCLUDES - ANSI-LOOP::LOOP-UNIVERSE-ITERATION-KEYWORDS - COMMON-LISP::HOST-NAMESTRING - COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM COMMON-LISP::LOGNOT - SYSTEM::BREAK-FORWARD-SEARCH-STACK - SLOOP::SUBSTITUTE-SLOOP-BODY - COMMON-LISP::CONCATENATED-STREAM-STREAMS - ANSI-LOOP::LOOP-MINIMAX-OPERATIONS SYSTEM::ADD-TO-HOTLIST - SYSTEM::RESTART-REPORT-FUNCTION COMMON-LISP::THIRD - SYSTEM::DWIM SYSTEM::GET-INSTREAM SYSTEM::TOGGLE-CASE - SYSTEM::INSTREAM-P COMMON-LISP::DELETE-FILE - SYSTEM::BEST-ARRAY-ELEMENT-TYPE COMMON-LISP::ISQRT - SYSTEM::INSERT-BREAK-POINT SYSTEM::WILD-DIR-ELEMENT-P - COMMON-LISP::ABS SYSTEM::WHICH COMMON-LISP::ACOS - SYSTEM::COERCE-SLASH-TERMINATED - COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS - ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD - COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM SYSTEM::DIR-P - SYSTEM::SETUP-INFO SYSTEM::S-DATA-TYPE - ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS - SYSTEM::PRINT-SYMBOL-APROPOS SYSTEM::S-DATA-FROZEN - SYSTEM::REAL-ASINH ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS - SLOOP::PARSE-NO-BODY SYSTEM::INSPECT-STRING SYSTEM::PRINT-FRS - SYSTEM::LEAP-YEAR-P SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE - SYSTEM::RESTART-INTERACTIVE-FUNCTION - SYSTEM::S-DATA-SLOT-DESCRIPTIONS SYSTEM::S-DATA-STATICP - SYSTEM::INSPECT-STRUCTURE COMMON-LISP::ASINH - ANSI-LOOP::LOOP-PATH-USER-DATA SYSTEM::RE-QUOTE-STRING - SYSTEM::MLP SYSTEM::GET-STRING-INPUT-STREAM-INDEX - SYSTEM::INFO-GET-FILE COMMON-LISP::EIGHTH - SYSTEM::SHOW-BREAK-POINT SYSTEM::SIMPLE-ARRAY-P - COMMON-LISP::RESTART-NAME SLOOP::POINTER-FOR-COLLECT - COMMON-LISP::PHASE SYSTEM::LNP - SYSTEM::REWRITE-RESTART-CASE-CLAUSE - SLOOP::LOOP-COLLECT-KEYWORD-P SYSTEM::S-DATA-HAS-HOLES - SYSTEM::EVAL-FEATURE ANSI-LOOP::DESTRUCTURING-SIZE - COMMON-LISP::BROADCAST-STREAM-STREAMS - ANSI-LOOP::LOOP-PATH-FUNCTION COMMON-LISP::BYTE-POSITION - ANSI-LOOP::LOOP-MINIMAX-TYPE COMMON-LISP::TANH - SYSTEM::BKPT-FILE SYSTEM::FRS-KIND - SYSTEM::S-DATA-PRINT-FUNCTION SYSTEM::UNIQUE-ID - SYSTEM::IHS-NOT-INTERPRETED-ENV SYSTEM::INSPECT-PACKAGE - ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA SYSTEM::BKPT-FILE-LINE - ANSI-LOOP::LOOP-EMIT-BODY SYSTEM::PATCH-SHARP - ANSI-LOOP::LOOP-COLLECTOR-P SYSTEM::DIR-CONJ - SYSTEM::CHECK-TRACE-SPEC ANSI-LOOP::LOOP-COLLECTOR-HISTORY - ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS SYSTEM::FIX-LOAD-PATH - ANSI-LOOP::LOOP-COLLECTOR-NAME SYSTEM::PATH-STREAM-NAME - SLOOP::LOOP-LET-BINDINGS ANSI-LOOP::LOOP-TYPED-INIT - FPE::ST-LOOKUP SYSTEM::IHS-VISIBLE SYSTEM::INFO-GET-TAGS - SYSTEM::EXPAND-HOME-DIR SYSTEM::DM-KEY-NOT-ALLOWED - ANSI-LOOP::LOOP-UNIVERSE-P - SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY - COMMON-LISP::CONSTANTLY SYSTEM::WILD-NAMESTRING-P - SYSTEM::INSPECT-NUMBER SYSTEM::LOGICAL-PATHNAME-DESIGNATOR-P - COMMON-LISP::FOURTH SYSTEM::NODES-FROM-INDEX - SYSTEM::LOGICAL-PATHNAME-HOST-P SYSTEM::S-DATA-NAMED - COMMON-LISP::INVOKE-DEBUGGER SYSTEM::INSPECT-VECTOR - SYSTEM::VERSION-PARSE SYSTEM::WILD-PATH-ELEMENT-P - SLOOP::RETURN-SLOOP-MACRO SYSTEM::REGEXP-CONV - SYSTEM::NUMBER-OF-DAYS-FROM-1900 - COMMON-LISP::ECHO-STREAM-INPUT-STREAM SYSTEM::CHDIR - SYSTEM::DBL-RPL-LOOP COMMON-LISP::ASIN COMMON-LISP::RATIONAL - ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED - COMMON-LISP::NAMESTRING SYSTEM::TRACE-ONE-PREPROCESS - SYSTEM::TERMINAL-INTERRUPT SYSTEM::SEQTYPE SYSTEM::S-DATA-RAW - SYSTEM::GET-NEXT-VISIBLE-FUN FPE::XMM-LOOKUP - SYSTEM::MAKE-KCL-TOP-RESTART ANSI-LOOP::LOOP-MINIMAX-P - ANSI-LOOP::LOOP-MAXMIN-COLLECTION - COMMON-LISP::COMPILER-MACRO-FUNCTION SYSTEM::BKPT-FUNCTION - SYSTEM::DIRECTORY-LIST-CHECK SYSTEM::S-DATA-SLOT-POSITION - SYSTEM::SHORT-NAME SYSTEM::DBL-EVAL - ANSI-LOOP::LOOP-COLLECTOR-DATA SYSTEM::S-DATA-DOCUMENTATION - ANSI-LOOP::LOOP-EMIT-FINAL-VALUE COMMON-LISP::NINTH - SYSTEM::CHECK-DECLARATIONS ANSI-LOOP::LOOP-PATH-NAMES - COMMON-LISP::LOGICAL-PATHNAME COMMON-LISP::SIGNUM - COMMON-LISP::FIND-ALL-SYMBOLS COMMON-LISP::FIFTH - SYSTEM::S-DATA-P ANSI-LOOP::LOOP-CONSTANTP SYSTEM::IDESCRIBE - SYSTEM::BKPT-FORM ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE - SLOOP::SLOOP-SLOOP-MACRO SYSTEM::NEXT-STACK-FRAME - SYSTEM::INSPECT-CONS SYSTEM::KNOWN-TYPE-P - SYSTEM::RESET-TRACE-DECLARATIONS COMMON-LISP::SINH - ANSI-LOOP::LOOP-PATH-P COMMON-LISP::PROVIDE - SYSTEM::INSPECT-SYMBOL SYSTEM::FIND-DOCUMENTATION - ANSI-LOOP::LOOP-MAKE-DESETQ COMMON-LISP::TENTH - SYSTEM::MAKE-DEFPACKAGE-FORM COMMON-LISP::FILE-WRITE-DATE - COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM - COMMON-LISP::TRUENAME COMMON-LISP::COMPLEMENT - COMMON-LISP::FIRST ANSI-LOOP::LOOP-COLLECTOR-CLASS - ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS COMMON-LISP::ATANH - SYSTEM::LOGICAL-PATHNAMEP COMMON-LISP::DIRECTORY-NAMESTRING - SYSTEM::RESTART-P ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE - SYSTEM::FIND-KCL-TOP-RESTART COMMON-LISP::FILE-NAMESTRING - COMMON-LISP::STREAM-EXTERNAL-FORMAT COMMON-LISP::SECOND - COMMON-LISP::FILE-LENGTH SYSTEM::INSTREAM-STREAM - ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE COMMON-LISP::PATHNAME - SYSTEM::DO-F COMMON-LISP::FILE-AUTHOR - SYSTEM::LOAD-PATHNAME-EXISTS SLOOP::AVERAGING-SLOOP-MACRO - ANSI-LOOP::LOOP-CONSTRUCT-RETURN ANSI-LOOP::LOOP-UNIVERSE-ANSI - ANSI-LOOP::LOOP-PSEUDO-BODY SLOOP::PARSE-LOOP - ANSI-LOOP::LOOP-HACK-ITERATION SYSTEM::S-DATA-CONC-NAME - SYSTEM::SEARCH-STACK ANSI-LOOP::LOOP-DO-THEREIS - COMMON-LISP::BYTE-SIZE ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE - COMMON-LISP::ACOSH SYSTEM::GET-PATH - COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS - SYSTEM::S-DATA-CONSTRUCTORS SYSTEM::ENSURE-DIR-STRING - SYSTEM::FREEZE-DEFSTRUCT SYSTEM::PRINT-IHS - SYSTEM::INSPECT-CHARACTER COMMON-LISP::ARRAY-DIMENSIONS - SLOOP::PARSE-LOOP-INITIALLY SYSTEM::COMPUTING-ARGS-P - SYSTEM::INSTREAM-STREAM-NAME SYSTEM::PROCESS-ARGS FPE::GREF - SYSTEM::S-DATA-NAME ANSI-LOOP::LOOP-UNIVERSE-TYPE-KEYWORDS - SYSTEM::GET-BYTE-STREAM-NCHARS SYSTEM::S-DATA-INCLUDED - SYSTEM::WALK-THROUGH SYSTEM::RESTART-FUNCTION - SLOOP::TRANSLATE-NAME - ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED - COMMON-LISP::SEVENTH COMMON-LISP::CIS FPE::LOOKUP - COMMON-LISP::COSH COMMON-LISP::VECTOR-POP SYSTEM::IHS-FNAME - SYSTEM::BREAK-BACKWARD-SEARCH-STACK SLOOP::REPEAT-SLOOP-MACRO - COMMON-LISP::PROBE-FILE ANSI-LOOP::LOOP-LIST-COLLECTION - SYSTEM::CONTEXT-P COMMON-LISP::SIXTH SYSTEM::NC - SYSTEM::MAKE-FRAME COMMON-LISP::COMPILE-FILE-PATHNAME - SYSTEM::INFO-NODE-FROM-POSITION SYSTEM::NODE-OFFSET - SYSTEM::RESTART-TEST-FUNCTION SYSTEM::ALOAD - ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS - ANSI-LOOP::LOOP-COLLECTOR-DTYPE SYSTEM::S-DATA-OFFSET - SYSTEM::SHOW-ENVIRONMENT COMMON-LISP::SYNONYM-STREAM-SYMBOL - SYSTEM::INSPECT-ARRAY ANSI-LOOP::LOOP-MAKE-PSETQ)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - SYSTEM::BREAK-QUIT SYSTEM::DBL-BACKTRACE - SYSTEM::BREAK-PREVIOUS SYSTEM::INFO-ERROR SYSTEM::BREAK-VS - SYSTEM::BREAK-LOCAL SYSTEM::IHS-BACKTRACE - ANSI-LOOP::LOOP-OPTIONAL-TYPE SYSTEM::BREAK-NEXT - COMMON-LISP::MUFFLE-WARNING SYSTEM::BREAK-BDS - COMMON-LISP::CONTINUE SYSTEM::SHOW-BREAK-VARIABLES)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::VECTOR COMMON-LISP::T)) - SYSTEM::CONTEXT-VEC)) -(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::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::T) - SYSTEM::MAYBE-BREAK SYSTEM::MME3 SYSTEM::FIND-LINE-IN-FUN - SYSTEM::SETF-STRUCTURE-ACCESS SYSTEM::EXPAND-RANGE - SYSTEM::MINMAX SYSTEM::COERCE-TO-CONDITION - SLOOP::FIRST-SLOOP-FOR SLOOP::FIRST-USE-SLOOP-FOR - SYSTEM::DO-BREAK-LEVEL SYSTEM::ELSUB - ANSI-LOOP::LOOP-FOR-ARITHMETIC SYSTEM::CALL-TEST - SYSTEM::ELEMENT SYSTEM::LOAD-PATHNAME)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::T) - SYSTEM::SHARP-P-READER ANSI-LOOP::HIDE-VARIABLE-REFERENCE - SYSTEM::CHECK-TRACE-ARGS SYSTEM::SHARP-U-READER - SYSTEM::FLOATING-POINT-ERROR ANSI-LOOP::LOOP-FOR-IN - COMMON-LISP::DEPOSIT-FIELD SYSTEM::GET-SLOT-POS - SYSTEM::SHARP-A-READER SYSTEM::SHARP-V-READER - SYSTEM::PATHNAME-PARSE - SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS SYSTEM::SETF-EXPAND-1 - COMMON-LISP::DPB SYSTEM::RESTART-CASE-EXPRESSION-CONDITION - SYSTEM::CHECK-S-DATA ANSI-LOOP::LOOP-FOR-BEING - SYSTEM::TO-REGEXP-OR-NAMESTRING SYSTEM::APPLY-DISPLAY-FUN - ANSI-LOOP::LOOP-ANSI-FOR-EQUALS ANSI-LOOP::LOOP-SUM-COLLECTION - ANSI-LOOP::LOOP-FOR-ON SYSTEM::MFR - ANSI-LOOP::LOOP-STANDARD-EXPANSION SYSTEM::PROG?* - ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE - SYSTEM::SHARP-DQ-READER SYSTEM::RECURSE-DIR SYSTEM::DM-VL - ANSI-LOOP::LOOP-FOR-ACROSS ANSI-LOOP::PRINT-LOOP-UNIVERSE - SYSTEM::WARN-VERSION ANSI-LOOP::LOOP-TRANSLATE - SYSTEM::DEFMACRO* SYSTEM::MAKE-BREAK-POINT SYSTEM::MAKE-T-TYPE - FPE::REF)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + COMMON-LISP::YES-OR-NO-P SYSTEM::GPROF-START + SYSTEM::BREAK-LOCALS ANSI-LOOP::MAKE-LOOP-UNIVERSE + SYSTEM::MAKE-CONTEXT SYSTEM::MAYBE-CLEAR-INPUT + COMMON-LISP::Y-OR-N-P SLOOP::PARSE-LOOP-DECLARE + SYSTEM::STEP-INTO SYSTEM::STEP-NEXT + COMMON-LISP::USER-HOMEDIR-PATHNAME COMMON-LISP::ABORT + SYSTEM::MAKE-INSTREAM COMMON-LISP::COMPUTE-RESTARTS + SYSTEM::LOC SYSTEM::NEXT-MATCH SLOOP::PARSE-LOOP-WITH + ANSI-LOOP::LOOP-GENTEMP SYSTEM::CURRENT-STEP-FUN + COMMON-LISP::BREAK ANSI-LOOP::MAKE-LOOP-COLLECTOR + SYSTEM::MAKE-RESTART COMMON-LISP::MAKE-PATHNAME + ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE SYSTEM::MAKE-S-DATA + SYSTEM::GPROF-QUIT SYSTEM::TRANSFORM-KEYWORDS + COMMON-LISP::DRIBBLE SYSTEM::DESCRIBE-ENVIRONMENT + COMMON-LISP::VECTOR SYSTEM::DBL-READ + ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL + ANSI-LOOP::MAKE-LOOP-PATH + ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::*) - COMMON-LISP::T) - SYSTEM::MME2 COMMON-LISP::SUBSTITUTE-IF-NOT - ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH - COMMON-LISP::SUBSTITUTE SYSTEM::WALK-DIR - SYSTEM::CHECK-TYPE-SYMBOL COMMON-LISP::TRANSLATE-PATHNAME - ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH - COMMON-LISP::MAP ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH - ANSI-LOOP::ADD-LOOP-PATH SLOOP::LOOP-DECLARE-BINDING - SYSTEM::COMPLETE-PROP SYSTEM::MATCH-COMPONENT - COMMON-LISP::NSUBSTITUTE COMMON-LISP::NSUBSTITUTE-IF - COMMON-LISP::SUBSTITUTE-IF COMMON-LISP::NSUBSTITUTE-IF-NOT - SYSTEM::PUSH-LET-BINDING ANSI-LOOP::LOOP-MAKE-VARIABLE)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) + SYSTEM::BREAK-GO SYSTEM::END-WAITING ANSI-LOOP::NAMED-VARIABLE + ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES SYSTEM::INSPECT-OBJECT + SYSTEM::GET-&ENVIRONMENT SYSTEM::BREAK-LEVEL-INVOKE-RESTART + COMMON-LISP::INSPECT SYSTEM::DO-F COMMON-LISP::DESCRIBE + SYSTEM::WAITING SYSTEM::FIND-DECLARATIONS + COMMON-LISP::PRIN1-TO-STRING ANSI-LOOP::LOOP-LIST-STEP + SYSTEM::REWRITE-RESTART-CASE-CLAUSE SYSTEM::EXPAND-RANGES + SYSTEM::PARSE-BODY-HEADER + COMMON-LISP::INVOKE-RESTART-INTERACTIVELY SYSTEM::INFO-SUBFILE + COMMON-LISP::PRINC-TO-STRING SYSTEM::INSTREAM-NAME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + ((COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T) COMMON-LISP::T) - COMMON-LISP::DELETE-IF-NOT COMMON-LISP::FILL - COMMON-LISP::SET-EXCLUSIVE-OR ANSI-LOOP::LOOP-CHECK-DATA-TYPE - SYSTEM::INTERNAL-COUNT-IF-NOT COMMON-LISP::SOME - COMMON-LISP::COUNT COMMON-LISP::NOTANY SYSTEM::INTERNAL-COUNT - COMMON-LISP::POSITION-IF-NOT COMMON-LISP::SET-DIFFERENCE - SLOOP::IN-ARRAY-SLOOP-FOR COMMON-LISP::NUNION - COMMON-LISP::BIT-NAND SYSTEM::PROCESS-ERROR - COMMON-LISP::BIT-ANDC2 COMMON-LISP::POSITION-IF - COMMON-LISP::NSET-DIFFERENCE COMMON-LISP::WRITE-SEQUENCE - COMMON-LISP::BIT-XOR COMMON-LISP::READ-SEQUENCE - COMMON-LISP::DELETE-IF COMMON-LISP::MAP-INTO - COMMON-LISP::SUBSETP COMMON-LISP::REMOVE-IF-NOT - COMMON-LISP::FIND-IF COMMON-LISP::INTERSECTION - COMMON-LISP::REPLACE COMMON-LISP::VECTOR-PUSH-EXTEND - COMMON-LISP::BIT-ORC2 COMMON-LISP::POSITION - COMMON-LISP::CERROR COMMON-LISP::FIND COMMON-LISP::BIT-ORC1 - SYSTEM::BREAK-CALL SLOOP::PARSE-LOOP-MACRO COMMON-LISP::EVERY - COMMON-LISP::COUNT-IF-NOT COMMON-LISP::ADJUST-ARRAY - COMMON-LISP::SEARCH COMMON-LISP::REMOVE-IF - COMMON-LISP::NOTEVERY COMMON-LISP::TYPEP COMMON-LISP::COUNT-IF - SYSTEM::WREADDIR SYSTEM::INTERNAL-COUNT-IF COMMON-LISP::DELETE - COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::UNION - COMMON-LISP::BIT-EQV COMMON-LISP::NINTERSECTION - COMMON-LISP::MISMATCH SYSTEM::FIND-IHS COMMON-LISP::REMOVE - SYSTEM::VECTOR-PUSH-STRING COMMON-LISP::BIT-IOR - COMMON-LISP::FIND-IF-NOT COMMON-LISP::MAKE-SEQUENCE - COMMON-LISP::BIT-ANDC1 SLOOP::LOOP-ADD-BINDING - COMMON-LISP::BIT-NOR COMMON-LISP::BIT-AND)) + SYSTEM::SMALLNTHCDR)) (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::INTEGER -9223372036854775808 + 9223372036854775807) + COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::DO-ARG-COUNT-ERROR SYSTEM::PUSH-SUB-LIST-BINDING)) + SYSTEM::QUICK-SORT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + (COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807) COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::MAKE-PREDICATE SYSTEM::DO?* SYSTEM::MAKE-CONSTRUCTOR)) + SYSTEM::BIGNTHCDR)) (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::T) - ANSI-LOOP::LOOP-SEQUENCER)) + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + ANSI-LOOP::LOOP-DO-RETURN SLOOP::PARSE-LOOP-COLLECT + SYSTEM::READ-EVALUATED-FORM SYSTEM::INSPECT-INDENT-1 + SLOOP::PARSE-LOOP-WHEN SYSTEM::TEST-ERROR SLOOP::LOOP-POP + SYSTEM::DM-TOO-FEW-ARGUMENTS SYSTEM::INSPECT-READ-LINE + SYSTEM::GET-SIG-FN-NAME SLOOP::LOOP-PEEK + COMMON-LISP::TYPE-ERROR SYSTEM::SET-UP-TOP-LEVEL + ANSI-LOOP::LOOP-DO-REPEAT ANSI-LOOP::LOOP-GET-PROGN + SYSTEM::GET-TEMP-DIR SLOOP::PARSE-LOOP1 SYSTEM::SHOW-RESTARTS + SYSTEM::KCL-TOP-RESTARTS + COMMON-LISP::LISP-IMPLEMENTATION-VERSION SYSTEM::SET-ENV + SLOOP::PARSE-ONE-WHEN-CLAUSE SYSTEM::GET-INDEX-NODE + ANSI-LOOP::LOOP-DO-INITIALLY SYSTEM::INSPECT-INDENT + ANSI-LOOP::LOOP-BIND-BLOCK ANSI-LOOP::LOOP-WHEN-IT-VARIABLE + SYSTEM::INIT-BREAK-POINTS SYSTEM::DEFAULT-INFO-HOTLIST + SYSTEM::ILLEGAL-BOA ANSI-LOOP::LOOP-DO-FINALLY + ANSI-LOOP::LOOP-GET-FORM SYSTEM::CURRENT-DIRECTORY-PATHNAME + ANSI-LOOP::LOOP-ITERATION-DRIVER ANSI-LOOP::LOOP-DO-WITH + SLOOP::PARSE-LOOP-FOR SLOOP::LOOP-UN-POP + ANSI-LOOP::LOOP-CONTEXT SYSTEM::DBL ANSI-LOOP::LOOP-DO-DO + SYSTEM::CLEANUP SYSTEM::DEFAULT-SYSTEM-BANNER + SYSTEM::STEP-READ-LINE SYSTEM::ALL-TRACE-DECLARATIONS + SLOOP::PARSE-LOOP-DO SYSTEM::SET-CURRENT + SYSTEM::DM-TOO-MANY-ARGUMENTS ANSI-LOOP::LOOP-DO-NAMED + ANSI-LOOP::LOOP-POP-SOURCE SYSTEM::SETUP-LINEINFO + SYSTEM::TOP-LEVEL)) (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::FUNCTION (COMMON-LISP::T COMMON-LISP::T) COMMON-LISP::T) - SYSTEM::EXPAND-WILD-DIRECTORY SLOOP::DEF-LOOP-INTERNAL - COMMON-LISP::MERGE SYSTEM::PRINT-STACK-FRAME)) + COMMON-LISP::LOGORC2 COMMON-LISP::WITH-PACKAGE-ITERATOR + ANSI-LOOP::LOOP-DO-WHILE SLOOP::THEREIS-SLOOP-COLLECT + SYSTEM::ADD-FILE SLOOP::IN-CAREFULLY-SLOOP-FOR + SLOOP::IN-PACKAGE-SLOOP-MAP SYSTEM::MV-SETQ SYSTEM::IF-ERROR + SYSTEM::WITHOUT-INTERRUPTS SYSTEM::DM-NTH COMMON-LISP::CASE + ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE + COMMON-LISP::DEFINE-MODIFY-MACRO SLOOP::COUNT-SLOOP-COLLECT + SYSTEM::GET-MATCH COMMON-LISP::SHIFTF SYSTEM::*BREAK-POINTS* + COMMON-LISP::RETURN COMMON-LISP::LDB + COMMON-LISP::WITH-SIMPLE-RESTART COMMON-LISP::LOGORC1 + COMMON-LISP::MULTIPLE-VALUE-BIND FPE::RF + COMMON-LISP::WITH-STANDARD-IO-SYNTAX + SLOOP::MINIMIZE-SLOOP-COLLECT SYSTEM::DEFINE-SETF-METHOD + COMMON-LISP::ECASE COMMON-LISP::DOTIMES + SLOOP::DEF-LOOP-COLLECT COMMON-LISP::PROG1 + ANSI-LOOP::LOOP-LOOKUP-KEYWORD SYSTEM::SET-BACK + COMMON-LISP::LDB-TEST SYSTEM::OBJLT SLOOP::NEVER-SLOOP-COLLECT + COMMON-LISP::VECTOR-PUSH SYSTEM::DBL-UP COMMON-LISP::ASSERT + SYSTEM::MSUB ANSI-LOOP::LOOP-BODY SYSTEM::COERCE-TO-STRING + SYSTEM::GET-INFO-CHOICES SLOOP::IN-FRINGE-SLOOP-MAP + COMMON-LISP::PSETF SYSTEM::ALL-MATCHES COMMON-LISP::DO + ANSI-LOOP::MAKE-LOOP-MINIMAX SYSTEM::PARSE-SLOT-DESCRIPTION + SYSTEM::SET-PATH-STREAM-NAME COMMON-LISP::LOOP-FINISH + COMMON-LISP::NTHCDR COMMON-LISP::DO-ALL-SYMBOLS SYSTEM::SGEN + SYSTEM::PUT-AUX COMMON-LISP::CCASE SYSTEM::DM-V + COMMON-LISP::LOCALLY SLOOP::ALWAYS-SLOOP-COLLECT + COMMON-LISP::LAMBDA COMMON-LISP::DEFMACRO + ANSI-LOOP::LOOP-TMEMBER COMMON-LISP::WITH-OPEN-STREAM + SLOOP::MAXIMIZE-SLOOP-COLLECT SLOOP::DESETQ1 + COMMON-LISP::TRACE SYSTEM::CHECK-SEQ-START-END + COMMON-LISP::DEFTYPE SLOOP::MAKE-VALUE COMMON-LISP::TYPECASE + ANSI-LOOP::LOOP-TEQUAL ANSI-LOOP::LOOP-DO-ALWAYS + ANSI-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD SYSTEM::INFO-AUX + COMMON-LISP::WITH-OPEN-FILE COMMON-LISP::PROG2 + COMMON-LISP::DEFSTRUCT SLOOP::DESETQ SYSTEM::QUOTATION-READER + SYSTEM::DM-NTH-CDR SYSTEM::MATCH-DIMENSIONS COMMON-LISP::BYTE + FPE::READ-OPERANDS COMMON-LISP::TIME COMMON-LISP::COND + COMMON-LISP::DO-EXTERNAL-SYMBOLS + COMMON-LISP::WITH-HASH-TABLE-ITERATOR + COMMON-LISP::MULTIPLE-VALUE-SETQ COMMON-LISP::DEFCONSTANT + ANSI-LOOP::LOOP-DECLARE-VARIABLE COMMON-LISP::LOGNOR + ANSI-LOOP::LOOP-COLLECT-ANSWER COMMON-LISP::DEFVAR + SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS + SYSTEM::LOOKUP-KEYWORD SYSTEM::SEQUENCE-CURSOR + SLOOP::LOGXOR-SLOOP-COLLECT FPE::%-READER SLOOP::DEF-LOOP-FOR + COMMON-LISP::PSETQ SLOOP::COLLATE-SLOOP-COLLECT + SLOOP::PARSE-LOOP-MAP COMMON-LISP::NTH SYSTEM::SUBSTRINGP + SYSTEM::GET-NODES SYSTEM::COERCE-TO-PACKAGE + COMMON-LISP::PATHNAME-MATCH-P + ANSI-LOOP::HIDE-VARIABLE-REFERENCES + SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS ANSI-LOOP::LOOP-DO-IF + SYSTEM::INSPECT-PRINT SYSTEM::DOT-DIR-P SYSTEM::SETF-HELPER + COMMON-LISP::ROTATEF COMMON-LISP::FILE-STRING-LENGTH + COMMON-LISP::POP COMMON-LISP::DO-SYMBOLS + ANSI-LOOP::LOOP-MAYBE-BIND-FORM + COMMON-LISP::WITH-INPUT-FROM-STRING COMMON-LISP::PROG + SLOOP::=-SLOOP-FOR ANSI-LOOP::LOOP-COLLECT-RPLACD + COMMON-LISP::DOLIST SYSTEM::SET-DIR COMMON-LISP::WHEN + FPE::READ-INSTRUCTION SYSTEM::ITERATE-OVER-BKPTS + COMMON-LISP::OR COMMON-LISP::DEFPACKAGE COMMON-LISP::UNTRACE + COMMON-LISP::ETYPECASE COMMON-LISP::DO* COMMON-LISP::LOGTEST + SYSTEM::IN-INTERVAL-P SYSTEM::LEFT-PARENTHESIS-READER + SLOOP::DEF-LOOP-MACRO SLOOP::SLOOP SLOOP::L-EQUAL + SYSTEM::BREAK-STEP-NEXT COMMON-LISP::COERCE + SYSTEM::GPROF-OUTPUT SLOOP::SUM-SLOOP-COLLECT + COMMON-LISP::REMF ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION + SLOOP::LOCAL-FINISH COMMON-LISP::CHECK-TYPE + ANSI-LOOP::LOOP-COPYLIST* COMMON-LISP::WITH-OUTPUT-TO-STRING + SYSTEM::CONDITION-PASS SLOOP::DEF-LOOP-MAP + COMMON-LISP::DOCUMENTATION COMMON-LISP::DECF + COMMON-LISP::WRITE-BYTE COMMON-LISP::WITH-CONDITION-RESTARTS + SYSTEM::INSPECT-RECURSIVELY COMMON-LISP::PUSH + COMMON-LISP::MULTIPLE-VALUE-LIST + ANSI-LOOP::LOOP-STORE-TABLE-DATA SYSTEM::DISPLAY-ENV + SYSTEM::LIST-DELQ COMPILER::COMPILER-DEF-HOOK + SLOOP::LOOP-RETURN COMMON-LISP::PROG* SYSTEM::TP-ERROR + SYSTEM::LIST-TOGGLE-CASE COMMON-LISP::DECLAIM + SYSTEM::SAFE-EVAL COMMON-LISP::DEFSETF COMMON-LISP::LOGANDC1 + SYSTEM::SUPER-GO COMMON-LISP::LOGNAND SYSTEM::WHILE + SYSTEM::DISPLAY-COMPILED-ENV COMMON-LISP::AND + COMMON-LISP::PUSHNEW SYSTEM::INCREMENT-CURSOR + COMMON-LISP::INCF COMMON-LISP::NTH-VALUE FPE::0-READER + COMMON-LISP::DEFPARAMETER SYSTEM::?PUSH SYSTEM::NODE + FPE::PAREN-READER SLOOP::THE-TYPE COMMON-LISP::UNLESS + ANSI-LOOP::LOOP-TASSOC COMMON-LISP::LOOP + SYSTEM::GET-LINE-OF-FORM SLOOP::IN-TABLE-SLOOP-MAP + COMMON-LISP::RESTART-BIND SYSTEM::CHECK-TYPE-EVAL + COMMON-LISP::LOGANDC2 COMMON-LISP::STEP + SYSTEM::KEYWORD-SUPPLIED-P SLOOP::SLOOP-FINISH SLOOP::LCASE + ANSI-LOOP::WITH-MINIMAX-VALUE COMMON-LISP::DEFUN + COMMON-LISP::CTYPECASE COMMON-LISP::RESTART-CASE + SYSTEM::BREAK-STEP-INTO SLOOP::SLOOP-SWAP + COMMON-LISP::DESTRUCTURING-BIND SYSTEM::SUB-INTERVAL-P + SYSTEM::MV-VALUES COMMON-LISP::WITH-COMPILATION-UNIT + SYSTEM::SETF-EXPAND)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T - (COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::T) - SYSTEM::SHARP-EQ-READER SYSTEM::SHARP-SHARP-READER)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + COMMON-LISP::FCEILING COMMON-LISP::WRITE-TO-STRING + COMMON-LISP::USE-VALUE COMMON-LISP::INVOKE-RESTART + COMMON-LISP::FROUND COMMON-LISP::ENSURE-DIRECTORIES-EXIST + COMMON-LISP::DECODE-UNIVERSAL-TIME SYSTEM::SHOW-INFO + SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE + COMMON-LISP::STORE-VALUE COMMON-LISP::PARSE-NAMESTRING + SYSTEM::BREAK-FUNCTION SYSTEM::INFO COMMON-LISP::APROPOS + COMMON-LISP::APROPOS-LIST + ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE + COMMON-LISP::READ-FROM-STRING COMMON-LISP::FFLOOR + SYSTEM::STEPPER COMMON-LISP::FTRUNCATE + COMMON-LISP::GET-SETF-EXPANSION SYSTEM::APROPOS-DOC + SYSTEM::PRINT-DOC)) (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::ENCODE-UNIVERSAL-TIME)) + ((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 COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - SYSTEM::UNIVERSAL-ERROR-HANDLER)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::FIXNUM) + SYSTEM::RELATIVE-LINE ANSI-LOOP::DUPLICATABLE-CODE-P + SYSTEM::FASLINK SYSTEM::LENEL SYSTEM::THE-END + SYSTEM::GET-NODE-INDEX)) +(COMMON-LISP::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(SYSTEM::CONDITIONP SYSTEM::TRACE-ONE SYSTEM::SI-FIND-CLASS + SYSTEM::SI-CLASS-OF SYSTEM::CONDITION-CLASS-P + FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS + SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::AUTOLOAD + SYSTEM::UNTRACE-ONE SYSTEM::MAKE-ACCESS-FUNCTION + SYSTEM::SI-CLASSP SYSTEM::AUTOLOAD-MACRO SYSTEM::WARNINGP + SYSTEM::SI-CLASS-NAME SYSTEM::SIMPLE-CONDITION-CLASS-P + SYSTEM::RECORD-FN SYSTEM::DEFINE-STRUCTURE)) (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 COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - SYSTEM::PARSE-DEFMACRO SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST)) + SLOOP::FIND-IN-ORDERED-LIST COMMON-LISP::STABLE-SORT + COMMON-LISP::SUBTYPEP SYSTEM::PARSE-BODY COMMON-LISP::REDUCE + COMMON-LISP::SORT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - COMMON-LISP::SUBST COMMON-LISP::SUBST-IF-NOT - COMMON-LISP::SUBST-IF SYSTEM::MASET)) + COMMON-LISP::SUBST-IF COMMON-LISP::SUBST-IF-NOT + COMMON-LISP::SUBST 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::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::*) - SYSTEM::READ-INSPECT-COMMAND SYSTEM::RESTART-PRINT - ANSI-LOOP::LOOP-GET-COLLECTION-INFO SYSTEM::SHARP-+-READER - SYSTEM::VERIFY-KEYWORDS SYSTEM::SHARP-S-READER - SYSTEM::LIST-MERGE-SORT SYSTEM::SHARP---READER)) + SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST SYSTEM::PARSE-DEFMACRO)) (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::*) - SYSTEM::PARSE-BODY COMMON-LISP::SORT - SLOOP::FIND-IN-ORDERED-LIST COMMON-LISP::REDUCE - COMMON-LISP::STABLE-SORT COMMON-LISP::SUBTYPEP)) + SYSTEM::SHARP---READER SYSTEM::LIST-MERGE-SORT + SYSTEM::RESTART-PRINT ANSI-LOOP::LOOP-GET-COLLECTION-INFO + SYSTEM::VERIFY-KEYWORDS SYSTEM::SHARP-+-READER + SYSTEM::READ-INSPECT-COMMAND SYSTEM::SHARP-S-READER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -352,54 +285,61 @@ SYSTEM::PUSH-OPTIONAL-BINDING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - SYSTEM::MAKE-CONTEXT ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE - ANSI-LOOP::MAKE-LOOP-UNIVERSE SYSTEM::MAKE-S-DATA - SYSTEM::NEXT-MATCH COMMON-LISP::USER-HOMEDIR-PATHNAME - SYSTEM::STEP-NEXT ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL - COMMON-LISP::VECTOR SLOOP::PARSE-LOOP-WITH - COMMON-LISP::COMPUTE-RESTARTS COMMON-LISP::BREAK - ANSI-LOOP::MAKE-LOOP-PATH ANSI-LOOP::LOOP-GENTEMP - COMMON-LISP::ABORT COMMON-LISP::YES-OR-NO-P - SYSTEM::MAKE-INSTREAM SYSTEM::DBL-READ - SYSTEM::MAYBE-CLEAR-INPUT SYSTEM::MAKE-RESTART - ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL COMMON-LISP::Y-OR-N-P - SLOOP::PARSE-LOOP-DECLARE ANSI-LOOP::MAKE-LOOP-COLLECTOR - SYSTEM::DESCRIBE-ENVIRONMENT SYSTEM::STEP-INTO - SYSTEM::CURRENT-STEP-FUN COMMON-LISP::DRIBBLE - COMMON-LISP::MAKE-PATHNAME SYSTEM::BREAK-LOCALS SYSTEM::LOC - SYSTEM::TRANSFORM-KEYWORDS)) + (COMMON-LISP::FUNCTION + ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER + COMMON-LISP::*)) + COMMON-LISP::T) + SYSTEM::RESET-SYS-PATHS)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES - COMMON-LISP::PRIN1-TO-STRING SYSTEM::GET-&ENVIRONMENT - COMMON-LISP::INSPECT SYSTEM::BREAK-GO - SYSTEM::PARSE-BODY-HEADER COMMON-LISP::PRINC-TO-STRING - SYSTEM::EXPAND-RANGES ANSI-LOOP::NAMED-VARIABLE - ANSI-LOOP::LOOP-LIST-STEP SYSTEM::INSTREAM-NAME - SYSTEM::WAITING SYSTEM::END-WAITING COMMON-LISP::DESCRIBE - SYSTEM::INFO-SUBFILE SYSTEM::FIND-DECLARATIONS - SYSTEM::INSPECT-OBJECT SYSTEM::BREAK-LEVEL-INVOKE-RESTART - COMMON-LISP::INVOKE-RESTART-INTERACTIVELY)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) + (COMMON-LISP::VECTOR COMMON-LISP::T)) + SYSTEM::CONTEXT-VEC)) (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::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::AUTOLOAD - SYSTEM::UNTRACE-ONE SYSTEM::TRACE-ONE SYSTEM::CONDITIONP - SYSTEM::MAKE-ACCESS-FUNCTION SYSTEM::SI-CLASS-NAME - SYSTEM::SI-CLASSP SYSTEM::SI-CLASS-OF SYSTEM::SI-FIND-CLASS - SYSTEM::CONDITION-CLASS-P SYSTEM::AUTOLOAD-MACRO - SYSTEM::WARNINGP SYSTEM::DEFINE-STRUCTURE - FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS - SYSTEM::SIMPLE-CONDITION-CLASS-P)) + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + COMMON-LISP::MAKE-STRING-INPUT-STREAM SYSTEM::FILE-TO-STRING + SYSTEM::LINK-EXPAND COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE + COMMON-LISP::DELETE-DUPLICATES COMMON-LISP::PATHNAME-HOST + COMMON-LISP::ARRAY-ROW-MAJOR-INDEX SYSTEM::BAD-SEQ-LIMIT + SYSTEM::LOGICAL-PATHNAME-PARSE COMMON-LISP::OPEN + SYSTEM::BREAK-LEVEL COMMON-LISP::DIRECTORY + SLOOP::LOOP-ADD-TEMPS SYSTEM::DIR-PARSE + COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME SYSTEM::MGSUB + COMMON-LISP::MERGE-PATHNAMES SYSTEM::MGLIST + SYSTEM::FILE-SEARCH SYSTEM::PROCESS-SOME-ARGS + COMMON-LISP::ARRAY-IN-BOUNDS-P COMMON-LISP::SBIT + COMMON-LISP::FILE-POSITION COMMON-LISP::PATHNAME-VERSION + COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::PATHNAME-DEVICE + SYSTEM::NLOAD COMMON-LISP::WARN COMMON-LISP::ENOUGH-NAMESTRING + SYSTEM::NTH-STACK-FRAME + ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES COMMON-LISP::BIT + COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::READ-BYTE + COMMON-LISP::BIT-NOT COMMON-LISP::REQUIRE + ANSI-LOOP::LOOP-ERROR ANSI-LOOP::LOOP-WARN + COMMON-LISP::PATHNAME-NAME COMMON-LISP::MAKE-ARRAY + COMMON-LISP::REMOVE-DUPLICATES SYSTEM::INFO-SEARCH + SLOOP::ADD-FROM-DATA SYSTEM::TO-REGEXP COMMON-LISP::LOAD + COMMON-LISP::SIGNAL COMMON-LISP::PATHNAME-TYPE + COMMON-LISP::FIND-RESTART SYSTEM::LIST-MATCHES + COMMON-LISP::CONCATENATE COMMON-LISP::ERROR)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + SYSTEM::FIND-DOC COMMON-LISP::RENAME-FILE SYSTEM::DO-REPL + SYSTEM::RESTART-REPORT ANSI-LOOP::ESTIMATE-CODE-SIZE + ANSI-LOOP::LOOP-REALLY-DESETQ ANSI-LOOP::ESTIMATE-CODE-SIZE-1 + SYSTEM::NEW-SEMI-COLON-READER SYSTEM::SOURCE-PORTION + SYSTEM::NEWLINE)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) + SYSTEM::BREAK-MESSAGE SYSTEM::GCL-TOP-LEVEL + SYSTEM::SIMPLE-BACKTRACE SYSTEM::BREAK-RESUME + ANSI-LOOP::LOOP-DO-FOR SYSTEM::BREAK-CURRENT + SYSTEM::BREAK-HELP)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -409,259 +349,318 @@ 9223372036854775807)) COMMON-LISP::FIXNUM) SYSTEM::ROUND-UP)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + ((COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::FIXNUM) + SYSTEM::DBL-WHAT-FRAME FPE::FE-ENABLE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) - COMMON-LISP::HASH-TABLE) - SYSTEM::CONTEXT-SPICE)) + (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::VALUES COMMON-LISP::T COMMON-LISP::T)) - SYSTEM::MAKE-KEYWORD)) + COMMON-LISP::HASH-TABLE) + SYSTEM::CONTEXT-SPICE)) (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::INTEGER -9223372036854775808 + 9223372036854775807)) COMMON-LISP::T) - SYSTEM::QUICK-SORT)) + SYSTEM::GET-CONTEXT SYSTEM::PUSH-CONTEXT)) (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) COMMON-LISP::T) - SYSTEM::BIGNTHCDR)) + SYSTEM::EXPAND-RANGE SYSTEM::SETF-STRUCTURE-ACCESS + SYSTEM::MME3 SYSTEM::FIND-LINE-IN-FUN SYSTEM::LOAD-PATHNAME + SYSTEM::MINMAX SYSTEM::ELSUB SYSTEM::COERCE-TO-CONDITION + SYSTEM::DO-BREAK-LEVEL ANSI-LOOP::LOOP-FOR-ARITHMETIC + SLOOP::FIRST-USE-SLOOP-FOR SYSTEM::CALL-TEST + SLOOP::FIRST-SLOOP-FOR SYSTEM::MAYBE-BREAK)) (COMMON-LISP::PROCLAIM '(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::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::T) + SYSTEM::WALK-DIR SYSTEM::PUSH-LET-BINDING SYSTEM::MME2 + ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH + COMMON-LISP::SUBSTITUTE-IF-NOT + ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH SYSTEM::MATCH-COMPONENT + SYSTEM::COMPLETE-PROP COMMON-LISP::NSUBSTITUTE-IF-NOT + COMMON-LISP::SUBSTITUTE-IF COMMON-LISP::NSUBSTITUTE + ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH + SYSTEM::CHECK-TYPE-SYMBOL COMMON-LISP::MAP + COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::SUBSTITUTE + ANSI-LOOP::ADD-LOOP-PATH ANSI-LOOP::LOOP-MAKE-VARIABLE + SLOOP::LOOP-DECLARE-BINDING COMMON-LISP::NSUBSTITUTE-IF)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - ANSI-LOOP::LOOP-DO-INITIALLY SYSTEM::GET-INDEX-NODE - SLOOP::PARSE-ONE-WHEN-CLAUSE SYSTEM::STEP-READ-LINE - SYSTEM::DM-TOO-MANY-ARGUMENTS SYSTEM::READ-EVALUATED-FORM - SYSTEM::DM-TOO-FEW-ARGUMENTS SYSTEM::KCL-TOP-RESTARTS - ANSI-LOOP::LOOP-ITERATION-DRIVER - SYSTEM::CURRENT-DIRECTORY-PATHNAME SYSTEM::INSPECT-INDENT - SYSTEM::CLEANUP ANSI-LOOP::LOOP-WHEN-IT-VARIABLE - SLOOP::PARSE-LOOP-WHEN ANSI-LOOP::LOOP-DO-NAMED - ANSI-LOOP::LOOP-GET-FORM SYSTEM::GET-TEMP-DIR - SYSTEM::ILLEGAL-BOA SYSTEM::SET-UP-TOP-LEVEL - SYSTEM::SETUP-LINEINFO ANSI-LOOP::LOOP-CONTEXT - SYSTEM::TOP-LEVEL SYSTEM::DBL SLOOP::LOOP-UN-POP - SYSTEM::SET-CURRENT ANSI-LOOP::LOOP-GET-PROGN - ANSI-LOOP::LOOP-DO-REPEAT SYSTEM::INIT-BREAK-POINTS - SLOOP::PARSE-LOOP-FOR SLOOP::LOOP-POP - ANSI-LOOP::LOOP-POP-SOURCE ANSI-LOOP::LOOP-DO-WITH - ANSI-LOOP::LOOP-DO-DO COMMON-LISP::LISP-IMPLEMENTATION-VERSION - ANSI-LOOP::LOOP-DO-RETURN SLOOP::PARSE-LOOP-DO - SLOOP::LOOP-PEEK ANSI-LOOP::LOOP-BIND-BLOCK - SYSTEM::DEFAULT-SYSTEM-BANNER SLOOP::PARSE-LOOP1 - SYSTEM::INSPECT-READ-LINE ANSI-LOOP::LOOP-DO-FINALLY - SYSTEM::TEST-ERROR COMMON-LISP::TYPE-ERROR - SYSTEM::DEFAULT-INFO-HOTLIST SYSTEM::SHOW-RESTARTS - SYSTEM::SET-ENV SLOOP::PARSE-LOOP-COLLECT - SYSTEM::ALL-TRACE-DECLARATIONS SYSTEM::GET-SIG-FN-NAME - SYSTEM::INSPECT-INDENT-1)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + SYSTEM::SHARP-V-READER COMMON-LISP::DEPOSIT-FIELD + ANSI-LOOP::LOOP-FOR-ON SYSTEM::SETF-EXPAND-1 + SYSTEM::SHARP-DQ-READER SYSTEM::CHECK-TRACE-ARGS + SYSTEM::PROG?* SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS + ANSI-LOOP::PRINT-LOOP-UNIVERSE ANSI-LOOP::LOOP-FOR-IN + SYSTEM::CHECK-S-DATA SYSTEM::WARN-VERSION + ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE SYSTEM::DEFMACRO* + ANSI-LOOP::LOOP-SUM-COLLECTION SYSTEM::PATHNAME-PARSE + SYSTEM::GET-SLOT-POS SYSTEM::MAKE-T-TYPE + SYSTEM::SHARP-A-READER + SYSTEM::RESTART-CASE-EXPRESSION-CONDITION SYSTEM::RECURSE-DIR + SYSTEM::SHARP-U-READER SYSTEM::APPLY-DISPLAY-FUN SYSTEM::DM-VL + ANSI-LOOP::HIDE-VARIABLE-REFERENCE SYSTEM::MAKE-BREAK-POINT + SYSTEM::TO-REGEXP-OR-NAMESTRING ANSI-LOOP::LOOP-FOR-BEING + SYSTEM::FLOATING-POINT-ERROR SYSTEM::SHARP-P-READER + ANSI-LOOP::LOOP-TRANSLATE COMMON-LISP::DPB + ANSI-LOOP::LOOP-FOR-ACROSS FPE::REF SYSTEM::WRITE-SYMTAB + ANSI-LOOP::LOOP-STANDARD-EXPANSION + ANSI-LOOP::LOOP-ANSI-FOR-EQUALS)) (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::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + SYSTEM::DO?* SYSTEM::MAKE-PREDICATE SYSTEM::MAKE-CONSTRUCTOR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::FIXNUM) - SYSTEM::LENEL SYSTEM::GET-NODE-INDEX SYSTEM::FASLINK - SYSTEM::THE-END ANSI-LOOP::DUPLICATABLE-CODE-P - SYSTEM::RELATIVE-LINE)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + COMMON-LISP::NSET-DIFFERENCE COMMON-LISP::COUNT-IF + COMMON-LISP::FIND-IF-NOT SYSTEM::INTERNAL-COUNT-IF + COMMON-LISP::INTERSECTION COMMON-LISP::REMOVE-IF-NOT + SYSTEM::VECTOR-PUSH-STRING COMMON-LISP::EVERY + COMMON-LISP::POSITION COMMON-LISP::POSITION-IF-NOT + SYSTEM::FIND-IHS SYSTEM::INTERNAL-COUNT COMMON-LISP::BIT-ANDC2 + COMMON-LISP::DELETE-IF-NOT COMMON-LISP::BIT-ANDC1 + COMMON-LISP::UNION COMMON-LISP::NSET-EXCLUSIVE-OR + COMMON-LISP::BIT-XOR SYSTEM::WREADDIR COMMON-LISP::MISMATCH + COMMON-LISP::FIND-IF COMMON-LISP::BIT-ORC1 + COMMON-LISP::MAKE-SEQUENCE COMMON-LISP::REMOVE + COMMON-LISP::COUNT COMMON-LISP::BIT-NOR COMMON-LISP::MAP-INTO + COMMON-LISP::NOTEVERY SLOOP::PARSE-LOOP-MACRO + COMMON-LISP::FIND COMMON-LISP::BIT-AND COMMON-LISP::CERROR + ANSI-LOOP::LOOP-CHECK-DATA-TYPE COMMON-LISP::READ-SEQUENCE + COMMON-LISP::BIT-ORC2 COMMON-LISP::FILL COMMON-LISP::SOME + COMMON-LISP::NUNION SYSTEM::INTERNAL-COUNT-IF-NOT + COMMON-LISP::VECTOR-PUSH-EXTEND COMMON-LISP::REPLACE + SLOOP::LOOP-ADD-BINDING COMMON-LISP::NOTANY + COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::ADJUST-ARRAY + COMMON-LISP::SET-DIFFERENCE COMMON-LISP::BIT-NAND + COMMON-LISP::DELETE COMMON-LISP::POSITION-IF + COMMON-LISP::SUBSETP COMMON-LISP::DELETE-IF SYSTEM::BREAK-CALL + COMMON-LISP::REMOVE-IF COMMON-LISP::WRITE-SEQUENCE + COMMON-LISP::BIT-IOR SLOOP::IN-ARRAY-SLOOP-FOR + COMMON-LISP::SEARCH COMMON-LISP::COUNT-IF-NOT + COMMON-LISP::TYPEP COMMON-LISP::NINTERSECTION + COMMON-LISP::BIT-EQV SYSTEM::PROCESS-ERROR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) - COMMON-LISP::FIXNUM) - SYSTEM::DBL-WHAT-FRAME FPE::FE-ENABLE)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T) + SYSTEM::PRINT-STACK-FRAME COMMON-LISP::MERGE + SYSTEM::EXPAND-WILD-DIRECTORY SLOOP::DEF-LOOP-INTERNAL + SYSTEM::ELEMENT)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) - SYSTEM::GCL-TOP-LEVEL SYSTEM::BREAK-CURRENT - SYSTEM::BREAK-RESUME SYSTEM::BREAK-HELP SYSTEM::BREAK-MESSAGE - ANSI-LOOP::LOOP-DO-FOR SYSTEM::SIMPLE-BACKTRACE)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::T) + SYSTEM::SHARP-EQ-READER SYSTEM::SHARP-SHARP-READER)) (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::T COMMON-LISP::T + COMMON-LISP::*) COMMON-LISP::T) - SYSTEM::PROCESS-SOME-ARGS COMMON-LISP::CONCATENATE - SYSTEM::TO-REGEXP COMMON-LISP::PATHNAME-DEVICE - SYSTEM::LIST-MATCHES ANSI-LOOP::LOOP-WARN - COMMON-LISP::REMOVE-DUPLICATES COMMON-LISP::PATHNAME-HOST - COMMON-LISP::BIT COMMON-LISP::SBIT - COMMON-LISP::ENOUGH-NAMESTRING SYSTEM::DIR-PARSE - SYSTEM::FILE-SEARCH SYSTEM::BREAK-LEVEL ANSI-LOOP::LOOP-ERROR - SYSTEM::MGLIST COMMON-LISP::PATHNAME-NAME - COMMON-LISP::MAKE-STRING-INPUT-STREAM SLOOP::ADD-FROM-DATA - COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME COMMON-LISP::DIRECTORY - SYSTEM::FILE-TO-STRING COMMON-LISP::ARRAY-ROW-MAJOR-INDEX - SYSTEM::NTH-STACK-FRAME SLOOP::LOOP-ADD-TEMPS - COMMON-LISP::WARN - ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES - SYSTEM::LINK-EXPAND COMMON-LISP::PATHNAME-TYPE - COMMON-LISP::OPEN COMMON-LISP::BIT-NOT - COMMON-LISP::DELETE-DUPLICATES COMMON-LISP::ERROR - COMMON-LISP::FILE-POSITION COMMON-LISP::PATHNAME-VERSION - COMMON-LISP::ARRAY-IN-BOUNDS-P COMMON-LISP::REQUIRE - SYSTEM::MGSUB COMMON-LISP::MERGE-PATHNAMES COMMON-LISP::LOAD - COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::SIGNAL - COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::FIND-RESTART - SYSTEM::INFO-SEARCH SYSTEM::LOGICAL-PATHNAME-PARSE - SYSTEM::BAD-SEQ-LIMIT COMMON-LISP::READ-BYTE - COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE SYSTEM::NLOAD - COMMON-LISP::MAKE-ARRAY)) + COMMON-LISP::ENCODE-UNIVERSAL-TIME)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - COMMON-LISP::RENAME-FILE ANSI-LOOP::ESTIMATE-CODE-SIZE-1 - SYSTEM::FIND-DOC SYSTEM::SOURCE-PORTION SYSTEM::NEWLINE - SYSTEM::DO-REPL SYSTEM::RESTART-REPORT - ANSI-LOOP::ESTIMATE-CODE-SIZE SYSTEM::NEW-SEMI-COLON-READER)) + (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::DO-ARG-COUNT-ERROR SYSTEM::PUSH-SUB-LIST-BINDING)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION - ((COMMON-LISP::INTEGER -9223372036854775808 - 9223372036854775807)) + (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::T) - SYSTEM::GET-CONTEXT SYSTEM::PUSH-CONTEXT)) + ANSI-LOOP::LOOP-SEQUENCER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - COMMON-LISP::PSETF COMMON-LISP::PROG* SYSTEM::BREAK-STEP-INTO - SLOOP::IN-PACKAGE-SLOOP-MAP SLOOP::SLOOP-FINISH - SYSTEM::CHECK-SEQ-START-END SLOOP::SLOOP - COMMON-LISP::MULTIPLE-VALUE-SETQ COMMON-LISP::ASSERT - SLOOP::MINIMIZE-SLOOP-COLLECT COMMON-LISP::ROTATEF - SYSTEM::LIST-TOGGLE-CASE SYSTEM::INCREMENT-CURSOR - ANSI-LOOP::LOOP-COLLECT-ANSWER COMMON-LISP::PROG2 - SLOOP::SLOOP-SWAP COMMON-LISP::DEFTYPE - SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS SYSTEM::?PUSH - COMMON-LISP::DO-EXTERNAL-SYMBOLS - ANSI-LOOP::LOOP-COLLECT-RPLACD COMMON-LISP::TRACE - ANSI-LOOP::LOOP-DO-IF ANSI-LOOP::MAKE-LOOP-MINIMAX - SYSTEM::SUBSTRINGP COMMON-LISP::LOGORC2 - ANSI-LOOP::LOOP-DO-WHILE ANSI-LOOP::LOOP-LOOKUP-KEYWORD - SLOOP::DEF-LOOP-COLLECT SYSTEM::SETF-HELPER - COMMON-LISP::WITH-CONDITION-RESTARTS SYSTEM::INSPECT-PRINT - SLOOP::PARSE-LOOP-MAP SYSTEM::KEYWORD-SUPPLIED-P - COMMON-LISP::LOOP-FINISH ANSI-LOOP::LOOP-TASSOC - SYSTEM::GET-LINE-OF-FORM ANSI-LOOP::LOOP-STORE-TABLE-DATA - SLOOP::L-EQUAL COMMON-LISP::ETYPECASE - SLOOP::THEREIS-SLOOP-COLLECT COMMON-LISP::RETURN - SYSTEM::SUB-INTERVAL-P COMMON-LISP::ECASE - COMMON-LISP::WRITE-BYTE SYSTEM::LOOKUP-KEYWORD - COMMON-LISP::DEFSETF ANSI-LOOP::LOOP-DO-ALWAYS - SYSTEM::PARSE-SLOT-DESCRIPTION COMMON-LISP::VECTOR-PUSH - SYSTEM::GET-INFO-CHOICES SYSTEM::SETF-EXPAND - SYSTEM::LEFT-PARENTHESIS-READER SLOOP::DEF-LOOP-FOR - COMMON-LISP::PROG SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS - SYSTEM::SUPER-GO COMMON-LISP::LDB SYSTEM::NODE - SYSTEM::COERCE-TO-PACKAGE COMMON-LISP::DO SYSTEM::TP-ERROR - SYSTEM::GET-NODES SLOOP::THE-TYPE ANSI-LOOP::LOOP-TMEMBER - ANSI-LOOP::LOOP-TEQUAL COMMON-LISP::DEFPARAMETER - COMMON-LISP::WITH-OPEN-STREAM SYSTEM::DEFINE-SETF-METHOD - SYSTEM::IF-ERROR ANSI-LOOP::HIDE-VARIABLE-REFERENCES - SLOOP::DESETQ1 COMMON-LISP::LOOP COMMON-LISP::CTYPECASE - COMMON-LISP::DEFSTRUCT COMMON-LISP::CASE SYSTEM::DOT-DIR-P - SYSTEM::INSPECT-RECURSIVELY COMMON-LISP::DOTIMES - SYSTEM::BREAK-STEP-NEXT SYSTEM::ALL-MATCHES - COMMON-LISP::LOCALLY SLOOP::IN-TABLE-SLOOP-MAP - SYSTEM::DISPLAY-ENV COMMON-LISP::MULTIPLE-VALUE-LIST - COMMON-LISP::LDB-TEST COMMON-LISP::DECLAIM - COMMON-LISP::WITH-STANDARD-IO-SYNTAX SYSTEM::SGEN - SLOOP::ALWAYS-SLOOP-COLLECT COMMON-LISP::PUSHNEW - COMMON-LISP::MULTIPLE-VALUE-BIND FPE::%-READER - COMMON-LISP::CCASE SLOOP::DEF-LOOP-MACRO - ANSI-LOOP::LOOP-REALLY-DESETQ SYSTEM::IN-INTERVAL-P - SYSTEM::DBL-UP SLOOP::DEF-LOOP-MAP ANSI-LOOP::LOOP-BODY - SYSTEM::SEQUENCE-CURSOR COMMON-LISP::COERCE - COMMON-LISP::PATHNAME-MATCH-P SYSTEM::OBJLT - COMMON-LISP::RESTART-CASE - COMMON-LISP::WITH-HASH-TABLE-ITERATOR COMMON-LISP::STEP - SYSTEM::QUOTATION-READER SYSTEM::PUT-AUX COMMON-LISP::TYPECASE - SYSTEM::*BREAK-POINTS* COMMON-LISP::LOGTEST - SYSTEM::CONDITION-PASS COMMON-LISP::DEFVAR - COMMON-LISP::WITH-OUTPUT-TO-STRING SYSTEM::SET-BACK - COMMON-LISP::NTHCDR COMMON-LISP::DO-ALL-SYMBOLS - SYSTEM::INFO-AUX COMMON-LISP::LOGANDC1 COMMON-LISP::PROG1 - FPE::READ-OPERANDS SYSTEM::DISPLAY-COMPILED-ENV - COMMON-LISP::DEFCONSTANT SYSTEM::DM-V SLOOP::LOOP-RETURN - SYSTEM::ADD-FILE SYSTEM::WHILE SYSTEM::WITHOUT-INTERRUPTS - COMMON-LISP::NTH-VALUE COMMON-LISP::OR - ANSI-LOOP::LOOP-COPYLIST* SLOOP::IN-CAREFULLY-SLOOP-FOR - ANSI-LOOP::LOOP-DECLARE-VARIABLE SYSTEM::GET-MATCH - ANSI-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD - ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION SYSTEM::MV-SETQ - SLOOP::COLLATE-SLOOP-COLLECT COMMON-LISP::LOGORC1 - SYSTEM::DM-NTH-CDR COMPILER::COMPILER-DEF-HOOK - SYSTEM::CHECK-TYPE-EVAL COMMON-LISP::DECF - COMMON-LISP::WITH-PACKAGE-ITERATOR SYSTEM::COERCE-TO-STRING - COMMON-LISP::DEFINE-MODIFY-MACRO FPE::0-READER - COMMON-LISP::WITH-COMPILATION-UNIT COMMON-LISP::LOGNAND - COMMON-LISP::CHECK-TYPE COMMON-LISP::INCF - SLOOP::MAXIMIZE-SLOOP-COLLECT SYSTEM::ITERATE-OVER-BKPTS - SLOOP::LOGXOR-SLOOP-COLLECT SLOOP::NEVER-SLOOP-COLLECT - SYSTEM::MV-VALUES SYSTEM::MSUB COMMON-LISP::DO* - SLOOP::=-SLOOP-FOR COMMON-LISP::UNLESS - SYSTEM::MATCH-DIMENSIONS COMMON-LISP::DOLIST - ANSI-LOOP::LOOP-MAYBE-BIND-FORM SLOOP::LOCAL-FINISH - COMMON-LISP::PSETQ COMMON-LISP::COND - COMMON-LISP::WITH-SIMPLE-RESTART COMMON-LISP::DO-SYMBOLS - COMMON-LISP::FILE-STRING-LENGTH COMMON-LISP::LAMBDA - ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE - SLOOP::IN-FRINGE-SLOOP-MAP SYSTEM::SET-DIR - COMMON-LISP::WITH-INPUT-FROM-STRING SYSTEM::LIST-DELQ - COMMON-LISP::BYTE COMMON-LISP::DOCUMENTATION SYSTEM::SAFE-EVAL - COMMON-LISP::DEFMACRO SLOOP::DESETQ COMMON-LISP::POP - SLOOP::COUNT-SLOOP-COLLECT SLOOP::LCASE - COMMON-LISP::DEFPACKAGE COMMON-LISP::DEFUN COMMON-LISP::TIME - COMMON-LISP::LOGNOR COMMON-LISP::RESTART-BIND - COMMON-LISP::PUSH COMMON-LISP::SHIFTF COMMON-LISP::AND - COMMON-LISP::WHEN SYSTEM::DM-NTH COMMON-LISP::WITH-OPEN-FILE - SLOOP::MAKE-VALUE COMMON-LISP::UNTRACE FPE::PAREN-READER - ANSI-LOOP::WITH-MINIMAX-VALUE COMMON-LISP::NTH - FPE::READ-INSTRUCTION SLOOP::SUM-SLOOP-COLLECT - COMMON-LISP::REMF COMMON-LISP::DESTRUCTURING-BIND - SYSTEM::SET-PATH-STREAM-NAME FPE::RF COMMON-LISP::LOGANDC2)) + SYSTEM::UNIVERSAL-ERROR-HANDLER)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - COMMON-LISP::FCEILING COMMON-LISP::APROPOS-LIST - COMMON-LISP::READ-FROM-STRING - COMMON-LISP::ENSURE-DIRECTORIES-EXIST SYSTEM::APROPOS-DOC - COMMON-LISP::FTRUNCATE SYSTEM::BREAK-FUNCTION - SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE SYSTEM::STEPPER - COMMON-LISP::DECODE-UNIVERSAL-TIME - ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE - COMMON-LISP::STORE-VALUE COMMON-LISP::GET-SETF-EXPANSION - SYSTEM::PRINT-DOC SYSTEM::INFO COMMON-LISP::APROPOS - COMMON-LISP::WRITE-TO-STRING COMMON-LISP::USE-VALUE - COMMON-LISP::FROUND COMMON-LISP::PARSE-NAMESTRING - COMMON-LISP::INVOKE-RESTART COMMON-LISP::FFLOOR - SYSTEM::SHOW-INFO)) \ No newline at end of file + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) + ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS SYSTEM::CHECK-DECLARATIONS + COMMON-LISP::RESTART-NAME ANSI-LOOP::LOOP-COLLECTOR-P + COMMON-LISP::LOGNOT ANSI-LOOP::LOOP-CONSTANTP + COMMON-LISP::COMPILER-MACRO-FUNCTION SYSTEM::IDESCRIBE + COMMON-LISP::FIRST ANSI-LOOP::LOOP-MAKE-DESETQ + ANSI-LOOP::LOOP-COLLECTOR-DTYPE SYSTEM::S-DATA-CONC-NAME + SYSTEM::VERSION-PARSE SYSTEM::IHS-NOT-INTERPRETED-ENV + SYSTEM::EXPAND-HOME-DIR SYSTEM::LOAD-PATHNAME-EXISTS + ANSI-LOOP::LOOP-UNIVERSE-P SYSTEM::SIMPLE-ARRAY-P + COMMON-LISP::FIFTH SYSTEM::BKPT-FILE-LINE + SYSTEM::TRACE-ONE-PREPROCESS + SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY + COMMON-LISP::PROBE-FILE COMMON-LISP::TRUENAME + COMMON-LISP::CONCATENATED-STREAM-STREAMS + SYSTEM::SHOW-ENVIRONMENT COMMON-LISP::NINTH + SYSTEM::INSPECT-NUMBER SYSTEM::DBL-RPL-LOOP + COMMON-LISP::PROVIDE SYSTEM::SETUP-INFO + SLOOP::AVERAGING-SLOOP-MACRO COMMON-LISP::ACOS SYSTEM::LNP + SYSTEM::COERCE-SLASH-TERMINATED SYSTEM::FIND-KCL-TOP-RESTART + ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS SYSTEM::S-DATA-OFFSET + COMMON-LISP::SECOND COMMON-LISP::PHASE SYSTEM::EVAL-FEATURE + ANSI-LOOP::LOOP-PATH-USER-DATA + ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS + ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE SYSTEM::PATCH-SHARP + ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS + COMMON-LISP::COMPILE-FILE-PATHNAME SYSTEM::DIR-P + SYSTEM::PATH-STREAM-NAME COMMON-LISP::CIS SYSTEM::S-DATA-RAW + SYSTEM::S-DATA-SLOT-DESCRIPTIONS SYSTEM::RESTART-TEST-FUNCTION + SYSTEM::KNOWN-TYPE-P + ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED + COMMON-LISP::FILE-WRITE-DATE COMMON-LISP::RATIONAL + ANSI-LOOP::LOOP-UNIVERSE-ITERATION-KEYWORDS + SYSTEM::GET-NEXT-VISIBLE-FUN SLOOP::PARSE-LOOP-INITIALLY + SYSTEM::S-DATA-STATICP COMMON-LISP::BYTE-SIZE + COMMON-LISP::VECTOR-POP COMMON-LISP::PATHNAME + SYSTEM::DIRECTORY-LIST-CHECK + COMMON-LISP::BROADCAST-STREAM-STREAMS + COMMON-LISP::SYNONYM-STREAM-SYMBOL SYSTEM::PNL1 + COMMON-LISP::SEVENTH SYSTEM::INFO-GET-TAGS + ANSI-LOOP::LOOP-TYPED-INIT SYSTEM::WALK-THROUGH + SYSTEM::NUMBER-OF-DAYS-FROM-1900 + ANSI-LOOP::LOOP-EMIT-FINAL-VALUE COMMON-LISP::ASINH + SYSTEM::S-DATA-FROZEN SYSTEM::GET-STRING-INPUT-STREAM-INDEX + SYSTEM::INSTREAM-STREAM SLOOP::LOOP-LET-BINDINGS + COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM + ANSI-LOOP::LOOP-COLLECTOR-CLASS COMMON-LISP::DELETE-FILE + SYSTEM::GET-PATH SYSTEM::LEAP-YEAR-P SYSTEM::REGEXP-CONV + COMMON-LISP::SIXTH COMMON-LISP::ATANH SYSTEM::INFO-GET-FILE + SYSTEM::S-DATA-PRINT-FUNCTION + COMMON-LISP::DIRECTORY-NAMESTRING SYSTEM::INSPECT-CHARACTER + SYSTEM::S-DATA-CONSTRUCTORS ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE + SYSTEM::INSPECT-VECTOR ANSI-LOOP::LOOP-MINIMAX-TYPE + SYSTEM::BKPT-FILE SLOOP::REPEAT-SLOOP-MACRO COMMON-LISP::ABS + COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS + COMMON-LISP::SINH COMMON-LISP::TANH SYSTEM::RESTART-FUNCTION + SLOOP::POINTER-FOR-COLLECT + COMMON-LISP::ECHO-STREAM-INPUT-STREAM + SYSTEM::PRINT-SYMBOL-APROPOS SYSTEM::CHDIR SYSTEM::MLP + ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE FPE::GREF + COMMON-LISP::BYTE-POSITION SYSTEM::INSTREAM-STREAM-NAME + SYSTEM::BKPT-FUNCTION ANSI-LOOP::DESTRUCTURING-SIZE + SYSTEM::NORMALIZE-TYPE ANSI-LOOP::LOOP-EMIT-BODY + SYSTEM::SEARCH-STACK SYSTEM::INSERT-BREAK-POINT + SYSTEM::S-DATA-INCLUDES COMMON-LISP::FOURTH + COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM FPE::ST-LOOKUP + SYSTEM::NODE-OFFSET SYSTEM::S-DATA-TYPE SYSTEM::INSPECT-SYMBOL + SLOOP::TRANSLATE-NAME SYSTEM::S-DATA-NAMED SYSTEM::REAL-ASINH + SYSTEM::TOGGLE-CASE SLOOP::SLOOP-SLOOP-MACRO + ANSI-LOOP::LOOP-DO-THEREIS FPE::LOOKUP SYSTEM::S-DATA-NAME + ANSI-LOOP::LOOP-COLLECTOR-DATA + SYSTEM::BREAK-FORWARD-SEARCH-STACK COMMON-LISP::EIGHTH + ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE + SYSTEM::S-DATA-SLOT-POSITION SYSTEM::INFO-NODE-FROM-POSITION + COMMON-LISP::THIRD SYSTEM::FRS-KIND + SYSTEM::WILD-PATH-ELEMENT-P ANSI-LOOP::LOOP-MAXMIN-COLLECTION + SYSTEM::PRINT-FRS SYSTEM::GET-INSTREAM + SLOOP::SUBSTITUTE-SLOOP-BODY SYSTEM::RESTART-P + COMMON-LISP::FILE-AUTHOR SYSTEM::ADD-TO-HOTLIST + SYSTEM::COMPUTING-ARGS-P COMMON-LISP::FILE-NAMESTRING + SYSTEM::ENSURE-DIR-STRING COMMON-LISP::FIND-ALL-SYMBOLS + SYSTEM::S-DATA-P SYSTEM::BREAK-BACKWARD-SEARCH-STACK + SYSTEM::GET-BYTE-STREAM-NCHARS ANSI-LOOP::LOOP-MAKE-PSETQ + SYSTEM::ALOAD ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA + SYSTEM::MAKE-DEFPACKAGE-FORM COMMON-LISP::ASIN + SYSTEM::WILD-DIR-ELEMENT-P SYSTEM::MAKE-FRAME + ANSI-LOOP::LOOP-PSEUDO-BODY SYSTEM::DIR-CONJ SYSTEM::DBL-EVAL + ANSI-LOOP::LOOP-COLLECTOR-NAME SYSTEM::INSPECT-ARRAY + SYSTEM::DM-KEY-NOT-ALLOWED COMMON-LISP::ARRAY-DIMENSIONS + ANSI-LOOP::LOOP-CONSTRUCT-RETURN COMMON-LISP::LOGICAL-PATHNAME + COMMON-LISP::ACOSH ANSI-LOOP::LOOP-PATH-NAMES + ANSI-LOOP::LOOP-PATH-FUNCTION SYSTEM::CHECK-TRACE-SPEC + COMMON-LISP::ISQRT SYSTEM::NODES-FROM-INDEX SYSTEM::PRINT-IHS + SYSTEM::INSPECT-CONS COMMON-LISP::CONSTANTLY + ANSI-LOOP::LOOP-PATH-P SYSTEM::WILD-NAMESTRING-P + SYSTEM::DM-BAD-KEY ANSI-LOOP::LOOP-MINIMAX-P SYSTEM::SEQTYPE + FPE::XMM-LOOKUP SYSTEM::LOGICAL-PATHNAME-HOST-P + COMMON-LISP::INVOKE-DEBUGGER + ANSI-LOOP::LOOP-UNIVERSE-TYPE-KEYWORDS SYSTEM::INSPECT-STRING + SYSTEM::NEXT-STACK-FRAME ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS + SYSTEM::LOGICAL-PATHNAMEP + ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED + SLOOP::LOOP-COLLECT-KEYWORD-P COMMON-LISP::SIGNUM + SYSTEM::WHICH ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD + SYSTEM::SHORT-NAME SYSTEM::SHOW-BREAK-POINT + SYSTEM::INSPECT-STRUCTURE SYSTEM::S-DATA-INCLUDED + SYSTEM::INSTREAM-P SYSTEM::RE-QUOTE-STRING + SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE + SYSTEM::RESTART-INTERACTIVE-FUNCTION + ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS SYSTEM::UNIQUE-ID + SYSTEM::FIX-LOAD-PATH SLOOP::RETURN-SLOOP-MACRO + ANSI-LOOP::LOOP-COLLECTOR-HISTORY SYSTEM::S-DATA-DOCUMENTATION + SYSTEM::TERMINAL-INTERRUPT COMMON-LISP::TENTH + COMMON-LISP::COMPLEMENT SYSTEM::BEST-ARRAY-ELEMENT-TYPE + SYSTEM::IHS-VISIBLE SYSTEM::LOGICAL-PATHNAME-DESIGNATOR-P + COMMON-LISP::COSH COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS + SYSTEM::BKPT-FORM SYSTEM::FREEZE-DEFSTRUCT + SYSTEM::INSPECT-PACKAGE ANSI-LOOP::LOOP-UNIVERSE-ANSI + SLOOP::PARSE-NO-BODY ANSI-LOOP::LOOP-MINIMAX-OPERATIONS + ANSI-LOOP::LOOP-LIST-COLLECTION SYSTEM::NC + SYSTEM::FIND-DOCUMENTATION SYSTEM::S-DATA-HAS-HOLES + COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM + COMMON-LISP::NAMESTRING COMMON-LISP::HOST-NAMESTRING + SYSTEM::DWIM SYSTEM::MAKE-KCL-TOP-RESTART SLOOP::PARSE-LOOP + SYSTEM::IHS-FNAME COMMON-LISP::STREAM-EXTERNAL-FORMAT + SYSTEM::RESTART-REPORT-FUNCTION COMMON-LISP::FILE-LENGTH + SYSTEM::PROCESS-ARGS ANSI-LOOP::LOOP-HACK-ITERATION + SYSTEM::CONTEXT-P SYSTEM::RESET-TRACE-DECLARATIONS)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) + SYSTEM::BREAK-LOCAL SYSTEM::BREAK-VS + ANSI-LOOP::LOOP-OPTIONAL-TYPE COMMON-LISP::CONTINUE + SYSTEM::BREAK-QUIT SYSTEM::BREAK-PREVIOUS + SYSTEM::DBL-BACKTRACE SYSTEM::INFO-ERROR + COMMON-LISP::MUFFLE-WARNING SYSTEM::SHOW-BREAK-VARIABLES + SYSTEM::BREAK-BDS SYSTEM::IHS-BACKTRACE 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::T) COMMON-LISP::FIXNUM) + SYSTEM::THE-START FPE::REG-LOOKUP SYSTEM::INSTREAM-LINE + SYSTEM::S-DATA-LENGTH SYSTEM::S-DATA-SIZE)) \ No newline at end of file diff --git a/o/alloc.c b/o/alloc.c index 0343ab7..1e1350a 100644 --- a/o/alloc.c +++ b/o/alloc.c @@ -1004,12 +1004,8 @@ alloc_contblock_no_gc(size_t n,char *limit) { } -#ifndef MAX_CODE_ADDRESS -#define MAX_CODE_ADDRESS -1UL -#endif - void * -alloc_code_space(size_t sz) { +alloc_code_space(size_t sz,ufixnum max_code_address) { void *v; @@ -1026,7 +1022,15 @@ alloc_code_space(size_t sz) { } else v=alloc_contblock(sz); - massert(v && (unsigned long)(v+sz)s.s_dbind); return v; diff --git a/o/cfun.c b/o/cfun.c index 05b4cfc..9b946f6 100755 --- a/o/cfun.c +++ b/o/cfun.c @@ -316,6 +316,16 @@ make_si_special_form_internal(char *s, void (*f)()) return(x); } +object +make_macro_internal(char *s, void (*f)()) +{ + object x; + x = make_ordinary(s); + x->s.s_gfdef = make_cfun(f, x, Cnil, NULL, 0); + x->s.s_mflag=TRUE; + return(x); +} + DEFUN_NEW("COMPILED-FUNCTION-NAME",object,fScompiled_function_name,SI ,1,1,NONE,OO,OO,OO,OO,(object fun),"") diff --git a/o/cmac.c b/o/cmac.c index eec704e..b597b6c 100755 --- a/o/cmac.c +++ b/o/cmac.c @@ -21,9 +21,17 @@ object *gclModulus; /* Note: the gclModulus is guaranteed > 0 */ -#define FIX_MOD(X,MOD) {register fixnum MOD_2; \ - if (X > (MOD_2=(MOD >>1))) X=X-MOD; else \ - if (X < -MOD_2) X=X+MOD;} +#define FIX_MOD(X,MOD) { \ + register fixnum MOD_2; \ + if (X > (MOD_2=(MOD>>1))) \ + X=X-MOD; \ + else \ + if (X < -MOD_2) \ + X=X+MOD; \ + else \ + if (X == -MOD_2 && (MOD&0x1)==0) \ + X=X+MOD; \ + } object ctimes(object a, object b),cplus(object a, object b),cdifference(object a, object b),cmod(object x); diff --git a/o/hash.d b/o/hash.d index 4ccaee0..ff208f0 100755 --- a/o/hash.d +++ b/o/hash.d @@ -26,6 +26,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. object sLeq; object sLeql; object sLequal; +object sLequalp; object sKsize; object sKrehash_size; @@ -194,6 +195,144 @@ DEFUN_NEW("HASH-EQUAL",object,fShash_equal,SI,2,2,NONE,OO,IO,OO,OO,(object x,fix RETURN1(make_fixnum(ihash_equal(x,depth))); } +unsigned long +ihash_equalp(object x,int depth) { + + enum type tx; + unsigned long h = 0,j; + long i; + + cs_check(x); + +BEGIN: + if (depth++ <=3) + switch ((tx=type_of(x))) { + case t_cons: + h += ihash_equalp(x->c.c_car,depth); + x = x->c.c_cdr; + goto BEGIN; + break; + case t_symbol: + /* x=coerce_to_string(x); */ + { + ufixnum len=x->st.st_fillp; + uchar *s=(void *)x->st.st_self; + for (;len--;) + h^=rtb[toupper(*s++)]; + } + break; + + case t_package: + break; + + /* case t_simple_string: */ + case t_string: + /* case t_simple_bitvector: */ + /* case t_simple_vector: */ + case t_bitvector: + case t_vector: + h^=ufixhash(j=x->st.st_fillp); + j=j>10 ? 10 : j; + for (i=0;ia.a_rank); + for (i=0;ia.a_dims[i]); + j=x->a.a_dim; + j=j>10 ? 10 : j; + for (i=0;iht.ht_nent); + h^=ufixhash(x->ht.ht_test); + j=j>10 ? 10 : j; + for (i=0;iht.ht_self[i].hte_key!=OBJNULL) + switch (x->ht.ht_test) { + case htt_eq: + h^=(((unsigned long)x->ht.ht_self[i].hte_key)>>3) ^ + ihash_equalp(x->ht.ht_self[i].hte_value,depth); + break; + case htt_eql: + h^=hash_eql(x->ht.ht_self[i].hte_key) ^ + ihash_equalp(x->ht.ht_self[i].hte_value,depth); + break; + case htt_equal: + h^=ihash_equal(x->ht.ht_self[i].hte_key,depth) ^ + ihash_equalp(x->ht.ht_self[i].hte_value,depth); + break; + case htt_equalp: + h^=ihash_equalp(x->ht.ht_self[i].hte_key,depth) ^ + ihash_equalp(x->ht.ht_self[i].hte_value,depth); + break; + } + break; + + case t_pathname: + h^=ihash_equalp(x->pn.pn_host,depth); + h^=ihash_equalp(x->pn.pn_device,depth); + h^=ihash_equalp(x->pn.pn_directory,depth); + h^=ihash_equalp(x->pn.pn_name,depth); + h^=ihash_equalp(x->pn.pn_type,depth); + h^=ihash_equalp(x->pn.pn_version,depth); + break; + + case t_structure: + { + unsigned char *s_type; + struct s_data *def; + def=S_DATA(x->str.str_def); + s_type= & SLOT_TYPE(x->str.str_def,0); + h^=ihash_equalp(def->name,depth); + for (i=0;ilength;i++) + if (s_type[i]==aet_object) + h^=ihash_equalp(x->str.str_self[i],depth); + else + h^=ufixhash((long)x->str.str_self[i]); + break; + } + + case t_character: + { + vs_mark; /*FIXME*/ + object *base=vs_base; + vs_base=vs_top; + vs_push(x); + Lchar_upcase(); + x=vs_base[0]; + vs_base=base; + vs_reset; + h^=hash_eql(x); + break; + } + + case t_fixnum: + case t_bignum: + case t_ratio: + case t_shortfloat: + case t_longfloat: + + h^=hash_eql(make_longfloat(number_to_double(x))); + break; + + default: + h^=hash_eql(x); + break; + } + + return MHSH(h); + +} + + +DEFUN_NEW("HASH-EQUALP",object,fShash_equalp,SI,2,2,NONE,OO,IO,OO,OO,(object x,fixnum depth),"") { + RETURN1(make_fixnum(ihash_equalp(x,depth))); +} struct htent * gethash(object key, object ht) { @@ -227,6 +366,9 @@ gethash(object key, object ht) { case htt_equal: hash_loop(equal,ihash_equal(key,0)); break; + case htt_equalp: + hash_loop(equalp,ihash_equalp(key,0)); + break; default: FEerror( "gethash: Hash table not of type EQ, EQL, or EQUAL." ,0); return &dummy; @@ -341,7 +483,9 @@ DEFUN_NEW("MAKE-HASH-TABLE",object,fLmake_hash_table,LISP,0,63,NONE,OO,OO,OO,OO, else if (test == sLeql || test == sLeql->s.s_gfdef) htt = htt_eql; else if (test == sLequal || test == sLequal->s.s_gfdef) - htt = htt_equal; + htt = htt_equal; + else if (test == sLequalp || test == sLequalp->s.s_gfdef) + htt = htt_equalp; else FEerror("~S is an illegal hash-table test function.", 1, test); @@ -529,7 +673,10 @@ DEFUNM_NEW("NEXT-HASH-TABLE-ENTRY",object,fSnext_hash_table_entry,SI,2,2,NONE,OO DEFUN_NEW("HASH-TABLE-TEST",object,fLhash_table_test,LISP,1,1,NONE,OO,OO,OO,OO,(object table), "Given a HASH-TABLE return a symbol which specifies the function used in its test") -{ switch(table->ht.ht_test) { +{ + check_type_hash_table(&table); + switch(table->ht.ht_test) { + case htt_equalp: RETURN1(sLequalp); case htt_equal: RETURN1(sLequal); case htt_eq: RETURN1(sLeq); case htt_eql: RETURN1(sLeql); @@ -540,6 +687,7 @@ DEFUN_NEW("HASH-TABLE-TEST",object,fLhash_table_test,LISP,1,1,NONE,OO,OO,OO,OO,( DEFUN_NEW("HASH-TABLE-SIZE",object,fLhash_table_size,LISP,1,1,NONE,OO,OO,OO,OO,(object table),"") { + check_type_hash_table(&table); RETURN1(make_fixnum(table->ht.ht_size)); } @@ -564,6 +712,7 @@ gcl_init_hash() sLeq = make_ordinary("EQ"); sLeql = make_ordinary("EQL"); sLequal = make_ordinary("EQUAL"); + sLequalp = make_ordinary("EQUALP"); sKsize = make_keyword("SIZE"); sKtest = make_keyword("TEST"); sKrehash_size = make_keyword("REHASH-SIZE"); diff --git a/o/main.c b/o/main.c index 8bbc5a6..7ea6e6f 100755 --- a/o/main.c +++ b/o/main.c @@ -1229,6 +1229,10 @@ init_main(void) { ADD_FEATURE("STATIC"); #endif +#ifdef LARGE_MEMORY_MODEL + ADD_FEATURE("LARGE-MEMORY-MODEL"); +#endif + make_special("*FEATURES*",features);} make_si_function("SAVE-SYSTEM", siLsave_system); diff --git a/o/num_co.c b/o/num_co.c index 73403a6..e4dd733 100755 --- a/o/num_co.c +++ b/o/num_co.c @@ -63,8 +63,9 @@ gcl_isnormal_double(double d) { } -int gcl_isnormal_float(float f) -{ +int +gcl_isnormal_float(float f) { + union {float f;int i;} u; if (!ISFINITE(f) || !f) @@ -75,6 +76,44 @@ int gcl_isnormal_float(float f) } +static inline int +gcl_isnan_double(double d) { + + if (ISFINITE(d)) + return 0; + if (d==d) + return 0; + return 1; + +} + +static inline int +gcl_isnan_float(float f) { + + if (ISFINITE(f)) + return 0; + if (f==f) + return 0; + return 1; + +} + +int +gcl_isnan(object x) { + + switch(type_of(x)) { + case t_shortfloat: + return gcl_isnan_float(sf(x)); + case t_longfloat: + return gcl_isnan_double(lf(x)); + default: + return 0; + } + +} + + + static void integer_decode_double(double d, int *hp, int *lp, int *ep, int *sp) { diff --git a/o/num_comp.c b/o/num_comp.c index a8c5212..310f730 100755 --- a/o/num_comp.c +++ b/o/num_comp.c @@ -257,8 +257,14 @@ Lnumber_compare(int s, int t) narg = vs_top - vs_base; if (narg == 0) too_few_arguments(); - for (i = 0; i < narg; i++) + for (i = 0; i < narg; i++) { check_type_or_rational_float(&vs_base[i]); + if (gcl_isnan(vs_base[i])) { + vs_top = vs_base+1; + vs_base[0] = Cnil; + return; + } + } for (i = 1; i < narg; i++) if (s*number_compare(vs_base[i], vs_base[i-1]) < t) { vs_top = vs_base+1; diff --git a/o/package.d b/o/package.d index 556257f..0b5bbc9 100755 --- a/o/package.d +++ b/o/package.d @@ -37,27 +37,51 @@ void check_type_or_symbol_string_package(object *); #define P_EXTERNAL(x,j) ((x)->p.p_external[(j) % (x)->p.p_external_size]) - +#define string_eq(a,b) \ + ((a)->st.st_fillp==(b)->st.st_fillp && \ + bcmp((a)->st.st_self,(b)->st.st_self,(a)->st.st_fillp)==0) static bool -member_string_equal(x, l) +member_string_eq(x, l) object x, l; { - for (; type_of(l) == t_cons; l = l->c.c_cdr) - if (string_equal(x, l->c.c_car)) + for (; consp(l); l = l->c.c_cdr) + if (string_eq(x, l->c.c_car)) return(TRUE); return(FALSE); } +static inline object +coerce_to_str(object x) { + + switch(type_of(x)) { + case t_string: + case t_symbol: + return x; + case t_fixnum: + case t_character: + return coerce_to_string(x); + /* printf("foobar\n");fflush(stdout); */ + /* token->st.st_self=(char *)&x->ch.ch_code;/\*FIXME*\/ */ + /* token->st.st_fillp=1; */ + /* return token; */ + default: + TYPE_ERROR(x,TSor_symbol_string); + return Cnil; + } + +} + + static bool designate_package(object x,struct package *p) { switch(type_of(x)) { case t_string: case t_symbol: - return string_equal(x,p->p_name) || member_string_equal(x, p->p_nicknames); + return string_eq(x,p->p_name) || member_string_eq(x, p->p_nicknames); break; case t_character: - return designate_package(coerce_to_string(x),p); + return designate_package(coerce_to_str(x),p); break; case t_package: return x==(object)p; @@ -74,7 +98,7 @@ designate_package(object x,struct package *p) { /* (memchr((a)->st.st_self,'-',(a)->st.st_fillp) || \ */ /* ((a)->st.st_self[0]=='*' && (a)->st.st_fillp==1))) */ -#define check_package_designator(a) if (type_of(a)!=t_string && \ +#define check_package_designator(a) if (!stringp(a) && \ type_of(a)!=t_character && \ type_of(a)!=t_symbol && \ type_of(a)!=t_package) \ @@ -82,10 +106,8 @@ designate_package(object x,struct package *p) { #define check_type_or_symbol_string_package(a) check_package_designator(*a) static void -rehash_pack(ptab,n,m) - object **ptab; - int *n,m; -{ object *ntab; +rehash_pack(object **ptab,int *n,int m) { + object *ntab; object *tab = *ptab; object l,ll; int k,i; @@ -97,7 +119,7 @@ rehash_pack(ptab,n,m) *n=m; while(ic.c_car)%m; ll=l->c.c_cdr; l->c.c_cdr = ntab[j]; @@ -127,11 +149,6 @@ suitable_package_size(int n) and uses packages in list ul, which must be a list of packages or package names i.e. strings or symbols. */ -static void -package_already(object); -static void -no_package(object); - static object make_package(n, ns, ul,isize,esize) object n, ns, ul; @@ -142,15 +159,13 @@ int isize,esize; int i; vs_mark; { BEGIN_NO_INTERRUPT; - if (type_of(n) == t_symbol) { - vs_push(alloc_simple_string(n->s.s_fillp)); - vs_head->st.st_self = n->s.s_self; - n = vs_head; - } - if (type_of(n)==t_character) + BEGIN: n=coerce_to_string(n); - if (find_package(n) != Cnil) - package_already(n); + if (find_package(n) != Cnil) { + PACKAGE_CERROR(n,"Input new package","Package already exists",0); + NEW_INPUT(n); + goto BEGIN; + } x = alloc_object(t_package); x->p.p_name = n; x->p.p_nicknames = Cnil; @@ -166,17 +181,13 @@ int isize,esize; vs_push(x); for (; !endp(ns); ns = ns->c.c_cdr) { - n = ns->c.c_car; - if (type_of(n) == t_symbol) { - vs_push(alloc_simple_string(n->s.s_fillp)); - vs_head->st.st_self = n->s.s_self; - n = vs_head; - } - if (type_of(n)==t_character) - n=coerce_to_string(n); + n = ns->c.c_car; + n=coerce_to_string(n); if (find_package(n) != Cnil) { vs_reset; - package_already(n); + PACKAGE_CERROR(n,"Input new nicknames list","Package already exists",0); + NEW_INPUT(ns); + goto BEGIN; } x->p.p_nicknames = make_cons(n, x->p.p_nicknames); } @@ -185,8 +196,10 @@ int isize,esize; y = ul->c.c_car; else { y = find_package(ul->c.c_car); - if (y == Cnil) - no_package(ul->c.c_car); + if (y == Cnil) { + PACKAGE_CERROR(ul->c.c_car,"Continue anyway","No such package",0); + continue; + } } x->p.p_uselist = make_cons(y, x->p.p_uselist); y->p.p_usedbylist = make_cons(x, y->p.p_usedbylist); @@ -218,30 +231,32 @@ int isize,esize; object x, y; vs_mark; + BEGIN: x = find_package(n); if (x == Cnil) { #ifdef ANSI_COMMON_LISP - FEpackage_error(n,"No such package"); - return Cnil; + PACKAGE_CERROR(n,"Input new package","No such package",0); + NEW_INPUT(n); + goto BEGIN; + return Cnil; #else - x = make_package(n, ns, ul,isize,esize); - goto L; + x = make_package(n, ns, ul,isize,esize); + goto L; #endif } if (isize) rehash_pack(&(x->p.p_internal), &x->p.p_internal_size,isize); for (; !endp(ns); ns = ns->c.c_cdr) { n = ns->c.c_car; - if (type_of(n) == t_symbol) { - vs_push(alloc_simple_string(n->s.s_fillp)); - vs_head->st.st_self = n->s.s_self; - n = vs_head; - } + n=coerce_to_string(n); y = find_package(n); if (x == y) continue; - if (y != Cnil) - package_already(n); + if (y != Cnil) { + PACKAGE_CERROR(n,"Input new nicknames list","Package already exists",0); + NEW_INPUT(ns); + goto BEGIN; + } x->p.p_nicknames = make_cons(n, x->p.p_nicknames); } for (; !endp(ul); ul = ul->c.c_cdr) @@ -262,32 +277,27 @@ object x, n, ns; object y; vs_mark; - if (type_of(n) == t_symbol) { - vs_push(alloc_simple_string(n->s.s_fillp)); - vs_head->st.st_self = n->s.s_self; - n = vs_head; - } - if (type_of(n)==t_character) - n=coerce_to_string(n); + BEGIN: + n=coerce_to_string(n); if (!(equal(x->p.p_name,n)) && - find_package(n) != Cnil) - package_already(n); + find_package(n) != Cnil) { + PACKAGE_CERROR(n,"Input new package","Package already exists",0); + NEW_INPUT(n); + goto BEGIN; + } x->p.p_name = n; x->p.p_nicknames = Cnil; for (; !endp(ns); ns = ns->c.c_cdr) { n = ns->c.c_car; - if (type_of(n) == t_symbol) { - vs_push(alloc_simple_string(n->s.s_fillp)); - vs_head->st.st_self = n->s.s_self; - n = vs_head; - } - if (type_of(n)==t_character) - n=coerce_to_string(n); + n=coerce_to_string(n); y = find_package(n); if (x == y) continue; - if (y != Cnil) - package_already(n); + if (y != Cnil) { + PACKAGE_CERROR(n,"Input nicknames list","Package already exists",0); + NEW_INPUT(ns); + goto BEGIN; + } x->p.p_nicknames = make_cons(n, x->p.p_nicknames); } vs_reset; @@ -322,8 +332,11 @@ object p; if (type_of(p) == t_package) return(p); pp = find_package(p); - if (pp == Cnil) - no_package(p); + if (pp == Cnil) { + PACKAGE_CERROR(p,"Input new package","No such package",0); + NEW_INPUT(p); + return coerce_to_package(p); + } return(pp); } @@ -350,7 +363,8 @@ int pack_hash(x) object x; {unsigned int h=0; - {int len=x->st.st_fillp; + x=coerce_to_str(x); + {int len=x->st.st_fillp; char *s; #define HADD(i,j,k,l) (h+=s[i],h+=s[j]<<8,h+=s[k]<<13,h+=s[l]<<23) #define HADD2(i,j) (h+=s[i]<<5,h+=s[j]<<15) @@ -378,7 +392,35 @@ object x; return(h); }} +DEFUN_NEW("PACK-HASH",fixnum,fSpack_hash,SI,1,1,NONE,IO,OO,OO,OO,(object x),"") { + RETURN1(pack_hash(x)); +} + +DEFUN_NEW("SET-SYMBOL-HPACK",object,fSset_symbol_hpack,SI,2,2,NONE,OO,OO,OO,OO,(object p,object s),"") { + check_type_package(&p); + check_type_sym(&s); + RETURN1(s->s.s_hpack=p); +} + +/* DEFUN_NEW("PACKAGE-INTERNAL",object,fSpackage_internal,SI,2,2,NONE,OO,IO,OO,OO,(object x,fixnum i),"") { */ +/* check_type_package(&x); */ +/* RETURN1(x->p.p_internal[i]); */ +/* } */ + +DEFUN_NEW("PACKAGE-INTERNAL_SIZE",fixnum,fSpackage_internal_size,SI,1,1,NONE,IO,OO,OO,OO,(object x),"") { + check_type_package(&x); + RETURN1(x->p.p_internal_size); +} + +/* DEFUN_NEW("PACKAGE-EXTERNAL",object,fSpackage_external,SI,2,2,NONE,OO,IO,OO,OO,(object x,fixnum i),"") { */ +/* check_type_package(&x); */ +/* RETURN1(x->p.p_external[i]); */ +/* } */ +DEFUN_NEW("PACKAGE-EXTERNAL_SIZE",fixnum,fSpackage_external_size,SI,1,1,NONE,IO,OO,OO,OO,(object x),"") { + check_type_package(&x); + RETURN1(x->p.p_external_size); +} /* Intern(st, p) interns string st in package p. @@ -391,27 +433,25 @@ object st, p; object x, *ip, *ep, l, ul; vs_mark; + st=coerce_to_str(st); {BEGIN_NO_INTERRUPT; j = pack_hash(st); ip = &P_INTERNAL(p ,j); -#define string_eq(a,b) \ - ((a)->st.st_fillp==(b)->st.st_fillp && \ - bcmp((a)->st.st_self,(b)->st.st_self,(a)->st.st_fillp)==0) - for (l = *ip; type_of(l) == t_cons; l = l->c.c_cdr) + for (l = *ip; consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = INTERNAL; END_NO_INTERRUPT;return(l->c.c_car); } ep = &P_EXTERNAL(p,j); - for (l = *ep; type_of(l) == t_cons; l = l->c.c_cdr) + for (l = *ep; consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = EXTERNAL; END_NO_INTERRUPT;return(l->c.c_car); } - for (ul=p->p.p_uselist; type_of(ul)==t_cons; ul=ul->c.c_cdr) + for (ul=p->p.p_uselist; consp(ul); ul=ul->c.c_cdr) for (l = P_EXTERNAL(ul->c.c_car,j); - type_of(l) == t_cons; + consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = INHERITED; @@ -448,23 +488,23 @@ object st, p; int j; object *ip, *ep, l, ul; {BEGIN_NO_INTERRUPT; - if (type_of(st)==t_character) st=coerce_to_string(st); + st=coerce_to_str(st); j = pack_hash(st); ip = &P_INTERNAL(p ,j); - for (l = *ip; type_of(l) == t_cons; l = l->c.c_cdr) + for (l = *ip; consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = INTERNAL; END_NO_INTERRUPT;return(l->c.c_car); } ep = &P_EXTERNAL(p,j); - for (l = *ep; type_of(l) == t_cons; l = l->c.c_cdr) + for (l = *ep; consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = EXTERNAL; END_NO_INTERRUPT;return(l->c.c_car); } - for (ul=p->p.p_uselist; type_of(ul)==t_cons; ul=ul->c.c_cdr) + for (ul=p->p.p_uselist; consp(ul); ul=ul->c.c_cdr) for (l = P_EXTERNAL(ul->c.c_car,j); - type_of(l) == t_cons; + consp(l); l = l->c.c_cdr) if (string_eq(l->c.c_car, st)) { intern_flag = INHERITED; @@ -499,14 +539,16 @@ object s, p; L: x = OBJNULL; - for (l = p->p.p_uselist; type_of(l) == t_cons; l = l->c.c_cdr) { + for (l = p->p.p_uselist; consp(l); l = l->c.c_cdr) { y = find_symbol(s, l->c.c_car); if (intern_flag == EXTERNAL) { if (x == OBJNULL) x = y; - else if (x != y) - FEpackage_error(p,"Cannot unintern the shadowing symbol"\ - "as it will produce a name conflict"); + else if (x != y) { + PACKAGE_CERROR(p,"Input new symbol","Name conflict on unintern of shadowing symbol ~s",1,s); + NEW_INPUT(s); + goto L; + } } } delete_eq(s, &p->p.p_shadowings); @@ -541,15 +583,21 @@ BEGIN: ip = &P_INTERNAL(p ,j); else if (intern_flag == EXTERNAL) return; - } else - FEpackage_error(p,"Symbol not accessible."); + } else { + PACKAGE_CERROR(p,"Input new symbol","Symbol ~s not accessible",1,s); + NEW_INPUT(s); + goto BEGIN; + } for (l = p->p.p_usedbylist; - type_of(l) == t_cons; + consp(l); l = l->c.c_cdr) { - x = find_symbol(s, l->c.c_car); + x = find_symbol(s, l->c.c_car); if (intern_flag && s != x && - !member_eq(x, l->c.c_car->p.p_shadowings)) - FEpackage_error(p,"Cannot export symbol as it will produce a name conflict."); + !member_eq(x, l->c.c_car->p.p_shadowings)) { + PACKAGE_CERROR(p,"Input new symbol","Name conflict on exporting ~s",1,s); + NEW_INPUT(s); + goto BEGIN; + } } if (ip != NULL) {delete_eq(s, ip); @@ -566,11 +614,18 @@ object s, p; object x, *ep, *ip; int j; - if (p == keyword_package) - FEpackage_error(p,"Cannot unexport a symbol from the keyword."); + BEGIN: + if (p == keyword_package) { + PACKAGE_CERROR(p,"Input new package","Cannot unexport a symbol from the keyword",0); + NEW_INPUT(p); + goto BEGIN; + } x = find_symbol(s, p); - if (/* intern_flag != EXTERNAL || */ x != s) - FEpackage_error(p,"Symbol not in package."); + if (/* intern_flag != EXTERNAL || */ x != s) { + PACKAGE_CERROR(p,"Input new symbol","Symbol ~s not in package.",1,s); + NEW_INPUT(s); + goto BEGIN; + } /* "Cannot unexport the symbol ~S~%\ */ /* from ~S,~%\ */ /* because the symbol is not an external symbol~%\ */ @@ -591,17 +646,22 @@ object s, p; int j; object *ip; + BEGIN: x = find_symbol(s, p); if (intern_flag) { - if (x != s) - FEpackage_error(p,"Cannot import symbol as it will produce a name conflict"); - if (intern_flag == INTERNAL || intern_flag == EXTERNAL) - return; + if (x != s) { + PACKAGE_CERROR(p,"Input new symbol","Name conflict on importing ~s",1,s); + NEW_INPUT(s); + goto BEGIN; + } + if (intern_flag == INTERNAL || intern_flag == EXTERNAL) + return; } j = pack_hash(s); ip = &P_INTERNAL(p ,j); p->p.p_internal_fp++; *ip = make_cons(s, *ip); + if (s->s.s_hpack==Cnil) {if (p==keyword_package) s->s.tt=2;s->s.s_hpack=p;} } static void @@ -610,7 +670,7 @@ object s, p; { object x, *ip; - x = find_symbol(s, p); + x=find_symbol(s, p); if (intern_flag && intern_flag != INHERITED) { if (x == s) { if (!member_eq(x, p->p.p_shadowings)) @@ -640,12 +700,12 @@ shadow(s, p) object s, p; { int j; - object *ip; + object *ip,x; - if (type_of(s)==t_character) s=coerce_to_string(s); - find_symbol(s, p); + s=coerce_to_str(s); + x=find_symbol(s, p); if (intern_flag == INTERNAL || intern_flag == EXTERNAL) { - p->p.p_shadowings = make_cons(s, p->p.p_shadowings); + p->p.p_shadowings = make_cons(x, p->p.p_shadowings); return; } j = pack_hash(s); @@ -666,27 +726,36 @@ object x0, p; int i; object y, l; + BEGIN: if (type_of(x) != t_package) { x = find_package(x); - if (x == Cnil) - no_package(x0); + if (x == Cnil) { + PACKAGE_CERROR(x0,"Input new package","No such package",0); + NEW_INPUT(x0); + goto BEGIN; + } + } + if (x == keyword_package) { + PACKAGE_CERROR(x,"Input new package","Cannot use keyword package",0); + NEW_INPUT(x); + goto BEGIN; } - if (x == keyword_package) - FEpackage_error(x,"Cannot use keyword package."); if (p == x) return; if (member_eq(x, p->p.p_uselist)) return; for (i = 0; i < x->p.p_external_size; i++) for (l = P_EXTERNAL(x ,i); - type_of(l) == t_cons; + consp(l); l = l->c.c_cdr) { y = find_symbol(l->c.c_car, p); if (intern_flag && l->c.c_car != y && ! member_eq(y,p->p.p_shadowings) - ) - FEpackage_error(p,"Cannot use package as it will produce" - " a name conflict"); + ) { + PACKAGE_CERROR(p,"Input new package","Name conflict on using ~s from ~s",2,p,y); + NEW_INPUT(p); + goto BEGIN; + } } p->p.p_uselist = make_cons(x, p->p.p_uselist); x->p.p_usedbylist = make_cons(p, x->p.p_usedbylist); @@ -698,10 +767,14 @@ object x0, p; { object x = x0; + BEGIN: if (type_of(x) != t_package) { x = find_package(x); - if (x == Cnil) - no_package(x0); + if (x == Cnil) { + PACKAGE_CERROR(x0,"Input new package","No such package",0); + NEW_INPUT(x0); + goto BEGIN; + } } delete_eq(x, &p->p.p_uselist); delete_eq(p, &x->p.p_usedbylist); @@ -721,9 +794,11 @@ delete_package(object n) { if (p->p_usedbylist!=Cnil) { - FEpackage_error((object)p,"Package used by other packages."); + PACKAGE_CERROR((object)n,"Delete anyway","Package used by other packages",0); + for (t=p->p_usedbylist;!endp(t);t=t->c.c_cdr) unuse_package((object)p,t->c.c_car); + } if (p->p_uselist!=Cnil) { @@ -742,8 +817,11 @@ delete_package(object n) { } - if (type_of(n)!=t_package) - FEpackage_error(n,"No such package."); + if (type_of(n)!=t_package) { + PACKAGE_CERROR(n,"Input new package","No such package",0); + NEW_INPUT(n); + return delete_package(n); + } return(Cnil); @@ -759,7 +837,6 @@ delete_package(object n) { (external `small_fixnum(0)`) ) @ - if (type_of(pack_name)==t_character) pack_name=coerce_to_string(pack_name); check_type_or_string_symbol(&pack_name); @(return `make_package(pack_name, nicknames, use, fix(internal),fix(external))`) @@ -770,18 +847,51 @@ delete_package(object n) { (external `small_fixnum(0)`) ) @ - if (type_of(pack_name)==t_character) pack_name=coerce_to_string(pack_name); check_type_or_string_symbol(&pack_name); if (find_package(pack_name) == Cnil && !(use_sp)) use = make_cons(lisp_package, Cnil); @(return `in_package(pack_name, nicknames, use,fix(internal),fix(external))`) @) -LFD(Lfind_package)() -{ - check_arg(1); +extern object sKuse; +extern object sKnicknames; +DEF_ORDINARY("IN-PACKAGE-INTERNAL",sSin_package_internal,SI,""); +DEFUN_NEW("IN-PACKAGE-INTERNAL",object,fSin_package_internal,SI,2,2,NONE,OO,OO,OO,OO,(object p,object r),"") { + + object use=Cnil,nick=Cnil; + + /*fixme non-std error check?*/ + for (;consp(r) && consp(r->c.c_cdr);r=r->c.c_cdr->c.c_cdr) { + if (r->c.c_car==sKuse) + use=Ieval1(r->c.c_cdr->c.c_car); + if (r->c.c_car==sKnicknames) + nick=Ieval1(r->c.c_cdr->c.c_car); + } + + RETURN1(in_package(p,nick,use,0,0)); + +} + +#ifdef ANSI_COMMON_LISP + +static void +FFN(Fin_package)(void) { - vs_base[0] = find_package(vs_base[0]); + object x; + + if (vs_top-vs_base!=2) + FEwrong_no_args("Fin_package requires two arguments",make_fixnum(vs_top-vs_base)); + x=MMcadr(vs_base[0]); + x=type_of(x)==t_symbol ? list(2,sLquote,x) : x; + vs_base[0]=list(3,sSin_package_internal,x,list(2,sLquote,MMcddr(vs_base[0]))); + vs_top=vs_base+1; + +} + +#endif + +DEFUN_NEW("FIND-PACKAGE",object,fLfind_package,LISP,1,1,NONE,OO,OO,OO,OO,(object x),"") { + RETURN1(find_package(x));/*FIXME p->p_link not exposable in lisp*/ } LFD(Ldelete_package)() @@ -816,7 +926,6 @@ LFD(Lpackage_nicknames)() @ check_package_designator(pack); pack = coerce_to_package(pack); - if (type_of(new_name)==t_character) new_name=coerce_to_string(new_name); check_type_or_string_symbol(&new_name); @(return `rename_package(pack, new_name, new_nicknames)`) @) @@ -921,9 +1030,11 @@ BEGIN: break; case t_cons: - for (l = symbols; !endp(l); l = l->c.c_cdr) - export(l->c.c_car, pack); - break; + for (l = symbols; !endp(l); l = l->c.c_cdr) { + check_type_sym(&l->c.c_car); + export(l->c.c_car, pack); + } + break; default: check_type_sym(&symbols); @@ -947,8 +1058,10 @@ BEGIN: break; case t_cons: - for (l = symbols; !endp(l); l = l->c.c_cdr) - unexport(l->c.c_car, pack); + for (l = symbols; !endp(l); l = l->c.c_cdr) { + check_type_sym(&l->c.c_car); + unexport(l->c.c_car, pack); + } break; default: @@ -1122,20 +1235,6 @@ LFD(siLpackage_external)() vs_popp; } -static void -no_package(n) -object n; -{ - FEwrong_type_argument(TSor_symbol_string_package,n); -} - -static void -package_already(n) -object n; -{ - FEpackage_error(n,"A package with this name already exists."); -} - static void FFN(siLpackage_size)() {object p; @@ -1188,8 +1287,12 @@ gcl_init_package_function() { make_function("MAKE-PACKAGE", Lmake_package); make_function("DELETE-PACKAGE", Ldelete_package); +#ifdef ANSI_COMMON_LISP + make_si_function("KCL-IN-PACKAGE", Lin_package); + make_macro_function("IN-PACKAGE", Fin_package); +#else make_function("IN-PACKAGE", Lin_package); - make_function("FIND-PACKAGE", Lfind_package); +#endif make_function("PACKAGE-NAME", Lpackage_name); make_function("PACKAGE-NICKNAMES", Lpackage_nicknames); make_function("RENAME-PACKAGE", Lrename_package); diff --git a/o/sfaslcoff.c b/o/sfaslcoff.c index cdc3b6b..459c4bb 100644 --- a/o/sfaslcoff.c +++ b/o/sfaslcoff.c @@ -209,7 +209,7 @@ load_memory(struct scnhdr *sec1,struct scnhdr *sece,void *st) { memory=new_cfdata(); memory->cfd.cfd_size=sz; - memory->cfd.cfd_start=alloc_code_space(sz); + memory->cfd.cfd_start=alloc_code_space(sz,-1UL); for (sec=sec1;secs_paddr+=(ul)memory->cfd.cfd_start; diff --git a/o/sfaslelf.c b/o/sfaslelf.c index 5e03dfa..a1b1999 100755 --- a/o/sfaslelf.c +++ b/o/sfaslelf.c @@ -243,6 +243,31 @@ relocate_symbols(Sym *sym,Sym *syme,Shdr *sec1,Shdr *sece,const char *st1) { } +#ifdef LARGE_MEMORY_MODEL + +DEFUN_NEW("MARK-AS-LARGE-MEMORY-MODEL",object,fSmark_as_large_memory_model,SI,1,1, + NONE,OO,OO,OO,OO,(object x),"") { + + FILE *f; + void *ve; + Ehdr *fhp; + + coerce_to_filename(x,FN1); + + massert(f=fopen(FN1,"r+")); + massert(fhp=get_mmap_shared(f,&ve)); + + fhp->e_flags|=1; + + massert(!un_mmap(fhp,ve)); + massert(!fclose(f)); + + return Cnil; + +} + +#endif + static object load_memory(Shdr *sec1,Shdr *sece,void *v1,ul **got,ul **gote) { @@ -274,7 +299,17 @@ load_memory(Shdr *sec1,Shdr *sece,void *v1,ul **got,ul **gote) { memory=new_cfdata(); memory->cfd.cfd_size=sz; - memory->cfd.cfd_start=alloc_code_space(sz); + memory->cfd.cfd_start=alloc_code_space(sz, +#ifdef MAX_DEFAULT_MEMORY_MODEL_CODE_ADDRESS +#ifdef LARGE_MEMORY_MODEL + (((Ehdr *)v1)->e_flags) ? -1UL : MAX_DEFAULT_MEMORY_MODEL_CODE_ADDRESS +#else + MAX_DEFAULT_MEMORY_MODEL_CODE_ADDRESS +#endif +#else + -1UL +#endif + ); a=(ul)memory->cfd.cfd_start; a=(a+ma)&~ma; diff --git a/o/sfaslmacho.c b/o/sfaslmacho.c index ff9da57..c39f52f 100644 --- a/o/sfaslmacho.c +++ b/o/sfaslmacho.c @@ -205,7 +205,7 @@ load_memory(struct section *sec1,struct section *sece,void *v1, memory=new_cfdata(); memory->cfd.cfd_size=sz; - memory->cfd.cfd_start=alloc_code_space(sz); + memory->cfd.cfd_start=alloc_code_space(sz,-1UL); a=(ul)memory->cfd.cfd_start; a=(a+ma)&~ma; diff --git a/o/unixfsys.c b/o/unixfsys.c index 100c445..79d3945 100755 --- a/o/unixfsys.c +++ b/o/unixfsys.c @@ -498,8 +498,8 @@ un_mmap(void *v1,void *ve) { #include -void * -get_mmap(FILE *fp,void **ve) { +static void * +get_mmap_flags(FILE *fp,void **ve,int flags) { int n; void *v1; @@ -508,7 +508,7 @@ get_mmap(FILE *fp,void **ve) { massert((n=fileno(fp))>2); massert(!fstat(n,&ss)); if (sSAload_with_freadA->s.s_dbind==Cnil) { - massert((v1=mmap(0,ss.st_size,PROT_READ|PROT_WRITE,MAP_PRIVATE,n,0))!=(void *)-1); + massert((v1=mmap(0,ss.st_size,PROT_READ|PROT_WRITE,flags,n,0))!=(void *)-1); } else { massert(v1=malloc(ss.st_size)); massert(fread(v1,ss.st_size,1,fp)==1); @@ -519,6 +519,19 @@ get_mmap(FILE *fp,void **ve) { } +void * +get_mmap(FILE *fp,void **ve) { + + return get_mmap_flags(fp,ve,MAP_PRIVATE); + +} + +void * +get_mmap_shared(FILE *fp,void **ve) { + + return get_mmap_flags(fp,ve,MAP_SHARED); + +} int un_mmap(void *v1,void *ve) { diff --git a/pcl/sys-proclaim.lisp b/pcl/sys-proclaim.lisp index 4c3c4fe..489a51a 100644 --- a/pcl/sys-proclaim.lisp +++ b/pcl/sys-proclaim.lisp @@ -1,674 +1,1016 @@ (COMMON-LISP::IN-PACKAGE "PCL") +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) + PCL::RENEW-SYS-FILES PCL::MAKE-ARG-INFO PCL::INITIAL-DFUN-INFO + PCL::BOOTSTRAP-META-BRAID PCL::UPDATE-DISPATCH-DFUNS + PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1 + PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2 + PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST + PCL::STRUCTURE-FUNCTIONS-EXIST-P PCL::SHOW-DFUN-CONSTRUCTORS + PCL::DEFAULT-METHOD-ONLY-DFUN-INFO + PCL::INITIAL-DISPATCH-DFUN-INFO PCL::MAKE-CPD + PCL::%%ALLOCATE-INSTANCE--CLASS PCL::IN-THE-COMPILER-P + PCL::SHOW-EMF-CALL-TRACE PCL::DISPATCH-DFUN-INFO + PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::LIST-ALL-DFUNS + PCL::NO-METHODS-DFUN-INFO PCL::SHOW-FREE-CACHE-VECTORS + PCL::MAKE-CACHE PCL::GET-EFFECTIVE-METHOD-GENSYM + PCL::CACHES-TO-ALLOCATE)) +(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-EFFECTIVE-METHOD-FUNCTION-INTERNAL + PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| + PCL::EMIT-CHECKING-OR-CACHING-FUNCTION + PCL::LOAD-SHORT-DEFCOMBIN + PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))| + PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| + PCL::ACCESSOR-MISS PCL::EMIT-CHECKING-OR-CACHING + PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION + PCL::MAKE-FINAL-CHECKING-DFUN + PCL::GET-ACCESSOR-METHOD-FUNCTION + PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| + PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| + PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| + PCL::BOOTSTRAP-ACCESSOR-DEFINITION + PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| + PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))| + PCL::EXPAND-CACHE PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))| + PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| + PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN + PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION + PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY + PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| + PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN + PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| + PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| + PCL::ACCESSOR-VALUES PCL::REAL-MAKE-METHOD-LAMBDA + PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| + PCL::GENERATE-DISCRIMINATION-NET + PCL::MAKE-SHARED-INITIALIZE-FORM-LIST PCL::ORDER-SPECIALIZERS + PCL::SET-CLASS-SLOT-VALUE-1 + PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| + PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| + PCL::CACHING-MISS + PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION + PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION + PCL::EMIT-READER/WRITER + PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| + PCL::ACCESSOR-VALUES1 PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER + PCL::FIX-SLOT-ACCESSORS PCL::CHECK-METHOD-ARG-INFO + PCL::EMIT-READER/WRITER-FUNCTION PCL::GET-CLASS-SLOT-VALUE-1 + PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| + PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| + PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION + PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN + PCL::MAKE-FINAL-CACHING-DFUN ITERATE::RENAME-VARIABLES + PCL::CHECKING-MISS PCL::GENERATING-LISP + PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| + WALKER::WALK-LET-IF PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P + PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| + PCL::CONVERT-METHODS PCL::SLOT-VALUE-USING-CLASS-DFUN + PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION + WALKER::WALK-FORM-INTERNAL ITERATE::WALK-GATHERING-BODY + PCL::ACCESSOR-VALUES-INTERNAL PCL::CACHE-MISS-VALUES + PCL::CONSTANT-VALUE-MISS + PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION + ITERATE::EXPAND-INTO-LET + PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| + PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| + PCL::LOAD-LONG-DEFCOMBIN + PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| + PCL::SLOT-BOUNDP-USING-CLASS-DFUN + PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| + PCL::SET-SLOT-VALUE + PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| + PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| + PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + PCL::SLOT-VALUE-OR-DEFAULT + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE + PCL::LOAD-DEFGENERIC PCL::MAKE-DEFAULT-INITARGS-FORM-LIST + PCL::GET-SIMPLE-INITIALIZATION-FUNCTION + PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS PCL::CPL-ERROR + PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-CHECKING-DFUN + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION PCL::REAL-ADD-METHOD + PCL::MAKE-FINAL-ACCESSOR-DFUN + PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION + PCL::MAKE-ACCESSOR-TABLE WALKER::NESTED-WALK-FORM + PCL::MAKE-N-N-ACCESSOR-DFUN PCL::TYPES-FROM-ARGUMENTS)) +(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::*) + PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| + PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1 + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| + PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| + PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| + PCL::ADD-METHOD-DECLARATIONS PCL::WALK-METHOD-LAMBDA + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| + PCL::MAKE-INSTANCE-FUNCTION-SIMPLE + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| + PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN + PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| + PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT 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 ADD-BOUNDP-METHOD (SLOT-CLASS T T))| + PCL::MAKE-INSTANCE-FUNCTION-COMPLEX + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| + PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) +(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::*) + 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) PCL::NON-NEGATIVE-FIXNUM) - PCL::CACHE-SIZE PCL::CACHE-MASK PCL::CACHE-NLINES - PCL::CACHE-MAX-LOCATION)) + PCL::CACHE-SIZE PCL::CACHE-NLINES PCL::CACHE-MAX-LOCATION + PCL::CACHE-MASK)) +(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::MAKE-LONG-METHOD-COMBINATION-FUNCTION + PCL::GENERATE-DISCRIMINATION-NET-INTERNAL + PCL::MEMF-CODE-CONVERTER PCL::CACHE-MISS-VALUES-INTERNAL + PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) +(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::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::*) + COMMON-LISP::*) + PCL::GET-SECONDARY-DISPATCH-FUNCTION WALKER::WALK-DECLARATIONS + PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) +(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::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::*) + PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) +(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::MAPC + (COMMON-LISP::LAMBDA (COMPILER::X) + (COMMON-LISP::SETF + (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) + COMMON-LISP::T)) + '(PCL::TRACE-METHOD-INTERNAL PCL::FDEFINE-CAREFULLY + PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST + PCL::DO-STANDARD-DEFSETF-1 PCL::REDEFINE-FUNCTION)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FUNCTION) + PCL::METHOD-CALL-FUNCTION PCL::CACHE-LIMIT-FN + PCL::FAST-METHOD-CALL-FUNCTION)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T) - PCL::COMPILE-LAMBDA-DEFERRED - PCL::EARLY-SLOT-DEFINITION-LOCATION PCL::FGEN-SYSTEM - PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::MAKE-CLASS-EQ-PREDICATE - PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS PCL::USE-CACHING-DFUN-P + PCL::GF-INFO-STATIC-C-A-M-EMF + PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL PCL::FGEN-SYSTEM + PCL::SETFBOUNDP PCL::ONE-CLASS-CACHE PCL::PARSE-SPECIALIZERS + PCL::UNENCAPSULATED-FDEFINITION PCL::INTERN-EQL-SPECIALIZER + PCL::ECD-OTHER-INITARGS SYSTEM::%STRUCTURE-NAME + PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::DEFAULT-STRUCTURE-TYPE + WALKER::VARIABLE-GLOBALLY-SPECIAL-P PCL::INITIALIZE-INFO-P + PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES PCL::COUNT-DFUN + PCL::ONE-CLASS-INDEX PCL::ONE-INDEX-DFUN-INFO-P + PCL::ARG-INFO-LAMBDA-LIST PCL::DNET-METHODS-P + PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION + PCL::ARG-INFO-METATYPES PCL::UNDEFMETHOD-1 + WALKER::ENV-WALK-FORM PCL::INITIALIZE-INFO-CACHED-VALID-P + PCL::STRUCTURE-SVUC-METHOD + PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::EVAL-FORM PCL::DEFAULT-CONSTANTP PCL::SLOT-BOUNDP-SYMBOL + PCL::MAKE-FUNCTION-INLINE PCL::CHECK-WRAPPER-VALIDITY + PCL::COMPUTE-LINE-SIZE PCL::STRUCTURE-SLOT-BOUNDP + PCL::DEFAULT-METHOD-ONLY-CACHE PCL::GF-DFUN-CACHE + PCL::MAKE-CALLS-TYPE-DECLARATION PCL::INITIAL-P + PCL::ACCESSOR-DFUN-INFO-CACHE PCL::EARLY-CLASS-SLOTS + PCL::COMPUTE-STD-CPL-PHASE-2 PCL::STRUCTURE-SLOTD-NAME + PCL::BOOTSTRAP-CLASS-PREDICATES PCL::EARLY-METHOD-QUALIFIERS WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE - PCL::SFUN-P PCL::INTERN-EQL-SPECIALIZER - PCL::ACCESSOR-DFUN-INFO-P WALKER::ENV-WALK-FORM - PCL::ARG-INFO-NUMBER-OPTIONAL PCL::TWO-CLASS-ACCESSOR-TYPE - PCL::FREE-CACHE PCL::SHOW-DFUN-COSTS PCL::CHECKING-CACHE - PCL::EARLY-GF-P PCL::EARLY-COLLECT-CPL PCL::NO-METHODS-CACHE - PCL::EXTRACT-PARAMETERS PCL::DEFAULT-CONSTANTP - PCL::PARSE-SPECIALIZERS - PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION - PCL::DFUN-INFO-P PCL::CLASS-PRECEDENCE-DESCRIPTION-P - PCL::%FBOUNDP PCL::ONE-INDEX-DFUN-INFO-INDEX - PCL::ONE-CLASS-CACHE PCL::DEFAULT-STRUCTURE-INSTANCE-P - PCL::CONSTANT-VALUE-CACHE PCL::STRUCTURE-SVUC-METHOD - PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P - PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P - PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::CCLOSUREP - PCL::COUNT-DFUN PCL::COMPUTE-STD-CPL-PHASE-2 + PCL::MAKE-CONSTANT-FUNCTION PCL::CPD-SUPERS + PCL::INITIAL-DISPATCH-P PCL::METHOD-FUNCTION-METHOD + PCL::MAP-ALL-GENERIC-FUNCTIONS + PCL::STRUCTURE-SLOTD-READER-FUNCTION + PCL::MAKE-PERMUTATION-VECTOR PCL::DISPATCH-P PCL::CHECKING-P + PCL::CHECKING-FUNCTION PCL::FGEN-GENERATOR + PCL::ARG-INFO-NUMBER-OPTIONAL PCL::EXTRACT-PARAMETERS + ITERATE::VARIABLES-FROM-LET PCL::STRUCTURE-TYPE-P + PCL::ONE-INDEX-INDEX PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 + PCL::TWO-CLASS-CACHE PCL::RESET-CLASS-INITIALIZE-INFO + PCL::GET-SETF-FUNCTION-NAME PCL::ARG-INFO-PRECEDENCE + PCL::INITIALIZE-INFO-CACHED-CONSTANTS + PCL::FUNCALLABLE-INSTANCE-P PCL::%FBOUNDP + COMMON-LISP::CLASS-OF PCL::EARLY-CLASS-DEFINITION + PCL::SORT-CALLS PCL::%CCLOSURE-ENV PCL::ACCESSOR-DFUN-INFO-P + PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION + PCL::WRAPPER-FIELD PCL::STRUCTURE-SLOTD-INIT-FORM + PCL::CACHING-CACHE PCL::CHECK-CACHE PCL::TWO-CLASS-P + PCL::ECD-SOURCE PCL::EARLY-METHOD-STANDARD-ACCESSOR-P + PCL::TYPE-CLASS PCL::ECD-METACLASS + PCL::CONSTANT-VALUE-DFUN-INFO PCL::%STD-INSTANCE-WRAPPER + PCL::RESET-CLASS-INITIALIZE-INFO-1 + PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::COMPUTE-CLASS-SLOTS + PCL::UNPARSE-SPECIALIZERS PCL::CONSTANT-VALUE-CACHE + PCL::EARLY-COLLECT-CPL PCL::EXPAND-LONG-DEFCOMBIN + PCL::FUNCTION-RETURNING-T PCL::GET-BUILT-IN-CLASS-SYMBOL + PCL::FAST-METHOD-CALL-ARG-INFO PCL::SHOW-DFUN-COSTS + PCL::CANONICAL-SLOT-NAME PCL::ARG-INFO-APPLYP PCL::ONE-CLASS-P + PCL::FORMAT-CYCLE-REASONS PCL::STRUCTURE-TYPE + PCL::USE-CACHING-DFUN-P PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME + PCL::DFUN-INFO-P PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL + PCL::ECD-CANONICAL-SLOTS PCL::GET-PV-CELL-FOR-CLASS + PCL::ECD-CLASS-NAME PCL::SFUN-P PCL::EARLY-GF-NAME + PCL::DISPATCH-CACHE PCL::NO-METHODS-CACHE PCL::CCLOSUREP + PCL::ARG-INFO-VALID-P PCL::CACHING-DFUN-INFO + PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::SYMBOL-PKG-NAME + PCL::ARG-INFO-KEYWORDS PCL::UPDATE-C-A-M-GF-INFO + PCL::COPY-CACHE PCL::INITIALIZE-INFO-KEY PCL::CHECKING-CACHE PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME - PCL::EARLY-SLOT-DEFINITION-NAME PCL::MAP-SPECIALIZERS - PCL::MAKE-CONSTANT-FUNCTION PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P - PCL::DEFAULT-TEST-CONVERTER - PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES PCL::TWO-CLASS-INDEX - PCL::CACHE-P PCL::ARG-INFO-PRECEDENCE - PCL::STRUCTURE-SLOTD-INIT-FORM PCL::INITIAL-P - PCL::EXTRACT-REQUIRED-PARAMETERS PCL::%STD-INSTANCE-WRAPPER - PCL::FUNCTION-PRETTY-ARGLIST PCL::INTERN-FUNCTION-NAME - PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST - PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::TWO-CLASS-P - PCL::CHECK-CACHE PCL::RESET-INITIALIZE-INFO - PCL::ONE-INDEX-DFUN-INFO-P PCL::LEGAL-CLASS-NAME-P - PCL::UPDATE-PV-TABLE-CACHE-INFO - PCL::RESET-CLASS-INITIALIZE-INFO PCL::DISPATCH-P - PCL::%STD-INSTANCE-SLOTS PCL::SETFBOUNDP PCL::LOOKUP-FGEN - PCL::MAKE-INITFUNCTION PCL::FORCE-CACHE-FLUSHES - PCL::COMPLICATED-INSTANCE-CREATION-METHOD - PCL::NET-TEST-CONVERTER WALKER::ENV-DECLARATIONS - SYSTEM::%STRUCTURE-NAME PCL::GMAKUNBOUND PCL::TWO-CLASS-CACHE - PCL::STRUCTURE-TYPE PCL::CPD-CLASS PCL::CPD-AFTER - PCL::FAST-METHOD-CALL-P PCL::FGEN-GENERATOR-LAMBDA - PCL::CHECKING-FUNCTION PCL::DEFAULT-CONSTANT-CONVERTER - PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 - PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL PCL::EARLY-METHOD-CLASS - PCL::BUILT-IN-WRAPPER-OF PCL::EXPAND-SHORT-DEFCOMBIN - PCL::WRAPPER-OF - PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION - PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION - PCL::PV-TABLEP PCL::EARLY-CLASS-NAME-OF - PCL::GET-MAKE-INSTANCE-FUNCTION PCL::ARG-INFO-KEY/REST-P - PCL::MAKE-EQL-PREDICATE PCL::STRUCTURE-SLOTD-READER-FUNCTION - PCL::CACHING-DFUN-INFO PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE - PCL::N-N-ACCESSOR-TYPE PCL::FAST-METHOD-CALL-PV-CELL + PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P + PCL::MAKE-PV-TYPE-DECLARATION PCL::STRUCTURE-OBJECT-P + PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::UPDATE-GF-INFO + PCL::WRAPPER-FOR-STRUCTURE PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE + PCL::CACHING-DFUN-COST PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE + PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::FREE-CACHE-VECTOR + PCL::GFS-OF-TYPE PCL::MAKE-CALL-METHODS + WALKER::GET-WALKER-TEMPLATE + PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION PCL::METHOD-CALL-P + ITERATE::SEQUENCE-ACCESSOR PCL::METHOD-LL->GENERIC-FUNCTION-LL + PCL::SLOT-WRITER-SYMBOL PCL::NEXT-WRAPPER-FIELD + PCL::DEFAULT-METHOD-ONLY-P + PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE PCL::TWO-CLASS-WRAPPER0 + PCL::WRAPPER-OF PCL::STD-INSTANCE-P PCL::GET-CACHE-VECTOR + PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::FAST-METHOD-CALL-P PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION - PCL::EXTRACT-SPECIALIZER-NAMES PCL::MAKE-TYPE-PREDICATE - PCL::GET-CACHE-VECTOR PCL::SORT-SLOTS - PCL::DEFAULT-STRUCTURE-TYPE SYSTEM::%COMPILED-FUNCTION-NAME - PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS WALKER::ENV-LOCK - PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::ONE-INDEX-P - PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION - PCL::STANDARD-SVUC-METHOD PCL::MAKE-FUNCTION-INLINE - PCL::ALLOCATE-CACHE-VECTOR PCL::SLOT-BOUNDP-SYMBOL - PCL::METHOD-CALL-P PCL::STD-INSTANCE-P - PCL::GET-BUILT-IN-WRAPPER-SYMBOL PCL::FUNCALLABLE-INSTANCE-P - PCL::ECD-CANONICAL-SLOTS PCL::GET-BUILT-IN-CLASS-SYMBOL - PCL::FREE-CACHE-VECTOR PCL::GF-INFO-STATIC-C-A-M-EMF - PCL::EARLY-GF-NAME PCL::UPDATE-CLASS-CAN-PRECEDE-P - PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P - PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ARG-INFO-VALID-P - PCL::ONE-CLASS-INDEX WALKER::GET-WALKER-TEMPLATE - PCL::GFS-OF-TYPE PCL::N-N-P PCL::METHOD-CALL-CALL-METHOD-ARGS - PCL::BOOTSTRAP-CLASS-PREDICATES PCL::MAKE-INITIAL-DFUN - PCL::ONE-CLASS-WRAPPER0 PCL::ECD-OTHER-INITARGS - PCL::TWO-CLASS-WRAPPER1 PCL::MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::FUNCTION-RETURNING-T PCL::STRUCTURE-SLOTD-TYPE - PCL::ARG-INFO-APPLYP PCL::ECD-SUPERCLASS-NAMES - PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME - PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION - PCL::FGEN-GENSYMS PCL::EARLY-METHOD-STANDARD-ACCESSOR-P - PCL::DEFAULT-METHOD-ONLY-CACHE WALKER::ENV-LEXICAL-VARIABLES - PCL::ECD-CLASS-NAME PCL::GET-MAKE-INSTANCE-FUNCTIONS - PCL::EARLY-CLASS-DEFINITION PCL::ECD-METACLASS - PCL::UNDEFMETHOD-1 PCL::MAKE-CALL-METHODS - PCL::METHOD-LL->GENERIC-FUNCTION-LL PCL::SORT-CALLS - ITERATE::VARIABLES-FROM-LET PCL::GF-LAMBDA-LIST - PCL::INITIALIZE-INFO-KEY PCL::EARLY-CLASS-DIRECT-SUBCLASSES - PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE - PCL::MAKE-PERMUTATION-VECTOR PCL::EXTRACT-LAMBDA-LIST - PCL::CONSTANT-VALUE-DFUN-INFO PCL::DNET-METHODS-P - PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME - PCL::UPDATE-GFS-OF-CLASS PCL::SLOT-VECTOR-SYMBOL - PCL::COMPUTE-MCASE-PARAMETERS PCL::GBOUNDP - PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD PCL::CONSTANT-SYMBOL-P - PCL::CPD-SUPERS PCL::DEFAULT-METHOD-ONLY-P - PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::CACHE-OWNER PCL::FAST-INSTANCE-BOUNDP-P - PCL::INITIALIZE-INFO-WRAPPER - PCL::INITIALIZE-INFO-CACHED-VALID-P PCL::EVAL-FORM - PCL::DEFAULT-STRUCTUREP PCL::FUNCTION-RETURNING-NIL - PCL::ONE-CLASS-P PCL::ARG-INFO-KEYWORDS - PCL::EARLY-CLASS-SLOTDS PCL::GET-PV-CELL-FOR-CLASS - PCL::ONE-CLASS-ACCESSOR-TYPE PCL::GENERIC-CLOBBERS-FUNCTION - PCL::DFUN-INFO-CACHE PCL::MAKE-PV-TABLE-TYPE-DECLARATION - PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::CLASS-FROM-TYPE + PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST PCL::N-N-P + PCL::TWO-CLASS-WRAPPER1 PCL::DEFAULT-CONSTANT-CONVERTER + PCL::ONE-INDEX-ACCESSOR-TYPE PCL::CONSTANT-VALUE-P + PCL::CPD-CLASS PCL::ARG-INFO-NKEYS PCL::GMAKUNBOUND + PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION + PCL::INITIAL-DISPATCH-CACHE PCL::GENERIC-CLOBBERS-FUNCTION + PCL::ECD-SUPERCLASS-NAMES PCL::LOOKUP-FGEN + PCL::FLUSH-CACHE-VECTOR-INTERNAL + PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION + PCL::GDEFINITION PCL::UPDATE-ALL-C-A-M-GF-INFO + PCL::FAST-INSTANCE-BOUNDP-P PCL::N-N-ACCESSOR-TYPE PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST + WALKER::ENV-WALK-FUNCTION PCL::CPD-AFTER + PCL::METHOD-FUNCTION-PLIST PCL::ONE-INDEX-DFUN-INFO-INDEX + PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL + PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P + PCL::FREE-CACHE SYSTEM::%COMPILED-FUNCTION-NAME + PCL::MAKE-INITFUNCTION PCL::SORT-SLOTS PCL::KEYWORD-SPEC-NAME + PCL::GF-DFUN-INFO PCL::DEFAULT-STRUCTUREP + PCL::LIST-LARGE-CACHE PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS + PCL::N-N-CACHE PCL::INTERNED-SYMBOL-P PCL::ONE-INDEX-P + PCL::NET-TEST-CONVERTER WALKER::ENV-LOCK + PCL::EXTRACT-LAMBDA-LIST PCL::COMPUTE-MCASE-PARAMETERS + PCL::LEGAL-CLASS-NAME-P PCL::GF-INFO-FAST-MF-P + PCL::ALLOCATE-CACHE-VECTOR PCL::ONE-CLASS-WRAPPER0 PCL::EARLY-METHOD-LAMBDA-LIST - PCL::EARLY-COLLECT-DEFAULT-INITARGS - PCL::COMPILE-LAMBDA-UNCOMPILED - PCL::INITIALIZE-INFO-CACHED-RI-VALID-P PCL::STRUCTURE-TYPE-P - PCL::%SYMBOL-FUNCTION PCL::MAKE-CALLS-TYPE-DECLARATION - PCL::SLOT-READER-SYMBOL PCL::KEYWORD-SPEC-NAME - PCL::FIND-CYCLE-REASONS PCL::UPDATE-ALL-C-A-M-GF-INFO - PCL::INITIALIZE-INFO-P + PCL::METHOD-CALL-CALL-METHOD-ARGS PCL::GBOUNDP + PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS PCL::SLOT-READER-SYMBOL + PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::CACHE-P + PCL::MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::MAKE-PV-TABLE-TYPE-DECLARATION + PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::METHOD-FUNCTION-NEEDS-NEXT-METHODS-P - PCL::INITIAL-DISPATCH-CACHE PCL::CACHING-CACHE - PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS - PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST - PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS PCL::CONSTANT-VALUE-P - PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL PCL::EARLY-CLASS-SLOTS - PCL::UPDATE-C-A-M-GF-INFO PCL::GDEFINITION - PCL::ARG-INFO-LAMBDA-LIST PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL - PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION - PCL::MAKE-PV-TYPE-DECLARATION - PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P PCL::DISPATCH-CACHE - PCL::ONE-INDEX-ACCESSOR-TYPE - PCL::INITIALIZE-INFO-CACHED-CONSTANTS PCL::NO-METHODS-P PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION - PCL::CACHING-DFUN-COST PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE - PCL::COMPUTE-CLASS-SLOTS PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE - PCL::GF-INFO-FAST-MF-P PCL::GF-INFO-C-A-M-EMF-STD-P - PCL::FGEN-TEST PCL::STRUCTURE-SLOTD-NAME PCL::CLASS-PREDICATE - PCL::STRUCTURE-SLOT-BOUNDP PCL::EARLY-CLASS-NAME - PCL::LIST-LARGE-CACHE PCL::ONE-INDEX-CACHE - PCL::SYMBOL-PKG-NAME PCL::INITIAL-CACHE - PCL::UNENCAPSULATED-FDEFINITION PCL::STORE-FGEN - PCL::FINAL-ACCESSOR-DFUN-TYPE - PCL::INITIALIZE-INFO-CACHED-NEW-KEYS PCL::TYPE-CLASS - PCL::%CCLOSURE-ENV PCL::INITIALIZE-INFO-BOUND-SLOTS - PCL::GF-DFUN-CACHE PCL::EXPAND-LONG-DEFCOMBIN - PCL::FGEN-GENERATOR PCL::DFUN-ARG-SYMBOL - PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST - PCL::EARLY-METHOD-QUALIFIERS - WALKER::VARIABLE-GLOBALLY-SPECIAL-P COMMON-LISP::CLASS-OF - PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION - PCL::GET-SETF-FUNCTION-NAME PCL::ARG-INFO-P - WALKER::ENV-WALK-FUNCTION PCL::LIST-DFUN - PCL::CHECK-WRAPPER-VALIDITY PCL::ARG-INFO-METATYPES - PCL::EXPAND-MAKE-INSTANCE-FORM PCL::STRUCTURE-OBJECT-P - PCL::COMPUTE-LINE-SIZE PCL::CANONICAL-SLOT-NAME - PCL::INITIAL-DISPATCH-P PCL::NEXT-WRAPPER-FIELD - PCL::WRAPPER-FIELD PCL::WRAPPER-FOR-STRUCTURE - PCL::METHOD-FUNCTION-PV-TABLE PCL::COPY-CACHE PCL::ECD-SOURCE - PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::UNPARSE-SPECIALIZERS PCL::CHECKING-P - PCL::FORMAT-CYCLE-REASONS PCL::N-N-CACHE - PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION - PCL::MAP-ALL-GENERIC-FUNCTIONS PCL::METHOD-FUNCTION-METHOD - PCL::UPDATE-GF-INFO PCL::ARG-INFO-NKEYS - PCL::TWO-CLASS-WRAPPER0 PCL::GF-DFUN-INFO PCL::ONE-INDEX-INDEX - PCL::EARLY-COLLECT-SLOTS PCL::CACHING-P - PCL::METHOD-FUNCTION-PLIST PCL::SLOT-WRITER-SYMBOL - PCL::FAST-METHOD-CALL-ARG-INFO PCL::INTERNED-SYMBOL-P - ITERATE::SEQUENCE-ACCESSOR)) + PCL::MAKE-CLASS-EQ-PREDICATE PCL::%SYMBOL-FUNCTION + PCL::SLOT-VECTOR-SYMBOL PCL::MAKE-EQL-PREDICATE + PCL::CLASS-PREDICATE + PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION + PCL::ONE-INDEX-CACHE PCL::EARLY-CLASS-PRECEDENCE-LIST + PCL::STANDARD-SVUC-METHOD PCL::EARLY-CLASS-NAME + PCL::INITIALIZE-INFO-WRAPPER + PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS + PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE + PCL::EXPAND-MAKE-INSTANCE-FORM + PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::CONSTANT-SYMBOL-P + PCL::CACHE-OWNER PCL::FGEN-GENSYMS PCL::EARLY-COLLECT-SLOTS + PCL::FGEN-GENERATOR-LAMBDA + PCL::COMPLICATED-INSTANCE-CREATION-METHOD + PCL::RESET-INITIALIZE-INFO PCL::TWO-CLASS-ACCESSOR-TYPE + PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P + PCL::EARLY-METHOD-CLASS PCL::METHOD-FUNCTION-PV-TABLE + PCL::LIST-DFUN PCL::INITIAL-CACHE PCL::PV-TABLEP + PCL::GF-INFO-C-A-M-EMF-STD-P PCL::DFUN-ARG-SYMBOL + PCL::GET-BUILT-IN-WRAPPER-SYMBOL + PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::TWO-CLASS-INDEX + PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS PCL::FGEN-TEST + PCL::FUNCTION-RETURNING-NIL PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P + PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::ARG-INFO-P + PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD + PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST + PCL::CLASS-FROM-TYPE WALKER::ENV-LEXICAL-VARIABLES + PCL::DFUN-INFO-CACHE PCL::INTERN-FUNCTION-NAME + PCL::EARLY-SLOT-DEFINITION-LOCATION PCL::CACHING-P + PCL::NO-METHODS-P PCL::ARG-INFO-KEY/REST-P PCL::GF-LAMBDA-LIST + PCL::EXTRACT-SPECIALIZER-NAMES PCL::EXPAND-SHORT-DEFCOMBIN + PCL::STORE-FGEN PCL::BUILT-IN-WRAPPER-OF + PCL::INITIALIZE-INFO-CACHED-NEW-KEYS PCL::EARLY-CLASS-SLOTDS + PCL::FORCE-CACHE-FLUSHES PCL::EARLY-GF-P + PCL::STRUCTURE-SLOTD-TYPE + PCL::INITIALIZE-INFO-CACHED-RI-VALID-P + PCL::ONE-CLASS-ACCESSOR-TYPE + PCL::CLASS-PRECEDENCE-DESCRIPTION-P WALKER::ENV-DECLARATIONS + PCL::EARLY-SLOT-DEFINITION-NAME PCL::FAST-METHOD-CALL-PV-CELL + PCL::%STD-INSTANCE-SLOTS PCL::EXTRACT-REQUIRED-PARAMETERS + PCL::EARLY-CLASS-NAME-OF PCL::DEFAULT-TEST-CONVERTER + PCL::FUNCTION-PRETTY-ARGLIST)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*) - PCL::LIST-LARGE-CACHES - PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::UNTRACE-METHOD - COMMON-LISP::INVALID-METHOD-ERROR - COMMON-LISP::METHOD-COMBINATION-ERROR)) + PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::MAKE-PROGN + COMMON-LISP::METHOD-COMBINATION-ERROR PCL::UNTRACE-METHOD + PCL::LIST-LARGE-CACHES PCL::FIX-EARLY-GENERIC-FUNCTIONS + COMMON-LISP::INVALID-METHOD-ERROR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) - PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| - PCL::|__si::MAKE-TWO-CLASS| PCL::FALSE PCL::MAKE-PV-TABLE - PCL::|__si::MAKE-DISPATCH| PCL::MAKE-INITIALIZE-INFO - PCL::|__si::MAKE-PV-TABLE| PCL::MAKE-FAST-INSTANCE-BOUNDP - PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| - WALKER::UNBOUND-LEXICAL-FUNCTION - PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| PCL::|__si::MAKE-N-N| - PCL::USE-PACKAGE-PCL PCL::|__si::MAKE-CHECKING| - PCL::|STRUCTURE-OBJECT class constructor| - PCL::|__si::MAKE-CONSTANT-VALUE| - PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::|__si::MAKE-INITIAL| - PCL::|__si::MAKE-CACHE| PCL::|__si::MAKE-ONE-INDEX| - PCL::MAKE-PROGN PCL::TRUE PCL::MAKE-FAST-METHOD-CALL - PCL::|__si::MAKE-ARG-INFO| PCL::INTERN-PV-TABLE - PCL::|__si::MAKE-DFUN-INFO| PCL::|__si::MAKE-STD-INSTANCE| - PCL::|__si::MAKE-CACHING| PCL::|__si::MAKE-ONE-CLASS| - PCL::PV-WRAPPERS-FROM-PV-ARGS PCL::ZERO - PCL::|__si::MAKE-INITIAL-DISPATCH| - PCL::|__si::MAKE-NO-METHODS| PCL::STRING-APPEND - PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| PCL::MAKE-METHOD-CALL - PCL::FIX-EARLY-GENERIC-FUNCTIONS)) + (COMMON-LISP::FUNCTION + (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*) + COMMON-LISP::T) + PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION + PCL::GET-CACHE-FROM-CACHE)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) - PCL::METHOD-PROTOTYPE-FOR-GF PCL::SPECIALIZER-FROM-TYPE - PCL::EMIT-ONE-INDEX-WRITERS PCL::*NORMALIZE-TYPE - PCL::COMPUTE-APPLICABLE-METHODS-EMF PCL::ANALYZE-LAMBDA-LIST - PCL::PARSE-DEFMETHOD PCL::GET-DISPATCH-FUNCTION - PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA - PCL::EMIT-CONSTANT-VALUE PCL::FIND-WRAPPER - PCL::MAKE-FINAL-DISPATCH-DFUN PCL::EARLY-COLLECT-INHERITANCE - PCL::GENERIC-FUNCTION-NAME-P PCL::EMIT-TWO-CLASS-READER - PCL::PARSE-METHOD-GROUP-SPECIFIER PCL::EMIT-ONE-CLASS-READER - PCL::FIND-STRUCTURE-CLASS PCL::EMIT-TWO-CLASS-WRITER - PCL::CONVERT-TO-SYSTEM-TYPE PCL::TYPE-FROM-SPECIALIZER - PCL::EMIT-ONE-CLASS-WRITER PCL::EARLY-METHOD-FUNCTION - PCL::MAKE-DISPATCH-DFUN PCL::NET-CODE-CONVERTER - PCL::GET-GENERIC-FUNCTION-INFO PCL::DEFAULT-CODE-CONVERTER - PCL::COMPILE-IIS-FUNCTIONS PCL::EMIT-ONE-INDEX-READERS - PCL::STRUCTURE-WRAPPER PCL::CLASS-EQ-TYPE - PCL::EMIT-IN-CHECKING-CACHE-P PCL::PCL-DESCRIBE)) + (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 COMMON-LISP::T COMMON-LISP::T) + (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::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 COMMON-LISP::T) COMMON-LISP::T) - ITERATE::RENAME-AND-CAPTURE-VARIABLES - PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| - WALKER::WALK-PROG PCL::INVALIDATE-WRAPPER - PCL::COMPUTE-PRECEDENCE - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| - WALKER::WALK-LAMBDA PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD - PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| - WALKER::WALK-MULTIPLE-VALUE-BIND - PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))| - PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| - PCL::NOTE-PV-TABLE-REFERENCE - PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))| - PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| - WALKER::WALK-MULTIPLE-VALUE-SETQ PCL::CONVERT-TABLE - WALKER::WALK-LET - PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| - PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| - PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| - PCL::SKIP-FAST-SLOT-ACCESS-P - PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| - PCL::OPTIMIZE-SLOT-BOUNDP PCL::TRACE-EMF-CALL-INTERNAL - ITERATE::SIMPLE-EXPAND-GATHERING-FORM - PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - WALKER::WALK-FLET PCL::ONE-CLASS-DFUN-INFO - WALKER::WALK-COMPILER-LET - PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| - PCL::FIRST-FORM-TO-LISP WALKER::WALK-DO* - PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| - PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| - PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| - PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| - PCL::PRINT-STD-INSTANCE - PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| - WALKER::WALK-MACROLET PCL::GET-FUNCTION-GENERATOR - PCL::INITIALIZE-INTERNAL-SLOT-GFS* - PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| - PCL::COMPUTE-EFFECTIVE-METHOD PCL::EXPAND-DEFGENERIC - PCL::OBSOLETE-INSTANCE-TRAP WALKER::WALK-TAGBODY-1 - PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL - PCL::GET-NEW-FUNCTION-GENERATOR PCL::SORT-METHODS - WALKER::WALK-DO PCL::MAKE-DFUN-CALL - PCL::OPTIMIZE-GF-CALL-INTERNAL - PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| - PCL::OPTIMIZE-SET-SLOT-VALUE - PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| - PCL::ENTRY-IN-CACHE-P - PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| - WALKER::WALK-IF PCL::MAKE-METHOD-SPEC PCL::SET-FUNCTION-NAME-1 - WALKER::WALK-SETQ - PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| - PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| - PCL::DECLARE-STRUCTURE PCL::EMIT-BOUNDP-CHECK - WALKER::WALK-LOCALLY - PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION - PCL::CAN-OPTIMIZE-ACCESS PCL::|SETF PCL PLIST-VALUE| - WALKER::WALK-LABELS PCL::EMIT-1-T-DLAP - PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| - PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| - PCL::SORT-APPLICABLE-METHODS - PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - WALKER::WALK-NAMED-LAMBDA ITERATE::OPTIMIZE-ITERATE-FORM - PCL::MAP-ALL-ORDERS - PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| - ITERATE::OPTIMIZE-GATHERING-FORM - PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| - PCL::ONE-INDEX-DFUN-INFO - PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| - PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| - PCL::FLUSH-CACHE-TRAP WALKER::WALK-PROG* - ITERATE::VARIABLE-SAME-P PCL::EMIT-SLOT-READ-FORM - PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| - PCL::EMIT-GREATER-THAN-1-DLAP - PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| - PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS WALKER::WALK-LET* - WALKER::WALK-SYMBOL-MACROLET WALKER::VARIABLE-DECLARATION - PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| - WALKER::RECONS - PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| - PCL::OPTIMIZE-SLOT-VALUE WALKER::RELIST-INTERNAL - PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| - PCL::|SETF PCL METHOD-FUNCTION-GET| WALKER::WALK-TAGBODY - WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL - PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| - PCL::PRINT-CACHE PCL::MAKE-TOP-LEVEL-FORM - PCL::FIX-SLOT-ACCESSORS WALKER::WALK-UNEXPECTED-DECLARE - PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P - PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|)) + PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST PCL::MODIFY-CACHE + PCL::CHECKING-DFUN-INFO WALKER::WALKER-ENVIRONMENT-BIND + PCL::INITIALIZE-INFO-COMBINED-INITIALIZE-FUNCTION + PCL::CACHE-LOCK-COUNT PCL::MAKE-PV-TABLE-INTERNAL + PCL::FIND-CLASS-CELL-CLASS PCL::MAKE-DFUN-LAMBDA-LIST + PCL::WRAPPER-REF PCL::SIMPLE-LEXICAL-METHOD-FUNCTIONS + PCL::INITIAL-CLASSES-AND-WRAPPERS PCL::UPDATE-SLOTS PCL::ASSQ + PCL::ADD-DIRECT-SUBCLASSES PCL::SAUT-NOT-CLASS-EQ + PCL::CHECK-MEMBER PCL::FIN-LAMBDA-FN PCL::INSTANCE-SLOT-INDEX + PCL::SAUT-NOT-CLASS WALKER::VARIABLE-SYMBOL-MACRO-P + COMMON-LISP::SYMBOL-MACROLET PCL::PV-TABLE-LOOKUP + PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION PCL::MCASE + PCL::PRINTING-RANDOM-THING PCL::MAYBE-CHECK-CACHE + WALKER::WITH-NEW-DEFINITION-IN-ENVIRONMENT + PCL::WITH-MAKE-INSTANCE-FUNCTION-VALID-P-CHECK + PCL::WRAPPER-CLASS* PCL::FSC-INSTANCE-WRAPPER + PCL::FUNCALLABLE-INSTANCE-DATA-1 + PCL::|SETF PCL METHOD-FUNCTION-PLIST| + PCL::DEFINE-INITIALIZE-INFO ITERATE::LIST-ELEMENTS + PCL::INSTANCE-READ PCL::EMIT-1-NIL-DLAP + PCL::RESET-INITIALIZE-INFO-INTERNAL + PCL::QUALIFIER-CHECK-RUNTIME PCL::STD-INSTANCE-CLASS + PCL::EMIT-READER/WRITER-MACRO PCL::UNDEFMETHOD PCL::SCASE + PCL::EMIT-DEFAULT-ONLY-MACRO PCL::INSTANCE-WRITE + PCL::PV-BINDING PCL::DELQ PCL::FIND-STANDARD-II-METHOD + PCL::ACCESSOR-SLOT-VALUE PCL::SET-STANDARD-SVUC-METHOD + ITERATE::JOINING PCL::COMPUTE-STD-CPL + PCL::PCL-DESTRUCTURING-BIND PCL::FIND-CLASS-CELL-PREDICATE + PCL::UPDATE-STD-OR-STR-METHODS PCL::EARLY-GF-ARG-INFO + PCL::PRECOMPILE-DFUN-CONSTRUCTORS PCL::FUNCTION-FUNCALL + PCL::DFUN-INFO-FUNCTION PCL::CALLSREF + PCL::UPDATE-ALL-PV-TABLE-CACHES PCL::RASSQ + PCL::REMOVE-DIRECT-SUBCLASSES PCL::MEC-ALL-CLASS-LISTS + PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS ITERATE::SUMMING + PCL::SET-METHODS PCL::WITH-HASH-TABLE + PCL::INITIALIZE-INFO-SHARED-INITIALIZE-NIL-FUNCTION + PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS + PCL::METHOD-FUNCTION-RETURNING-NIL PCL::WRAPPER-STATE + PCL::WITH-LOCAL-CACHE-FUNCTIONS PCL::DFUN-INFO-ACCESSOR-TYPE + PCL::CHECK-WRAPPER-VALIDITY1 PCL::INVALID-WRAPPER-P + PCL::INSTANCE-BOUNDP COMMON-LISP::DEFINE-METHOD-COMBINATION + PCL::DO-SATISFIES-DEFTYPE PCL::EQL-TEST + PCL::PRECOMPILE-IIS-FUNCTIONS + PCL::PRINTING-RANDOM-THING-INTERNAL + PCL::UPDATE-INITIALIZE-INFO-INTERNAL ITERATE::WITH-GATHERING + PCL::BOOTSTRAP-GET-SLOT PCL::INITIALIZE-INFO-CONSTANTS + PCL::GET-INSTANCE-WRAPPER-OR-NIL + PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::VECTORIZING + PCL::N-N-DFUN-INFO PCL::INSTANCE-ACCESSOR-PARAMETER PCL::IF* + PCL::PV-OFFSET PCL::GET-SLOTS PCL::CACHE-NUMBER-VECTOR-REF + PCL::ALLOCATE-STANDARD-INSTANCE--MACRO ITERATE::MINIMIZING + PCL::%SET-CCLOSURE-ENV + PCL::ALLOCATE-FUNCALLABLE-INSTANCE-SLOTS + WALKER::DEFINE-WALKER-TEMPLATE COMMON-LISP::WITH-ACCESSORS + PCL::MAKE-CDXR COMMON-LISP::DEFMETHOD PCL::SYMBOL-LESSP + PCL::INVOKE-FAST-METHOD-CALL + PCL::BIND-SIMPLE-LEXICAL-METHOD-MACROS + PCL::CANONICALIZE-DEFCLASS-OPTION PCL::DESCRIBE-PACKAGE + PCL::%SET-SVREF PCL::FSC-INSTANCE-P PCL::MAKE-DFUN-ARG-LIST + PCL::GET-SLOTS-OR-NIL PCL::WRAPPER-INSTANCE-SLOTS-LAYOUT + PCL::DO-STANDARD-DEFSETF PCL::STD-INSTANCE-SLOTS + PCL::INVOKE-METHOD-CALL1 PCL::PARSE-GSPEC + PCL::ACCESSOR-SET-SLOT-VALUE PCL::DEFINE-CACHED-READER + PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION-SYMBOL + PCL::SET-WRAPPER PCL::SAUT-NOT-PROTOTYPE + PCL::MAKE-CLASS-PREDICATE + PCL::FIRST-WRAPPER-CACHE-NUMBER-INDEX PCL::MDOTIMES + PCL::FUNCTION-APPLY PCL::UPDATE-CLASS PCL::GET-KEY-ARG1 + WALKER::ENVIRONMENT-FUNCTION PCL::DOPLIST + PCL::WRAPPER-CLASS-SLOTS PCL::FMC-FUNCALL + WALKER::VARIABLE-LEXICAL-P COMMON-LISP::ADD-METHOD + PCL::INSTANCE-READER ITERATE::EACHTIME + PCL::CLASSES-HAVE-COMMON-SUBCLASS-P + PCL::INITIALIZE-INFO-INITARGS-FORM-LIST + PCL::REMOVE-SLOT-ACCESSORS PCL::DEFINE-GF-PREDICATE + PCL::CHANGE-CLASS-INTERNAL PCL::INVOKE-METHOD-CALL + PCL::PARSE-QUALIFIER-PATTERN COMMON-LISP::CALL-METHOD + PCL::IIS-BODY PCL::NO-SLOT PCL::WRAPPER-NO-OF-INSTANCE-SLOTS + PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::INSTANCE-WRITE-INTERNAL + PCL::MEMQ PCL::MAP-PV-TABLE-REFERENCES-OF + PCL::|SETF PCL FIND-CLASS| COMMON-LISP::SLOT-EXISTS-P + PCL::WITH-DFUN-WRAPPERS PCL::CLASS-MIGHT-PRECEDE-P + PCL::BOOTSTRAP-SLOT-INDEX PCL::MEC-ALL-CLASSES-INTERNAL + PCL::%SVREF PCL::INITIALIZE-INFO-DEFAULT-INITARGS-FUNCTION + ITERATE::COLLECTING PCL::MAKE-FIND-CLASS-CELL PCL::COMPUTE-PV + PCL::SUPERCLASSES-COMPATIBLE-P + PCL::REDIRECT-EARLY-FUNCTION-INTERNAL + WALKER::WITH-AUGMENTED-ENVIRONMENT PCL::WITHOUT-INTERRUPTS + PCL::CACHE-VECTOR-LOCK-COUNT + SYSTEM::%SET-COMPILED-FUNCTION-NAME PCL::MAKE-WRAPPER-INTERNAL + PCL::ASV-FUNCALL PCL::FUNCALLABLE-INSTANCE-DATA-POSITION + PCL::WRAPPER-CLASS PCL::DFUN-INFO-WRAPPER1 ITERATE::LIST-TAILS + PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION + PCL::DEFCONSTRUCTOR PCL::MAKE-METHOD-FUNCTION + PCL::VALUE-FOR-CACHING PCL::INITIALIZE-INFO-VALID-P + PCL::MAKE-DLAP-LAMBDA-LIST PCL::GET-WRAPPER PCL::*LIST-TAILS + PCL::UPDATE-CPL PCL::SET-STRUCTURE-SVUC-METHOD PCL::POSQ + PCL::SYMBOL-OR-CONS-LESSP PCL::FSC-INSTANCE-SLOTS + PCL::ADD-TO-CVECTOR PCL::AUGMENT-TYPE PCL::DFUN-MISS + PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION-FAST PCL::ALIST-ENTRY + PCL::MEMF-CONSTANT-CONVERTER PCL::PROCLAIM-DEFGENERIC + WALKER::NOTE-LEXICAL-BINDING PCL::WRAPPER-OF-MACRO + ITERATE::MAXIMIZING ITERATE::ELEMENTS + PCL::EXPANDING-MAKE-INSTANCE + PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST + ITERATE::ITERATE PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION + WALKER::WALK-REPEAT-EVAL PCL::%INSTANCE-REF + PCL::INSTANCE-READ-INTERNAL PCL::DFUN-INFO-INDEX + ITERATE::GATHERING PCL::NEQ PCL::FIND-SLOT-DEFINITION + PCL::STD-INSTANCE-WRAPPER + PCL::%ALLOCATE-STATIC-SLOT-STORAGE--CLASS PCL::MEC-ALL-CLASSES + PCL::PVREF PCL::DESTRUCTURE-INTERNAL PCL::CALL-METHOD-LIST + PCL::STANDARD-INSTANCE-ACCESS + PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-MACRO + PCL::WITH-EQ-HASH-TABLE PCL::LIST-EQ + WALKER::VARIABLE-SPECIAL-P PCL::SLOT-SYMBOL + PCL::EARLY-GF-METHODS COMMON-LISP::REMOVE-METHOD + PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION PCL::COPY-PV + PCL::CALL-INITIALIZE-FUNCTION ITERATE::MV-SETQ + PCL::DFUN-INFO-WRAPPER0 PCL::METHOD-FUNCTION-RETURNING-T + PCL::EMIT-CHECKING-OR-CACHING-MACRO + PCL::PRECOMPILE-FUNCTION-GENERATORS PCL::MAKE-PLIST + PCL::COMPUTE-LAYOUT PCL::EXPANDING-MAKE-INSTANCE-TOP-LEVEL + PCL::DOLIST-CAREFULLY PCL::ACCESSOR-SLOT-BOUNDP + PCL::INITIALIZE-INFO-RI-VALID-P PCL::PV-BINDING1 + PCL::CANONICALIZE-SLOT-SPECIFICATION + PCL::REAL-ENSURE-GF-INTERNAL PCL::COPY-INSTANCE-INTERNAL + PCL::REMTAIL ITERATE::PLIST-ELEMENTS + PCL::INSTANCE-BOUNDP-INTERNAL PCL::COLLECTING-ONCE + PCL::CACHE-VECTOR-REF PCL::INSTANCE-REF PCL::MAKE-CAXR + PCL::ADD-FORMS PCL::CLASS-NO-OF-INSTANCE-SLOTS + PCL::|SETF PCL FIND-CLASS-PREDICATE| + PCL::DEAL-WITH-ARGUMENTS-OPTION PCL::TRACE-EMF-CALL + PCL::COMPUTE-CALLS WALKER::ENVIRONMENT-MACRO + PCL::FSC-INSTANCE-CLASS PCL::ADD-SLOT-ACCESSORS + PCL::INSTANCE-WRITER PCL::SWAP-WRAPPERS-AND-SLOTS + PCL::GATHERING1 PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST + PCL::BIND-ARGS PCL::MAKE-CHECKING-OR-CACHING-FUNCTION-LIST + PCL::UPDATE-INITS PCL::DFUN-UPDATE ITERATE::INTERVAL + PCL::COPY-SLOTS COMMON-LISP::DEFGENERIC + WALKER::GET-WALKER-TEMPLATE-INTERNAL PCL::CACHE-VECTOR-SIZE + PCL::VARIABLE-CLASS PCL::NEXT-WRAPPER-CACHE-NUMBER-INDEX + PCL::SAUT-NOT-EQL PCL::PV-WRAPPERS-FROM-ALL-ARGS + ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::PLIST-VALUE + PCL::FUNCALLABLE-INSTANCE-MARKER + PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-EARLY-ACCESSOR + PCL::*LIST-ELEMENTS PCL::PROCLAIM-DEFMETHOD + PCL::|SETF PCL GDEFINITION| PCL::INITIALIZE-INFO-NEW-KEYS + COMMON-LISP::WITH-SLOTS PCL::ESETF PCL::CLASS-TEST + PCL::METHODS-CONVERTER PCL::FAST-LEXICAL-METHOD-FUNCTIONS + PCL::DEFINE-INLINES PCL::MLOOKUP PCL::CLASS-EQ-TEST + PCL::ONCE-ONLY PCL::CLASS-CAN-PRECEDE-P + WALKER::NOTE-DECLARATION PCL::WRAPPER-CACHE-NUMBER-VECTOR-REF + PCL::BUILT-IN-OR-STRUCTURE-WRAPPER + PCL::PRECOMPILE-RANDOM-CODE-SEGMENTS PCL::GET-KEY-ARG + COMMON-LISP::DEFCLASS PCL::ORIGINAL-DEFINITION + PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION + PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER PCL::NET-CONSTANT-CONVERTER + PCL::RAISE-METATYPE PCL::METHOD-FUNCTION-CLOSURE-GENERATOR + PCL::FIND-CLASS-CELL-MAKE-INSTANCE-FUNCTION-KEYS + ITERATE::WHILE PCL::PV-ENV ITERATE::EXTRACT-SPECIAL-BINDINGS + ITERATE::UNTIL + PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRECOMPILED + PCL::WRAPPER-CACHE-NUMBER-VECTOR + PCL::GET-CACHE-VECTOR-LOCK-COUNT + PCL::INITIALIZE-INFO-SHARED-INITIALIZE-T-FUNCTION + PCL::BIND-FAST-LEXICAL-METHOD-MACROS)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + PCL::GET-DFUN-CONSTRUCTOR PCL::ALLOCATE-STRUCTURE-INSTANCE + PCL::COERCE-TO-CLASS WALKER::WALK-FORM + PCL::GET-METHOD-FUNCTION COMMON-LISP::ENSURE-GENERIC-FUNCTION + PCL::MAKE-SPECIALIZABLE PCL::PARSE-METHOD-OR-SPEC + PCL::COMPILE-LAMBDA WALKER::MACROEXPAND-ALL PCL::ENSURE-CLASS + PCL::EXTRACT-DECLARATIONS PCL::MAKE-CONSTANT-VALUE-DFUN + PCL::MAKE-CACHING-DFUN PCL::MAKE-INSTANCE-1 + PCL::MAKE-FINAL-DFUN-INTERNAL PCL::GET-FUNCTION + PCL::MAKE-METHOD-FUNCTION-INTERNAL + PCL::MAKE-METHOD-LAMBDA-INTERNAL PCL::GET-FUNCTION1 + PCL::PARSE-SPECIALIZED-LAMBDA-LIST PCL::DISPATCH-DFUN-COST + PCL::MAP-ALL-CLASSES)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN) + PCL::CACHE-VALUEP)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (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 COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::T) - PCL::GET-DECLARATION - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE - PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION - PCL::GET-METHOD-FUNCTION-PV-CELL - PCL::NAMED-OBJECT-PRINT-FUNCTION - PCL::FIND-CLASS-PREDICATE-FROM-CELL - PCL::GET-EFFECTIVE-METHOD-FUNCTION1 PCL::RECORD-DEFINITION - PCL::PROBE-CACHE PCL::INITIALIZE-INFO PCL::EMIT-MISS - PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION - PCL::FIND-CLASS-FROM-CELL PCL::PRECOMPUTE-EFFECTIVE-METHODS - PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 - PCL::METHOD-FUNCTION-GET PCL::MAP-CACHE - WALKER::CONVERT-MACRO-TO-LAMBDA PCL::MAKE-EMF-FROM-METHOD - PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS - PCL::REAL-ENSURE-GF-USING-CLASS--NULL)) + (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::T) - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL - PCL::BOOTSTRAP-SET-SLOT - PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| - PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - PCL::|(FAST-METHOD PRINT-OBJECT (T T))| - PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - WALKER::WALK-TEMPLATE - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| - PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| - PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| - PCL::OPTIMIZE-WRITER - PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| - PCL::|(FAST-METHOD DOCUMENTATION (T))| - PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| - PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 - PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| - PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::ADJUST-CACHE - WALKER::WALK-PROG/PROG* - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| - PCL::OPTIMIZE-READER - PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| - PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| - WALKER::WALK-BINDINGS-2 PCL::MEMF-TEST-CONVERTER - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| - PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR - PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))| - PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| - PCL::MAKE-DISPATCH-LAMBDA - PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| - PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| - PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - WALKER::WALK-DO/DO* PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE - PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| - PCL::GET-WRAPPERS-FROM-CLASSES - PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::EXPAND-CACHE - PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))| - PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| - PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| - PCL::EXPAND-SYMBOL-MACROLET-INTERNAL - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| - PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))| - WALKER::WALK-LET/LET* - PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| - PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| - PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| - PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| - PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))| - PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| - PCL::EXPAND-DEFCLASS PCL::INITIALIZE-INSTANCE-SIMPLE - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| - PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))| - PCL::MAYBE-EXPAND-ACCESSOR-FORM - PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| - PCL::FILL-CACHE-P - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| - PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| - PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| - PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY - PCL::TWO-CLASS-DFUN-INFO)) + (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T) + PCL::MAKE-PV-TABLE PCL::|__si::MAKE-N-N| + PCL::|__si::MAKE-ONE-CLASS| PCL::|__si::MAKE-ONE-INDEX| + PCL::MAKE-FAST-METHOD-CALL PCL::|__si::MAKE-CACHE| + PCL::|__si::MAKE-CACHING| PCL::|__si::MAKE-ARG-INFO| PCL::ZERO + PCL::MAKE-INITIALIZE-INFO PCL::|__si::MAKE-CONSTANT-VALUE| + WALKER::UNBOUND-LEXICAL-FUNCTION + PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| + PCL::PV-WRAPPERS-FROM-PV-ARGS PCL::FALSE + PCL::|__si::MAKE-DISPATCH| PCL::CALLED-FIN-WITHOUT-FUNCTION + PCL::|__si::MAKE-STD-INSTANCE| PCL::STRING-APPEND + PCL::MAKE-METHOD-CALL PCL::|__si::MAKE-DFUN-INFO| + PCL::|__si::MAKE-INITIAL| PCL::|__si::MAKE-PV-TABLE| + PCL::MAKE-FAST-INSTANCE-BOUNDP + PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| + PCL::|__si::MAKE-NO-METHODS| PCL::USE-PACKAGE-PCL + PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| + PCL::|STRUCTURE-OBJECT class constructor| + PCL::|__si::MAKE-INITIAL-DISPATCH| PCL::TRUE + PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| PCL::INTERN-PV-TABLE + PCL::|__si::MAKE-CHECKING| PCL::|__si::MAKE-TWO-CLASS|)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*) + PCL::EMIT-ONE-INDEX-WRITERS PCL::ANALYZE-LAMBDA-LIST + PCL::FIND-CYCLE-REASONS PCL::MAKE-TYPE-PREDICATE + PCL::FINAL-ACCESSOR-DFUN-TYPE + PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::COMPILE-LAMBDA-DEFERRED PCL::MAP-SPECIALIZERS + PCL::PARSE-DEFMETHOD PCL::CONVERT-TO-SYSTEM-TYPE + PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::GET-MAKE-INSTANCE-FUNCTION PCL::*NORMALIZE-TYPE + PCL::EMIT-ONE-INDEX-READERS + PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION PCL::STRUCTURE-WRAPPER + PCL::NET-CODE-CONVERTER PCL::CLASS-EQ-TYPE + PCL::FIND-STRUCTURE-CLASS PCL::EMIT-TWO-CLASS-WRITER + PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA + PCL::SPECIALIZER-FROM-TYPE PCL::UPDATE-GFS-OF-CLASS + PCL::METHOD-PROTOTYPE-FOR-GF PCL::EMIT-CONSTANT-VALUE + PCL::EMIT-ONE-CLASS-WRITER PCL::EMIT-ONE-CLASS-READER + PCL::MAKE-INITIAL-DFUN PCL::COMPUTE-APPLICABLE-METHODS-EMF + PCL::COMPILE-LAMBDA-UNCOMPILED PCL::GET-GENERIC-FUNCTION-INFO + PCL::FIND-WRAPPER PCL::GET-DISPATCH-FUNCTION + PCL::EARLY-METHOD-FUNCTION PCL::MAKE-DISPATCH-DFUN + PCL::TYPE-FROM-SPECIALIZER PCL::PCL-DESCRIBE + PCL::EMIT-TWO-CLASS-READER PCL::MAKE-FINAL-DISPATCH-DFUN + PCL::EARLY-COLLECT-INHERITANCE PCL::EMIT-IN-CHECKING-CACHE-P + PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION + PCL::GENERIC-FUNCTION-NAME-P PCL::COMPILE-IIS-FUNCTIONS + PCL::PARSE-METHOD-GROUP-SPECIFIER PCL::DEFAULT-CODE-CONVERTER)) (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::EXPAND-EMF-CALL-METHOD - PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| - PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS - PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| - PCL::MAKE-INSTANCE-FUNCTION-COMPLEX - PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| - PCL::UPDATE-SLOTS-IN-PV - PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))| - PCL::MAKE-PARAMETER-REFERENCES - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| - PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1 - PCL::OPTIMIZE-INSTANCE-ACCESS PCL::OPTIMIZE-ACCESSOR-CALL - PCL::OPTIMIZE-GENERIC-FUNCTION-CALL - PCL::REAL-MAKE-METHOD-INITARGS-FORM - PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))| - PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| - PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))| - PCL::COMPUTE-PV-SLOT PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 - PCL::LOAD-FUNCTION-GENERATOR - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| - PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL - PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))| - PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| - WALKER::WALK-BINDINGS-1 PCL::MAKE-INSTANCE-FUNCTION-SIMPLE - PCL::MAKE-FGEN WALKER::WALK-TEMPLATE-HANDLE-REPEAT - PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| - PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| - PCL::MAKE-EMF-CACHE)) + (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::*) + PCL::FIND-FREE-CACHE-LINE)) (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::T) - PCL::BOOTSTRAP-INITIALIZE-CLASS)) + (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::T COMMON-LISP::T - COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) + (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::LIST) + PCL::PV-TABLE-SLOT-NAME-LISTS PCL::PV-TABLE-CALL-LIST + PCL::CACHE-OVERFLOW)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::*) + PCL::ENSURE-CLASS-VALUES + PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR + PCL::REAL-REMOVE-METHOD COMMON-LISP::SLOT-VALUE PCL::SAUT-AND + PCL::COMPUTE-STD-CPL-PHASE-1 PCL::INSURE-DFUN + PCL::CHECK-INITARGS-VALUES PCL::MUTATE-SLOTS-AND-CALLS + PCL::INVOKE-EMF PCL::MAKE-STD-READER-METHOD-FUNCTION + PCL::*SUBTYPEP PCL::MAKE-STD-WRITER-METHOD-FUNCTION + COMMON-LISP::SLOT-BOUNDP PCL::MAKE-INSTANCE-FUNCTION-TRAP + PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::COMPUTE-TEST + PCL::COMPUTE-CODE PCL::UPDATE-SLOT-VALUE-GF-INFO + ITERATE::PARSE-DECLARATIONS COMMON-LISP::SLOT-MAKUNBOUND + PCL::SAUT-PROTOTYPE PCL::COMPUTE-CONSTANTS + PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION + PCL::ACCESSOR-MISS-FUNCTION PCL::SAUT-CLASS-EQ + PCL::SET-FUNCTION-NAME PCL::SAUT-CLASS + PCL::EMIT-DEFAULT-ONLY-FUNCTION PCL::SAUT-EQL + PCL::FORM-LIST-TO-LISP PCL::INITIAL-DFUN + PCL::GF-MAKE-FUNCTION-FROM-EMF + PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL PCL::SAUT-NOT + PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P + PCL::CPL-INCONSISTENT-ERROR + PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P + PCL::SLOT-NAME-LISTS-FROM-SLOTS PCL::DESTRUCTURE + PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION + PCL::MAKE-DIRECT-SLOTD + PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES + PCL::MAKE-UNORDERED-METHODS-EMF PCL::EMIT-CACHING + PCL::EMIT-CHECKING PCL::FIND-SUPERCLASS-CHAIN + PCL::EMIT-DEFAULT-ONLY + PCL::SPLIT-DECLARATIONS PCL::SLOT-UNBOUND-INTERNAL + PCL::SDFUN-FOR-CACHING)) +(COMMON-LISP::PROCLAIM + '(COMMON-LISP::FTYPE + (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - PCL::REAL-LOAD-DEFCLASS PCL::LOAD-DEFCLASS - PCL::OPTIMIZE-GF-CALL PCL::MAKE-EARLY-CLASS-DEFINITION - WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 PCL::EMIT-SLOT-ACCESS - PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION - PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::SET-ARG-INFO1)) + PCL::MAKE-FINAL-DFUN COMMON-LISP::FIND-CLASS WALKER::RELIST + PCL::EARLY-METHOD-SPECIALIZERS PCL::UPDATE-DFUN + PCL::FIND-CLASS-CELL PCL::MAKE-WRAPPER ITERATE::MAYBE-WARN + WALKER::RELIST* PCL::USE-DISPATCH-DFUN-P PCL::TRACE-METHOD + PCL::INITIALIZE-METHOD-FUNCTION + PCL::INITIALIZE-INTERNAL-SLOT-GFS PCL::CAPITALIZE-WORDS + PCL::SET-DFUN PCL::PV-TABLE-LOOKUP-PV-ARGS + PCL::USE-CONSTANT-VALUE-DFUN-P PCL::ALLOCATE-STANDARD-INSTANCE + ITERATE::FUNCTION-LAMBDA-P PCL::MAKE-EARLY-GF + PCL::FIND-CLASS-PREDICATE WALKER::WALKER-ENVIRONMENT-BIND-1 + PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::SET-ARG-INFO + PCL::MAKE-TYPE-PREDICATE-NAME)) (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) - PCL::FILL-CACHE PCL::REAL-GET-METHOD PCL::MAKE-EMF-CALL - PCL::EMIT-FETCH-WRAPPER PCL::CHECK-INITARGS-1 - PCL::CAN-OPTIMIZE-ACCESS1 PCL::CHECK-INITARGS-2-PLIST - PCL::CHECK-INITARGS-2-LIST WALKER::WALK-ARGLIST - PCL::GET-METHOD)) + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| + PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| + PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| + PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| + PCL::INITIALIZE-INSTANCE-SIMPLE + PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))| + PCL::MAYBE-EXPAND-ACCESSOR-FORM WALKER::WALK-LET/LET* + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| + PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))| + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| + PCL::|(FAST-METHOD PRINT-OBJECT (T T))| + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| + PCL::TWO-CLASS-DFUN-INFO + PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| + WALKER::WALK-BINDINGS-2 + PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| + PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| + PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 + PCL::|(FAST-METHOD DOCUMENTATION (T))| + PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| + PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| + PCL::OPTIMIZE-READER + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| + PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| + PCL::OPTIMIZE-WRITER + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| + PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))| + PCL::MAKE-DISPATCH-LAMBDA + PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))| + PCL::MEMF-TEST-CONVERTER + PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| + PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| + PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| + PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| + PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| + PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| + PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| + PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| + PCL::EXPAND-DEFCLASS + PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| + PCL::BOOTSTRAP-SET-SLOT + PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR PCL::FILL-CACHE-P + PCL::GET-WRAPPERS-FROM-CLASSES + PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| + PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| + PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| + PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| + PCL::EXPAND-SYMBOL-MACROLET-INTERNAL + PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))| + WALKER::WALK-PROG/PROG* + PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| + PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| + PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| + PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| + WALKER::WALK-DO/DO* + PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| + PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| + WALKER::WALK-TEMPLATE PCL::ADJUST-CACHE + PCL::LOAD-PRECOMPILED-IIS-ENTRY)) (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) - PCL::GET-SECONDARY-DISPATCH-FUNCTION1 PCL::EMIT-DLAP)) + PCL::CHECK-INITARGS-2-LIST WALKER::WALK-ARGLIST + PCL::EMIT-FETCH-WRAPPER PCL::REAL-GET-METHOD + PCL::CHECK-INITARGS-1 PCL::CAN-OPTIMIZE-ACCESS1 + PCL::FILL-CACHE PCL::GET-METHOD PCL::MAKE-EMF-CALL + PCL::CHECK-INITARGS-2-PLIST)) (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::FILL-DFUN-CACHE PCL::EARLY-ADD-NAMED-METHOD - PCL::REAL-ADD-NAMED-METHOD)) + PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE + PCL::EARLY-ADD-NAMED-METHOD)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::ACCESSOR-VALUES1 PCL::CHECK-METHOD-ARG-INFO - PCL::EMIT-READER/WRITER PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P - PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| - PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION - PCL::CACHE-MISS-VALUES - PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION - PCL::MAKE-FINAL-CACHING-DFUN - PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION - PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| - PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN - PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| - PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| - PCL::ACCESSOR-VALUES-INTERNAL ITERATE::EXPAND-INTO-LET - PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION - PCL::CONSTANT-VALUE-MISS - PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION - WALKER::WALK-LET-IF ITERATE::WALK-GATHERING-BODY - PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER - PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| - PCL::CHECKING-MISS PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN - PCL::GENERATING-LISP ITERATE::RENAME-VARIABLES - PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| - PCL::CONVERT-METHODS PCL::SLOT-VALUE-USING-CLASS-DFUN - PCL::EMIT-READER/WRITER-FUNCTION - PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| - PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| - PCL::CACHING-MISS - PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION - PCL::GET-CLASS-SLOT-VALUE-1 WALKER::WALK-FORM-INTERNAL - PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::LOAD-LONG-DEFCOMBIN - PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| - PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| - PCL::SET-SLOT-VALUE - PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| - PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T - COMMON-LISP::T) - COMMON-LISP::*) - PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN - PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| - PCL::ORDER-SPECIALIZERS - PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| - PCL::EMIT-CHECKING-OR-CACHING - PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| - PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))| - PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| - PCL::GENERATE-DISCRIMINATION-NET - PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))| - PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| - PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| - PCL::GET-ACCESSOR-METHOD-FUNCTION - PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| - PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| - PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN - PCL::EMIT-CHECKING-OR-CACHING-FUNCTION PCL::ACCESSOR-MISS - PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| - PCL::LOAD-SHORT-DEFCOMBIN PCL::MAKE-FINAL-CHECKING-DFUN - PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| - PCL::MAKE-SHARED-INITIALIZE-FORM-LIST - PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))| - PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION - PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| - PCL::ACCESSOR-VALUES PCL::REAL-MAKE-METHOD-LAMBDA - PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| - PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))| - PCL::BOOTSTRAP-ACCESSOR-DEFINITION - PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| - PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN - PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION - PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| - PCL::SET-CLASS-SLOT-VALUE-1)) -(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::*) - PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| - PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| - PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| - PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - PCL::WALK-METHOD-LAMBDA - PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| - PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL - PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| - PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| - PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN - PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| - PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD 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 SHARED-INITIALIZE :BEFORE (CLASS T))| - PCL::ADD-METHOD-DECLARATIONS - PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|)) -(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::T) + PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| + WALKER::WALK-NAMED-LAMBDA WALKER::WALK-MACROLET + PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| + PCL::GET-FUNCTION-GENERATOR + PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| + PCL::ENTRY-IN-CACHE-P PCL::COMPUTE-PRECEDENCE + PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| + PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| + PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| + PCL::TRACE-EMF-CALL-INTERNAL + ITERATE::SIMPLE-EXPAND-GATHERING-FORM + PCL::NOTE-PV-TABLE-REFERENCE + PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| + PCL::OPTIMIZE-GF-CALL-INTERNAL + PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| + WALKER::WALK-COMPILER-LET ITERATE::VARIABLE-SAME-P + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + PCL::SET-FUNCTION-NAME-1 + PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| + PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| + PCL::MAKE-METHOD-SPEC + PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| + PCL::MAP-ALL-ORDERS + PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| + PCL::EMIT-SLOT-READ-FORM WALKER::WALK-LABELS + PCL::EMIT-BOUNDP-CHECK PCL::ONE-CLASS-DFUN-INFO + WALKER::WALK-DO PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL + PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| + WALKER::WALK-PROG PCL::MAKE-TOP-LEVEL-FORM + PCL::COMPUTE-EFFECTIVE-METHOD + PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| + WALKER::WALK-IF + PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| + PCL::MAKE-DFUN-CALL + PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| + PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::WALK-LAMBDA + PCL::OPTIMIZE-SET-SLOT-VALUE + PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| + PCL::EMIT-GREATER-THAN-1-DLAP WALKER::WALK-UNEXPECTED-DECLARE + WALKER::WALK-FLET WALKER::WALK-MULTIPLE-VALUE-BIND + PCL::EMIT-1-T-DLAP PCL::SKIP-FAST-SLOT-ACCESS-P + PCL::CAN-OPTIMIZE-ACCESS + PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| + WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| + PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| + PCL::INITIALIZE-INTERNAL-SLOT-GFS* + PCL::|SETF PCL METHOD-FUNCTION-GET| WALKER::WALK-SETQ + PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION + PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| + PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| + PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P WALKER::WALK-PROG* + PCL::FIRST-FORM-TO-LISP + PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| + PCL::PRINT-STD-INSTANCE + PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| + WALKER::WALK-LET* + PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| + PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| + PCL::OPTIMIZE-SLOT-VALUE PCL::FLUSH-CACHE-TRAP + WALKER::WALK-DO* + PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| + PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| + PCL::|SETF PCL PLIST-VALUE| PCL::GET-NEW-FUNCTION-GENERATOR + PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| + PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| + PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| + ITERATE::RENAME-AND-CAPTURE-VARIABLES PCL::EXPAND-DEFGENERIC + PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| + WALKER::WALK-SYMBOL-MACROLET + PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| + WALKER::WALK-TAGBODY-1 + PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))| + WALKER::WALK-LOCALLY PCL::INVALIDATE-WRAPPER + ITERATE::OPTIMIZE-ITERATE-FORM + PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))| WALKER::WALK-LET + WALKER::RECONS PCL::OBSOLETE-INSTANCE-TRAP + WALKER::VARIABLE-DECLARATION WALKER::WALK-TAGBODY + PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION + PCL::DECLARE-STRUCTURE PCL::SORT-APPLICABLE-METHODS + PCL::OPTIMIZE-SLOT-BOUNDP + PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| + ITERATE::OPTIMIZE-GATHERING-FORM PCL::CONVERT-TABLE + PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| + PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| + PCL::SORT-METHODS PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD + WALKER::RELIST-INTERNAL PCL::PRINT-CACHE + PCL::ONE-INDEX-DFUN-INFO)) (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-EFFECTIVE-METHOD-FUNCTION PCL::LOAD-DEFGENERIC - PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS - PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION - PCL::SLOT-VALUE-OR-DEFAULT PCL::MAKE-CHECKING-DFUN - PCL::MAKE-FINAL-ACCESSOR-DFUN WALKER::NESTED-WALK-FORM - PCL::MAKE-ACCESSOR-TABLE PCL::REAL-ADD-METHOD - PCL::TYPES-FROM-ARGUMENTS - PCL::GET-SIMPLE-INITIALIZATION-FUNCTION PCL::CPL-ERROR - PCL::MAKE-EFFECTIVE-METHOD-FUNCTION - PCL::MAKE-N-N-ACCESSOR-DFUN)) + (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T COMMON-LISP::T) + COMMON-LISP::T) + PCL::REAL-MAKE-METHOD-INITARGS-FORM PCL::COMPUTE-PV-SLOT + PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))| + PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + PCL::OPTIMIZE-ACCESSOR-CALL + PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL + WALKER::WALK-TEMPLATE-HANDLE-REPEAT + PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| + PCL::MAKE-EMF-CACHE + PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| + PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| + PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| + PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))| + WALKER::WALK-BINDINGS-1 + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| + PCL::UPDATE-SLOTS-IN-PV + PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| + PCL::MAKE-PARAMETER-REFERENCES PCL::LOAD-FUNCTION-GENERATOR + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| + PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| + PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))| + PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL + PCL::EXPAND-EMF-CALL-METHOD + PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| + PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 + PCL::OPTIMIZE-GENERIC-FUNCTION-CALL PCL::MAKE-FGEN + PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| + PCL::OPTIMIZE-INSTANCE-ACCESS + PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS + PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| + PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))| + PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) (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::OPTIMIZE-GF-CALL PCL::MAKE-EARLY-CLASS-DEFINITION + PCL::REAL-LOAD-DEFCLASS PCL::EMIT-SLOT-ACCESS + PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 + PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION PCL::SET-ARG-INFO1 + PCL::LOAD-DEFCLASS)) (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::T) - PCL::LOAD-DEFMETHOD-INTERNAL PCL::EXPAND-DEFMETHOD)) + PCL::GET-METHOD-FUNCTION-PV-CELL PCL::RECORD-DEFINITION + PCL::PROBE-CACHE PCL::FIND-CLASS-PREDICATE-FROM-CELL + PCL::EMIT-MISS PCL::INITIALIZE-INFO PCL::MAKE-EMF-FROM-METHOD + PCL::PRECOMPUTE-EFFECTIVE-METHODS + PCL::REAL-ENSURE-GF-USING-CLASS--NULL + PCL::GET-EFFECTIVE-METHOD-FUNCTION1 + PCL::NAMED-OBJECT-PRINT-FUNCTION + WALKER::CONVERT-MACRO-TO-LAMBDA PCL::METHOD-FUNCTION-GET + PCL::GET-DECLARATION PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS + PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::MAP-CACHE + PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION + PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION + PCL::FIND-CLASS-FROM-CELL)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -676,36 +1018,31 @@ COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - PCL::EARLY-MAKE-A-METHOD PCL::LOAD-DEFMETHOD - PCL::MAKE-DEFMETHOD-FORM PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) + PCL::MAKE-DEFMETHOD-FORM-INTERNAL PCL::MAKE-DEFMETHOD-FORM + PCL::LOAD-DEFMETHOD PCL::EARLY-MAKE-A-METHOD)) (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::T COMMON-LISP::T COMMON-LISP::T + COMMON-LISP::T) + COMMON-LISP::T) + PCL::EXPAND-DEFMETHOD PCL::LOAD-DEFMETHOD-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::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::MEMF-CODE-CONVERTER - PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) + (COMMON-LISP::T COMMON-LISP::T + (COMMON-LISP::INTEGER -9223372036854775808 + 9223372036854775807)) + COMMON-LISP::T) + PCL::COMPUTE-STD-CPL-PHASE-3)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (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::FIXNUM) + COMMON-LISP::T) + PCL::GET-CACHE PCL::FILL-CACHE-FROM-CACHE-P)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION @@ -719,386 +1056,56 @@ (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::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::*) COMMON-LISP::T) - PCL::COMPUTE-STD-CPL-PHASE-3)) + PCL::BOOTSTRAP-INITIALIZE-CLASS)) (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::PROCLAIM - '(COMMON-LISP::FTYPE - (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) 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) - PCL::MEC-ALL-CLASS-LISTS PCL::REMOVE-SLOT-ACCESSORS - PCL::PARSE-GSPEC PCL::STANDARD-INSTANCE-ACCESS - PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER - PCL::UPDATE-STD-OR-STR-METHODS PCL::CLASS-MIGHT-PRECEDE-P - PCL::ACCESSOR-SET-SLOT-VALUE PCL::DOPLIST - PCL::ADD-SLOT-ACCESSORS PCL::DFUN-MISS - PCL::FSC-INSTANCE-WRAPPER PCL::CLASS-EQ-TEST - PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION - PCL::MAKE-EARLY-ACCESSOR WALKER::ENVIRONMENT-MACRO - PCL::WITH-DFUN-WRAPPERS PCL::WRAPPER-STATE - PCL::DFUN-INFO-WRAPPER0 - WALKER::WITH-NEW-DEFINITION-IN-ENVIRONMENT PCL::IF* - PCL::CHECK-WRAPPER-VALIDITY1 - PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION-SYMBOL - PCL::BUILT-IN-OR-STRUCTURE-WRAPPER - PCL::FIND-CLASS-CELL-PREDICATE PCL::CLASS-CAN-PRECEDE-P - COMMON-LISP::CALL-METHOD PCL::NET-CONSTANT-CONVERTER - PCL::UPDATE-INITIALIZE-INFO-INTERNAL - PCL::GET-CACHE-VECTOR-LOCK-COUNT PCL::UNDEFMETHOD - PCL::%SET-SVREF PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS - PCL::WRAPPER-NO-OF-INSTANCE-SLOTS PCL::CACHE-VECTOR-LOCK-COUNT - WALKER::VARIABLE-LEXICAL-P PCL::FIN-LAMBDA-FN - PCL::INITIAL-CLASSES-AND-WRAPPERS PCL::MLOOKUP - PCL::RAISE-METATYPE ITERATE::WHILE PCL::EARLY-GF-ARG-INFO - PCL::INVALID-WRAPPER-P WALKER::VARIABLE-SPECIAL-P - PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION - PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRECOMPILED - PCL::INSTANCE-WRITE-INTERNAL WALKER::WALK-REPEAT-EVAL - WALKER::GET-WALKER-TEMPLATE-INTERNAL ITERATE::PLIST-ELEMENTS - PCL::MAKE-FIND-CLASS-CELL COMMON-LISP::WITH-ACCESSORS - PCL::MAKE-METHOD-FUNCTION PCL::SIMPLE-LEXICAL-METHOD-FUNCTIONS - PCL::CANONICALIZE-DEFCLASS-OPTION PCL::UPDATE-INITS PCL::SCASE - PCL::INSTANCE-BOUNDP-INTERNAL PCL::FMC-FUNCALL - PCL::SET-METHODS PCL::CACHE-LOCK-COUNT PCL::GET-WRAPPER - PCL::INVOKE-METHOD-CALL1 PCL::MAKE-CLASS-PREDICATE - PCL::PRINTING-RANDOM-THING PCL::UPDATE-SLOTS - PCL::FUNCTION-APPLY PCL::AUGMENT-TYPE ITERATE::WITH-GATHERING - PCL::CHECKING-DFUN-INFO PCL::LIST-EQ PCL::CACHE-VECTOR-SIZE - PCL::DESCRIBE-PACKAGE PCL::WRAPPER-REF PCL::PLIST-VALUE - PCL::%INSTANCE-REF WALKER::NOTE-DECLARATION - PCL::MAKE-STD-READER-METHOD-FUNCTION - PCL::EMIT-READER/WRITER-MACRO WALKER::ENVIRONMENT-FUNCTION - PCL::N-N-DFUN-INFO - PCL::FIND-CLASS-CELL-MAKE-INSTANCE-FUNCTION-KEYS - PCL::DEFCONSTRUCTOR PCL::INSTANCE-SLOT-INDEX - PCL::CLASS-NO-OF-INSTANCE-SLOTS ITERATE::ELEMENTS - PCL::NEXT-WRAPPER-CACHE-NUMBER-INDEX - PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST - COMMON-LISP::DEFINE-METHOD-COMBINATION PCL::MDOTIMES - PCL::REMOVE-DIRECT-SUBCLASSES PCL::MAKE-WRAPPER-INTERNAL - ITERATE::MAXIMIZING PCL::PV-OFFSET - PCL::DEAL-WITH-ARGUMENTS-OPTION PCL::INSTANCE-READER - PCL::ALLOCATE-STANDARD-INSTANCE--MACRO PCL::DEFINE-INLINES - PCL::WRAPPER-CACHE-NUMBER-VECTOR PCL::GATHERING1 - PCL::FIND-CLASS-CELL-CLASS PCL::SWAP-WRAPPERS-AND-SLOTS - PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION PCL::PV-TABLE-LOOKUP - PCL::WRAPPER-INSTANCE-SLOTS-LAYOUT - WALKER::WALKER-ENVIRONMENT-BIND PCL::COPY-SLOTS PCL::MCASE - PCL::ADD-TO-CVECTOR PCL::ADD-DIRECT-SUBCLASSES - PCL::%SET-CCLOSURE-ENV PCL::PRECOMPILE-RANDOM-CODE-SEGMENTS - PCL::UPDATE-CLASS PCL::SLOT-SYMBOL PCL::VALUE-FOR-CACHING - PCL::EXPANDING-MAKE-INSTANCE-TOP-LEVEL PCL::REMTAIL - PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST - PCL::CLASSES-HAVE-COMMON-SUBCLASS-P - PCL::FIRST-WRAPPER-CACHE-NUMBER-INDEX - PCL::INITIALIZE-INFO-INITARGS-FORM-LIST - PCL::WITH-MAKE-INSTANCE-FUNCTION-VALID-P-CHECK - PCL::FUNCALLABLE-INSTANCE-DATA-1 PCL::SAUT-NOT-EQL - PCL::EARLY-GF-METHODS ITERATE::EXTRACT-SPECIAL-BINDINGS - PCL::MEMQ PCL::DFUN-UPDATE - PCL::MAKE-CHECKING-OR-CACHING-FUNCTION-LIST PCL::ONCE-ONLY - PCL::GET-INSTANCE-WRAPPER-OR-NIL PCL::SYMBOL-LESSP - PCL::|SETF PCL FIND-CLASS| PCL::PARSE-QUALIFIER-PATTERN - ITERATE::SIMPLE-EXPAND-ITERATE-FORM - PCL::INITIALIZE-INFO-SHARED-INITIALIZE-T-FUNCTION - PCL::RESET-INITIALIZE-INFO-INTERNAL - PCL::INITIALIZE-INFO-DEFAULT-INITARGS-FUNCTION - PCL::DESTRUCTURE-INTERNAL PCL::DFUN-INFO-INDEX - PCL::PRECOMPILE-IIS-FUNCTIONS PCL::INSTANCE-WRITE - COMMON-LISP::DEFCLASS PCL::UPDATE-ALL-PV-TABLE-CACHES - PCL::WRAPPER-CACHE-NUMBER-VECTOR-REF - PCL::INITIALIZE-INFO-COMBINED-INITIALIZE-FUNCTION - PCL::MODIFY-CACHE PCL::BOOTSTRAP-SLOT-INDEX - PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::COMPUTE-LAYOUT - PCL::CALL-METHOD-LIST PCL::GET-KEY-ARG ITERATE::LIST-TAILS - PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION ITERATE::EACHTIME - PCL::INSTANCE-REF PCL::WITH-EQ-HASH-TABLE - PCL::QUALIFIER-CHECK-RUNTIME PCL::CALLSREF ITERATE::MV-SETQ - PCL::PRINTING-RANDOM-THING-INTERNAL PCL::CHECK-MEMBER - PCL::INSTANCE-WRITER PCL::CANONICALIZE-SLOT-SPECIFICATION - PCL::BIND-LEXICAL-METHOD-FUNCTIONS ITERATE::LIST-ELEMENTS - PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION-FAST - PCL::INVOKE-METHOD-CALL PCL::INITIALIZE-INFO-RI-VALID-P - PCL::SET-WRAPPER PCL::STD-INSTANCE-CLASS - PCL::EXPANDING-MAKE-INSTANCE PCL::BIND-ARGS - PCL::INITIALIZE-INFO-VALID-P PCL::STD-INSTANCE-WRAPPER - PCL::FSC-INSTANCE-SLOTS PCL::REAL-ENSURE-GF-INTERNAL PCL::NEQ - PCL::PRECOMPILE-DFUN-CONSTRUCTORS PCL::MAKE-DLAP-LAMBDA-LIST - PCL::FIND-SLOT-DEFINITION - PCL::BIND-SIMPLE-LEXICAL-METHOD-MACROS - PCL::ACCESSOR-SLOT-VALUE PCL::METHOD-FUNCTION-RETURNING-NIL - PCL::MAKE-DFUN-LAMBDA-LIST WALKER::VARIABLE-SYMBOL-MACRO-P - PCL::DFUN-INFO-FUNCTION COMMON-LISP::WITH-SLOTS - PCL::FUNCTION-FUNCALL PCL::EQL-TEST - PCL::INITIALIZE-INFO-CONSTANTS PCL::POSQ PCL::DOLIST-CAREFULLY - PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-MACRO PCL::MAKE-CAXR - ITERATE::ITERATE PCL::DEFINE-INITIALIZE-INFO PCL::ALIST-ENTRY - PCL::WITH-LOCAL-CACHE-FUNCTIONS PCL::WRAPPER-OF-MACRO - PCL::RASSQ PCL::SUPERCLASSES-COMPATIBLE-P - PCL::METHOD-FUNCTION-RETURNING-T PCL::CHANGE-CLASS-INTERNAL - PCL::PRECOMPILE-FUNCTION-GENERATORS - WALKER::DEFINE-WALKER-TEMPLATE PCL::CACHE-VECTOR-REF - PCL::GET-SLOTS PCL::MEC-ALL-CLASSES-INTERNAL - COMMON-LISP::SLOT-EXISTS-P PCL::WITHOUT-INTERRUPTS - PCL::MAKE-UNORDERED-METHODS-EMF PCL::GET-KEY-ARG1 - PCL::MAKE-STD-WRITER-METHOD-FUNCTION PCL::COMPUTE-CONSTANTS - PCL::BOOTSTRAP-GET-SLOT PCL::DEFINE-GF-PREDICATE - PCL::REDIRECT-EARLY-FUNCTION-INTERNAL - PCL::SET-STRUCTURE-SVUC-METHOD PCL::WRAPPER-CLASS - ITERATE::UNTIL PCL::PV-BINDING1 PCL::UPDATE-CPL PCL::PV-ENV - PCL::PV-BINDING PCL::INSTANCE-READ-INTERNAL - COMMON-LISP::DEFGENERIC ITERATE::COLLECTING - WALKER::NOTE-LEXICAL-BINDING PCL::ORIGINAL-DEFINITION - PCL::COLLECTING-ONCE PCL::GET-SLOTS-OR-NIL PCL::TRACE-EMF-CALL - PCL::WITH-HASH-TABLE PCL::FUNCALLABLE-INSTANCE-MARKER - PCL::INITIALIZE-INFO-NEW-KEYS PCL::STD-INSTANCE-SLOTS - PCL::ACCESSOR-SLOT-BOUNDP PCL::SAUT-NOT-PROTOTYPE - PCL::MAP-PV-TABLE-REFERENCES-OF COMMON-LISP::ADD-METHOD - PCL::MAKE-CDXR PCL::CALL-INITIALIZE-FUNCTION PCL::ASV-FUNCALL - PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION PCL::IIS-BODY - COMMON-LISP::DEFMETHOD PCL::SYMBOL-OR-CONS-LESSP - PCL::SAUT-NOT-CLASS-EQ PCL::METHODS-CONVERTER PCL::PVREF - PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION - PCL::EMIT-CHECKING-OR-CACHING-MACRO ITERATE::SUMMING - PCL::|SETF PCL GDEFINITION| PCL::ESETF PCL::COPY-PV - PCL::WRAPPER-CLASS* COMMON-LISP::REMOVE-METHOD - PCL::|SETF PCL FIND-CLASS-PREDICATE| - PCL::ACCESSOR-MISS-FUNCTION PCL::MEMF-CONSTANT-CONVERTER - PCL::DELQ PCL::VECTORIZING PCL::MAKE-DFUN-ARG-LIST - PCL::VARIABLE-CLASS PCL::INSTANCE-ACCESSOR-PARAMETER - PCL::ALLOCATE-FUNCALLABLE-INSTANCE-SLOTS - PCL::EMIT-DEFAULT-ONLY-MACRO PCL::NO-SLOT - PCL::MAYBE-CHECK-CACHE PCL::FUNCALLABLE-INSTANCE-DATA-POSITION - PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST - PCL::DO-STANDARD-DEFSETF PCL::SAUT-NOT-CLASS - PCL::DFUN-INFO-ACCESSOR-TYPE PCL::DEFINE-CACHED-READER - PCL::SET-STANDARD-SVUC-METHOD PCL::CLASS-TEST - PCL::MAKE-PV-TABLE-INTERNAL PCL::PROCLAIM-DEFGENERIC - PCL::GF-MAKE-FUNCTION-FROM-EMF PCL::COMPUTE-PV - PCL::EMIT-1-NIL-DLAP PCL::FIND-STANDARD-II-METHOD - PCL::BIND-FAST-LEXICAL-METHOD-MACROS PCL::DO-SATISFIES-DEFTYPE - PCL::FAST-LEXICAL-METHOD-FUNCTIONS PCL::COMPUTE-CALLS - PCL::COPY-INSTANCE-INTERNAL COMMON-LISP::SYMBOL-MACROLET - PCL::FSC-INSTANCE-P PCL::MAKE-PLIST PCL::%SVREF - PCL::PCL-DESTRUCTURING-BIND - SYSTEM::%SET-COMPILED-FUNCTION-NAME ITERATE::JOINING - ITERATE::MINIMIZING PCL::METHOD-FUNCTION-CLOSURE-GENERATOR - PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::*LIST-ELEMENTS - PCL::ADD-FORMS - PCL::INITIALIZE-INFO-SHARED-INITIALIZE-NIL-FUNCTION - ITERATE::INTERVAL PCL::INSTANCE-BOUNDP PCL::FSC-INSTANCE-CLASS - WALKER::WITH-AUGMENTED-ENVIRONMENT - PCL::CACHE-NUMBER-VECTOR-REF - PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION PCL::ASSQ - PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION - PCL::WRAPPER-CLASS-SLOTS PCL::MEC-ALL-CLASSES - ITERATE::GATHERING PCL::INSTANCE-READ PCL::COMPUTE-STD-CPL - PCL::PROCLAIM-DEFMETHOD - PCL::%ALLOCATE-STATIC-SLOT-STORAGE--CLASS PCL::*LIST-TAILS - PCL::|SETF PCL METHOD-FUNCTION-PLIST| - PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS - PCL::DFUN-INFO-WRAPPER1 PCL::INVOKE-FAST-METHOD-CALL)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - PCL::COMPILE-LAMBDA PCL::COERCE-TO-CLASS - PCL::MAKE-METHOD-FUNCTION-INTERNAL - PCL::MAKE-CONSTANT-VALUE-DFUN PCL::GET-FUNCTION - PCL::MAKE-CACHING-DFUN PCL::MAKE-INSTANCE-1 - PCL::MAKE-FINAL-DFUN-INTERNAL WALKER::MACROEXPAND-ALL - COMMON-LISP::ENSURE-GENERIC-FUNCTION PCL::MAP-ALL-CLASSES - PCL::GET-METHOD-FUNCTION PCL::MAKE-METHOD-LAMBDA-INTERNAL - PCL::PARSE-SPECIALIZED-LAMBDA-LIST PCL::GET-FUNCTION1 - WALKER::WALK-FORM PCL::ALLOCATE-STRUCTURE-INSTANCE - PCL::ENSURE-CLASS PCL::GET-DFUN-CONSTRUCTOR - PCL::EXTRACT-DECLARATIONS PCL::DISPATCH-DFUN-COST - PCL::PARSE-METHOD-OR-SPEC)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T) - COMMON-LISP::*) - PCL::SDFUN-FOR-CACHING PCL::SAUT-AND PCL::EMIT-CHECKING - PCL::SPLIT-DECLARATIONS - PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES PCL::COMPUTE-CODE - PCL::*SUBTYPEP ITERATE::PARSE-DECLARATIONS - PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P - PCL::SLOT-NAME-LISTS-FROM-SLOTS COMMON-LISP::SLOT-VALUE - PCL::COMPUTE-STD-CPL-PHASE-1 PCL::SAUT-CLASS - PCL::FORM-LIST-TO-LISP PCL::INITIAL-DFUN - PCL::FIND-SUPERCLASS-CHAIN PCL::EMIT-CACHING PCL::SAUT-NOT - PCL::CHECK-INITARGS-VALUES PCL::REAL-REMOVE-METHOD - PCL::CPL-INCONSISTENT-ERROR COMMON-LISP::SLOT-BOUNDP - PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P - PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::SAUT-CLASS-EQ - PCL::SLOT-UNBOUND-INTERNAL PCL::SAUT-PROTOTYPE - PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR - PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL - PCL::EMIT-DEFAULT-ONLY PCL::CLASS-APPLICABLE-USING-CLASS-P - PCL::COMPUTE-TEST PCL::MUTATE-SLOTS-AND-CALLS - PCL::EMIT-DEFAULT-ONLY-FUNCTION PCL::ENSURE-CLASS-VALUES - PCL::INVOKE-EMF COMMON-LISP::SLOT-MAKUNBOUND - PCL::MAKE-DIRECT-SLOTD PCL::INSURE-DFUN PCL::SET-FUNCTION-NAME - PCL::DESTRUCTURE PCL::SAUT-EQL PCL::UPDATE-SLOT-VALUE-GF-INFO)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*) + COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*) COMMON-LISP::T) - WALKER::RELIST* PCL::UPDATE-DFUN - PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-SPECIALIZABLE - PCL::TRACE-METHOD PCL::ALLOCATE-STANDARD-INSTANCE - WALKER::RELIST COMMON-LISP::FIND-CLASS PCL::MAKE-WRAPPER - PCL::PV-TABLE-LOOKUP-PV-ARGS ITERATE::FUNCTION-LAMBDA-P - PCL::SET-DFUN PCL::EARLY-METHOD-SPECIALIZERS - WALKER::WALKER-ENVIRONMENT-BIND-1 - PCL::INITIALIZE-METHOD-FUNCTION PCL::MAKE-TYPE-PREDICATE-NAME - PCL::MAKE-FINAL-DFUN PCL::FIND-CLASS-CELL - PCL::INITIALIZE-INTERNAL-SLOT-GFS PCL::MAKE-EARLY-GF - PCL::USE-DISPATCH-DFUN-P ITERATE::MAYBE-WARN - PCL::USE-CONSTANT-VALUE-DFUN-P PCL::FIND-CLASS-PREDICATE - PCL::SET-ARG-INFO PCL::CAPITALIZE-WORDS)) + PCL::EMIT-DLAP)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (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 (COMMON-LISP::T) - COMMON-LISP::SIMPLE-VECTOR) - PCL::CACHE-VECTOR)) -(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::OR PCL::CACHE COMMON-LISP::NULL)) - PCL::PV-TABLE-CACHE)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::*) - COMMON-LISP::*) - PCL::FIND-FREE-CACHE-LINE)) -(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::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION - (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*) - COMMON-LISP::T) - PCL::GET-CACHE-FROM-CACHE - PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) -(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::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*) - PCL::EMIT-N-N-WRITERS PCL::COUNT-ALL-DFUNS - PCL::EMIT-N-N-READERS)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T) - PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::RENEW-SYS-FILES - PCL::UPDATE-DISPATCH-DFUNS PCL::IN-THE-COMPILER-P - PCL::SHOW-FREE-CACHE-VECTORS PCL::BOOTSTRAP-BUILT-IN-CLASSES - PCL::MAKE-CACHE PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2 - PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1 - PCL::STRUCTURE-FUNCTIONS-EXIST-P PCL::NO-METHODS-DFUN-INFO - PCL::SHOW-EMF-CALL-TRACE PCL::INITIAL-DFUN-INFO - PCL::DISPATCH-DFUN-INFO PCL::MAKE-ARG-INFO - PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST - PCL::%%ALLOCATE-INSTANCE--CLASS - PCL::INITIAL-DISPATCH-DFUN-INFO PCL::CACHES-TO-ALLOCATE - PCL::MAKE-CPD PCL::LIST-ALL-DFUNS PCL::SHOW-DFUN-CONSTRUCTORS - PCL::BOOTSTRAP-META-BRAID PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) -(COMMON-LISP::PROCLAIM - '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN) - PCL::CACHE-VALUEP)) -(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) COMMON-LISP::FIXNUM) - PCL::ONE-INDEX-LIMIT-FN PCL::EARLY-CLASS-SIZE PCL::CACHE-COUNT - PCL::PV-TABLE-PV-SIZE PCL::DEFAULT-LIMIT-FN - PCL::CHECKING-LIMIT-FN PCL::CACHING-LIMIT-FN - PCL::N-N-ACCESSORS-LIMIT-FN PCL::CPD-COUNT - PCL::FAST-INSTANCE-BOUNDP-INDEX PCL::ARG-INFO-NUMBER-REQUIRED - PCL::PV-CACHE-LIMIT-FN)) + PCL::CACHE-COUNT PCL::ARG-INFO-NUMBER-REQUIRED + PCL::PV-TABLE-PV-SIZE PCL::FAST-INSTANCE-BOUNDP-INDEX + PCL::CACHING-LIMIT-FN PCL::DEFAULT-LIMIT-FN + PCL::CHECKING-LIMIT-FN PCL::EARLY-CLASS-SIZE + PCL::ONE-INDEX-LIMIT-FN PCL::PV-CACHE-LIMIT-FN PCL::CPD-COUNT + PCL::N-N-ACCESSORS-LIMIT-FN)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T) PCL::POWER-OF-TWO-CEILING)) -(COMMON-LISP::MAPC - (COMMON-LISP::LAMBDA (COMPILER::X) - (COMMON-LISP::SETF - (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE) - COMMON-LISP::T)) - '(PCL::TRACE-METHOD-INTERNAL PCL::FDEFINE-CAREFULLY - PCL::REDEFINE-FUNCTION PCL::DO-STANDARD-DEFSETF-1)) -(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::PROCLAIM '(COMMON-LISP::FTYPE - (COMMON-LISP::FUNCTION (COMMON-LISP::T) - (COMMON-LISP::INTEGER 1 255)) - PCL::CACHE-NKEYS)) + (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::T) - (COMMON-LISP::INTEGER 1 256)) - PCL::CACHE-LINE-SIZE)) + COMMON-LISP::SIMPLE-VECTOR) + PCL::CACHE-VECTOR)) (COMMON-LISP::PROCLAIM '(COMMON-LISP::FTYPE (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::T) + (COMMON-LISP::OR PCL::CACHE COMMON-LISP::NULL)) + PCL::PV-TABLE-CACHE)) (IN-PACKAGE "PCL") (DOLIST (V '(|(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)| @@ -1196,104 +1203,104 @@ |(BOUNDP OPTIONS)| |(WRITER METHOD)| |PCL::DEPENDENT-UPDATE-MIXIN class predicate| GENERIC-FUNCTION-PRETTY-ARGLIST |(WRITER SOURCE)| - |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| - |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| - |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| |(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))| - |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| |(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))| - |(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))| - |(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))| - |(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| + |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))| + |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))| + |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))| + |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))| |(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER 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 SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))| + |(FAST-METHOD SPECIALIZER-CLASS (EQL-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 (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))| + |(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| + |(FAST-METHOD CHANGE-CLASS (T SYMBOL))| + |(FAST-METHOD MAKE-INSTANCE (SYMBOL))| + |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| + |(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))| + |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| + |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| + |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| + |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| + |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| + |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T 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-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 SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD SLOT-MAKUNBOUND-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 GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| - |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| - |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| - |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| - |(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| - |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| + |(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| + |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| |(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| |(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))| + |(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| |(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))| - |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))| |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))| - |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))| - |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))| - |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))| - |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))| - |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))| - |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))| - |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))| - |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))| - |(FAST-METHOD METHOD-PRETTY-ARGLIST (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 MAKE-INSTANCE (SYMBOL))| - |(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))| - |(FAST-METHOD CHANGE-CLASS (T SYMBOL))| - |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))| + |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))| + |(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| + |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))| + |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))| + |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))| + |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))| + |(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| + |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| + |(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| + |(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))| - |(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| + |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD MAKE-INSTANCE (CLASS))| + |(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| + |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| + |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| + |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| + |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| + |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| + |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| + |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| + |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| + |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| + |(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| + |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))| + |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| + |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| + |(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))| + |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| + |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + |(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| + |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))| + |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| + |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))| - |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))| - |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))| + |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| + |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))| - |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))| - |(FAST-METHOD SPECIALIZER-CLASS (CLASS))| - |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))| - |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))| - |(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))| - |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))| - |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))| - |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| - |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))| |(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))| - |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))| - |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))| - |(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| - |(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))| - |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))| - |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))| |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))| - |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))| - |(FAST-METHOD MAKE-INSTANCE (CLASS))| - |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))| - |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))| - |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))| - |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))| - |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))| - |(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))| - |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))| - |(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))| - |(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))| - |(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))| - |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))| + |(FAST-METHOD SPECIALIZER-CLASS (CLASS))| + |(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))| + |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))| + |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))| CLASS-PREDICATE-NAME |PCL::STRUCTURE-SLOT-DEFINITION class predicate| |PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate| @@ -1583,90 +1590,90 @@ GENERIC-FUNCTION-P |PCL::SLOT-DEFINITION class predicate| |(READER NAME)| |(READER CLASS)| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| + |(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))| + |(FAST-METHOD SLOT-MISSING (T T T T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| + |(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| + |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| + |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| + |(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| + |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| + |(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| + |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))| + |(FAST-METHOD DESCRIBE-OBJECT (T T))| + |(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| + |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| + |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| + |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| + |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| + |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| + |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| + |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| + |(FAST-METHOD (SETF DOCUMENTATION) (T T))| + |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| + |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))| - |(FAST-METHOD SLOT-UNBOUND (T T T))| |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))| - |(FAST-METHOD REMOVE-NAMED-METHOD (T T))| - |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))| |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))| - |(FAST-METHOD (SETF DOCUMENTATION) (T T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))| - |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))| - |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))| + |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))| + |(FAST-METHOD REMOVE-NAMED-METHOD (T T))| + |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))| + |(FAST-METHOD SLOT-UNBOUND (T T T))| + |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))| |(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))| - |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| - |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| - |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| - |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| - |(FAST-METHOD PRINT-OBJECT (CLASS T))| - |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| - |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))| |(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))| + |(FAST-METHOD PRINT-OBJECT (CLASS T))| + |(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| + |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))| + |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| + |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| |(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))| + |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))| + |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))| + |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| + |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| |(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| - |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| + |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))| - |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))| - |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| + |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))| |(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))| + |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| + |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))| |(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))| - |(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| + |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))| |(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))| - |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))| - |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))| + |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))| + |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))| + |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| + |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))| + |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| |(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))| + |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))| |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| - |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))| - |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))| - |(FAST-METHOD PRINT-OBJECT (T T))| - |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))| - |(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))| - |(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))| - |(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))| - |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))| - |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))| - |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))| - |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))| - |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))| - |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))| - |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))| - |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))| - |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))| - |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))| - |(FAST-METHOD DESCRIBE-OBJECT (T T))| - |(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| - |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))| - |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))| - |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION 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)| - CLASS-WRAPPER |(READER PLIST)| - |(FAST-METHOD CLASS-PREDICATE-NAME (T))| - |(FAST-METHOD DOCUMENTATION (T))| + |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))| + |(FAST-METHOD PRINT-OBJECT (T T))| LEGAL-SLOT-NAME-P + |(READER TYPE)| |(READER OBJECT)| CLASS-WRAPPER + |(READER PLIST)| |(FAST-METHOD NO-APPLICABLE-METHOD (T))| + |(FAST-METHOD DOCUMENTATION (T))| + |(FAST-METHOD CLASS-PREDICATE-NAME (T))| |(READER SLOTS)| |(WRITER NAME)| DEFINITION-SOURCE |PCL::SLOT-OBJECT class predicate| DEFAULT-INITARGS |(WRITER CLASS)| CLASS-SLOT-VALUE |(WRITER TYPE)| diff --git a/unixport/makefile b/unixport/makefile index 8bf14bd..c2806f5 100644 --- a/unixport/makefile +++ b/unixport/makefile @@ -76,6 +76,7 @@ sys_init.lsp: sys_init.lsp.in -e "s#@LI-EXTVERS@#`cat ../minvers | cut -f2 -d.`#1" \ -e "s#@LI-MINVERS@#`cat ../minvers | cut -f1 -d.`#1" \ -e "s#@LI-MAJVERS@#`cat ../majvers`#1" \ + -e "s#@LI-GITTAG@#`cat ../git.tag`#1" \ -e "s#@LI-RELEASE@#`cat ../release`#1" \ -e "s#@LI-CC@#\"$(GCL_CC) -c $(filter-out -pg,$(FINAL_CFLAGS))\"#1" \ -e "s#@LI-DFP@#\"$(filter -pg,$(FINAL_CFLAGS))\"#1" \ @@ -92,6 +93,7 @@ saved_%:raw_% $(RSYM) sys_init.lsp raw_%_map msys \ $(LSPDIR)/gcl_auto_new.lsp cp sys_init.lsp foo +# [ "$(@F)" != "$(FLISP)" ] || echo "#+large-memory-model (setq compiler::*default-large-memory-model-p* t)" >>foo echo "(unless si::*quit-tags* (in-package \"USER\")(system:save-system \"$@\"))" >>foo j=$$(ar t lib$*.a |grep ^gcl_);[ "$$j" = "" ] || ar x lib$*.a $$j #accelerator $(PORTDIR)/raw_$*$(EXE) $(PORTDIR)/ -libdir $(GCLDIR)/ < foo diff --git a/unixport/sys_init.lsp.in b/unixport/sys_init.lsp.in index 0d38476..ce41b9b 100644 --- a/unixport/sys_init.lsp.in +++ b/unixport/sys_init.lsp.in @@ -49,6 +49,7 @@ (setq *gcl-extra-version* @LI-EXTVERS@ *gcl-minor-version* @LI-MINVERS@ *gcl-major-version* @LI-MAJVERS@ + *gcl-git-tag* @LI-GITTAG@ *gcl-release-date* "@LI-RELEASE@") (defvar *system-banner* (default-system-banner)) -- 2.30.2