REPL Output
;;; ASDF-INSTALL: Downloading 152267 bytes from http://web.inf.tu-dresden.de/~s1054849/kr_2.3.4.tar.gz to /Users/gwking/temporary/asdf-test/KR.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/KR.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
kr_2.3.4/
kr_2.3.4/kr.asd
kr_2.3.4/kr-doc.lisp
kr_2.3.4/ChangeLog
kr_2.3.4/constraints.lisp
kr_2.3.4/kr.changes
kr_2.3.4/kr.lisp
kr_2.3.4/kr-manual.ps
kr_2.3.4/kr-macros.lisp
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/"
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr-macros.lisp" (written 18 OCT 2004 05:40:24 PM):
; compiling (DEFPACKAGE KR-DEBUG)
; compiling (DEFPACKAGE KR ...)
; compiling (IN-PACKAGE "KR")
; compiling (DEFPARAMETER *KR-VERSION* ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFVAR *SPECIAL-KR-OPTIMIZATION* ...)
; compiling (DEFSTRUCT (SCHEMA # ...) ...)
; compiling (DEFSTRUCT (A-FORMULA # ...) ...)
; compiling (DEFSTRUCT (SL #) ...)
; compiling (DEFSTRUCT (FULL-SL #) ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE
; compiling (DEFMACRO DEFPARAM ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE
; compiling (DEFVAR *STORE-LAMBDAS* ...)
; compiling (DEFVAR *TYPES-ENABLED* ...)
; compiling (DEFVAR *WARNING-ON-CREATE-SCHEMA* ...)
; compiling (DEFVAR *WARNING-ON-CIRCULARITY* ...)
; compiling (DEFVAR *WARNING-ON-EVALUATION* ...)
; compiling (DEFVAR *WARNING-ON-NULL-LINK* ...)
; compiling (DEFVAR *WARNING-ON-DISCONNECTED-FORMULA* ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE
; compiling (DEFVAR *PRINT-NEW-INSTANCES* ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE
; compiling (DEFMACRO A-LOCAL-ONLY-SLOT ...)
; compiling (DEFVAR *SETTING-FORMULA-P* ...)
; compiling (DEFVAR *WITHIN-G-VALUE* ...)
; compiling (DEFVAR *SWEEP-MARK* ...)
; compiling (DEFVAR *DEMONS-DISABLED* ...)
; compiling (DEFVAR *CONSTANTS-DISABLED* ...)
; compiling (DEFVAR *REDEFINE-OK* ...)
; compiling (DEFVAR *PRE-SET-DEMON* ...)
; compiling (DEFVAR *SLOT-SETTER-DEBUG* ...)
; compiling (DEFVAR *SCHEMA-SELF* ...)
; compiling (DEFVAR *SCHEMA-SLOT* ...)
; compiling (DEFVAR *CURRENT-FORMULA* ...)
; compiling (DEFVAR *LAST-FORMULA* ...)
; compiling (DEFVAR *INHERITANCE-RELATIONS* ...)
; compiling (DEFVAR *INHERITANCE-INVERSE-RELATIONS* ...)
; compiling (DEFVAR *RELATIONS* ...)
; compiling (DEFPARAMETER *REUSE-FORMULAS* ...)
; compiling (DEFPARAMETER *REUSE-SLOTS* ...)
; compiling (DEFPARAMETER *REUSE-DIRECTORIES* ...)
; compiling (DEFVAR *SCHEMA-IS-NEW* ...)
; compiling (DEFVAR *PRINT-AS-STRUCTURE* ...)
; compiling (DEFVAR *PRINT-STRUCTURE-SLOTS* ...)
; compiling (DEFPARAM *NO-VALUE* ...)
; compiling (DEFVAR *SCHEMA-COUNTER* ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFPARAM *TYPE-BITS* ...)
; compiling (DEFPARAM *TYPE-MASK* ...)
; compiling (DEFPARAM *INHERITED-BIT* ...)
; compiling (DEFPARAM *IS-PARENT-BIT* ...)
; compiling (DEFPARAM *IS-CONSTANT-BIT* ...)
; compiling (DEFPARAM *IS-UPDATE-SLOT-BIT* ...)
; compiling (DEFPARAM *IS-LOCAL-ONLY-SLOT-BIT* ...)
; compiling (DEFPARAM *IS-PARAMETER-SLOT-BIT* ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFPARAM *LOCAL-MASK* ...)
; compiling (DEFPARAM *CONSTANT-MASK* ...)
; compiling (DEFPARAM *IS-UPDATE-SLOT-MASK* ...)
; compiling (DEFPARAM *INHERITED-MASK* ...)
; compiling (DEFPARAM *IS-PARENT-MASK* ...)
; compiling (DEFPARAM *CLEAR-SLOT-MASK* ...)
; compiling (DEFPARAM *INHERITED-PARENT-MASK* ...)
; compiling (DEFPARAM *NOT-INHERITED-MASK* ...)
; compiling (DEFPARAM *NOT-PARENT-MASK* ...)
; compiling (DEFPARAM *NOT-PARENT-CONSTANT-MASK* ...)
; compiling (DEFPARAM *ALL-BITS-MASK* ...)
; compiling (DEFVAR *CHECK-CONSTANTS* ...)
; compiling (DEFVAR *IS-CONSTANT* ...)
; compiling (DEFVAR *ACCESSED-SLOTS* ...)
; compiling (DEFVAR *KR-SEND-SELF* ...)
; compiling (DEFVAR *KR-SEND-SLOT* ...)
; compiling (DEFVAR *KR-SEND-PARENT* ...)
; compiling (DEFVAR *CREATE-SCHEMA-SCHEMA* ...)
; compiling (DEFMACRO WHEN-DEBUG ...)
; compiling (DEFMACRO FORMULA-P ...)
; compiling (DEFMACRO DELETED-P ...)
; compiling (DEFMACRO NOT-DELETED-P ...)
; compiling (DEFMACRO IS-INHERITED ...)
; compiling (DEFMACRO IS-PARENT ...)
; compiling (DEFMACRO IS-CONSTANT ...)
; compiling (DEFMACRO IS-UPDATE-SLOT ...)
; compiling (DEFMACRO SET-IS-UPDATE-SLOT ...)
; compiling (DEFMACRO IS-LOCAL-ONLY ...)
; compiling (DEFMACRO IS-PARAMETER ...)
; compiling (DEFMACRO EXTRACT-TYPE-CODE ...)
; compiling (DEFMACRO GET-ENTRY-TYPE-CODE ...)
; compiling (DEFMACRO CODE-TO-TYPE ...)
; compiling (DEFMACRO CODE-TO-TYPE-FN ...)
; compiling (DEFMACRO CODE-TO-TYPE-DOC ...)
; compiling (DEFMACRO CHECK-KR-TYPE ...)
; compiling (DEFMACRO DEF-KR-TYPE ...)
; compiling (DEFMACRO MEMBERQ ...)
; compiling (DEFMACRO ASSOCQ ...)
; compiling (DEFMACRO DO-ONE-OR-LIST ...)
; compiling (DEFMACRO PUSH-ONE-OR-LIST ...)
; compiling (DEFMACRO DELETE-ONE-OR-LIST ...)
; compiling (DEFMACRO CONTINUE-OUT ...)
; compiling (DEFMACRO GET-DEPENDENT-FORMULA ...)
; compiling (DEFMACRO SLOT-DEPENDENTS ...)
; compiling (DEFMACRO SLOT-ACCESSOR ...)
; compiling (DEFMACRO SET-SLOT-ACCESSOR ...)
; compiling (DEFMACRO A-FORMULA-NUMBER ...)
; compiling (DEFMACRO SET-FORMULA-NUMBER ...)
; compiling (DEFMACRO ON-SCHEMA ...)
; compiling (DEFMACRO ON-SLOT ...)
; compiling (DEFMACRO CACHED-VALUE ...)
; compiling (DEFMACRO CACHE-IS-VALID ...)
; compiling (DEFMACRO SET-CACHE-IS-VALID ...)
; compiling (DEFMACRO CACHE-MARK ...)
; compiling (DEFMACRO SET-CACHE-MARK ...)
; compiling (DEFPARAMETER ITERATE-SLOT-VALUE-ENTRY ...)
; compiling (DEFMACRO ITERATE-SLOT-VALUE ...)
; compiling (DEFMACRO DOSLOTS ...)
; compiling (DEFUN GET-LOCAL-VALUE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr-macros.lisp
; in: DEFUN GET-LOCAL-VALUE
; (KR::IS-INHERITED (KR::SL-BITS KR::ENTRY))
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFMACRO GET-LOCAL-VALUES ...)
; compiling (DEFMACRO EXPAND-ACCESSOR ...)
; compiling (DEFMACRO WITH-CONSTANTS-DISABLED ...)
; compiling (DEFMACRO WITH-TYPES-DISABLED ...)
; compiling (DEFMACRO WITH-DEPENDENCIES-DISABLED ...)
; compiling (DEFMACRO WITH-DEMONS-DISABLED ...)
; compiling (DEFMACRO WITH-DEMON-DISABLED ...)
; compiling (DEFMACRO WITH-DEMON-ENABLED ...)
; compiling (DEFMACRO RELATION-P ...)
; compiling (DEFMACRO G-VALUE-BODY ...)
; compiling (DEFMACRO GET-VALUE ...)
; compiling (DEFMACRO G-VALUE ...)
; compiling (DEFMACRO G-LOCAL-VALUE ...)
; compiling (DEFMACRO SLOT-REQUIRES-DEMON ...)
; compiling (DEFMACRO RUN-INVALIDATE-DEMONS ...)
; compiling (DEFMACRO RUN-PRE-SET-DEMONS ...)
; compiling (DEFUN S-VALUE-CHAIN ...)
; compiling (DEFMACRO S-VALUE ...)
; compiling (DEFMACRO DOVALUES ...)
; compiling (DEFMACRO CREATE-RELATION ...)
; compiling (DEFUN HAS-SLOT-P ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr-macros.lisp
; in: DEFUN HAS-SLOT-P
; (KR::IS-INHERITED (KR::SL-BITS KR::ENTRY))
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFMACRO SET-VALUES ...)
; compiling (DEFMACRO KR-SEND ...)
; compiling (DEFMACRO CALL-PROTOTYPE-METHOD ...)
; compiling (DEFMACRO APPLY-PROTOTYPE-METHOD ...)
; compiling (DEFMACRO DEFINE-METHOD ...)
; compiling (DEFMACRO METHOD-TRACE ...)
; compiling (DEFMACRO CREATE-SCHEMA ...)
; compiling (DEFMACRO CREATE-PROTOTYPE ...)
; compiling (DEFMACRO CREATE-INSTANCE ...)
; compiling (DEFMACRO BEGIN-CREATE-INSTANCE ...)
; compiling (DEFSETF G-VALUE ...)
; compiling (DEFSETF GET-VALUES ...)
; compiling (DEFSETF GET-LOCAL-VALUES ...)
; compiling (DEFSETF G-LOCAL-VALUE ...)
; compiling (DEFSETF GV ...)
; compiling (DEFMACRO WITH ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr-macros.fasl written
; compilation finished in 0:00:03
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {40006E99}> on
#<CL-SOURCE-FILE "kr-macros" {40006EA9}>.
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp" (written 18 OCT 2004 05:40:24 PM):
; compiling (IN-PACKAGE "KR")
; compiling (DEFUN SCHEMA-P ...)
; compiling (DEFUN CLEAR-ONE-SLOT ...)
; compiling (DEFUN CLEAR-SCHEMA-SLOTS ...)
; compiling (DEFUN VALUE-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN VALUE-FN
; (KR::G-VALUE-BODY KR:SCHEMA KR::SLOT T T)
; --> LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G44))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN G-LOCAL-VALUE-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN G-LOCAL-VALUE-FN
; (KR::G-VALUE-BODY KR:SCHEMA KR::SLOT NIL T)
; --> LOCALLY LET* IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G54))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (LET (#) ...)
; compiling (DEFUN GET-LAMBDA ...)
; compiling (DEFUN ENABLE-A-DEMON ...)
; compiling (DEFUN DISABLE-A-DEMON ...)
; compiling (DEFUN DEMON-IS-DISABLED ...)
; compiling (DEFUN G-VALUE-INHERIT-VALUES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN G-VALUE-INHERIT-VALUES
; (KR::SET-SLOT-ACCESSOR KR::PARENT
; KR::SLOT
; KR::VALUE
; (LOGIOR KR::BITS KR::*IS-PARENT-MASK*)
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; compiling (DEFUN G-CACHED-VALUE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN G-CACHED-VALUE
; (KR:GET-VALUE KR:SCHEMA KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G468))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN G-VALUE-NO-COPY ...)
; compiling (DEFPARAMETER *DEBUG-NAMES-LENGTH* ...)
; compiling (DEFVAR *DEBUG-NAMES* ...)
; compiling (DEFVAR *DEBUG-INDEX* ...)
; compiling (DEFVAR *INTERN-UNNAMED-SCHEMATA* ...)
; compiling (DEFUN CACHE-SCHEMA-NAME ...)
; compiling (DEFUN MAKE-NEW-SCHEMA-NAME ...)
; compiling (DEFUN PRINT-THE-SLOT ...)
; compiling (DEFUN PRINT-THE-SCHEMA ...)
; compiling (DEFUN NAME-FOR-SCHEMA ...)
; compiling (DEFUN S ...)
; compiling (DEFUN UNLINK-ONE-VALUE ...)
; compiling (DEFUN UNLINK-ALL-VALUES ...)
; compiling (DEFUN LINK-IN-RELATION ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN LINK-IN-RELATION
; (KR::SET-SLOT-ACCESSOR KR::VALUE
; KR::INVERSE
; (LIST KR:SCHEMA)
; KR::*LOCAL-MASK*
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::INVERSE
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::INVERSE
;
; note: deleting unreachable code
; compiling (DEFUN CHECK-RELATION-SLOT ...)
; compiling (DEFUN INHERITED-P ...)
; compiling (DEFPARAMETER TYPES-TABLE ...)
; compiling (DEFPARAMETER *TYPES-ARRAY-INC* ...)
; compiling (DEFPARAMETER *NEXT-TYPE-CODE* ...)
; compiling (DEFPARAMETER TYPES-ARRAY ...)
; compiling (DEFPARAMETER TYPE-FNS-ARRAY ...)
; compiling (DEFPARAMETER TYPE-DOCS-ARRAY ...)
; compiling (DEFUN FIND-LISP-PREDICATE ...)
; compiling (DEFUN MAKE-LAMBDA-BODY ...)
; compiling (DEFUN TYPE-TO-FN ...)
; compiling (DEFUN COPY-EXTEND-ARRAY ...)
; compiling (DEFUN GET-NEXT-TYPE-CODE ...)
; compiling (DEFUN ADD-NEW-TYPE ...)
; compiling (DEFUN KR-TYPE-ERROR ...)
; compiling (DEFUN ENCODE-TYPE ...)
; compiling (DEFUN SET-TYPE-DOCUMENTATION ...)
; compiling (DEFUN GET-TYPE-DOCUMENTATION ...)
; compiling (DEFUN ELIMINATE-CONSTANT-FORMULA ...)
; compiling (DEFPARAMETER *WARNING-LEVEL* ...)
; compiling (DEFUN SLOT-IS-CONSTANT ...)
; compiling (DEFUN RE-EVALUATE-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN RE-EVALUATE-FORMULA
; (KR::RUN-PRE-SET-DEMONS KR::*SCHEMA-SELF*
; KR::*SCHEMA-SLOT*
; KR::NEW-V
; :CURRENT-FORMULA
; :FORMULA-EVALUATION)
; --> UNLESS COND IF PROGN IF IF IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN G-VALUE-FORMULA-VALUE ...)
; compiling (DEFUN COPY-TO-ALL-INSTANCES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN COPY-TO-ALL-INSTANCES
; (KR:GET-VALUE KR::CHILD KR::A-SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1398))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN UPDATE-INHERITED-INTERNAL ...)
; compiling (DEFUN UPDATE-INHERITED-VALUES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN UPDATE-INHERITED-VALUES
; (KR::RUN-PRE-SET-DEMONS KR:SCHEMA
; KR::A-SLOT
; KR::VALUE
; NIL
; :INHERITANCE-PROPAGATION)
; --> UNLESS COND IF PROGN IF IF IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::A-SLOT NIL)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1445))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN MARK-AS-CHANGED ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN MARK-AS-CHANGED
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1493))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN MARK-AS-INVALID ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN MARK-AS-INVALID
; (KR:GET-VALUE KR:SCHEMA KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1523))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN RECOMPUTE-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN RECOMPUTE-FORMULA
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET OR LET IF OR
; --> KR::SLOT-ACCESSOR VALUES PROG1 LET GETHASH SB-IMPL::GETHASH2
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1537))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN PROPAGATE-CHANGE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN PROPAGATE-CHANGE
; (KR::RUN-INVALIDATE-DEMONS KR::NEW-SCHEMA KR::NEW-SLOT KR::NEW-ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1576))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN VISIT-INHERITED-VALUES ...)
; compiling (DEFUN RUN-DEMONS-AND-SET-VALUE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN RUN-DEMONS-AND-SET-VALUE
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::NEW-VALUE KR::NEW-BITS NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1670))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN CONSTANT-SLOT-ERROR ...)
; compiling (DEFMACRO CHECK-NOT-CONSTANT ...)
; compiling (DEFUN SLOT-CONSTANT-P ...)
; compiling (DEFUN SET-FORMULA-ERROR ...)
; compiling (DEFUN S-VALUE-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN S-VALUE-FN
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::VALUE KR::NEW-BITS NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; (OR KR::THE-BITS KR::*LOCAL-MASK*)
; --> LET IF OR
; ==>
; KR::*LOCAL-MASK*
;
; note: deleting unreachable code
; (KR::CHECK-NOT-CONSTANT KR:SCHEMA KR::SLOT KR::ENTRY)
; --> LET AND IF AND IF AND IF KR::IS-CONSTANT
; ==>
; (LOGBITP 12 (KR::SL-BITS #:G1824))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::IS-INHERITED KR::THE-BITS)
; ==>
; (LOGBITP 10 KR::THE-BITS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (INCF KR::*SCHEMA-COUNTER*)
; --> LET*
; ==>
; (+ KR::*SCHEMA-COUNTER* #:G1839)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (KR::RUN-PRE-SET-DEMONS KR:SCHEMA KR::SLOT KR::VALUE NIL :S-VALUE)
; --> UNLESS COND IF PROGN IF IF IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF IF IF IF FUNCALL SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G1848))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET IF UNLESS COND IF PROGN FUNCALL
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; (ZEROP (KR::A-FORMULA-NUMBER KR::OLD-VALUE))
; ==>
; (= (KR::A-FORMULA-NUMBER KR::OLD-VALUE) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (KR::IS-PARENT KR::THE-BITS)
; ==>
; (LOGBITP 11 KR::THE-BITS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (INCF KR::*SCHEMA-COUNTER*)
; --> LET*
; ==>
; (+ KR::*SCHEMA-COUNTER* #:G1839)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (LOGAND KR::THE-BITS KR::*NOT-INHERITED-MASK*)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (KR::SET-CACHE-IS-VALID KR::OLD-VALUE NIL)
; --> KR::SET-FORMULA-NUMBER SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; (LOGAND (KR::A-FORMULA-NUMBER KR::OLD-VALUE) -2)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; (KR::SET-CACHE-IS-VALID KR::OLD-VALUE T)
; --> KR::SET-FORMULA-NUMBER SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; (LOGIOR (KR::A-FORMULA-NUMBER KR::OLD-VALUE) 1)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; compiling (DEFUN INTERNAL-S-VALUE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN INTERNAL-S-VALUE
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::VALUE KR::*LOCAL-MASK* NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; compiling (DEFUN SET-IS-A ...)
; compiling (DEFUN ELIMINATE-FORMULA-DEPENDENCIES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN ELIMINATE-FORMULA-DEPENDENCIES
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T T)
; KR::SLOT
; KR::VALUE
; (LET ((KR::FORMULAS
; (KR::SLOT-DEPENDENTS
; KR::ITERATE-SLOT-VALUE-ENTRY)))
; (IF (LISTP KR::FORMULAS)
; (IF (KR::MEMBERQ KR:FORMULA KR::FORMULAS)
; (SETF # #))
; (IF (EQ KR:FORMULA KR::FORMULAS)
; (SETF # NIL)))))
; --> LOCALLY IF MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN DELETE-FORMULA ...)
; compiling (DEFUN DESTROY-SLOT-HELPER ...)
; compiling (DEFPARAMETER *IN-DESTROY-SLOT* ...)
; compiling (DEFPARAMETER *INVALID-DESTROY-SLOT* ...)
; compiling (DEFUN DESTROY-SLOT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN DESTROY-SLOT
; (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET OR LET IF OR
; --> KR::SLOT-ACCESSOR VALUES PROG1 LET GETHASH SB-IMPL::GETHASH2
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> UNLESS COND IF PROGN IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> UNLESS COND IF PROGN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF
; --> IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G2306))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::RUN-PRE-SET-DEMONS KR:SCHEMA
; KR::SLOT
; KR::NEW-VALUE
; KR::OLD-VALUE
; :DESTROY-SLOT)
; --> UNLESS COND IF PROGN IF IF IF KR::SLOT-REQUIRES-DEMON LOCALLY LET IF
; --> KR::IS-UPDATE-SLOT
; ==>
; (LOGBITP 13 (KR::SL-BITS KR::.ENTRY.))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN DELETE-SCHEMA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN DELETE-SCHEMA
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA NIL NIL NIL)
; KR::SLOT
; KR::VALUE
; (WHEN (KR:FORMULA-P KR::VALUE)
; (KR::DELETE-FORMULA KR::VALUE
; (NOT KR::RECURSIVE-P))
; (KR::DELETE-SCHEMA KR::VALUE KR::RECURSIVE-P)))
; --> LOCALLY PROGN MAPHASH FUNCTION LET UNLESS COND IF NOT IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA NIL NIL NIL)
; KR::VALUE
; (IF (KR:RELATION-P KR::SLOT)
; (KR::UNLINK-ALL-VALUES KR:SCHEMA KR::SLOT)))
; --> LOCALLY PROGN MAPHASH FUNCTION LET UNLESS COND IF NOT IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA NIL NIL NIL)
; KR::SLOT
; KR::VALUE
; (WHEN (KR:FORMULA-P KR::VALUE)
; (KR::DELETE-FORMULA KR::VALUE
; (NOT KR::RECURSIVE-P))
; (KR::DELETE-SCHEMA KR::VALUE KR::RECURSIVE-P)))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA NIL NIL NIL)
; KR::VALUE
; (IF (KR:RELATION-P KR::SLOT)
; (KR::UNLINK-ALL-VALUES KR:SCHEMA KR::SLOT)))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN FIND-DIRECT-DEPENDENCY ...)
; compiling (DEFUN DESTROY-SCHEMA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN DESTROY-SCHEMA
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T NIL)
; KR::SLOT
; (UNLESS (EQ KR::VALUE KR::*NO-VALUE*)
; (KR::DO-ONE-OR-LIST
; (KR:FORMULA
; (KR::SLOT-DEPENDENTS
; KR::ITERATE-SLOT-VALUE-ENTRY))
; (UNLESS (OR # #)
; (LET #
; #)))
; (IF (KR:FORMULA-P KR::VALUE)
; (KR::DELETE-FORMULA KR::VALUE T))))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN RECURSIVE-DESTROY-SCHEMA ...)
; compiling (DEFUN RESET-INHERITED-VALUES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN RESET-INHERITED-VALUES
; (KR::IS-INHERITED (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY))
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T NIL T)
; (UNLESS (KR:RELATION-P KR::SLOT)
; (UNLESS (EQ KR::VALUE KR::*NO-VALUE*)
; (IF (KR::IS-INHERITED #)
; (KR:DESTROY-SLOT KR:SCHEMA KR::SLOT)))))
; --> LOCALLY IF MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN PRINT-ONE-VALUE ...)
; compiling (DEFUN PRINT-ONE-SLOT-HELPER ...)
; compiling (DEFUN PRINT-META ...)
; compiling (DEFUN INDENT-BY ...)
; compiling (DEFUN FORCE-DOWN-HELPER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN FORCE-DOWN-HELPER
; (KR::MEMBERQ KR::SLOT KR::ORIGINAL-SLOTS)
; --> MEMBER BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> MEMBER BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T NIL)
; KR::VALUE
; (UNLESS (KR::MEMBERQ KR::SLOT KR::ORIGINAL-SLOTS)
; (PUSHNEW KR::SLOT KR::SLOTS)))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN FORCE-DOWN-ALL-INHERITANCE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN FORCE-DOWN-ALL-INHERITANCE
; (KR:GET-VALUE KR:SCHEMA KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G2787))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T NIL NIL)
; KR::VALUE
; (PUSH KR::SLOT KR::ORIGINAL-SLOTS))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN CALL-FUNC-ON-ONE-SLOT ...)
; compiling (DEFUN CALL-ON-PS-SLOTS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN CALL-ON-PS-SLOTS
; (KR::MEMBERQ KR::SLOT KR::SORTED)
; --> MEMBER BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> MEMBER BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; (KR::ASSOCQ KR::SLOT KR::LIMIT-VALUES)
; --> ASSOC BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> ASSOC BLOCK LET COND IF COND IF COND IF PROGN IF SB-IMPL::ASSOC-GUTS DO
; --> BLOCK LET TAGBODY TAGBODY WHEN COND IF AND IF AND
; ==>
; (EQL SB-IMPL::ITEM (FUNCALL SB-IMPL::KEY (CAAR SB-IMPL::ALIST)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; ==>
; (EQL SB-IMPL::ITEM (CAAR SB-IMPL::ALIST))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; ==>
; (EQL SB-IMPL::ITEM (FUNCALL SB-IMPL::KEY (CAAR SB-IMPL::ALIST)))
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; ==>
; (EQL SB-IMPL::ITEM (CAAR SB-IMPL::ALIST))
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T NIL NIL)
; (UNLESS
; (OR (KR::MEMBERQ KR::SLOT KR::SLOTS-IGNORED)
; (KR::MEMBERQ KR::SLOT KR::SORTED)
; (EQ KR::VALUE KR::*NO-VALUE*))
; (KR::CALL-FUNC-ON-ONE-SLOT KR:SCHEMA
; KR::SLOT
; KR::INHERIT
; FUNCTION
; KR::TYPES-P
; KR::INDENT
; (OR (SECOND #)
; KR::GLOBAL-LIMIT))))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T NIL)
; (UNLESS
; (OR (KR::MEMBERQ KR::SLOT KR::SLOTS-IGNORED)
; (KR::MEMBERQ KR::SLOT KR::SORTED)
; (EQ KR::VALUE KR::*NO-VALUE*))
; (KR::CALL-FUNC-ON-ONE-SLOT KR:SCHEMA
; KR::SLOT
; KR::INHERIT
; FUNCTION
; KR::TYPES-P
; KR::INDENT
; (OR (SECOND #)
; KR::GLOBAL-LIMIT))))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN CALL-ON-ONE-SLOT ...)
; compiling (DEFUN SLOT-PRINTER ...)
; compiling (DEFUN PS ...)
; compiling (DEFUN THE-BITS ...)
; compiling (DEFUN FULL-NORMAL-SLOT ...)
; compiling (DEFUN FULL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN FULL
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T NIL)
; KR::VALUE
; (KR::FULL-NORMAL-SLOT KR:SCHEMA KR::SLOT))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN FIND-PARENT ...)
; compiling (DEFUN OLD-KR-SEND-FUNCTION ...)
; compiling (DEFUN KR-CALL-INITIALIZE-METHOD ...)
; compiling (DEFUN KR-INIT-METHOD ...)
; compiling (DEFUN CALL-PROTOTYPE-FUNCTION ...)
; compiling (DEFUN ALLOCATE-SCHEMA-SLOTS ...)
; compiling (DEFUN MAKE-A-NEW-SCHEMA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN MAKE-A-NEW-SCHEMA
; (FORMAT T
; "Error in CREATE-SCHEMA - ~S is not a valid schema name.~%"
; KR::NAME)
; ==>
; KR::NAME
;
; note: deleting unreachable code
; (1+ KR::*SCHEMA-COUNTER*)
; ==>
; (+ KR::*SCHEMA-COUNTER* 1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFUN PROCESS-ONE-CONSTANT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN PROCESS-ONE-CONSTANT
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA
; KR::SLOT
; KR::*NO-VALUE*
; KR::*CONSTANT-MASK*
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; compiling (DEFUN DECLARE-CONSTANT ...)
; compiling (DEFUN MERGE-PROTOTYPE-VALUES ...)
; compiling (DEFUN PROCESS-CONSTANT-SLOTS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN PROCESS-CONSTANT-SLOTS
; (KR::SET-SLOT-ACCESSOR KR::THE-SCHEMA
; KR::SLOT
; KR::*NO-VALUE*
; (KR::SET-IS-UPDATE-SLOT KR::*LOCAL-MASK*)
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; (KR::SET-SLOT-ACCESSOR KR::THE-SCHEMA KR::SLOT KR::*NO-VALUE* KR::BITS NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; (KR::SET-IS-UPDATE-SLOT KR::*LOCAL-MASK*)
; --> LOGIOR
; ==>
; (LOGIOR SB-C::Y 8192)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; (KR::SET-IS-UPDATE-SLOT (KR::SL-BITS KR::ENTRY))
; --> LOGIOR
; ==>
; (LOGIOR SB-C::Y 8192)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; (LOGAND KR::BITS KR::*TYPE-MASK*)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (KR::EXTRACT-TYPE-CODE KR::SCHEMA-BITS)
; --> LOGAND
; ==>
; (LOGAND SB-C::Y 1023)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; (LOGAND KR::SCHEMA-BITS KR::*ALL-BITS-MASK*)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (LOGIOR (LOGAND KR::SCHEMA-BITS KR::*ALL-BITS-MASK*) KR::BITS)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; compiling (DEFUN ADD-UPDATE-SLOT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN ADD-UPDATE-SLOT
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA
; KR::SLOT
; KR::*NO-VALUE*
; (KR::SET-IS-UPDATE-SLOT KR::*LOCAL-MASK*)
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFUN CANNOT-BE-QUOTED ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFUN PROCESS-SLOT-DESCRIPTOR ...)
; compiling (DEFUN MERGE-DECLARATIONS ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFUN PROCESS-SLOTS ...)
; compiling (DEFUN HANDLE-IS-A ...)
; compiling (DEFUN DO-SCHEMA-BODY ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFUN CREATION-MESSAGE ...)
; compiling (DEFUN END-CREATE-INSTANCE ...)
; compiling (DEFMACRO GET-SLOT-TYPE-CODE ...)
; compiling (DEFUN G-TYPE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN G-TYPE
; (KR::GET-SLOT-TYPE-CODE KR::OBJECT KR::SLOT)
; --> LET AND IF AND KR::GET-ENTRY-TYPE-CODE LOCALLY KR::EXTRACT-TYPE-CODE
; --> LOGAND
; ==>
; (LOGAND SB-C::Y 1023)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; compiling (DEFUN CHECK-SLOT-TYPE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN CHECK-SLOT-TYPE
; (KR::GET-ENTRY-TYPE-CODE KR::ENTRY)
; --> LOCALLY KR::EXTRACT-TYPE-CODE LOGAND
; ==>
; (LOGAND SB-C::Y 1023)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; (KR::GET-SLOT-TYPE-CODE KR::OBJECT KR::SLOT)
; --> LET AND IF AND KR::GET-ENTRY-TYPE-CODE LOCALLY KR::EXTRACT-TYPE-CODE
; --> LOGAND
; ==>
; (LOGAND SB-C::Y 1023)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; compiling (DEFUN SET-SLOT-TYPE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN SET-SLOT-TYPE
; (KR::SET-SLOT-ACCESSOR KR::OBJECT KR::SLOT KR::*NO-VALUE* TYPE NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; compiling (DEFUN S-TYPE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN S-TYPE
; (KR:S-VALUE KR::OBJECT KR::SLOT KR::NEW-VALUE)
; --> KR::S-VALUE-FN
; ==>
; KR::OBJECT
;
; note: deleting unreachable code
; compiling (DEFUN GET-DECLARATIONS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.lisp
; in: DEFUN GET-DECLARATIONS
; (KR::IS-CONSTANT KR::BITS)
; ==>
; (LOGBITP 12 KR::BITS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::EXTRACT-TYPE-CODE KR::BITS)
; --> LOGAND
; ==>
; (LOGAND SB-C::Y 1023)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T NIL)
; KR::VALUE
; (LET ((KR::BITS
; (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY)))
; (CASE DECLARATION
; (:CONSTANT (IF # #))
; (:TYPE
; (LET #
; #)))))
; --> LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN GET-SLOT-DECLARATIONS ...)
; compiling (DEFUN T-P ...)
; compiling (DEFUN NO-TYPE-ERROR-P ...)
; compiling (DEFUN GET-TYPE-DEFINITION ...)
; compiling (DEFUN FIND-META ...)
; compiling (DEFUN G-FORMULA-VALUE ...)
; compiling (DEFUN S-FORMULA-VALUE ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (DEFUN K-READER ...)
;
; caught STYLE-WARNING:
; using deprecated EVAL-WHEN situation names LOAD COMPILE EVAL
; compiling (SET-DISPATCH-MACRO-CHARACTER #\# ...)
; compiling (DEFUN O-FORMULA-READER ...)
; compiling (SET-DISPATCH-MACRO-CHARACTER #\# ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/kr.fasl written
; compilation finished in 0:00:08
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {10006D39}> on
#<CL-SOURCE-FILE "kr" {10006D49}>.
STYLE-WARNING: redefining CANNOT-BE-QUOTED in DEFUN
STYLE-WARNING: redefining PROCESS-SLOT-DESCRIPTOR in DEFUN
STYLE-WARNING: redefining PROCESS-SLOTS in DEFUN
STYLE-WARNING: redefining CREATION-MESSAGE in DEFUN
STYLE-WARNING: redefining K-READER in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp" (written 18 OCT 2004 05:40:24 PM):
; compiling (IN-PACKAGE "KR")
; compiling (DEFVAR *SETUP-DEPENDENCIES* ...)
; compiling (DEFUN FIXED-PATH-ACCESSOR ...)
; compiling (DEFMACRO KR-PATH ...)
; compiling (DEFUN MAKE-NEW-FORMULA ...)
; compiling (DEFUN FORMULA-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN FORMULA-FN
; (INCF KR::*SCHEMA-COUNTER*)
; --> LET*
; ==>
; (+ KR::*SCHEMA-COUNTER* #:G95)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFMACRO FORMULA ...)
; compiling (DEFUN PREPARE-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN PREPARE-FORMULA
; (INCF KR::*SCHEMA-COUNTER*)
; --> LET*
; ==>
; (+ KR::*SCHEMA-COUNTER* #:G155)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFUN O-FORMULA-FN ...)
; compiling (DEFMACRO O-FORMULA ...)
; compiling (DEFUN MAKE-INTO-O-FORMULA ...)
; compiling (DEFUN CHANGE-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN CHANGE-FORMULA
; (KR:GET-VALUE KR:SCHEMA KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G222))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN MOVE-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN MOVE-FORMULA
; (KR::SET-SLOT-ACCESSOR KR::FROM-SCHEMA
; KR::FROM-SLOT
; KR::VALUE
; KR::*LOCAL-MASK*
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::FROM-SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::FROM-SLOT
;
; note: deleting unreachable code
; (KR:GET-VALUE KR::FROM-SCHEMA KR::FROM-SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G320))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFUN COPY-FORMULA ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN COPY-FORMULA
; (KR:DOSLOTS (KR::SLOT KR::META)
; (KR:S-VALUE KR::NEW-META KR::SLOT (KR:G-VALUE KR::META KR::SLOT)))
; --> KR::ITERATE-SLOT-VALUE LOCALLY PROGN MAPHASH FUNCTION LET UNLESS COND IF
; --> NOT IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS KR::ITERATE-SLOT-VALUE-ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; --> KR::ITERATE-SLOT-VALUE LOCALLY PROGN MAPHASH BLOCK LET DO BLOCK LET
; --> TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BROKEN-LINK-THROW ...)
; compiling (DEFUN SLOT-IS-NOT-CONSTANT ...)
; compiling (DEFUN GV-VALUE-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN GV-VALUE-FN
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::*NO-VALUE* 0 NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; (KR::IS-CONSTANT (KR::SL-BITS KR::ENTRY))
; ==>
; (LOGBITP 12 (KR::SL-BITS KR::ENTRY))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFMACRO GV-FN-BODY ...)
; compiling (DEFUN SETUP-DEPENDENCY ...)
; compiling (DEFUN GV-CHAIN ...)
; compiling (DEFMACRO GV ...)
; compiling (DEFUN GV-LOCAL-FN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN GV-LOCAL-FN
; (KR::GV-FN-BODY KR:G-LOCAL-VALUE)
; --> LOCALLY IF IF LET* WHEN COND IF PROGN IF AND IF AND KR::IS-CONSTANT
; ==>
; (LOGBITP 12 (KR::SL-BITS #:G723))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; compiling (DEFMACRO GV-LOCAL ...)
; compiling (DEFMACRO GVL ...)
; compiling (DEFUN INVALIDATE-DEMON ...)
; compiling (DEFUN DESTROY-CONSTRAINT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN DESTROY-CONSTRAINT
; (KR::SET-SLOT-ACCESSOR KR:SCHEMA
; KR::SLOT
; KR::VALUE
; (LOGIOR KR::*LOCAL-MASK*
; (LOGAND (KR::SL-BITS KR::ENTRY)
; KR::*IS-UPDATE-SLOT-MASK*))
; NIL)
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET*
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; --> LET* IF PROGN WHEN COND IF PROGN SETF LET* MULTIPLE-VALUE-BIND LET
; ==>
; KR::SLOT
;
; note: deleting unreachable code
; compiling (DEFUN INITIALIZE-KR ...)
Object PRINT-SCHEMA-CONTROL
; compiling (INITIALIZE-KR)
; compiling (DEFUN IS-A-P ...)
; compiling (DEFUN I-DEPEND-ON ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.lisp
; in: DEFUN I-DEPEND-ON
; (KR:GET-VALUE KR::OBJECT KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF IF IF KR::IS-INHERITED
; ==>
; (LOGBITP 10 (KR::SL-BITS #:G910))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
; (KR::ITERATE-SLOT-VALUE (KR:SCHEMA T T T)
; (IF (NOT (EQ KR::VALUE KR::*NO-VALUE*))
; (KR::DO-ONE-OR-LIST
; (KR::F
; (KR::SLOT-DEPENDENTS
; KR::ITERATE-SLOT-VALUE-ENTRY))
; (IF (EQ KR::F KR:FORMULA)
; (PUSH # KR::DEPENDENCIES)))))
; --> LOCALLY IF MAPHASH BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET*
; ==>
; (AREF SB-IMPL::KV-VECTOR (* 2 SB-IMPL::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (AREF SB-IMPL::KV-VECTOR (1+ (* 2 SB-IMPL::I)))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN SELF-OLD-VALUE ...)
; compiling (DEF-KR-TYPE KR-NO-TYPE ...)
; compiling (SETF (AREF TYPES-ARRAY ...) ...)
; compiling (DEF-KR-TYPE KR-BOOLEAN ...)
; compiling (DOLIST (TYPE #) ...)
; compiling (SETF (GET :GARNET-MODULES ...) ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kr_2.3.4/constraints.fasl written
; compilation finished in 0:00:02
;
; compilation unit finished
; caught 13 STYLE-WARNING conditions
; printed 147 notes
