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