'(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
(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.
(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*)
(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 " "")
))
+ #+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))
;;; Package operations.
(si:putprop 'in-package t 'eval-at-compile)
+(si:putprop 'si::in-package-internal t 'eval-at-compile)
;;; Pass 1 top-levels.
(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)
(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
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
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
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
[if test "$enable_ansi" = "no" ; then
SYSTEM=gcl
CLSTANDARD=CLtL1
+ else
+ AC_DEFINE([ANSI_COMMON_LISP],[1],[ANSI compliant image])
fi])
FLISP="saved_$SYSTEM"
--- /dev/null
+"Version_2_6_13pre125"
+
#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*/
/* punt guess for no randomize value */
#undef ADDR_NO_RANDOMIZE
+/* ANSI compliant image */
+#undef ANSI_COMMON_LISP
+
/* binding stack size */
#undef BDSSIZE
#undef FFD
#undef STATD
#undef make_function
+#undef make_macro_function
#undef make_si_function
#undef make_si_sfun
#undef make_special_form
#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_))
#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_)
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 */
/* 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)(); */
/* 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; */
int
gcl_isnormal_float(float);
+int
+gcl_isnan(object);
+
object
find_init_name1(char *,unsigned);
void *
get_mmap(FILE *,void **);
+void *
+get_mmap_shared(FILE *,void **);
+
int
un_mmap(void *,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);
(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)
"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))
(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)
(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
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
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
}
-#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;
} else
v=alloc_contblock(sz);
- massert(v && (unsigned long)(v+sz)<MAX_CODE_ADDRESS);
+ if (v && (unsigned long)(v+sz)<max_code_address)
+ return v;
+ else
+ FEerror("File ~a has been compiled for a restricted address space,~% and can no longer be loaded in this heap.~%"
+#ifdef LARGE_MEMORY_MODEL
+ "You can recompile with :large-memory-model-p t,~% or (setq compiler::*default-large-memory-model-p* t) before recompiling."
+#endif
+ ,
+ 1,sLAload_pathnameA->s.s_dbind);
return v;
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),"")
/* 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);
object sLeq;
object sLeql;
object sLequal;
+object sLequalp;
object sKsize;
object sKrehash_size;
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;i<j;i++)
+ h^=ihash_equalp(aref(x,i),depth);
+ break;
+
+ case t_array:
+ h^=ufixhash(j=x->a.a_rank);
+ for (i=0;i<j-1;i++)
+ h^=ufixhash(x->a.a_dims[i]);
+ j=x->a.a_dim;
+ j=j>10 ? 10 : j;
+ for (i=0;i<j;i++)
+ h^=ihash_equalp(aref(x,i),depth);
+ break;
+
+ case t_hashtable:
+ h^=ufixhash(j=x->ht.ht_nent);
+ h^=ufixhash(x->ht.ht_test);
+ j=j>10 ? 10 : j;
+ for (i=0;i<j;i++)
+ if (x->ht.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;i<def->length;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) {
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;
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);
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);
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));
}
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");
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);
}
-int gcl_isnormal_float(float f)
-{
+int
+gcl_isnormal_float(float f) {
+
union {float f;int i;} u;
if (!ISFINITE(f) || !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)
{
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;
#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;
/* (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) \
#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;
*n=m;
while(i<m) ntab[i++]=Cnil;
for(i=0 ; i< k; i++)
- for (l = tab[i]; type_of(l) == t_cons;)
+ for (l = tab[i]; consp(l);)
{int j =pack_hash(l->c.c_car)%m;
ll=l->c.c_cdr;
l->c.c_cdr = ntab[j];
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;
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;
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);
}
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);
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)
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;
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);
}
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)
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.
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;
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;
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);
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);
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~%\ */
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
{
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))
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);
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);
{
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);
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) {
}
- 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);
(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))`)
(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)()
@
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)`)
@)
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);
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:
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;
{
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);
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;sec<sece;sec++) {
sec->s_paddr+=(ul)memory->cfd.cfd_start;
}
+#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) {
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;
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;
#include <sys/mman.h>
-void *
-get_mmap(FILE *fp,void **ve) {
+static void *
+get_mmap_flags(FILE *fp,void **ve,int flags) {
int n;
void *v1;
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);
}
+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) {
(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
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
(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)|
|(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|
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)|
-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" \
$(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
(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))
projects / gcl27.git / commitdiff