[elephant-devel] 13 Warnings when loading elephant (SBCL, Mac OS X)
Jens Teich
info at jensteich.de
Mon Apr 7 05:50:28 UTC 2008
SBCL 1.0.15
Mac OS X 10.5
Do I have to worry about any of these warnings? Jens
; SLIME 2006-04-20
CL-USER> (asdf :elephant)
; loading system definition from
; /Users/jensteich/Lisp/elephant/elephant.asd into #<PACKAGE "ASDF0">
; registering #<SYSTEM ELEPHANT {121F5D51}> as ELEPHANT
; loading system definition from /Users/jensteich/Lisp/cl-base64.asd
into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM CL-BASE64 {123A51A1}> as CL-BASE64
; registering #<SYSTEM CL-BASE64-TESTS {11E167E9}> as CL-BASE64-TESTS
; loading system definition from /Users/jensteich/Lisp/uffi.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM UFFI {11F9A531}> as UFFI
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
package.lisp" (written 10 MAY 2006 02:42:59 AM):
; compiling (IN-PACKAGE #:CL-USER)
; compiling (DEFPACKAGE #:UFFI ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
primitives.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFMACRO DEF-CONSTANT ...)
; compiling (DEFMACRO DEF-TYPE ...)
; compiling (DEFMACRO NULL-CHAR-P ...)
; compiling (DEFMACRO DEF-FOREIGN-TYPE ...)
; compiling (DEFVAR +TYPE-CONVERSION-HASH+ ...)
; compiling (DEFVAR *CMU-DEF-TYPE-HASH* ...)
; compiling (DEFVAR *CMU-SBCL-DEF-TYPE-LIST* ...)
; compiling (DEFVAR *TYPE-CONVERSION-LIST* ...)
; compiling (SETQ *TYPE-CONVERSION-LIST* ...)
; compiling (DOLIST (TYPE *TYPE-CONVERSION-LIST*) ...)
; compiling (DOLIST (TYPE *CMU-SBCL-DEF-TYPE-LIST*) ...)
; compiling (DEFUN BASIC-CONVERT-FROM-UFFI-TYPE ...)
; compiling (DEFUN %CONVERT-FROM-UFFI-TYPE ...)
; compiling (DEFUN CONVERT-FROM-UFFI-TYPE ...)
; compiling (WHEN (CHAR= #\a ...) ...)
; compiling (WHEN (NOT #) ...)
; compiling (DEFUN MAKE-LISP-NAME ...)
; compiling (SETQ *FEATURES* ...)
; compiling (SETQ *FEATURES* ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/primitives.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
objects.lisp" (written 14 AUG 2006 06:26:22 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN SIZE-OF-FOREIGN-TYPE ...)
; compiling (DEFMACRO ALLOCATE-FOREIGN-OBJECT ...)
; compiling (DEFMACRO FREE-FOREIGN-OBJECT ...)
; compiling (DEFMACRO NULL-POINTER-P ...)
; compiling (DEFMACRO MAKE-NULL-POINTER ...)
; compiling (DEFMACRO MAKE-POINTER ...)
; compiling (DEFMACRO CHAR-ARRAY-TO-POINTER ...)
; compiling (DEFMACRO DEREF-POINTER ...)
; compiling (DEFMACRO ENSURE-CHAR-CHARACTER ...)
; compiling (DEFMACRO ENSURE-CHAR-INTEGER ...)
; compiling (DEFMACRO ENSURE-CHAR-STORABLE ...)
; compiling (DEFMACRO POINTER-ADDRESS ...)
; compiling (DEFMACRO WITH-FOREIGN-OBJECT ...)
; compiling (DEFMACRO WITH-FOREIGN-OBJECTS ...)
; compiling (DEFMACRO WITH-CAST-POINTER ...)
; compiling (DEFMACRO DEF-FOREIGN-VAR ...)
; compiling (DEFMACRO DEF-POINTER-VAR ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/objects.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
aggregates.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFMACRO DEF-ENUM ...)
; compiling (DEFMACRO DEF-ARRAY-POINTER ...)
; compiling (DEFUN PROCESS-STRUCT-FIELDS ...)
; compiling (DEFMACRO DEF-STRUCT ...)
; compiling (DEFMACRO GET-SLOT-VALUE ...)
; compiling (DEFMACRO GET-SLOT-POINTER ...)
; compiling (DEFMACRO DEREF-ARRAY ...)
; compiling (DEFMACRO DEF-UNION ...)
; compiling (SB-EXT:WITHOUT-PACKAGE-LOCKS (DEFVAR *SYSTEM-COPY-
FN* ...) ...)
; compiling (DEFUN CONVERT-FROM-FOREIGN-USB8 ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/aggregates.lisp
; in: DEFUN CONVERT-FROM-FOREIGN-USB8
; (MAKE-ARRAY UFFI::LEN :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a
INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (FUNCALL UFFI::*SYSTEM-COPY-FN* UFFI::SAP 0 UFFI::RESULT
; UFFI::+SYSTEM-COPY-OFFSET+
; (* UFFI::LEN UFFI::+SYSTEM-COPY-MULTIPLIER+))
; --> 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.
; /Users/jensteich/Lisp/uffi-1.6.0/src/aggregates.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
functions.lisp" (written 13 APR 2007 07:49:01 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN PROCESS-FUNCTION-ARGS ...)
; compiling (DEFUN PROCESS-ONE-FUNCTION-ARG ...)
; compiling (DEFUN ALLEGRO-CONVERT-RETURN-TYPE ...)
; compiling (DEFUN FUNCALLABLE-LAMBDA-LIST ...)
; compiling (DEFUN CONVERT-LISPWORKS-ARGS ...)
; compiling (DEFUN PREPROCESS-NAMES ...)
; compiling (DEFUN PREPROCESS-ARGS ...)
; compiling (DEFMACRO DEF-FUNCTION ...)
; compiling (DEFMACRO %DEF-FUNCTION ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/functions.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: redefining SIZE-OF-FOREIGN-TYPE in DEFUN
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
strings.lisp" (written 14 AUG 2006 08:25:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEF-POINTER-VAR +NULL-CSTRING-POINTER+ ...)
; compiling (DEFMACRO CONVERT-FROM-CSTRING ...)
; compiling (DEFMACRO CONVERT-TO-CSTRING ...)
; compiling (DEFMACRO FREE-CSTRING ...)
; compiling (DEFMACRO WITH-CSTRING ...)
; compiling (DEFMACRO WITH-CSTRINGS ...)
; compiling (DEFMACRO CONVERT-TO-FOREIGN-STRING ...)
; compiling (DEFMACRO CONVERT-FROM-FOREIGN-STRING ...); in: LAMBDA NIL
; (LET* ((UFFI::OBJ (CAR (CDR #:WHOLE48)))
; (LENGTH
; (IF (SB-KERNEL::KEYWORD-SUPPLIED-P :LENGTH #:KEYWORDS-51)
; (SB-KERNEL::LOOKUP-KEYWORD :LENGTH #:KEYWORDS-51) NIL))
; (UFFI::LOCALE
; (IF #:SUPPLIEDP-52 (SB-KERNEL::LOOKUP-KEYWORD ':LOCALE
#:KEYWORDS-51)
; :DEFAULT))
; (UFFI::NULL-TERMINATED-P
; (IF #:SUPPLIEDP-53
; (SB-KERNEL::LOOKUP-KEYWORD ':NULL-TERMINATED-P
#:KEYWORDS-51) T)))
; (BLOCK UFFI:CONVERT-FROM-FOREIGN-STRING
; (LET ((UFFI::STORED-OBJ #))
; `(LET (#)
; (IF # ,NIL #)))))
;
; caught STYLE-WARNING:
; The variable LOCALE is defined but never used.
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/strings.lisp
; in: DEFMACRO CONVERT-FROM-FOREIGN-STRING
; (DEFMACRO UFFI:CONVERT-FROM-FOREIGN-STRING
; (UFFI::OBJ
; &KEY LENGTH (UFFI::LOCALE :DEFAULT) (UFFI::NULL-
TERMINATED-P T))
; (LET ((UFFI::STORED-OBJ (GENSYM)))
; `(LET ((,UFFI::STORED-OBJ ,UFFI::OBJ))
; (IF (UFFI:NULL-POINTER-P ,UFFI::STORED-OBJ) ,NIL
; (UFFI::SBCL-NATURALIZE-CSTRING # :LENGTH ,LENGTH
; :NULL-TERMINATED-P ,UFFI::NULL-TERMINATED-P)))))
; --> EVAL-WHEN SB-C::%DEFMACRO LET*
; ==>
; (LET* ((UFFI::OBJ (CAR (CDR #:WHOLE48)))
; (LENGTH
; (IF (SB-KERNEL::KEYWORD-SUPPLIED-P :LENGTH #:KEYWORDS-51)
; (SB-KERNEL::LOOKUP-KEYWORD :LENGTH #:KEYWORDS-51) NIL))
; (UFFI::LOCALE
; (IF #:SUPPLIEDP-52 (SB-KERNEL::LOOKUP-KEYWORD ':LOCALE
#:KEYWORDS-51)
; :DEFAULT))
; (UFFI::NULL-TERMINATED-P
; (IF #:SUPPLIEDP-53
; (SB-KERNEL::LOOKUP-KEYWORD ':NULL-TERMINATED-P
#:KEYWORDS-51) T)))
; (BLOCK UFFI:CONVERT-FROM-FOREIGN-STRING
; (LET ((UFFI::STORED-OBJ #))
; `(LET (#)
; (IF # ,NIL #)))))
;
; caught STYLE-WARNING:
; The variable LOCALE is defined but never used.
; compiling (DEFMACRO ALLOCATE-FOREIGN-STRING ...)
; compiling (DEFUN FOREIGN-STRING-LENGTH ...)
; compiling (DEFMACRO WITH-FOREIGN-STRING ...)
; compiling (DEFMACRO WITH-FOREIGN-STRINGS ...)
; compiling (DEFUN SBCL-NATURALIZE-CSTRING ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/strings.lisp
; in: DEFUN SBCL-NATURALIZE-CSTRING
; (SUBSEQ UFFI::CASTED 0 LENGTH)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))),
not a LIST.
; (COPY-SEQ (SUBSEQ UFFI::CASTED 0 LENGTH))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a
VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a
LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a SB-
KERNEL:EXTENDED-SEQUENCE.
; (COPY-SEQ UFFI::CASTED)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))),
not a LIST.
; (FUNCALL UFFI::*SYSTEM-COPY-FN* UFFI::SAP 0 UFFI::RESULT
; UFFI::+SYSTEM-COPY-OFFSET+ (* LENGTH UFFI::+SYSTEM-COPY-
MULTIPLIER+))
; --> 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.
; compiling (DEF-FUNCTION "strlen" ...)
; compiling (DEF-TYPE CHAR-PTR-DEF ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/strings.fasl written
; compilation finished in 0:00:01
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {11FF3E59}> on
#<CL-SOURCE-FILE "strings" {12A69201}>.
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
libraries.lisp" (written 22 JUL 2007 09:09:39 PM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFVAR *LOADED-LIBRARIES* ...)
; compiling (DEFUN DEFAULT-FOREIGN-LIBRARY-TYPE ...)
; compiling (DEFUN FOREIGN-LIBRARY-TYPES ...)
; compiling (DEFUN FIND-FOREIGN-LIBRARY ...)
; compiling (DEFUN LOAD-FOREIGN-LIBRARY ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/libraries.lisp
; in: DEFUN LOAD-FOREIGN-LIBRARY
; (FLET ((UFFI::LOAD-FAILURE ()
; (ERROR "Unable to load foreign library \"~A\"."
UFFI::FILENAME)))
; (WHEN (AND UFFI::FILENAME (OR (NULL #) (PROBE-FILE
UFFI::FILENAME)))
; (IF (PATHNAMEP UFFI::FILENAME) (SETQ UFFI::FILENAME
(NAMESTRING #)))
; (IF
; (AND (NOT UFFI::FORCE-LOAD)
; (FIND UFFI::FILENAME UFFI::*LOADED-LIBRARIES* :TEST
; #'STRING-EQUAL))
; T
; (PROGN
; (HANDLER-CASE # #)
; (PUSH UFFI::FILENAME UFFI::*LOADED-LIBRARIES*)
; T))))
;
; note: deleting unused function
; (FLET LOAD-FAILURE)
; compiling (DEFUN CONVERT-SUPPORTING-LIBRARIES-TO-STRING ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/libraries.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
os.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN GETENV ...)
; compiling (DEFUN RUN-SHELL-COMMAND ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/os.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: redefining STRLEN in DEFUN
;
; compilation unit finished
; caught 2 STYLE-WARNING conditions
; printed 12 notes
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
package.lisp" (written 10 MAY 2006 02:42:59 AM):
; compiling (IN-PACKAGE #:CL-USER)
; compiling (DEFPACKAGE #:UFFI ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
primitives.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFMACRO DEF-CONSTANT ...)
; compiling (DEFMACRO DEF-TYPE ...)
; compiling (DEFMACRO NULL-CHAR-P ...)
; compiling (DEFMACRO DEF-FOREIGN-TYPE ...)
; compiling (DEFVAR +TYPE-CONVERSION-HASH+ ...)
; compiling (DEFVAR *CMU-DEF-TYPE-HASH* ...)
; compiling (DEFVAR *CMU-SBCL-DEF-TYPE-LIST* ...)
; compiling (DEFVAR *TYPE-CONVERSION-LIST* ...)
; compiling (SETQ *TYPE-CONVERSION-LIST* ...)
; compiling (DOLIST (TYPE *TYPE-CONVERSION-LIST*) ...)
; compiling (DOLIST (TYPE *CMU-SBCL-DEF-TYPE-LIST*) ...)
; compiling (DEFUN BASIC-CONVERT-FROM-UFFI-TYPE ...)
; compiling (DEFUN %CONVERT-FROM-UFFI-TYPE ...)
; compiling (DEFUN CONVERT-FROM-UFFI-TYPE ...)
; compiling (WHEN (CHAR= #\a ...) ...)
; compiling (WHEN (NOT #) ...)
; compiling (DEFUN MAKE-LISP-NAME ...)
; compiling (SETQ *FEATURES* ...)
; compiling (SETQ *FEATURES* ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/primitives.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: redefining BASIC-CONVERT-FROM-UFFI-TYPE in DEFUN
STYLE-WARNING: redefining %CONVERT-FROM-UFFI-TYPE in DEFUN
STYLE-WARNING: redefining CONVERT-FROM-UFFI-TYPE in DEFUN
STYLE-WARNING: redefining MAKE-LISP-NAME in DEFUN
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
objects.lisp" (written 14 AUG 2006 06:26:22 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN SIZE-OF-FOREIGN-TYPE ...)
;
; caught STYLE-WARNING:
; redefining SIZE-OF-FOREIGN-TYPE in DEFUN
; compiling (DEFMACRO ALLOCATE-FOREIGN-OBJECT ...)
; compiling (DEFMACRO FREE-FOREIGN-OBJECT ...)
; compiling (DEFMACRO NULL-POINTER-P ...)
; compiling (DEFMACRO MAKE-NULL-POINTER ...)
; compiling (DEFMACRO MAKE-POINTER ...)
; compiling (DEFMACRO CHAR-ARRAY-TO-POINTER ...)
; compiling (DEFMACRO DEREF-POINTER ...)
; compiling (DEFMACRO ENSURE-CHAR-CHARACTER ...)
; compiling (DEFMACRO ENSURE-CHAR-INTEGER ...)
; compiling (DEFMACRO ENSURE-CHAR-STORABLE ...)
; compiling (DEFMACRO POINTER-ADDRESS ...)
; compiling (DEFMACRO WITH-FOREIGN-OBJECT ...)
; compiling (DEFMACRO WITH-FOREIGN-OBJECTS ...)
; compiling (DEFMACRO WITH-CAST-POINTER ...)
; compiling (DEFMACRO DEF-FOREIGN-VAR ...)
; compiling (DEFMACRO DEF-POINTER-VAR ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/objects.fasl written
; compilation finished in 0:00:00
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {12A68EC1}> on
#<CL-SOURCE-FILE "objects" {11FB29F1}>.
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
aggregates.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFMACRO DEF-ENUM ...)
; compiling (DEFMACRO DEF-ARRAY-POINTER ...)
; compiling (DEFUN PROCESS-STRUCT-FIELDS ...)
; compiling (DEFMACRO DEF-STRUCT ...)
; compiling (DEFMACRO GET-SLOT-VALUE ...)
; compiling (DEFMACRO GET-SLOT-POINTER ...)
; compiling (DEFMACRO DEREF-ARRAY ...)
; compiling (DEFMACRO DEF-UNION ...)
; compiling (SB-EXT:WITHOUT-PACKAGE-LOCKS (DEFVAR *SYSTEM-COPY-
FN* ...) ...)
; compiling (DEFUN CONVERT-FROM-FOREIGN-USB8 ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/aggregates.lisp
; in: DEFUN CONVERT-FROM-FOREIGN-USB8
; (MAKE-ARRAY UFFI::LEN :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a
INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (FUNCALL UFFI::*SYSTEM-COPY-FN* UFFI::SAP 0 UFFI::RESULT
; UFFI::+SYSTEM-COPY-OFFSET+
; (* UFFI::LEN UFFI::+SYSTEM-COPY-MULTIPLIER+))
; --> 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.
; /Users/jensteich/Lisp/uffi-1.6.0/src/aggregates.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
functions.lisp" (written 13 APR 2007 07:49:01 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN PROCESS-FUNCTION-ARGS ...)
; compiling (DEFUN PROCESS-ONE-FUNCTION-ARG ...)
; compiling (DEFUN ALLEGRO-CONVERT-RETURN-TYPE ...)
; compiling (DEFUN FUNCALLABLE-LAMBDA-LIST ...)
; compiling (DEFUN CONVERT-LISPWORKS-ARGS ...)
; compiling (DEFUN PREPROCESS-NAMES ...)
; compiling (DEFUN PREPROCESS-ARGS ...)
; compiling (DEFMACRO DEF-FUNCTION ...)
; compiling (DEFMACRO %DEF-FUNCTION ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/functions.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining PROCESS-FUNCTION-ARGS in DEFUN
STYLE-WARNING: redefining PROCESS-ONE-FUNCTION-ARG in DEFUN
STYLE-WARNING: redefining ALLEGRO-CONVERT-RETURN-TYPE in DEFUN
STYLE-WARNING: redefining FUNCALLABLE-LAMBDA-LIST in DEFUN
STYLE-WARNING: redefining CONVERT-LISPWORKS-ARGS in DEFUN
STYLE-WARNING: redefining PREPROCESS-NAMES in DEFUN
STYLE-WARNING: redefining PREPROCESS-ARGS in DEFUN
STYLE-WARNING: redefining PROCESS-STRUCT-FIELDS in DEFUN
STYLE-WARNING: redefining CONVERT-FROM-FOREIGN-USB8 in DEFUN
STYLE-WARNING: redefining SIZE-OF-FOREIGN-TYPE in DEFUN
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
strings.lisp" (written 14 AUG 2006 08:25:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEF-POINTER-VAR +NULL-CSTRING-POINTER+ ...)
; compiling (DEFMACRO CONVERT-FROM-CSTRING ...)
; compiling (DEFMACRO CONVERT-TO-CSTRING ...)
; compiling (DEFMACRO FREE-CSTRING ...)
; compiling (DEFMACRO WITH-CSTRING ...)
; compiling (DEFMACRO WITH-CSTRINGS ...)
; compiling (DEFMACRO CONVERT-TO-FOREIGN-STRING ...)
; compiling (DEFMACRO CONVERT-FROM-FOREIGN-STRING ...); in: LAMBDA NIL
; (LET* ((UFFI::OBJ (CAR (CDR #:WHOLE48)))
; (LENGTH
; (IF (SB-KERNEL::KEYWORD-SUPPLIED-P :LENGTH #:KEYWORDS-51)
; (SB-KERNEL::LOOKUP-KEYWORD :LENGTH #:KEYWORDS-51) NIL))
; (UFFI::LOCALE
; (IF #:SUPPLIEDP-52 (SB-KERNEL::LOOKUP-KEYWORD ':LOCALE
#:KEYWORDS-51)
; :DEFAULT))
; (UFFI::NULL-TERMINATED-P
; (IF #:SUPPLIEDP-53
; (SB-KERNEL::LOOKUP-KEYWORD ':NULL-TERMINATED-P
#:KEYWORDS-51) T)))
; (BLOCK UFFI:CONVERT-FROM-FOREIGN-STRING
; (LET ((UFFI::STORED-OBJ #))
; `(LET (#)
; (IF # ,NIL #)))))
;
; caught STYLE-WARNING:
; The variable LOCALE is defined but never used.
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/strings.lisp
; in: DEFMACRO CONVERT-FROM-FOREIGN-STRING
; (DEFMACRO UFFI:CONVERT-FROM-FOREIGN-STRING
; (UFFI::OBJ
; &KEY LENGTH (UFFI::LOCALE :DEFAULT) (UFFI::NULL-
TERMINATED-P T))
; (LET ((UFFI::STORED-OBJ (GENSYM)))
; `(LET ((,UFFI::STORED-OBJ ,UFFI::OBJ))
; (IF (UFFI:NULL-POINTER-P ,UFFI::STORED-OBJ) ,NIL
; (UFFI::SBCL-NATURALIZE-CSTRING # :LENGTH ,LENGTH
; :NULL-TERMINATED-P
; ,UFFI::NULL-TERMINATED-
P)))))
; --> EVAL-WHEN SB-C::%DEFMACRO LET*
; ==>
; (LET* ((UFFI::OBJ (CAR (CDR #:WHOLE48)))
; (LENGTH
; (IF (SB-KERNEL::KEYWORD-SUPPLIED-P :LENGTH #:KEYWORDS-51)
; (SB-KERNEL::LOOKUP-KEYWORD :LENGTH #:KEYWORDS-51) NIL))
; (UFFI::LOCALE
; (IF #:SUPPLIEDP-52 (SB-KERNEL::LOOKUP-KEYWORD ':LOCALE
#:KEYWORDS-51)
; :DEFAULT))
; (UFFI::NULL-TERMINATED-P
; (IF #:SUPPLIEDP-53
; (SB-KERNEL::LOOKUP-KEYWORD ':NULL-TERMINATED-P
#:KEYWORDS-51) T)))
; (BLOCK UFFI:CONVERT-FROM-FOREIGN-STRING
; (LET ((UFFI::STORED-OBJ #))
; `(LET (#)
; (IF # ,NIL #)))))
;
; caught STYLE-WARNING:
; The variable LOCALE is defined but never used.
; compiling (DEFMACRO ALLOCATE-FOREIGN-STRING ...)
; compiling (DEFUN FOREIGN-STRING-LENGTH ...)
; compiling (DEFMACRO WITH-FOREIGN-STRING ...)
; compiling (DEFMACRO WITH-FOREIGN-STRINGS ...)
; compiling (DEFUN SBCL-NATURALIZE-CSTRING ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/strings.lisp
; in: DEFUN SBCL-NATURALIZE-CSTRING
; (SUBSEQ UFFI::CASTED 0 LENGTH)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))),
not a LIST.
; (COPY-SEQ (SUBSEQ UFFI::CASTED 0 LENGTH))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a
VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a
LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL
; SB-KERNEL:EXTENDED-SEQUENCE), not a SB-
KERNEL:EXTENDED-SEQUENCE.
; (COPY-SEQ UFFI::CASTED)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))),
not a LIST.
; (FUNCALL UFFI::*SYSTEM-COPY-FN* UFFI::SAP 0 UFFI::RESULT
; UFFI::+SYSTEM-COPY-OFFSET+ (* LENGTH UFFI::+SYSTEM-COPY-
MULTIPLIER+))
; --> 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.
; compiling (DEF-FUNCTION "strlen" ...)
;
; caught STYLE-WARNING:
; redefining STRLEN in DEFUN
; compiling (DEF-TYPE CHAR-PTR-DEF ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/strings.fasl written
; compilation finished in 0:00:00
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {12A68EC1}> on
#<CL-SOURCE-FILE "strings" {12A69201}>.
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
libraries.lisp" (written 22 JUL 2007 09:09:39 PM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFVAR *LOADED-LIBRARIES* ...)
; compiling (DEFUN DEFAULT-FOREIGN-LIBRARY-TYPE ...)
; compiling (DEFUN FOREIGN-LIBRARY-TYPES ...)
; compiling (DEFUN FIND-FOREIGN-LIBRARY ...)
; compiling (DEFUN LOAD-FOREIGN-LIBRARY ...)
; file: /Users/jensteich/Lisp/uffi-1.6.0/src/libraries.lisp
; in: DEFUN LOAD-FOREIGN-LIBRARY
; (FLET ((UFFI::LOAD-FAILURE ()
; (ERROR "Unable to load foreign library \"~A\"."
UFFI::FILENAME)))
; (WHEN (AND UFFI::FILENAME (OR (NULL #) (PROBE-FILE
UFFI::FILENAME)))
; (IF (PATHNAMEP UFFI::FILENAME) (SETQ UFFI::FILENAME
(NAMESTRING #)))
; (IF
; (AND (NOT UFFI::FORCE-LOAD)
; (FIND UFFI::FILENAME UFFI::*LOADED-LIBRARIES* :TEST
; #'STRING-EQUAL))
; T
; (PROGN
; (HANDLER-CASE # #)
; (PUSH UFFI::FILENAME UFFI::*LOADED-LIBRARIES*)
; T))))
;
; note: deleting unused function
; (FLET LOAD-FAILURE)
; compiling (DEFUN CONVERT-SUPPORTING-LIBRARIES-TO-STRING ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/libraries.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/uffi-1.6.0/src/
os.lisp" (written 18 APR 2006 02:07:09 AM):
; compiling (IN-PACKAGE #:UFFI)
; compiling (DEFUN GETENV ...)
; compiling (DEFUN RUN-SHELL-COMMAND ...)
; /Users/jensteich/Lisp/uffi-1.6.0/src/os.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: redefining FOREIGN-STRING-LENGTH in DEFUN
STYLE-WARNING: redefining SBCL-NATURALIZE-CSTRING in DEFUN
STYLE-WARNING: redefining STRLEN in DEFUN
STYLE-WARNING: redefining DEFAULT-FOREIGN-LIBRARY-TYPE in DEFUN
STYLE-WARNING: redefining FOREIGN-LIBRARY-TYPES in DEFUN
STYLE-WARNING: redefining FIND-FOREIGN-LIBRARY in DEFUN
STYLE-WARNING: redefining LOAD-FOREIGN-LIBRARY in DEFUN
STYLE-WARNING: redefining CONVERT-SUPPORTING-LIBRARIES-TO-STRING in
DEFUN
STYLE-WARNING: redefining GETENV in DEFUN
STYLE-WARNING: redefining RUN-SHELL-COMMAND in DEFUN
; compiling file "/Users/jensteich/Lisp/elephant/src/utils/
package.lisp" (written 12 APR 2007 04:47:51 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:ELEPHANT-UTILS ...)
; /Users/jensteich/Lisp/elephant/src/utils/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/utils/
convenience.lisp" (written 12 APR 2007 04:47:51 AM):
; compiling (IN-PACKAGE :ELEPHANT-UTILS)
; compiling (DEFMACRO WITH-GENSYMS ...)
; compiling (DEFMACRO DO-SUBSETS ...)
; compiling (DEFUN SUBSETS ...)
; compiling (DEFUN REMOVE-KEYWORDS ...)
; compiling (DEFUN CONCAT-SEPARATED-STRINGS ...)
; compiling (DEFUN APPEND-SUBLISTS ...)
; compiling (DEFMACRO IFRET ...)
; compiling (DEFMACRO AIF ...)
; compiling (DEFMACRO AWHEN ...)
; compiling (DEFUN MKLIST ...)
; compiling (DEFUN REMOVE-INDEXED-ELEMENT-AND-ADJUST ...)
; /Users/jensteich/Lisp/elephant/src/utils/convenience.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/utils/
locks.lisp" (written 12 APR 2007 04:47:51 AM):
; compiling (IN-PACKAGE :ELEPHANT-UTILS)
; compiling (DEFUN ELE-MAKE-LOCK ...)
; compiling (DEFMACRO ELE-WITH-LOCK ...)
; compiling (DEFUN ELE-MAKE-FAST-LOCK ...)
; compiling (DEFMACRO ELE-WITH-FAST-LOCK ...)
; compiling (DEFUN ELE-THREAD-HASH-KEY ...)
; /Users/jensteich/Lisp/elephant/src/utils/locks.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/utils/
os.lisp" (written 29 APR 2007 11:54:51 PM):
; compiling (IN-PACKAGE :ELEPHANT-UTILS)
; compiling (DEFMACRO IN-DIRECTORY ...)
; compiling (DEFUN LAUNCH-BACKGROUND-PROGRAM ...)
; compiling (DEFUN KILL-BACKGROUND-PROGRAM ...)
; /Users/jensteich/Lisp/elephant/src/utils/os.fasl written
; compilation finished in 0:00:01
Attempting to load libmemutil.dylib...
Loaded /Users/jensteich/Lisp/elephant/src/memutil/libmemutil.dylib
; compiling file "/Users/jensteich/Lisp/elephant/src/memutil/
memutil.lisp" (written 29 APR 2007 04:10:55 AM):
; compiling (DEFPACKAGE ELEPHANT-MEMUTIL ...)
; compiling (IN-PACKAGE "ELEPHANT-MEMUTIL")
; compiling (DEF-TYPE POINTER-INT ...)
; compiling (DEF-TYPE POINTER-VOID ...)
; compiling (DEF-FOREIGN-TYPE ARRAY-OR-POINTER-CHAR ...)
; compiling (DEF-TYPE ARRAY-OR-POINTER-CHAR ...)
; compiling (DEF-FUNCTION ("copy_buf" COPY-BUFS) ...)
; compiling (DEFVAR +NULL-VOID+ ...)
; compiling (DEFVAR +NULL-CHAR+ ...)
; compiling (DEFVAR *BUFFER-STREAMS* ...)
; compiling (DEFVAR *BUFFER-STREAMS-LOCK* ...)
; compiling (DEFSTRUCT BUFFER-STREAM ...)
; compiling (DEFUN GRAB-BUFFER-STREAM ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN GRAB-BUFFER-STREAM
; (LENGTH ELEPHANT-MEMUTIL::*BUFFER-STREAMS*)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFUN RETURN-BUFFER-STREAM ...)
; compiling (DEFMACRO WITH-BUFFER-STREAMS ...)
; compiling (DEFUN READ-INT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-INT32
; (DEFUN ELEPHANT-MEMUTIL::READ-INT32
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; "Read a 32-bit signed integer from a foreign char buffer."
; (DECLARE (TYPE (ALIEN (* UNSIGNED-CHAR)) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (THE (SIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* #)))))
; --> PROGN EVAL-WHEN
; ==>
; (SB-IMPL::%DEFUN 'ELEPHANT-MEMUTIL::READ-INT32
; (SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-INT32
; (ELEPHANT-MEMUTIL::BUF
; ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE
; (TYPE (ALIEN #) ELEPHANT-
MEMUTIL::BUF)
; (TYPE FIXNUM
; ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-
MEMUTIL::READ-INT32
; (THE (SIGNED-BYTE 32)
(DEREF #))))
; "Read a 32-bit signed integer from a foreign char
buffer."
; 'NIL (SB-C:SOURCE-LOCATION))
;
; note: doing signed word to integer coercion (cost 20) to "<return
value>"
; compiling (DEFUN READ-INT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-INT64
; (DEREF
; (CAST
; (SAP-ALIEN
; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::BUF) ELEPHANT-
MEMUTIL::OFFSET)
; (* UNSIGNED-CHAR))
; (* (SIGNED 64))))
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64 LOGIOR
; ==>
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET 4)) 32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a (SIGNED-BYTE 32), not a (UNSIGNED-BYTE
32).
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
&REST T).
; etc.
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64
; ==>
; (LOGIOR (SB-SYS:SAP-REF-32 SB-VM::SAP SB-VM::OFFSET)
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET
4)) 32))
;
; 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 (UNSIGNED-BYTE 32), not a FIXNUM.
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a FIXNUM.
; The result is a (VALUES (SIGNED-BYTE 64) &OPTIONAL), not a
(VALUES FIXNUM
; &REST
; T
).
; unable to do inline (signed-byte 32) arithmetic (cost 3)
because:
; The first argument is a (UNSIGNED-BYTE 32), not a (SIGNED-BYTE
32).
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a (SIGNED-
BYTE 32).
; The result is a (VALUES (SIGNED-BYTE 64) &OPTIONAL), not a
(VALUES
;
(SIGNED-BYTE
; 32)
;
&REST T).
; etc.
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64 LOGIOR
; ==>
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET 4)) 32)
;
; note: doing signed word to integer coercion (cost 20)
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64
; ==>
; (LOGIOR (SB-SYS:SAP-REF-32 SB-VM::SAP SB-VM::OFFSET)
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET
4)) 32))
;
; note: doing unsigned word to integer coercion (cost 20), for:
; the first argument of static-fun Two-arg-ior
; compiling (DEFUN READ-UINT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-UINT32
; (DEFUN ELEPHANT-MEMUTIL::READ-UINT32
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; "Read a 32-bit unsigned integer from a foreign char buffer."
; (DECLARE (TYPE (ALIEN (* UNSIGNED-CHAR)) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (THE (UNSIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* #)))))
; --> PROGN EVAL-WHEN
; ==>
; (SB-IMPL::%DEFUN 'ELEPHANT-MEMUTIL::READ-UINT32
; (SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-UINT32
; (ELEPHANT-MEMUTIL::BUF
; ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE
; (TYPE (ALIEN #) ELEPHANT-
MEMUTIL::BUF)
; (TYPE FIXNUM
; ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-
MEMUTIL::READ-UINT32
; (THE (UNSIGNED-BYTE 32)
(DEREF #))))
; "Read a 32-bit unsigned integer from a foreign
char buffer."
; 'NIL (SB-C:SOURCE-LOCATION))
;
; note: doing unsigned word to integer coercion (cost 20) to "<return
value>"
; compiling (DEFUN READ-UINT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-UINT64
; (DEREF
; (CAST
; (SAP-ALIEN
; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::BUF) ELEPHANT-
MEMUTIL::OFFSET)
; (* UNSIGNED-CHAR))
; (* (SIGNED 64))))
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64 LOGIOR
; ==>
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET 4)) 32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a (SIGNED-BYTE 32), not a (UNSIGNED-BYTE
32).
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
&REST T).
; etc.
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64
; ==>
; (LOGIOR (SB-SYS:SAP-REF-32 SB-VM::SAP SB-VM::OFFSET)
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET
4)) 32))
;
; 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 (UNSIGNED-BYTE 32), not a FIXNUM.
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a FIXNUM.
; The result is a (VALUES (SIGNED-BYTE 64) &OPTIONAL), not a
(VALUES FIXNUM
; &REST
; T
).
; unable to do inline (signed-byte 32) arithmetic (cost 3)
because:
; The first argument is a (UNSIGNED-BYTE 32), not a (SIGNED-BYTE
32).
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a (SIGNED-
BYTE 32).
; The result is a (VALUES (SIGNED-BYTE 64) &OPTIONAL), not a
(VALUES
;
(SIGNED-BYTE
; 32)
;
&REST T).
; etc.
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64 LOGIOR
; ==>
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET 4)) 32)
;
; note: doing signed word to integer coercion (cost 20)
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; --> SB-SYS:SIGNED-SAP-REF-64
; ==>
; (LOGIOR (SB-SYS:SAP-REF-32 SB-VM::SAP SB-VM::OFFSET)
; (ASH (SB-SYS:SIGNED-SAP-REF-32 SB-VM::SAP (+ SB-VM::OFFSET
4)) 32))
;
; note: doing unsigned word to integer coercion (cost 20), for:
; the first argument of static-fun Two-arg-ior
; compiling (DEFUN READ-FLOAT ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-FLOAT
; (DEFUN ELEPHANT-MEMUTIL::READ-FLOAT
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; "Read a single-float from a foreign char buffer."
; (DECLARE (TYPE (ALIEN (* UNSIGNED-CHAR)) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (THE SINGLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* SINGLE-
FLOAT)))))
; --> PROGN EVAL-WHEN
; ==>
; (SB-IMPL::%DEFUN 'ELEPHANT-MEMUTIL::READ-FLOAT
; (SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-FLOAT
; (ELEPHANT-MEMUTIL::BUF
; ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE
; (TYPE (ALIEN #) ELEPHANT-
MEMUTIL::BUF)
; (TYPE FIXNUM
; ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-
MEMUTIL::READ-FLOAT
; (THE SINGLE-FLOAT (DEREF
#))))
; "Read a single-float from a foreign char buffer."
; '(SB-C:LAMBDA-WITH-LEXENV NIL NIL NIL
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE (TYPE (ALIEN #) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-MEMUTIL::READ-FLOAT
; (THE SINGLE-FLOAT (DEREF #))))
; (SB-C:SOURCE-LOCATION))
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; compiling (DEFUN READ-DOUBLE ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-DOUBLE
; (DEFUN ELEPHANT-MEMUTIL::READ-DOUBLE
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; "Read a double-float from a foreign char buffer."
; (DECLARE (TYPE (ALIEN (* UNSIGNED-CHAR)) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (THE DOUBLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* DOUBLE-
FLOAT)))))
; --> PROGN EVAL-WHEN
; ==>
; (SB-IMPL::%DEFUN 'ELEPHANT-MEMUTIL::READ-DOUBLE
; (SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-DOUBLE
; (ELEPHANT-MEMUTIL::BUF
; ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE
; (TYPE (ALIEN #) ELEPHANT-
MEMUTIL::BUF)
; (TYPE FIXNUM
; ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-
MEMUTIL::READ-DOUBLE
; (THE DOUBLE-FLOAT (DEREF
#))))
; "Read a double-float from a foreign char buffer."
; '(SB-C:LAMBDA-WITH-LEXENV NIL NIL NIL
; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
; (DECLARE (TYPE (ALIEN #) ELEPHANT-MEMUTIL::BUF)
; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
; (BLOCK ELEPHANT-MEMUTIL::READ-DOUBLE
; (THE DOUBLE-FLOAT (DEREF #))))
; (SB-C:SOURCE-LOCATION))
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; compiling (DEFUN WRITE-INT32 ...)
; compiling (DEFUN WRITE-INT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN WRITE-INT64
; (SETF (DEREF
; (CAST
; (SAP-ALIEN (SB-SYS:SAP+ # ELEPHANT-MEMUTIL::OFFSET)
; (* UNSIGNED-CHAR))
; (* (SIGNED 64))))
; ELEPHANT-MEMUTIL::NUM)
; --> LET* MULTIPLE-VALUE-BIND LET SB-ALIEN-INTERNALS:%SET-DEREF
; --> SB-ALIEN-INTERNALS:DEPOSIT-ALIEN-VALUE LET
; --> SB-ALIEN-INTERNALS:MAYBE-WITH-PINNED-OBJECTS PROGN LET SETF
; --> SB-KERNEL:%SET-SIGNED-SAP-REF-64 PROGN SB-KERNEL:%SET-SAP-REF-32
; ==>
; (LOGAND SB-VM::VALUE 4294967295)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a (SIGNED-BYTE 64), not a (UNSIGNED-BYTE
32).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a (SIGNED-BYTE 64), not a (SIGNED-BYTE
32).
; etc.
; --> LET* MULTIPLE-VALUE-BIND LET SB-ALIEN-INTERNALS:%SET-DEREF
; --> SB-ALIEN-INTERNALS:DEPOSIT-ALIEN-VALUE LET
; --> SB-ALIEN-INTERNALS:MAYBE-WITH-PINNED-OBJECTS PROGN LET SETF
; --> SB-KERNEL:%SET-SIGNED-SAP-REF-64 PROGN
; --> SB-KERNEL:%SET-SIGNED-SAP-REF-32
; ==>
; (ASH SB-VM::VALUE -32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (SIGNED-BYTE 64), not a FIXNUM.
; The result is a (VALUES (SIGNED-BYTE 32) &OPTIONAL), not a
(VALUES FIXNUM
; &REST
; T
).
; unable to do inline ASH (cost 3) because:
; The first argument is a (SIGNED-BYTE 64), not a (UNSIGNED-BYTE
32).
; The result is a (VALUES (SIGNED-BYTE 32) &OPTIONAL), not a
(VALUES
;
(UNSIGNED-BYTE
; 32)
;
&REST T).
; etc.
; compiling (DEFUN WRITE-UINT32 ...)
; compiling (DEFUN WRITE-UINT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN WRITE-UINT64
; (SETF (DEREF
; (CAST
; (SAP-ALIEN (SB-SYS:SAP+ # ELEPHANT-MEMUTIL::OFFSET)
; (* UNSIGNED-CHAR))
; (* (UNSIGNED 64))))
; ELEPHANT-MEMUTIL::NUM)
; --> LET* MULTIPLE-VALUE-BIND LET SB-ALIEN-INTERNALS:%SET-DEREF
; --> SB-ALIEN-INTERNALS:DEPOSIT-ALIEN-VALUE LET
; --> SB-ALIEN-INTERNALS:MAYBE-WITH-PINNED-OBJECTS PROGN LET SETF
; --> SB-KERNEL:%SET-SAP-REF-64 PROGN SB-KERNEL:%SET-SAP-REF-32
; ==>
; (LOGAND SB-VM::VALUE 4294967295)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a (UNSIGNED-BYTE 64), not a (UNSIGNED-
BYTE 32).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a (UNSIGNED-BYTE 64), not a (SIGNED-BYTE
32).
; etc.
; ==>
; (ASH SB-VM::VALUE -32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
; The result is a (VALUES (UNSIGNED-BYTE 32) &OPTIONAL), not a
(VALUES
;
FIXNUM
;
&REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a (UNSIGNED-BYTE 64), not a (UNSIGNED-
BYTE 32).
; etc.
; compiling (DEFUN WRITE-FLOAT ...)
; compiling (DEFUN WRITE-DOUBLE ...)
; compiling (DEFUN OFFSET-CHAR-POINTER ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN OFFSET-CHAR-POINTER
; (SAP-ALIEN
; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-
MEMUTIL::OFFSET)
; (* UNSIGNED-CHAR))
; ==>
; (SB-ALIEN-INTERNALS:%SAP-ALIEN
; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-
MEMUTIL::OFFSET)
; '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (* (UNSIGNED 8))>)
;
; note: unable to
; optimize
; because:
; could not optimize away %SAP-ALIEN: forced to do runtime
; allocation of alien-value structure
;
; note: doing SAP to pointer coercion (cost 20)
; compiling (DEFMACRO BYTE-LENGTH ...)
; compiling (DEF-FUNCTION ("copy_buf" %COPY-STR-TO-BUF) ...)
; compiling (DEFUN COPY-STR-TO-BUF ...)
; compiling (DEFUN PROCESS-STRUCT-SLOT-DEFS ...)
; compiling (DEFMACRO WITH-STRUCT-SLOTS ...)
; compiling (DEFUN RESIZE-BUFFER-STREAM ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN RESIZE-BUFFER-STREAM
; (LET ((ELEPHANT-MEMUTIL::NEWLEN (MAX LENGTH (* ELEPHANT-
MEMUTIL::LEN 2))))
; (DECLARE (TYPE FIXNUM ELEPHANT-MEMUTIL::NEWLEN))
; (LET ((ELEPHANT-MEMUTIL::NEWBUF
; (UFFI:ALLOCATE-FOREIGN-OBJECT :UNSIGNED-CHAR
; ELEPHANT-MEMUTIL::NEWLEN)))
; (WHEN (UFFI:NULL-POINTER-P ELEPHANT-MEMUTIL::NEWBUF)
; (ERROR
; "Failed to allocate buffer stream of length ~A. allocate-
foreign-object returned a null pointer"
; ELEPHANT-MEMUTIL::NEWLEN))
; (ELEPHANT-MEMUTIL::COPY-BUFS ELEPHANT-MEMUTIL::NEWBUF 0
; ELEPHANT-MEMUTIL::BUF 0
; ELEPHANT-MEMUTIL::SIZE)
; (UFFI:FREE-FOREIGN-OBJECT ELEPHANT-MEMUTIL::BUF)
; (SETF ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::NEWBUF)
; (SETF ELEPHANT-MEMUTIL::LEN ELEPHANT-MEMUTIL::NEWLEN)
; NIL))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN RESIZE-BUFFER-STREAM-NO-COPY ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN RESIZE-BUFFER-STREAM-NO-COPY
; (LET ((ELEPHANT-MEMUTIL::NEWLEN (MAX LENGTH (* ELEPHANT-
MEMUTIL::LEN 2))))
; (DECLARE (TYPE FIXNUM ELEPHANT-MEMUTIL::NEWLEN))
; (LET ((ELEPHANT-MEMUTIL::NEWBUF
; (UFFI:ALLOCATE-FOREIGN-OBJECT :UNSIGNED-CHAR
; ELEPHANT-MEMUTIL::NEWLEN)))
; (WHEN (UFFI:NULL-POINTER-P ELEPHANT-MEMUTIL::NEWBUF)
; (ERROR
; "Failed to allocate buffer stream of length ~A. allocate-
foreign-object returned a null pointer"
; ELEPHANT-MEMUTIL::NEWLEN))
; (UFFI:FREE-FOREIGN-OBJECT ELEPHANT-MEMUTIL::BUF)
; (SETF ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::NEWBUF)
; (SETF ELEPHANT-MEMUTIL::LEN ELEPHANT-MEMUTIL::NEWLEN)
; NIL))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN RESET-BUFFER-STREAM ...)
; compiling (DEFUN BUFFER-WRITE-BYTE ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-BYTE
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1296D5D9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-376)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-INT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-INT32
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {129D9F51}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-386)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-UINT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-UINT32
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12A18581}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-395)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-INT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-INT64
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12A63551}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-404)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-UINT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-UINT64
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1177F999}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-413)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-FLOAT ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-FLOAT
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {117BB351}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-424)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-DOUBLE ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-DOUBLE
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11803F91}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-436)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-STRING
; (LET* ((ELEPHANT-MEMUTIL::STR-BYTES
; (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT-MEMUTIL::S))
; (ELEPHANT-MEMUTIL::NEEDED
; (+ ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::STR-BYTES)))
; (DECLARE (TYPE FIXNUM ELEPHANT-MEMUTIL::STR-BYTES ELEPHANT-
MEMUTIL::NEEDED)
; (DYNAMIC-EXTENT ELEPHANT-MEMUTIL::STR-BYTES ELEPHANT-
MEMUTIL::NEEDED))
; (WHEN (> ELEPHANT-MEMUTIL::NEEDED ELEPHANT-MEMUTIL::LEN)
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED))
; (ELEPHANT-MEMUTIL::COPY-STR-TO-BUF ELEPHANT-MEMUTIL::BUF
; ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::S 0 ELEPHANT-
MEMUTIL::STR-BYTES)
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; NIL)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-BYTE ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-BYTE
; (INCF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS))
; --> LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1195F5C9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-470)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-BYTE-VECTOR ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-BYTE
; (INCF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS))
; --> LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {119B5659}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-483)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-WRITE-BYTE-VECTOR ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-BYTE-VECTOR
; (LENGTH ELEPHANT-MEMUTIL::BV)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (AREF ELEPHANT-MEMUTIL::BV ELEPHANT-MEMUTIL::I)
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; in: DEFUN BUFFER-WRITE-BYTE
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11AF7BA1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-526)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-READ-TO-ARRAY-OFFSET ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-TO-ARRAY-OFFSET
; (LENGTH ELEPHANT-MEMUTIL::ARRY)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (SETF (AREF ELEPHANT-MEMUTIL::ARRY
; (+ ELEPHANT-MEMUTIL::I ELEPHANT-MEMUTIL::OFFSET))
; (ELEPHANT-MEMUTIL:BUFFER-READ-BYTE ELEPHANT-MEMUTIL::BS))
; --> SB-KERNEL:%ASET
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
; SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; in: DEFUN BUFFER-READ-BYTE
; (INCF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS))
; --> LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11BB6309}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-552)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; in: DEFUN BUFFER-READ-TO-ARRAY-OFFSET
; (SETF (AREF ELEPHANT-MEMUTIL::ARRY
; (+ ELEPHANT-MEMUTIL::I ELEPHANT-MEMUTIL::OFFSET))
; (ELEPHANT-MEMUTIL:BUFFER-READ-BYTE ELEPHANT-MEMUTIL::BS))
; --> SB-KERNEL:%ASET
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
; SB-C::NEW-VALUE)
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN BUFFER-WRITE-FROM-ARRAY-OFFSET ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-FROM-ARRAY-OFFSET
; (AREF ELEPHANT-MEMUTIL::ARRY (+ ELEPHANT-MEMUTIL::I ELEPHANT-
MEMUTIL::OFFSET))
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (DOTIMES (ELEPHANT-MEMUTIL::I LENGTH ELEPHANT-MEMUTIL::ARRY)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (AREF ELEPHANT-MEMUTIL::ARRY
; (+ ELEPHANT-MEMUTIL::I ELEPHANT-MEMUTIL::OFFSET))
; ELEPHANT-MEMUTIL::BS))
; --> DO BLOCK LET TAGBODY UNLESS IF >= IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; (+ ELEPHANT-MEMUTIL::I ELEPHANT-MEMUTIL::OFFSET)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912) &OPTIONAL), not a
(VALUES
; FIXNUM
; &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
; The result is a (VALUES (INTEGER -536870912) &OPTIONAL), not a
(VALUES
; (SIGNED
-BYTE
; 32
)
; &REST
T).
; etc.
; (DOTIMES (ELEPHANT-MEMUTIL::I LENGTH ELEPHANT-MEMUTIL::ARRY)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (AREF ELEPHANT-MEMUTIL::ARRY
; (+ ELEPHANT-MEMUTIL::I ELEPHANT-MEMUTIL::OFFSET))
; ELEPHANT-MEMUTIL::BS))
; --> DO BLOCK LET TAGBODY PSETQ PSETF LET* MULTIPLE-VALUE-BIND LET 1+
; ==>
; (+ ELEPHANT-MEMUTIL::I 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; etc.
; in: DEFUN BUFFER-WRITE-BYTE
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11C703C9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-570)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-WRITE-OID ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-INT32
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11D42E29}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-589)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-READ-OID ...)
; compiling (DEFUN BUFFER-READ-INT ...)
; compiling (DEFUN BUFFER-READ-FIXNUM ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-FIXNUM
; (THE FIXNUM (ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM32 ELEPHANT-
MEMUTIL::BS))
;
; note: type assertion too complex to check:
; (VALUES FIXNUM &REST T).
; compiling (DEFUN BUFFER-WRITE-INT ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-INT32
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12409EE9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-604)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFUN BUFFER-READ-UINT ...)
; compiling (DEFUN BUFFER-WRITE-UINT ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-WRITE-UINT32
; (SETF ELEPHANT-MEMUTIL::SIZE ELEPHANT-MEMUTIL::NEEDED)
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {124536C9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-615)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; compiling (DEFCONSTANT +2^32+ ...)
; compiling (DEFCONSTANT +2^64+ ...)
; compiling (DEFUN BUFFER-READ-FIXNUM32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-FIXNUM32
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 4))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {124B5609}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-624)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-INT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-INT32
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 4))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {124E4189}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-632)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-UINT32 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-UINT32
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 4))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12518D11}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-638)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-FIXNUM64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-FIXNUM64
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
; --> TRULY-THE SB-KERNEL:%INSTANCE-REF THE
; ==>
; ELEPHANT-MEMUTIL::BS
;
; note: deleting unreachable code
; (ASH SECOND 32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a (SIGNED-BYTE 32), not a (UNSIGNED-BYTE
32).
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
&REST T).
; etc.
; (+ FIRST (ASH SECOND 32))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372039002259456
9223372034707292159)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a (SIGNED-
BYTE 32).
; The result is a (VALUES
; (INTEGER -9223372039002259456
9223372034707292159)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
&REST T).
; etc.
; (ASH FIRST 32)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a (SIGNED-BYTE 32), not a (UNSIGNED-BYTE
32).
; The result is a (VALUES
; (INTEGER -9223372036854775808
9223372032559808512)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
&REST T).
; etc.
; (+ SECOND (ASH FIRST 32))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a FIXNUM.
; The result is a (VALUES
; (INTEGER -9223372039002259456
9223372034707292159)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The second argument is a (INTEGER -9223372036854775808
; 9223372032559808512), not a (SIGNED-
BYTE 32).
; The result is a (VALUES
; (INTEGER -9223372039002259456
9223372034707292159)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
&REST T).
; etc.
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 8))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12553EE9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-644)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL::READ-INT32
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) (+
POSITION 4))
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN BUFFER-READ-INT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-INT64
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 8))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12623C09}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-650)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-UINT64 ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-UINT64
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 8))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {126510D9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-656)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-FLOAT ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-FLOAT
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 4))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12677DE9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-662)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL::READ-FLOAT
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
POSITION)
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; compiling (DEFUN BUFFER-READ-DOUBLE ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-DOUBLE
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION 8))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {126CB249}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-668)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL::READ-DOUBLE
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
POSITION)
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; compiling (DEFUN BUFFER-READ-UCS1-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-UCS1-STRING
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION ELEPHANT-MEMUTIL:BYTE-LENGTH))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1271E5C1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-674)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN BUFFER-READ-UCS4-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-UCS4-STRING
; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
MEMUTIL::BS)
; (+ POSITION ELEPHANT-MEMUTIL:BYTE-LENGTH))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {127AAE09}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-721)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFPARAMETER +LITTLE-ENDIAN+ ...)
; compiling (DEFUN LITTLE-ENDIAN-P ...)
; /Users/jensteich/Lisp/elephant/src/memutil/memutil.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining COPY-BUFS in DEFUN
STYLE-WARNING: redefining PROCESS-STRUCT-SLOT-DEFS in DEFUN
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
package.lisp" (written 28 APR 2007 04:31:16 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE ELEPHANT ...)
; compiling (IN-PACKAGE "ELE")
; compiling (DEFPACKAGE :ELEPHANT-USER ...)
; /Users/jensteich/Lisp/elephant/src/elephant/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
variables.lisp" (written 07 MAY 2007 05:04:18 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFVAR *ELEPHANT-CODE-VERSION* ...)
; compiling (DEFVAR *ELEPHANT-UNMARKED-CODE-VERSION* ...)
; compiling (DEFVAR *ELEPHANT-PROPERTIES-LABEL* ...)
; compiling (DEFVAR *USER-CONFIGURABLE-PARAMETERS* ...)
; compiling (DEFVAR *CIRCULARITY-INITIAL-HASH-SIZE* ...)
; compiling (DEFPARAMETER *MAP-USING-DEGREE2* ...)
; compiling (DEFVAR *BERKELEY-DB-CACHESIZE* ...)
; compiling (DEFVAR *RESOURCED-BYTE-SPEC* ...)
; compiling (DEFVAR *STORE-CONTROLLER* ...)
; compiling (DEFVAR *CURRENT-TRANSACTION* ...)
; compiling (DEFVAR *WARN-ON-MANUAL-CLASS-FINALIZATION* ...)
; compiling (MAPCAR (LAMBDA # ...) ...)
; /Users/jensteich/Lisp/elephant/src/elephant/variables.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
transactions.lisp" (written 28 APR 2007 04:31:16 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFGENERIC EXECUTE-TRANSACTION ...)
; compiling (DEFUN MAKE-TRANSACTION-RECORD ...)
; compiling (DEFUN TRANSACTION-STORE ...)
; compiling (DEFUN TRANSACTION-OBJECT ...)
; compiling (DEFUN TRANSACTION-OBJECT-P ...)
; compiling (DEFUN OWNED-TXN-P ...)
; compiling (DEFINE-CONDITION TRANSACTION-RETRY-COUNT-EXCEEDED ...)
; compiling (DEFMACRO WITH-TRANSACTION ...)
; compiling (DEFMACRO ENSURE-TRANSACTION ...)
; compiling (DEFMACRO WITH-BATCH-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-START-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-COMMIT-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-ABORT-TRANSACTION ...)
; /Users/jensteich/Lisp/elephant/src/elephant/transactions.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
metaclasses.lisp" (written 23 APR 2007 04:26:53 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFCLASS PERSISTENT ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/metaclasses.lisp
; in: DEFMETHOD PRINT-OBJECT (PERSISTENT T)
; (FORMAT STREAM "#<~A oid:~A>" (TYPE-OF ELEPHANT::OBJ)
; (ELEPHANT::OID ELEPHANT::OBJ))
; ==>
; (FORMAT SB-C::DEST (FORMATTER "#<~A oid:~A>") #:G11 #:G12)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a STREAM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a
(MEMBER T).
; compiling (DEFCLASS PERSISTENT-METACLASS ...)
; compiling (DEFMACRO DEFPCLASS ...)
; compiling (DEFUN ADD-PERSISTENT-METACLASS-ARGUMENT ...)
; compiling (DEFMETHOD PERSISTENT-SLOTS ...)
; compiling (DEFMETHOD PERSISTENT-SLOTS ...)
; compiling (DEFMETHOD OLD-PERSISTENT-SLOTS ...)
; compiling (DEFMETHOD UPDATE-PERSISTENT-SLOTS ...)
; compiling (DEFCLASS PERSISTENT-SLOT-DEFINITION ...)
; compiling (DEFCLASS PERSISTENT-DIRECT-SLOT-DEFINITION ...)
; compiling (DEFCLASS PERSISTENT-EFFECTIVE-SLOT-DEFINITION ...)
; compiling (DEFCLASS TRANSIENT-SLOT-DEFINITION ...)
; compiling (DEFCLASS TRANSIENT-DIRECT-SLOT-DEFINITION ...)
; compiling (DEFCLASS TRANSIENT-EFFECTIVE-SLOT-DEFINITION ...)
; compiling (DEFGENERIC TRANSIENT ...)
; compiling (DEFCLASS INDEXING-RECORD ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/metaclasses.lisp
; in: DEFMETHOD PRINT-OBJECT (INDEXING-RECORD T)
; (LENGTH (ELEPHANT::INDEXING-RECORD-SLOTS ELEPHANT::OBJ))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (LENGTH (ELEPHANT::INDEXING-RECORD-DERIVED ELEPHANT::OBJ))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (FORMAT STREAM "#INDEXING-RECORD<islt: ~A dslt: ~A>"
; (LENGTH (ELEPHANT::INDEXING-RECORD-SLOTS ELEPHANT::OBJ))
; (LENGTH (ELEPHANT::INDEXING-RECORD-DERIVED ELEPHANT::OBJ)))
; ==>
; (FORMAT SB-C::DEST (FORMATTER "#INDEXING-RECORD<islt: ~A dslt:
~A>") #:G128
; #:G129)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a STREAM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a
(MEMBER T).
; compiling (DEFMETHOD INDEXED-RECORD ...)
; compiling (DEFMETHOD INDEXED-RECORD ...)
; compiling (DEFMETHOD OLD-INDEXED-RECORD ...)
; compiling (DEFMETHOD UPDATE-INDEXED-RECORD ...)
; compiling (DEFMETHOD MAKE-NEW-INDEXED-RECORD ...)
; compiling (DEFMETHOD REMOVED-INDEXING? ...)
; compiling (DEFUN INDEXED-SLOT-NAMES-FROM-DEFS ...)
; compiling (DEFMETHOD REGISTER-INDEXED-SLOT ...)
; compiling (DEFMETHOD UNREGISTER-INDEXED-SLOT ...)
; compiling (DEFMETHOD REGISTER-DERIVED-INDEX ...)
; compiling (DEFMETHOD UNREGISTER-DERIVED-INDEX ...)
; compiling (DEFMETHOD INDEXED ...)
; compiling (DEFMETHOD PREVIOUSLY-INDEXED ...)
; compiling (DEFMETHOD INDEXED ...)
; compiling (DEFMETHOD INDEXED ...)
; compiling (DEFVAR *INHIBIT-INDEXING-LIST* ...)
; compiling (DEFUN INHIBIT-INDEXING ...)
; compiling (DEFUN UNINHIBIT-INDEXING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/metaclasses.lisp
; in: DEFUN UNINHIBIT-INDEXING
; (DELETE ELEPHANT::UID ELEPHANT::*INHIBIT-INDEXING-LIST*)
;
; note: unable to
; convert to EQ test
; due to type uncertainty:
; The second argument is a SEQUENCE, not a LIST.
; compiling (DEFMETHOD SLOT-DEFINITION-ALLOCATION ...)
; compiling (DEFMETHOD DIRECT-SLOT-DEFINITION-CLASS ...)
; compiling (DEFMETHOD VALIDATE-SUPERCLASS ...)
; compiling (DEFMETHOD VALIDATE-SUPERCLASS ...)
; compiling (DEFGENERIC PERSISTENT-P ...)
; compiling (DEFMETHOD EFFECTIVE-SLOT-DEFINITION-CLASS ...)
; compiling (DEFUN ENSURE-TRANSIENT-CHAIN ...)
; compiling (DEFMETHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS ...)
; compiling (DEFUN FIND-SLOT-DEF-BY-NAME ...)
; compiling (DEFUN PERSISTENT-SLOT-DEFS ...)
; compiling (DEFUN TRANSIENT-SLOT-DEFS ...)
; compiling (DEFUN PERSISTENT-SLOT-NAMES ...)
; compiling (DEFUN TRANSIENT-SLOT-NAMES ...)
; /Users/jensteich/Lisp/elephant/src/elephant/metaclasses.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: Implicitly creating new generic function PERSISTENT-
SLOTS.
STYLE-WARNING:
Implicitly creating new generic function OLD-PERSISTENT-SLOTS.
STYLE-WARNING:
Implicitly creating new generic function UPDATE-PERSISTENT-SLOTS.
STYLE-WARNING: Implicitly creating new generic function INDEXED-RECORD.
STYLE-WARNING: Implicitly creating new generic function OLD-INDEXED-
RECORD.
STYLE-WARNING:
Implicitly creating new generic function UPDATE-INDEXED-RECORD.
STYLE-WARNING:
Implicitly creating new generic function MAKE-NEW-INDEXED-RECORD.
STYLE-WARNING: Implicitly creating new generic function REMOVED-
INDEXING?.
STYLE-WARNING:
Implicitly creating new generic function REGISTER-INDEXED-SLOT.
STYLE-WARNING:
Implicitly creating new generic function UNREGISTER-INDEXED-SLOT.
STYLE-WARNING:
Implicitly creating new generic function REGISTER-DERIVED-INDEX.
STYLE-WARNING:
Implicitly creating new generic function UNREGISTER-DERIVED-INDEX.
STYLE-WARNING: Implicitly creating new generic function PREVIOUSLY-
INDEXED.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
classes.lisp" (written 29 APR 2007 04:10:54 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFVAR *DEBUG-SI* ...)
; compiling (DECLAIM (OPTIMIZE #))
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS PERSISTENT-OBJECT ...)
; compiling (DEFMETHOD SHARED-INITIALIZE ...)
; compiling (DEFMETHOD FINALIZE-INHERITANCE ...)
; compiling (DEFMETHOD REINITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD SHARED-INITIALIZE ...)
; compiling (DEFUN INITIALIZE-PERSISTENT-SLOTS ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classes.lisp
; in: DEFUN INITIALIZE-PERSISTENT-SLOTS
; (FUNCALL ELEPHANT::INITFUN)
; --> 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.
; compiling (DEFMETHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS ...)
; compiling (DEFMETHOD CHANGE-CLASS ...)
; compiling (DEFMETHOD CHANGE-CLASS ...)
; compiling (DEFMETHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS ...)
; compiling (DEFMETHOD SLOT-VALUE-USING-CLASS ...)
; compiling (DEFMETHOD (SETF SLOT-VALUE-USING-CLASS) ...)
; compiling (DEFMETHOD SLOT-BOUNDP-USING-CLASS ...)
; compiling (DEFMETHOD SLOT-BOUNDP-USING-CLASS ...)
; compiling (DEFMETHOD SLOT-MAKUNBOUND-USING-CLASS ...)
; compiling (DEFUN VALID-PERSISTENT-REFERENCE-P ...)
; compiling (DEFINE-CONDITION CROSS-REFERENCE-ERROR ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classes.lisp
; in: DEFINE-CONDITION CROSS-REFERENCE-ERROR
; (FORMAT STREAM
; "Attempted to write object ~A with home store ~A into
store ~A"
; (ELEPHANT::CROSS-REFERENCE-ERROR-OBJECT CONDITION)
; (ELEPHANT::CROSS-REFERENCE-ERROR-HOME-CONTROLLER CONDITION)
; (ELEPHANT::CROSS-REFERENCE-ERROR-FOREIGN-CONTROLLER
CONDITION))
; ==>
; (FORMAT SB-C::DEST
; (FORMATTER
; "Attempted to write object ~A with home store ~A into
store ~A")
; #:G607 #:G608 #:G609)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a STREAM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a
(MEMBER T).
; compiling (DEFUN SIGNAL-CROSS-REFERENCE-ERROR ...)
; compiling (DEFUN MAKE-PERSISTENT-READER ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classes.lisp
; in: DEFUN MAKE-PERSISTENT-READER
; (LAMBDA (ELEPHANT::INSTANCE)
; (DECLARE (TYPE ELEPHANT:PERSISTENT-OBJECT ELEPHANT::INSTANCE))
; (ELEPHANT::PERSISTENT-SLOT-READER (ELEPHANT::GET-CON
ELEPHANT::INSTANCE)
; ELEPHANT::INSTANCE ELEPHANT::NAME))
; --> FUNCTION LOCALLY SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET UNLESS IF
; ==>
; (TYPEP #:G660 'ELEPHANT:PERSISTENT-OBJECT)
;
; note: can't open-code test of unknown type PERSISTENT-OBJECT
; compiling (DEFUN MAKE-PERSISTENT-WRITER ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classes.lisp
; in: DEFUN MAKE-PERSISTENT-WRITER
; (LAMBDA (ELEPHANT::NEW-VALUE ELEPHANT::INSTANCE)
; (DECLARE (OPTIMIZE (SPEED 3))
; (TYPE ELEPHANT:PERSISTENT-OBJECT ELEPHANT::INSTANCE))
; (ELEPHANT::PERSISTENT-SLOT-WRITER (ELEPHANT::GET-CON
ELEPHANT::INSTANCE)
; ELEPHANT::NEW-VALUE ELEPHANT::INSTANCE ELEPHANT::NAME))
; --> FUNCTION LOCALLY SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET UNLESS IF
; ==>
; (TYPEP #:G667 'ELEPHANT:PERSISTENT-OBJECT)
;
; note: can't open-code test of unknown type PERSISTENT-OBJECT
; compiling (DEFUN MAKE-PERSISTENT-SLOT-BOUNDP ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classes.lisp
; in: DEFUN MAKE-PERSISTENT-SLOT-BOUNDP
; (LAMBDA (ELEPHANT::INSTANCE)
; (DECLARE (TYPE ELEPHANT:PERSISTENT-OBJECT ELEPHANT::INSTANCE))
; (ELEPHANT::PERSISTENT-SLOT-BOUNDP (ELEPHANT::GET-CON
ELEPHANT::INSTANCE)
; ELEPHANT::INSTANCE ELEPHANT::NAME))
; --> FUNCTION LOCALLY SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET UNLESS IF
; ==>
; (TYPEP #:G673 'ELEPHANT:PERSISTENT-OBJECT)
;
; note: can't open-code test of unknown type PERSISTENT-OBJECT
; compiling (DEFMETHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS ...)
; /Users/jensteich/Lisp/elephant/src/elephant/classes.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
cache.lisp" (written 12 APR 2007 04:47:31 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFUN MAKE-CACHE-TABLE ...)
; compiling (DEFUN GET-CACHE ...)
; compiling (DEFUN MAKE-FINALIZER ...)
; compiling (DEFUN SETF-CACHE ...)
; compiling (DEFSETF GET-CACHE ...)
; /Users/jensteich/Lisp/elephant/src/elephant/cache.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
serializer.lisp" (written 12 APR 2007 04:47:33 AM):
; compiling (IN-PACKAGE :ELEPHANT)
; compiling (DEFUN SERIALIZE ...)
; compiling (DEFUN DESERIALIZE ...)
; compiling (DEFGENERIC STRUCT-CONSTRUCTOR ...)
; compiling (DEFMETHOD STRUCT-CONSTRUCTOR ...)
; compiling (DEFUN SERIALIZE-TO-BASE64-STRING ...)
; compiling (DEFUN CONVERT-BUFFER-TO-BASE64-STRING ...)
; compiling (DEFUN DESERIALIZE-FROM-BASE64-STRING ...)
; compiling (DEFUN CONVERT-BUFFER-FROM-BASE64-STRING ...)
; compiling (DEFCONSTANT +RESERVED-DBINFO+ ...)
; compiling (DEFCONSTANT +ELEPHANT-VERSION+ ...)
; compiling (DEFCONSTANT +ELEPHANT-SERIALIZER-VERSION+ ...)
; compiling (DEFUN SERIALIZE-DATABASE-VERSION-KEY ...)
; compiling (DEFUN SERIALIZE-DATABASE-VERSION-VALUE ...)
; compiling (DEFUN DESERIALIZE-DATABASE-VERSION-VALUE ...)
; compiling (DEFUN SERIALIZE-DATABASE-SERIALIZER-VERSION-KEY ...)
; compiling (DEFUN SERIALIZE-DATABASE-SERIALIZER-VERSION-VALUE ...)
; compiling (DEFUN DESERIALIZE-DATABASE-SERIALIZER-VERSION-VALUE ...)
; compiling (DEFUN SERIALIZE-RESERVED-TAG ...)
; compiling (DEFUN SERIALIZE-SYSTEM-TAG ...)
; compiling (DEFUN SERIALIZE-SYSTEM-INTEGER ...)
; compiling (DEFUN DESERIALIZE-SYSTEM-INTEGER ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer.lisp
; in: DEFUN DESERIALIZE-SYSTEM-INTEGER
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT::BS)
; --> BLOCK LET
; ==>
; (THE (SIGNED-BYTE 32)
; (ELEPHANT-MEMUTIL::READ-INT32
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
POSITION))
;
; note: type assertion too complex to check:
; (VALUES (SIGNED-BYTE 32) &REST T).
; compiling (DEFUN SLOTS-AND-VALUES ...)
; compiling (DEFUN STRUCT-SLOTS-AND-VALUES ...)
; compiling (DECLAIM (TYPE HASH-TABLE ...))
; compiling (DEFVAR ARRAY-TYPE-TO-BYTE ...)
; compiling (DEFVAR BYTE-TO-ARRAY-TYPE ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (SETF (GETHASH # ...) ...)
; compiling (DEFUN TYPE= ...)
; compiling (LET (#) ...)
; compiling (LOOP FOR ...)
; compiling (DEFUN ARRAY-TYPE-FROM-BYTE ...)
; compiling (DEFUN BYTE-FROM-ARRAY-TYPE ...)
; compiling (DEFUN INT-BYTE-SPEC ...)
; /Users/jensteich/Lisp/elephant/src/elephant/serializer.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
controller.lisp" (written 07 MAY 2007 10:39:33 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFVAR *ELEPHANT-DATA-STORES* ...)
; compiling (DEFVAR *ELEPHANT-CONTROLLER-INIT* ...)
; compiling (DEFUN REGISTER-DATA-STORE-CON-INIT ...)
; compiling (DEFUN LOOKUP-DATA-STORE-CON-INIT ...)
; compiling (DEFVAR *DBCONNECTION-SPEC* ...)
; compiling (DEFVAR *DBCONNECTION-LOCK* ...)
; compiling (DEFGENERIC GET-CON ...)
; compiling (DEFINE-CONDITION CONTROLLER-LOST-ERROR ...)
; compiling (DEFUN SIGNAL-CONTROLLER-LOST-ERROR ...)
; compiling (DEFMETHOD GET-CON ...)
; compiling (DEFUN GET-CONTROLLER ...)
; compiling (DEFUN BUILD-CONTROLLER ...)
; compiling (DEFUN LOAD-DATA-STORE ...)
; compiling (DEFUN SATISFY-ASDF-DEPENDENCIES ...)
; compiling (DEFUN GET-USER-CONFIGURATION-PARAMETER ...)
; compiling (DEFUN INITIALIZE-USER-PARAMETERS ...)
; compiling (DEFCLASS STORE-CONTROLLER ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFUN CACHE-INSTANCE ...)
; compiling (DEFUN GET-CACHED-INSTANCE ...)
; compiling (DEFMETHOD FLUSH-INSTANCE-CACHE ...)
; compiling (DEFGENERIC DATABASE-VERSION ...)
; compiling (DEFMETHOD DATABASE-VERSION ...)
; compiling (DEFUN PRIOR-VERSION-P ...)
; compiling (DEFPARAMETER *ELEPHANT-UPGRADE-TABLE* ...)
; compiling (DEFMETHOD UP-TO-DATE-P ...)
; compiling (DEFMETHOD UPGRADABLE-P ...)
; compiling (DEFGENERIC UPGRADE ...)
; compiling (DEFMETHOD UPGRADE ...)
; compiling (DEFMETHOD INITIALIZE-SERIALIZER ...)
; compiling (DEFVAR *ALWAYS-CONVERT* ...)
; compiling (DEFPARAMETER *LEGACY-SYMBOL-CONVERSIONS* ...)
; compiling (DEFUN ADD-SYMBOL-CONVERSION ...)
; compiling (DEFUN MAP-LEGACY-SYMBOLS ...)
; compiling (DEFPARAMETER *LEGACY-PACKAGE-CONVERSIONS* ...)
; compiling (DEFUN ADD-PACKAGE-CONVERSION ...)
; compiling (DEFUN MAP-LEGACY-PACKAGE-NAMES ...)
; compiling (DEFUN MAP-LEGACY-NAMES ...)
; compiling (DEFUN TRANSLATE-AND-INTERN-SYMBOL ...)
; compiling (DEFGENERIC OPEN-CONTROLLER ...)
; compiling (DEFGENERIC CLOSE-CONTROLLER ...)
; compiling (DEFMETHOD CLOSE-CONTROLLER ...)
; compiling (DEFGENERIC CONNECTION-IS-INDEED-OPEN ...)
; compiling (DEFGENERIC NEXT-OID ...)
; compiling (DEFGENERIC OPTIMIZE-LAYOUT ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-READER ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-WRITER ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-BOUNDP ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-MAKUNBOUND ...)
; compiling (DEFUN OPEN-STORE ...)
; compiling (DEFUN CLOSE-STORE ...)
; compiling (DEFMACRO WITH-OPEN-STORE ...)
; compiling (DEFUN ADD-TO-ROOT ...)
; compiling (DEFUN GET-FROM-ROOT ...)
; compiling (DEFUN ROOT-EXISTSP ...)
; compiling (DEFUN REMOVE-FROM-ROOT ...)
; compiling (DEFUN MAP-ROOT ...)
; compiling (DEFGENERIC DROP-POBJECT ...)
; compiling (DEFMETHOD DROP-POBJECT ...)
; compiling (DEFVAR *RESTRICTED-PROPERTIES* ...)
; compiling (DEFMETHOD CONTROLLER-PROPERTIES ...)
; compiling (DEFMETHOD SET-ELE-PROPERTY ...)
; compiling (DEFMETHOD GET-ELE-PROPERTY ...)
; /Users/jensteich/Lisp/elephant/src/elephant/controller.fasl written
; compilation finished in 0:00:01
STYLE-WARNING:
Implicitly creating new generic function FLUSH-INSTANCE-CACHE.
STYLE-WARNING: Implicitly creating new generic function UP-TO-DATE-P.
STYLE-WARNING: Implicitly creating new generic function UPGRADABLE-P.
STYLE-WARNING:
Implicitly creating new generic function INITIALIZE-SERIALIZER.
STYLE-WARNING:
Implicitly creating new generic function CONTROLLER-PROPERTIES.
STYLE-WARNING: Implicitly creating new generic function SET-ELE-
PROPERTY.
STYLE-WARNING: Implicitly creating new generic function GET-ELE-
PROPERTY.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
collections.lisp" (written 07 MAY 2007 08:38:29 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFCLASS PERSISTENT-COLLECTION ...)
; compiling (DEFUN MAKE-BTREE ...)
; compiling (DEFGENERIC BUILD-BTREE ...)
; compiling (DEFCLASS BTREE ...)
; compiling (DEFGENERIC GET-VALUE ...)
; compiling (DEFGENERIC (SETF GET-VALUE) ...)
; compiling (DEFGENERIC REMOVE-KV ...)
; compiling (DEFGENERIC EXISTSP ...)
; compiling (DEFMETHOD OPTIMIZE-LAYOUT ...)
; compiling (DEFGENERIC DROP-BTREE ...)
; compiling (DEFUN MAKE-INDEXED-BTREE ...)
; compiling (DEFGENERIC BUILD-INDEXED-BTREE ...)
; compiling (DEFCLASS INDEXED-BTREE ...)
; compiling (DEFGENERIC ADD-INDEX ...)
; compiling (DEFGENERIC GET-INDEX ...)
; compiling (DEFGENERIC REMOVE-INDEX ...)
; compiling (DEFGENERIC MAP-INDICES ...)
; compiling (DEFGENERIC BUILD-BTREE-INDEX ...)
; compiling (DEFCLASS BTREE-INDEX ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFCLASS BTREE-INDEX
; (DEFCLASS ELEPHANT:BTREE-INDEX (ELEPHANT:BTREE)
; ((ELEPHANT:PRIMARY :TYPE ELEPHANT:INDEXED-BTREE :READER
; ELEPHANT:PRIMARY :INITARG :PRIMARY)
; (ELEPHANT:KEY-FORM :READER ELEPHANT:KEY-
FORM :INITARG :KEY-FORM
; :INITFORM NIL)
; (ELEPHANT:KEY-FN :TYPE FUNCTION :ACCESSOR ELEPHANT:KEY-FN
; :TRANSIENT T))
; (:METACLASS ELEPHANT:PERSISTENT-METACLASS)
; (:DOCUMENTATION "Secondary index to an indexed-btree."))
; --> PROGN EVAL-WHEN LET LOCALLY SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET
; --> UNLESS IF
; ==>
; (TYPEP #:G30 'ELEPHANT:INDEXED-BTREE)
;
; note: can't open-code test of unknown type INDEXED-BTREE
; compiling (DEFMETHOD SHARED-INITIALIZE ...)
; compiling (DEFGENERIC GET-PRIMARY-KEY ...)
; compiling (DEFMETHOD (SETF GET-VALUE) ...)
; compiling (DEFMETHOD REMOVE-KV ...)
; compiling (DEFCLASS CURSOR ...)
; compiling (DEFGENERIC MAKE-CURSOR ...)
; compiling (DEFGENERIC MAKE-SIMPLE-CURSOR ...)
; compiling (DEFGENERIC CURSOR-CLOSE ...)
; compiling (DEFGENERIC CURSOR-DUPLICATE ...)
; compiling (DEFGENERIC CURSOR-CURRENT ...)
; compiling (DEFGENERIC CURSOR-FIRST ...)
; compiling (DEFGENERIC CURSOR-LAST ...)
; compiling (DEFGENERIC CURSOR-NEXT ...)
; compiling (DEFGENERIC CURSOR-PREV ...)
; compiling (DEFGENERIC CURSOR-SET ...)
; compiling (DEFGENERIC CURSOR-SET-RANGE ...)
; compiling (DEFGENERIC CURSOR-GET-BOTH ...)
; compiling (DEFGENERIC CURSOR-GET-BOTH-RANGE ...)
; compiling (DEFGENERIC CURSOR-DELETE ...)
; compiling (DEFGENERIC CURSOR-PUT ...)
; compiling (DEFCLASS SECONDARY-CURSOR ...)
; compiling (DEFGENERIC CURSOR-PCURRENT ...)
; compiling (DEFGENERIC CURSOR-PFIRST ...)
; compiling (DEFGENERIC CURSOR-PLAST ...)
; compiling (DEFGENERIC CURSOR-PNEXT ...)
; compiling (DEFGENERIC CURSOR-PPREV ...)
; compiling (DEFGENERIC CURSOR-PSET ...)
; compiling (DEFGENERIC CURSOR-PSET-RANGE ...)
; compiling (DEFGENERIC CURSOR-PGET-BOTH ...)
; compiling (DEFGENERIC CURSOR-PGET-BOTH-RANGE ...)
; compiling (DEFGENERIC CURSOR-NEXT-DUP ...)
; compiling (DEFGENERIC CURSOR-NEXT-NODUP ...)
; compiling (DEFGENERIC CURSOR-PNEXT-DUP ...)
; compiling (DEFGENERIC CURSOR-PNEXT-NODUP ...)
; compiling (DEFGENERIC CURSOR-PREV-DUP ...)
; compiling (DEFMETHOD CURSOR-PREV-DUP ...)
; compiling (DEFGENERIC CURSOR-PREV-NODUP ...)
; compiling (DEFGENERIC CURSOR-PPREV-DUP ...)
; compiling (DEFMETHOD CURSOR-PPREV-DUP ...)
; compiling (DEFGENERIC CURSOR-PPREV-NODUP ...)
; compiling (DEFMACRO WITH-BTREE-CURSOR ...)
; compiling (DEFMETHOD DROP-BTREE ...)
; compiling (DEFUN LISP-COMPARE<= ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFUN LISP-COMPARE<=
; (STRING<= ELEPHANT::A ELEPHANT::B)
; ==>
; (SB-KERNEL:STRING<=* SB-C::STRING1 SB-C::STRING2 SB-C::START1 SB-
C::END1
; SB-C::START2 SB-C::END2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The second argument is a (OR (VECTOR CHARACTER) (VECTOR NIL) BASE-
STRING
; SYMBOL CHARACTER), not a SIMPLE-BASE-
STRING.
; (STRING<= (SYMBOL-NAME ELEPHANT::A) (SYMBOL-NAME ELEPHANT::B))
; ==>
; (SB-KERNEL:STRING<=* SB-C::STRING1 SB-C::STRING2 SB-C::START1 SB-
C::END1
; SB-C::START2 SB-C::END2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The second argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; (<= (ELEPHANT::OID ELEPHANT::A) (ELEPHANT::OID ELEPHANT::B))
; --> OR LET < IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the
same type.
; (<= ELEPHANT::A ELEPHANT::B)
; --> OR LET < IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the
same type.
; (<= (ELEPHANT::OID ELEPHANT::A) (ELEPHANT::OID ELEPHANT::B))
; --> OR LET < IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (<= ELEPHANT::A ELEPHANT::B)
; --> OR LET < IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; compiling (DEFUN LISP-COMPARE-EQUAL ...)
; compiling (DEFGENERIC MAP-BTREE ...)
; compiling (DEFMETHOD MAP-BTREE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFMETHOD MAP-BTREE (T BTREE)
; (LET ((ELEPHANT::FN
; (IF ELEPHANT::COLLECT #'ELEPHANT::COLLECTOR ELEPHANT::FN)))
; (DECLARE (DYNAMIC-EXTENT #'ELEPHANT::CONTINUE-P
#'ELEPHANT::COLLECTOR))
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::KEY ELEPHANT::VALUE)
; (COND
; (ELEPHANT::VALUE-SET-P
; (ELEPHANT:CURSOR-SET ELEPHANT::CURS ELEPHANT::VALUE))
; ((AND # #) (ELEPHANT:CURSOR-FIRST ELEPHANT::CURS))
; ((AND ELEPHANT::FROM-END #) (ELEPHANT:CURSOR-LAST
ELEPHANT::CURS))
; (T (IF ELEPHANT::FROM-END # #)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS?
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END # #)
; (DECLARE #)
; (IF # # #)))))
;
; note: ignoring DYNAMIC-EXTENT declaration for free CONTINUE-P
;
; note: ignoring DYNAMIC-EXTENT declaration for free COLLECTOR
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::KEY ELEPHANT::VALUE)
; (COND
; (ELEPHANT::VALUE-SET-P
; (ELEPHANT:CURSOR-SET ELEPHANT::CURS ELEPHANT::VALUE))
; ((AND (NOT ELEPHANT::FROM-END) (NULL ELEPHANT::START))
; (ELEPHANT:CURSOR-FIRST ELEPHANT::CURS))
; ((AND ELEPHANT::FROM-END (NULL ELEPHANT::END))
; (ELEPHANT:CURSOR-LAST ELEPHANT::CURS))
; (T
; (IF ELEPHANT::FROM-END
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS ELEPHANT::END)
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS
ELEPHANT::START))))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS? (FUNCALL ELEPHANT::FN ELEPHANT::KEY
ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
; --> MULTIPLE-VALUE-CALL
; ==>
; #'(LAMBDA
; (&OPTIONAL (ELEPHANT::EXISTS?) (ELEPHANT::KEY)
(ELEPHANT::VALUE)
; &REST #:G232)
; (DECLARE (IGNORE #:G232))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS?
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV
ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
;
; note: ignoring DYNAMIC-EXTENT declaration for free K
;
; note: ignoring DYNAMIC-EXTENT declaration for free V
; (DEFMETHOD ELEPHANT:MAP-BTREE
; (ELEPHANT::FN (ELEPHANT:BTREE ELEPHANT:BTREE) &REST
ELEPHANT::ARGS
; &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-P)
ELEPHANT::FROM-END
; ELEPHANT::COLLECT &ALLOW-OTHER-KEYS)
; (LET ((ELEPHANT::END
; (IF ELEPHANT::VALUE-SET-P ELEPHANT::VALUE
ELEPHANT::END))
; (ELEPHANT::RESULTS NIL))
; (ELEPHANT:ENSURE-TRANSACTION
; (:STORE-CONTROLLER (ELEPHANT::GET-CON
ELEPHANT:BTREE) :DEGREE-2
; ELEPHANT::*MAP-USING-DEGREE2*)
; (ELEPHANT:WITH-BTREE-CURSOR (ELEPHANT::CURS
ELEPHANT:BTREE)
; (FLET #
; #)))
; ELEPHANT::RESULTS))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN
; ==>
; (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'ELEPHANT:MAP-BTREE 'NIL
; (LIST (FIND-CLASS 'T) (FIND-CLASS
'ELEPHANT:BTREE))
; '(ELEPHANT::FN ELEPHANT:BTREE &REST
ELEPHANT::ARGS
; &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-
P)
; ELEPHANT::FROM-END ELEPHANT::COLLECT
; &ALLOW-OTHER-KEYS)
; (LIST* :FUNCTION
; (LET* ((SB-PCL::FMF #) (SB-PCL::MF
#))
; (SB-MOP:SET-FUNCALLABLE-INSTANCE-
FUNCTION
; SB-PCL::MF
; (SB-PCL::METHOD-FUNCTION-FROM-
FAST-FUNCTION
; SB-PCL::FMF '#))
; SB-PCL::MF)
; '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
; (SB-C:SOURCE-LOCATION))
;
; caught STYLE-WARNING:
; The variable ARGS is defined but never used.
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V)
; --> 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.
;
; 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.
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; --> 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.
; compiling (DEFGENERIC MAP-INDEX ...)
; compiling (DEFMETHOD MAP-INDEX ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFMETHOD MAP-INDEX (T BTREE-INDEX)
; (LET ((ELEPHANT::FN
; (IF ELEPHANT::COLLECT #'ELEPHANT::COLLECTOR ELEPHANT::FN)))
; (DECLARE (DYNAMIC-EXTENT #'ELEPHANT::COLLECTOR))
; (ELEPHANT:ENSURE-TRANSACTION
; (:STORE-CONTROLLER ELEPHANT::SC :DEGREE-2 ELEPHANT::*MAP-USING-
DEGREE2*)
; (ELEPHANT:WITH-BTREE-CURSOR (ELEPHANT::CUR ELEPHANT::INDEX)
; (LABELS (# # # # #)
; (DECLARE #)
; (MULTIPLE-VALUE-BIND # # #)))))
;
; note: ignoring DYNAMIC-EXTENT declaration for free COLLECTOR
; (DEFMETHOD ELEPHANT:MAP-INDEX
; (ELEPHANT::FN (ELEPHANT::INDEX ELEPHANT:BTREE-INDEX)
&REST
; ELEPHANT::ARGS &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-P)
ELEPHANT::FROM-END
; ELEPHANT::COLLECT &ALLOW-OTHER-KEYS)
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::ARGS))
; (UNLESS
; (OR (NULL ELEPHANT::START) (NULL ELEPHANT::END)
; (ELEPHANT::LISP-COMPARE<= ELEPHANT::START
ELEPHANT::END))
; (ERROR
; "map-index called with start = ~A and end = ~A.
Start must be less than or equal to end according to elephant::lisp-
compare<=."
; ELEPHANT::START ELEPHANT::END))
; (LET ((ELEPHANT::SC (ELEPHANT::GET-CON ELEPHANT::INDEX))
; (ELEPHANT::END (OR ELEPHANT::VALUE ELEPHANT::END))
; (ELEPHANT::FROM-END (AND ELEPHANT::FROM-END #))
; (ELEPHANT::RESULTS NIL))
; (FLET ((ELEPHANT::COLLECTOR #
; #))
; (LET (#)
; (DECLARE #)
; (ELEPHANT:ENSURE-TRANSACTION # #)))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN
; ==>
; (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'ELEPHANT:MAP-INDEX 'NIL
; (LIST (FIND-CLASS 'T)
; (FIND-CLASS 'ELEPHANT:BTREE-INDEX))
; '(ELEPHANT::FN ELEPHANT::INDEX &REST
ELEPHANT::ARGS
; &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-
P)
; ELEPHANT::FROM-END ELEPHANT::COLLECT
; &ALLOW-OTHER-KEYS)
; (LIST* :FUNCTION
; (LET* ((SB-PCL::FMF #) (SB-PCL::MF
#))
; (SB-MOP:SET-FUNCALLABLE-INSTANCE-
FUNCTION
; SB-PCL::MF
; (SB-PCL::METHOD-FUNCTION-FROM-
FAST-FUNCTION
; SB-PCL::FMF '#))
; SB-PCL::MF)
; '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
; (SB-C:SOURCE-LOCATION))
;
; caught STYLE-WARNING:
; The variable ARGS is defined but never used.
; (FUNCALL ELEPHANT::FN ELEPHANT::SKEY ELEPHANT::VAL ELEPHANT::PKEY)
; --> 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.
;
; 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.
;
; 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.
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V ELEPHANT::PK)
; --> 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.
; (DEFMETHOD ELEPHANT:MAP-INDEX
; (ELEPHANT::FN (ELEPHANT::INDEX ELEPHANT:BTREE-INDEX)
&REST
; ELEPHANT::ARGS &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-P)
ELEPHANT::FROM-END
; ELEPHANT::COLLECT &ALLOW-OTHER-KEYS)
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::ARGS))
; (UNLESS
; (OR (NULL ELEPHANT::START) (NULL ELEPHANT::END)
; (ELEPHANT::LISP-COMPARE<= ELEPHANT::START
ELEPHANT::END))
; (ERROR
; "map-index called with start = ~A and end = ~A.
Start must be less than or equal to end according to elephant::lisp-
compare<=."
; ELEPHANT::START ELEPHANT::END))
; (LET ((ELEPHANT::SC (ELEPHANT::GET-CON ELEPHANT::INDEX))
; (ELEPHANT::END (OR ELEPHANT::VALUE ELEPHANT::END))
; (ELEPHANT::FROM-END (AND ELEPHANT::FROM-END #))
; (ELEPHANT::RESULTS NIL))
; (FLET ((ELEPHANT::COLLECTOR #
; #))
; (LET (#)
; (DECLARE #)
; (ELEPHANT:ENSURE-TRANSACTION # #)))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN
; ==>
; (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'ELEPHANT:MAP-INDEX 'NIL
; (LIST (FIND-CLASS 'T)
; (FIND-CLASS 'ELEPHANT:BTREE-INDEX))
; '(ELEPHANT::FN ELEPHANT::INDEX &REST
ELEPHANT::ARGS
; &KEY ELEPHANT::START ELEPHANT::END
; (ELEPHANT::VALUE NIL ELEPHANT::VALUE-SET-
P)
; ELEPHANT::FROM-END ELEPHANT::COLLECT
; &ALLOW-OTHER-KEYS)
; (LIST* :FUNCTION
; (LET* ((SB-PCL::FMF #) (SB-PCL::MF
#))
; (SB-MOP:SET-FUNCALLABLE-INSTANCE-
FUNCTION
; SB-PCL::MF
; (SB-PCL::METHOD-FUNCTION-FROM-
FAST-FUNCTION
; SB-PCL::FMF '#))
; SB-PCL::MF)
; '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
; (SB-C:SOURCE-LOCATION))
;
; note: Return type not fixed values, so can't use known return
convention:
; *
; compiling (DEFUN PSET-RANGE-FOR-DESCENDING ...)
; compiling (DEFUN PPREV-DUP-HACK ...)
; compiling (DEFMETHOD EMPTY-BTREE-P ...)
; compiling (DEFUN PRINT-BTREE-ENTRY ...)
; compiling (DEFUN DUMP-BTREE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFUN DUMP-BTREE
; (FUNCALL ELEPHANT::PRINT-FN ELEPHANT::K ELEPHANT::V)
; --> 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.
; (>= (INCF ELEPHANT::I) COUNT)
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: unable to open code because: The operands might not be the
same type.
; (INCF ELEPHANT::I)
; --> LET*
; ==>
; (+ ELEPHANT::I #:G439)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; etc.
; (>= (INCF ELEPHANT::I) COUNT)
; --> OR LET > IF
; ==>
; (> SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (INTEGER 1), not a FIXNUM.
; The second argument is a REAL, not a FIXNUM.
; compiling (DEFUN PRINT-BTREE-KEY-AND-TYPE ...)
; compiling (DEFUN BTREE-KEYS ...)
; compiling (DEFMETHOD BTREE-DIFFER-P ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFMETHOD BTREE-DIFFER-P (BTREE BTREE)
; (1+ ELEPHANT::I)
; ==>
; (+ ELEPHANT::I 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; etc.
; /Users/jensteich/Lisp/elephant/src/elephant/collections.fasl written
; compilation finished in 0:00:01
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {1221BDF1}> on
#<CL-SOURCE-FILE "collections" {11B47F79}>.
STYLE-WARNING: Implicitly creating new generic function EMPTY-BTREE-P.
STYLE-WARNING: Implicitly creating new generic function BTREE-DIFFER-P.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
pset.lisp" (written 25 APR 2007 04:28:02 AM):
; compiling (IN-PACKAGE :ELEPHANT)
; compiling (DEFCLASS PSET ...)
; compiling (DEFGENERIC INSERT-ITEM ...)
; compiling (DEFGENERIC REMOVE-ITEM ...)
; compiling (DEFGENERIC MAP-PSET ...)
; compiling (DEFGENERIC FIND-ITEM ...)
; compiling (DEFGENERIC PSET-LIST ...)
; compiling (DEFGENERIC BUILD-PSET ...)
; compiling (DEFGENERIC DROP-PSET ...)
; compiling (DEFCLASS DEFAULT-PSET ...)
; compiling (DEFMETHOD BUILD-PSET ...)
; compiling (DEFUN MAKE-PSET ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD REMOVE-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD MAP-PSET ...)
; compiling (DEFMETHOD PSET-LIST ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/pset.lisp
; in: DEFMETHOD PSET-LIST (DEFAULT-PSET)
; (FLET ((ELEPHANT::COLLECT (ELEPHANT::ITEM)
; (PUSH ELEPHANT::ITEM LIST)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::COLLECT))
; (ELEPHANT:MAP-BTREE
; (LAMBDA (ELEPHANT::ITEM ELEPHANT::DC)
; (DECLARE (IGNORE ELEPHANT::DC))
; (PUSH ELEPHANT::ITEM LIST))
; (ELEPHANT::PSET-BTREE ELEPHANT:PSET)))
;
; note: deleting unused function
; (FLET COLLECT)
; compiling (DEFMETHOD DROP-PSET ...)
; /Users/jensteich/Lisp/elephant/src/elephant/pset.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
classindex-utils.lisp" (written 12 APR 2007 04:47:32 AM):
; compiling (IN-PACKAGE :ELEPHANT)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFPARAMETER *DEFAULT-INDEXED-CLASS-SYNCH-POLICY* ...)
; compiling (DEFMETHOD CLASS-INDEX-CACHED? ...)
; compiling (DEFMETHOD DETERMINE-SYNCH-METHOD ...)
; compiling (DEFMETHOD SET-DB-SYNCH ...)
; compiling (DEFPARAMETER *DERIVED-INDEX-MARKER* ...)
; compiling (DEFUN MAKE-DERIVED-NAME ...)
; compiling (DEFUN DERIVED-NAME? ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex-
utils.lisp
; in: DEFUN DERIVED-NAME?
; (LENGTH ELEPHANT::NAME)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (LENGTH ELEPHANT::*DERIVED-INDEX-MARKER*)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (SUBSEQ ELEPHANT::NAME 0
; (MIN (LENGTH ELEPHANT::NAME)
; (LENGTH ELEPHANT::*DERIVED-INDEX-MARKER*)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (STRING=
; (SUBSEQ ELEPHANT::NAME 0
; (MIN (LENGTH ELEPHANT::NAME)
; (LENGTH ELEPHANT::*DERIVED-INDEX-MARKER*)))
; ELEPHANT::*DERIVED-INDEX-MARKER*)
; ==>
; (SB-KERNEL:STRING=* SB-C::STRING1 SB-C::STRING2 SB-C::START1 SB-
C::END1
; SB-C::START2 SB-C::END2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SIMPLE-ARRAY CHARACTER (*))
; (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-
STRING
; NULL), not a SIMPLE-BASE-STRING.
; The second argument is a (OR (VECTOR CHARACTER) (VECTOR NIL) BASE-
STRING
; SYMBOL CHARACTER), not a SIMPLE-BASE-
STRING.
; compiling (DEFUN GET-DERIVED-NAME-ROOT ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex-
utils.lisp
; in: DEFUN GET-DERIVED-NAME-ROOT
; (LENGTH ELEPHANT::*DERIVED-INDEX-MARKER*)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (SUBSEQ ELEPHANT::DNAME (LENGTH ELEPHANT::*DERIVED-INDEX-MARKER*))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; compiling (DEFUN MAKE-SLOT-KEY-FORM ...)
; compiling (DEFUN READ-SLOT-FOR-INDEX ...)
; compiling (DEFUN FIND-EFFECTIVE-SLOT-DEF ...)
; compiling (DEFUN MAKE-DERIVED-KEY-FORM ...)
; compiling (DEFUN COMPUTE-DERIVED-KEY-RESULT ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex-
utils.lisp
; in: DEFUN COMPUTE-DERIVED-KEY-RESULT
; (FUNCALL ELEPHANT::FN ELEPHANT::INSTANCE)
; --> 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.
; compiling (DEFCLASS SYNCH-RULE ...)
; compiling (DEFUN MAKE-SYNCH-RULE ...); in: LAMBDA NIL
; (POSITION 'ELEPHANT::=> ELEPHANT::RULE-SPEC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).
; (SUBSEQ ELEPHANT::RULE-SPEC 0 (POSITION 'ELEPHANT::=>
ELEPHANT::RULE-SPEC))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (POSITION 'ELEPHANT::=> ELEPHANT::RULE-SPEC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).
; (SUBSEQ ELEPHANT::RULE-SPEC (1+ (POSITION 'ELEPHANT::=>
ELEPHANT::RULE-SPEC)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex-
utils.lisp
; in: DEFUN MAKE-SYNCH-RULE
; (POSITION 'ELEPHANT::=> ELEPHANT::RULE-SPEC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).
; (SUBSEQ ELEPHANT::RULE-SPEC 0 (POSITION 'ELEPHANT::=>
ELEPHANT::RULE-SPEC))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (POSITION 'ELEPHANT::=> ELEPHANT::RULE-SPEC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).
; (SUBSEQ ELEPHANT::RULE-SPEC (1+ (POSITION 'ELEPHANT::=>
ELEPHANT::RULE-SPEC)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; compiling (DEFPARAMETER *SYNCHRONIZE-RULES* ...)
; compiling (DEFUN SYNCHRONIZE-CLASS-TO-STORE ...)
; compiling (DEFUN SYNCH-RULE-APPLICABLE? ...)
; compiling (DEFUN SIMPLE-MATCH-SET ...)
; compiling (DEFPARAMETER *PRINT-SYNCH-MESSAGES* ...)
; compiling (DEFUN APPLY-SYNCH-RULE ...)
; compiling (DEFUN APPLY-SYNCH-RULES ...)
; compiling (DEFUN COMPUTE-CLASS-AND-ELE-STATUS ...)
; compiling (DEFUN DESCRIBE-DB-CLASS-INDEX ...)
; compiling (DEFUN WIPE-INDEXED-CLASS ...)
; compiling (DEFUN DUMP-CLASS-INDEX ...)
; compiling (DEFUN REPORT-INDEXED-CLASSES ...)
; /Users/jensteich/Lisp/elephant/src/elephant/classindex-utils.fasl
written
; compilation finished in 0:00:01
STYLE-WARNING:
Implicitly creating new generic function CLASS-INDEX-CACHED?.
STYLE-WARNING:
Implicitly creating new generic function DETERMINE-SYNCH-METHOD.
STYLE-WARNING: Implicitly creating new generic function SET-DB-SYNCH.
STYLE-WARNING: redefining MAKE-SYNCH-RULE in DEFUN
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
classindex.lisp" (written 06 MAY 2007 12:10:40 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFGENERIC FIND-CLASS-INDEX ...)
; compiling (DEFGENERIC FIND-INVERTED-INDEX ...)
; compiling (DEFGENERIC ENABLE-CLASS-INDEXING ...)
; compiling (DEFGENERIC DISABLE-CLASS-INDEXING ...)
; compiling (DEFGENERIC ADD-CLASS-SLOT-INDEX ...)
; compiling (DEFGENERIC REMOVE-CLASS-SLOT-INDEX ...)
; compiling (DEFGENERIC ADD-CLASS-DERIVED-INDEX ...)
; compiling (DEFGENERIC REMOVE-CLASS-DERIVED-INDEX ...)
; compiling (DEFMETHOD FIND-CLASS-INDEX ...)
; compiling (DEFMETHOD CLASS-INDEXEDP-BY-NAME ...)
; compiling (DEFINE-CONDITION PERSISTENT-CLASS-NOT-INDEXED ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFINE-CONDITION PERSISTENT-CLASS-NOT-INDEXED
; (FORMAT STREAM "Class ~A is not enabled for indexing"
; (CLASS-NAME (ELEPHANT::UNINDEXED-CLASS-OBJ CONDITION)))
; ==>
; (FORMAT SB-C::DEST (FORMATTER "Class ~A is not enabled for
indexing") #:G54)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a STREAM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER NIL T) STREAM (VECTOR CHARACTER)
; (VECTOR NIL) BASE-STRING), not a
(MEMBER T).
; compiling (DEFUN SIGNAL-CLASS-NOT-INDEXED ...)
; compiling (DEFMETHOD FIND-CLASS-INDEX ...)
; compiling (DEFUN ENSURE-FINALIZED ...)
; compiling (DEFUN CACHE-EXISTING-CLASS-INDEX ...)
; compiling (DEFUN CACHE-NEW-CLASS-INDEX ...)
; compiling (DEFMETHOD FIND-INVERTED-INDEX ...)
; compiling (DEFMETHOD FIND-INVERTED-INDEX ...)
; compiling (DEFMETHOD FIND-INVERTED-INDEX-NAMES ...)
; compiling (DEFMETHOD CLOSE-CONTROLLER ...)
; compiling (DEFMETHOD INDEXED-SLOT-WRITER ...)
; compiling (DEFMETHOD INDEXED-SLOT-MAKUNBOUND ...)
; compiling (DEFUN NO-INDEXING-NEEDED? ...)
; compiling (DEFMETHOD ENABLE-CLASS-INDEXING ...)
; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...)
; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFMETHOD DISABLE-CLASS-INDEXING (PERSISTENT-METACLASS)
; (RETURN-FROM ELEPHANT:DISABLE-CLASS-INDEXING NIL)
;
; note: deleting unreachable code
; compiling (DEFMETHOD WIPE-CLASS-INDEXING ...)
; compiling (DEFMETHOD WIPE-CLASS-INDEXING ...)
; compiling (DEFMETHOD ADD-CLASS-SLOT-INDEX ...)
; compiling (DEFMETHOD ADD-CLASS-SLOT-INDEX ...)
; compiling (DEFMETHOD REMOVE-CLASS-SLOT-INDEX ...)
; compiling (DEFMETHOD REMOVE-CLASS-SLOT-INDEX ...)
; compiling (DEFMETHOD ADD-CLASS-DERIVED-INDEX ...)
; compiling (DEFMETHOD ADD-CLASS-DERIVED-INDEX ...)
; compiling (DEFMETHOD REMOVE-CLASS-DERIVED-INDEX ...)
; compiling (DEFMETHOD REMOVE-CLASS-DERIVED-INDEX ...)
; compiling (DEFGENERIC MAKE-INVERTED-CURSOR ...)
; compiling (DEFGENERIC MAKE-CLASS-CURSOR ...)
; compiling (DEFMETHOD MAKE-INVERTED-CURSOR ...)
; compiling (DEFMETHOD MAKE-INVERTED-CURSOR ...)
; compiling (DEFMACRO WITH-INVERTED-CURSOR ...)
; compiling (DEFMETHOD MAKE-CLASS-CURSOR ...)
; compiling (DEFMETHOD MAKE-CLASS-CURSOR ...)
; compiling (DEFMACRO WITH-CLASS-CURSOR ...)
; compiling (DEFUN MAP-CLASS ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFUN MAP-CLASS
; (FLET ((ELEPHANT::MAP-FN (ELEPHANT::K ELEPHANT::V)
; (DECLARE (IGNORE ELEPHANT::K))
; (FUNCALL ELEPHANT::FN ELEPHANT::V)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::MAP-FN))
; (ELEPHANT:MAP-BTREE #'ELEPHANT::MAP-FN ELEPHANT::CLASS-
IDX :COLLECT
; ELEPHANT::COLLECT))
;
; note: ignoring DYNAMIC-EXTENT declaration for free MAP-FN
; (FUNCALL ELEPHANT::FN ELEPHANT::V)
; --> 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.
; compiling (DEFUN MAP-INVERTED-INDEX ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFUN MAP-INVERTED-INDEX
; (FLET ((ELEPHANT::WRAPPER (ELEPHANT::KEY ELEPHANT::VALUE
ELEPHANT::PKEY)
; (DECLARE (IGNORE ELEPHANT::PKEY))
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::WRAPPER))
; (IF ELEPHANT::VALUE-P
; (ELEPHANT:MAP-INDEX #'ELEPHANT::WRAPPER ELEPHANT::INDEX :VALUE
; ELEPHANT::VALUE :COLLECT
ELEPHANT::COLLECT)
; (ELEPHANT:MAP-INDEX #'ELEPHANT::WRAPPER ELEPHANT::INDEX :START
; ELEPHANT::START :END ELEPHANT::END :FROM-
END
; ELEPHANT::FROM-END :COLLECT
ELEPHANT::COLLECT)))
;
; note: ignoring DYNAMIC-EXTENT declaration for free WRAPPER
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; --> 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.
; compiling (DEFGENERIC GET-INSTANCES-BY-CLASS ...)
; compiling (DEFGENERIC GET-INSTANCE-BY-VALUE ...)
; compiling (DEFGENERIC GET-INSTANCES-BY-VALUE ...)
; compiling (DEFGENERIC GET-INSTANCES-BY-RANGE ...)
; compiling (DEFUN IDENTITY2 ...)
; compiling (DEFUN IDENTITY3 ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-CLASS ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-CLASS ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-VALUE ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-VALUE ...)
; compiling (DEFMETHOD GET-INSTANCE-BY-VALUE ...)
; compiling (DEFMETHOD GET-INSTANCE-BY-VALUE ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-RANGE ...)
; compiling (DEFMETHOD GET-INSTANCES-BY-RANGE ...)
; compiling (DEFUN DROP-INSTANCES ...)
; /Users/jensteich/Lisp/elephant/src/elephant/classindex.fasl written
; compilation finished in 0:00:01
STYLE-WARNING:
Implicitly creating new generic function CLASS-INDEXEDP-BY-NAME.
STYLE-WARNING:
Implicitly creating new generic function FIND-INVERTED-INDEX-NAMES.
STYLE-WARNING:
Implicitly creating new generic function INDEXED-SLOT-WRITER.
STYLE-WARNING:
Implicitly creating new generic function INDEXED-SLOT-MAKUNBOUND.
STYLE-WARNING:
Implicitly creating new generic function WIPE-CLASS-INDEXING.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
serializer1.lisp" (written 12 APR 2007 04:47:33 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFPACKAGE :ELEPHANT-SERIALIZER1 ...)
; compiling (IN-PACKAGE :ELEPHANT-SERIALIZER1)
; compiling (DECLAIM (INLINE INT-BYTE-SPEC ...))
; compiling (UFFI:DEF-TYPE FOREIGN-CHAR ...)
; compiling (DEFCONSTANT +FIXNUM+ ...)
; compiling (DEFCONSTANT +CHAR+ ...)
; compiling (DEFCONSTANT +SINGLE-FLOAT+ ...)
; compiling (DEFCONSTANT +DOUBLE-FLOAT+ ...)
; compiling (DEFCONSTANT +NEGATIVE-BIGNUM+ ...)
; compiling (DEFCONSTANT +POSITIVE-BIGNUM+ ...)
; compiling (DEFCONSTANT +RATIONAL+ ...)
; compiling (DEFCONSTANT +NIL+ ...)
; compiling (DEFCONSTANT +UCS1-SYMBOL+ ...)
; compiling (DEFCONSTANT +UCS1-STRING+ ...)
; compiling (DEFCONSTANT +UCS1-PATHNAME+ ...)
; compiling (DEFCONSTANT +UCS2-SYMBOL+ ...)
; compiling (DEFCONSTANT +UCS2-STRING+ ...)
; compiling (DEFCONSTANT +UCS2-PATHNAME+ ...)
; compiling (DEFCONSTANT +UCS4-SYMBOL+ ...)
; compiling (DEFCONSTANT +UCS4-STRING+ ...)
; compiling (DEFCONSTANT +UCS4-PATHNAME+ ...)
; compiling (DEFCONSTANT +PERSISTENT+ ...)
; compiling (DEFCONSTANT +CONS+ ...)
; compiling (DEFCONSTANT +HASH-TABLE+ ...)
; compiling (DEFCONSTANT +OBJECT+ ...)
; compiling (DEFCONSTANT +ARRAY+ ...)
; compiling (DEFCONSTANT +RESERVED-DBINFO+ ...)
; compiling (DEFCONSTANT +FILL-POINTER-P+ ...)
; compiling (DEFCONSTANT +ADJUSTABLE-P+ ...)
; compiling (DEFVAR *LISP-OBJ-ID* ...)
; compiling (DEFVAR *CIRCULARITY-HASH* ...)
; compiling (DEFUN CLEAR-CIRCULARITY-HASH ...)
; compiling (DEFUN SERIALIZE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer1.lisp
; in: DEFUN SERIALIZE
; (CEILING (/ (INTEGER-LENGTH ELEPHANT-SERIALIZER1::NUM) 32))
; ==>
; (CEILING (/ (INTEGER-LENGTH ELEPHANT-SERIALIZER1::NUM) 32) 1)
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL 0 536870911/32), not a INTEGER.
; (INCF ELEPHANT-SERIALIZER1::*LISP-OBJ-ID*)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G42)
;
; 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).
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G48)
;
; 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).
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G75)
;
; 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).
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G82)
;
; 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).
; (ARRAY-RANK ELEPHANT-SERIALIZER1::FROB)
;
; note: unable to optimize because: The array rank is not known at
compile time: *
; (ARRAY-TOTAL-SIZE ELEPHANT-SERIALIZER1::FROB)
;
; note: unable to optimize because: can't tell the rank at compile time
; (ROW-MAJOR-AREF ELEPHANT-SERIALIZER1::FROB ELEPHANT-
SERIALIZER1::I)
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
; (SB-KERNEL:%CHECK-BOUND ARRAY
; (ARRAY-
TOTAL-SIZE
; ARRAY)
; SB-
INT:INDEX))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a ARRAY, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ARRAY-DIMENSION ELEPHANT-SERIALIZER1::FROB ELEPHANT-
SERIALIZER1::I)
;
; note: unable to optimize because: The axis is not constant.
; (LABELS ((ELEPHANT-SERIALIZER1::%SERIALIZE (ELEPHANT-
SERIALIZER1::FROB)
; (DECLARE (OPTIMIZE # #))
; (TYPECASE ELEPHANT-SERIALIZER1::FROB
; (FIXNUM # #)
; (NULL #)
; (SYMBOL #)
; (STRING #)
; (ELEPHANT:PERSISTENT # # #)
; (SINGLE-FLOAT # #)
; (DOUBLE-FLOAT # #)
; (CHARACTER # #)
; (PATHNAME #)
; (INTEGER #)
; ...)))
; (ELEPHANT-SERIALIZER1::%SERIALIZE ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::BS)
;
; note: Return type not fixed values, so can't use known return
convention:
; *
; (ABS ELEPHANT-SERIALIZER1::FROB)
; --> IF
; ==>
; (< SB-C::X 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; --> IF -
; ==>
; (SB-KERNEL:%NEGATE SB-C::X)
;
; note: forced to do GENERIC-NEGATE (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER * -1), not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 2)
because:
; The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
; (SIGNED-
BYTE 32)
; &REST T).
; (INTEGER-LENGTH ELEPHANT-SERIALIZER1::NUM)
;
; note: forced to do full call
; unable to do inline (unsigned-byte 32) integer-length (cost
26) because:
; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
; (< ELEPHANT-SERIALIZER1::FROB 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; (INCF ELEPHANT-SERIALIZER1::*LISP-OBJ-ID*)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G48)
;
; 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.
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G75)
;
; 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.
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G82)
;
; 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.
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER1::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+FILL-POINTER-P+ 0)
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+ADJUSTABLE-P+ 0))
; --> LOGIOR
; ==>
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER1::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+FILL-POINTER-P+ 0))
;
; 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 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).
; etc.
; ==>
; (LOGIOR
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER1::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+FILL-POINTER-P+ 0))
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+ADJUSTABLE-P+ 0))
;
; 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.
; unable to do inline (signed-byte 32) arithmetic (cost 3)
because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; etc.
; (INCF ELEPHANT-SERIALIZER1::*LISP-OBJ-ID*)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER1::*LISP-OBJ-ID* #:G42)
;
; 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.
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+FIXNUM+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+NIL+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT-SERIALIZER1::S)
; --> ETYPECASE LET COND IF COND IF PROGN * LOGAND
; ==>
; SB-C::X
;
; note: doing unsigned word to integer coercion (cost 20)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (ETYPECASE ELEPHANT-SERIALIZER1::S
; (BASE-STRING ELEPHANT-SERIALIZER1::+UCS1-SYMBOL+)
; (STRING ELEPHANT-SERIALIZER1::+UCS4-SYMBOL+))
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT ELEPHANT-SERIALIZER1::FROB
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+SINGLE-FLOAT+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE ELEPHANT-SERIALIZER1::FROB
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+DOUBLE-FLOAT+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+CHAR+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+RATIONAL+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+CONS+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER1::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+FILL-POINTER-P+ 0)
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER1::FROB)
; ELEPHANT-SERIALIZER1::+ADJUSTABLE-P+ 0))
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+ARRAY+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+OBJECT+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-SERIALIZER1::%SERIALIZE
; (HASH-TABLE-REHASH-THRESHOLD ELEPHANT-SERIALIZER1::FROB))
;
; note: doing float to pointer coercion (cost 13) to FROB
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER1::+HASH-
TABLE+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT
; (SB-BIGNUM:%BIGNUM-REF ELEPHANT-SERIALIZER1::NUM ELEPHANT-
SERIALIZER1::I)
; ELEPHANT-SERIALIZER1::BS)
;
; note: doing unsigned word to integer coercion (cost 20)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+NEGATIVE-BIGNUM+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+POSITIVE-BIGNUM+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT-SERIALIZER1::S)
; --> ETYPECASE LET COND IF COND IF PROGN * LOGAND
; ==>
; SB-C::X
;
; note: doing unsigned word to integer coercion (cost 20)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (ETYPECASE ELEPHANT-SERIALIZER1::S
; (BASE-STRING ELEPHANT-SERIALIZER1::+UCS1-PATHNAME+)
; (STRING ELEPHANT-SERIALIZER1::+UCS4-PATHNAME+))
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER1::+PERSISTENT+
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT-SERIALIZER1::FROB)
; --> ETYPECASE LET COND IF COND IF PROGN * LOGAND
; ==>
; SB-C::X
;
; note: doing unsigned word to integer coercion (cost 20)
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (ETYPECASE ELEPHANT-SERIALIZER1::FROB
; (BASE-STRING ELEPHANT-SERIALIZER1::+UCS1-STRING+)
; (STRING ELEPHANT-SERIALIZER1::+UCS4-STRING+))
; ELEPHANT-SERIALIZER1::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFPARAMETER *TRACE-SERIALIZER* ...)
; compiling (DEFPARAMETER *TAG-TABLE* ...)
; compiling (DEFUN ENABLE-SERIALIZER-TRACING ...)
; compiling (DEFUN DISABLE-SERIALIZER-TRACING ...)
; compiling (DEFUN PRINT-PRE-DESERIALIZE-TAG ...)
; compiling (DEFUN PRINT-POST-DESERIALIZE-TAG ...)
; compiling (DEFUN DESERIALIZE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer1.lisp
; in: DEFUN DESERIALIZE
; (OR
; (ELEPHANT-MEMUTIL:BUFFER-READ-UCS1-STRING ELEPHANT-SERIALIZER1::BS
; (ELEPHANT-
MEMUTIL:BUFFER-READ-FIXNUM
; ELEPHANT-
SERIALIZER1::BS))
; "")
; --> LET IF OR
; ==>
; ""
;
; note: deleting unreachable code
; (OR
; (ELEPHANT-MEMUTIL:BUFFER-READ-UCS4-STRING ELEPHANT-SERIALIZER1::BS
; (ELEPHANT-
MEMUTIL:BUFFER-READ-FIXNUM
; ELEPHANT-
SERIALIZER1::BS))
; "")
; --> LET IF OR
; ==>
; ""
;
; note: deleting unreachable code
; (SETF (SLOT-VALUE ELEPHANT-SERIALIZER1::O
; (ELEPHANT-SERIALIZER1::%DESERIALIZE
; ELEPHANT-SERIALIZER1::BS))
; (ELEPHANT-SERIALIZER1::%DESERIALIZE ELEPHANT-
SERIALIZER1::BS))
; ==>
; (SB-PCL::SET-SLOT-VALUE ELEPHANT-SERIALIZER1::O
; (ELEPHANT-SERIALIZER1::%DESERIALIZE
; ELEPHANT-SERIALIZER1::BS)
; (ELEPHANT-SERIALIZER1::%DESERIALIZE
; ELEPHANT-SERIALIZER1::BS))
;
; note: unable to optimize because: Slot name is not constant.
; (MAKE-ARRAY
; (LOOP ELEPHANT-SERIALIZER1::FOR ELEPHANT-SERIALIZER1::I FIXNUM
; ELEPHANT-SERIALIZER1::FROM 0 ELEPHANT-SERIALIZER1::BELOW
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT-SERIALIZER1::BS)
; ELEPHANT-SERIALIZER1::COLLECT
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT-SERIALIZER1::BS))
; :ELEMENT-TYPE
; (ELEPHANT::ARRAY-TYPE-FROM-BYTE (LOGAND 63 ELEPHANT-
SERIALIZER1::FLAGS))
; :FILL-POINTER
; (/= 0
; (LOGAND ELEPHANT-SERIALIZER1::+FILL-POINTER-P+
; ELEPHANT-SERIALIZER1::FLAGS))
; :ADJUSTABLE
; (/= 0
; (LOGAND ELEPHANT-SERIALIZER1::+ADJUSTABLE-P+
; ELEPHANT-SERIALIZER1::FLAGS)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a
INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (ARRAY-TOTAL-SIZE ELEPHANT-SERIALIZER1::A)
;
; note: unable to optimize because: can't tell the rank at compile time
; (SETF (ROW-MAJOR-AREF ELEPHANT-SERIALIZER1::A ELEPHANT-
SERIALIZER1::I)
; (ELEPHANT-SERIALIZER1::%DESERIALIZE ELEPHANT-
SERIALIZER1::BS))
; --> SB-KERNEL:%SET-ROW-MAJOR-AREF
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
; (SB-KERNEL:%CHECK-BOUND ARRAY
; (ARRAY-
TOTAL-SIZE
; ARRAY)
; SB-
INT:INDEX)
; SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a ARRAY, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ELEPHANT-SERIALIZER1::BS)
; --> BLOCK LET ELEPHANT-MEMUTIL::READ-FLOAT BLOCK THE DEREF
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; ==>
; ALIEN
;
; note: doing float to pointer coercion (cost 13)
; (ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ELEPHANT-SERIALIZER1::BS)
; --> BLOCK LET ELEPHANT-MEMUTIL::READ-DOUBLE BLOCK THE DEREF
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; ==>
; ALIEN
;
; note: doing float to pointer coercion (cost 13)
; compiling (DEFUN DESERIALIZE-BIGNUM ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer1.lisp
; in: DEFUN DESERIALIZE-BIGNUM
; (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT-SERIALIZER1::BS)
; ELEPHANT-SERIALIZER1::BYTE-SPEC ELEPHANT-SERIALIZER1::NUM)
; --> LET
; ==>
; (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT-
SERIALIZER1::BS)
; (BYTE-SIZE #:G641) (BYTE-POSITION #:G641)
; ELEPHANT-SERIALIZER1::NUM)
;
; note: unable to
; convert to inline logical operations
; due to type uncertainty:
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
(UNSIGNED-BYTE 32)
; &REST T).
;
; note: unable to
; convert to inline logical operations
; due to type uncertainty:
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-
BYTE 32)
; &REST T).
; (LOOP ELEPHANT-SERIALIZER1::FOR ELEPHANT-SERIALIZER1::I
; ELEPHANT-SERIALIZER1::FROM 0 ELEPHANT-SERIALIZER1::BELOW (/
LENGTH 4)
; ELEPHANT-SERIALIZER1::FOR ELEPHANT-SERIALIZER1::BYTE-SPEC =
; (ELEPHANT::INT-BYTE-SPEC ELEPHANT-SERIALIZER1::I)
; ELEPHANT-SERIALIZER1::WITH ...)
; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN IF >= IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a (RATIONAL -134217728 536870911/4),
not a FIXNUM.
; (- ELEPHANT-SERIALIZER1::NUM)
; ==>
; (SB-KERNEL:%NEGATE ELEPHANT-SERIALIZER1::NUM)
;
; note: forced to do GENERIC-NEGATE (cost 10)
; unable to do inline fixnum arithmetic (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 (signed-byte 32) arithmetic (cost 2)
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).
; /Users/jensteich/Lisp/elephant/src/elephant/serializer1.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
serializer2.lisp" (written 23 APR 2007 04:41:11 AM):
; compiling (IN-PACKAGE :ELEPHANT)
; compiling (DEFPACKAGE :ELEPHANT-SERIALIZER2 ...)
; compiling (IN-PACKAGE :ELEPHANT-SERIALIZER2)
; compiling (UFFI:DEF-TYPE FOREIGN-CHAR ...)
; compiling (DEFCONSTANT +FIXNUM32+ ...)
; compiling (DEFCONSTANT +FIXNUM64+ ...)
; compiling (DEFCONSTANT +CHAR+ ...)
; compiling (DEFCONSTANT +SINGLE-FLOAT+ ...)
; compiling (DEFCONSTANT +DOUBLE-FLOAT+ ...)
; compiling (DEFCONSTANT +NEGATIVE-BIGNUM+ ...)
; compiling (DEFCONSTANT +POSITIVE-BIGNUM+ ...)
; compiling (DEFCONSTANT +RATIONAL+ ...)
; compiling (DEFCONSTANT +UTF8-STRING+ ...)
; compiling (DEFCONSTANT +UTF16-STRING+ ...)
; compiling (DEFCONSTANT +UTF32-STRING+ ...)
; compiling (DEFCONSTANT +PATHNAME+ ...)
; compiling (DEFCONSTANT +SYMBOL+ ...)
; compiling (DEFCONSTANT +PERSISTENT+ ...)
; compiling (DEFCONSTANT +CONS+ ...)
; compiling (DEFCONSTANT +HASH-TABLE+ ...)
; compiling (DEFCONSTANT +OBJECT+ ...)
; compiling (DEFCONSTANT +ARRAY+ ...)
; compiling (DEFCONSTANT +STRUCT+ ...)
; compiling (DEFCONSTANT +CLASS+ ...)
; compiling (DEFCONSTANT +COMPLEX+ ...)
; compiling (DEFCONSTANT +SHORT-FLOAT+ ...)
; compiling (DEFCONSTANT +NIL+ ...)
; compiling (DEFCONSTANT +RESERVED-DBINFO+ ...)
; compiling (DEFCONSTANT +FILL-POINTER-P+ ...)
; compiling (DEFCONSTANT +ADJUSTABLE-P+ ...)
; compiling (DEFPARAMETER *CIRCULARITY-HASH-QUEUE* ...)
; compiling (DEFVAR *SERIALIZER-FAST-LOCK* ...)
; compiling (DEFUN GET-CIRCULARITY-HASH ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN GET-CIRCULARITY-HASH
; (LENGTH ELEPHANT-SERIALIZER2::*CIRCULARITY-HASH-QUEUE*)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFUN RELEASE-CIRCULARITY-HASH ...)
; compiling (DEFPARAMETER *CIRCULARITY-VECTOR-QUEUE* ...)
; compiling (DEFUN GET-CIRCULARITY-VECTOR ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN GET-CIRCULARITY-VECTOR
; (LENGTH ELEPHANT-SERIALIZER2::*CIRCULARITY-VECTOR-QUEUE*)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (MAKE-ARRAY 50 :ELEMENT-TYPE T :INITIAL-ELEMENT NIL :FILL-
POINTER 0
; :ADJUSTABLE T)
; --> LET MULTIPLE-VALUE-BIND LET
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY 0)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR T), not a SIMPLE-ARRAY.
; compiling (DEFUN RELEASE-CIRCULARITY-VECTOR ...)
; compiling (DEFCONSTANT +2^31+ ...)
; compiling (DEFCONSTANT +2^32+ ...)
; compiling (DEFCONSTANT +2^63+ ...)
; compiling (DEFCONSTANT +2^64+ ...)
; compiling (DEFUN SERIALIZE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN SERIALIZE
; (< 536870911 ELEPHANT-SERIALIZER2::+2^63+)
; ==>
; ELEPHANT-SERIALIZER2::+2^63+
;
; note: deleting unreachable code
; (EQ (< 536870911 ELEPHANT-SERIALIZER2::+2^63+) T)
;
; note: deleting unreachable code
; (ABS ELEPHANT-SERIALIZER2::FROB)
; ==>
; ELEPHANT-SERIALIZER2::FROB
;
; note: deleting unreachable code
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+FIXNUM32+
; ELEPHANT-SERIALIZER2::BS)
; ==>
; ELEPHANT-SERIALIZER2::+FIXNUM32+
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::FROB
; ELEPHANT-SERIALIZER2::BS)
; ==>
; ELEPHANT-SERIALIZER2::FROB
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+FIXNUM64+
; ELEPHANT-SERIALIZER2::BS)
; ==>
; ELEPHANT-SERIALIZER2::+FIXNUM64+
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT64 ELEPHANT-SERIALIZER2::FROB
; ELEPHANT-SERIALIZER2::BS)
; ==>
; ELEPHANT-SERIALIZER2::FROB
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; (REALPART ELEPHANT-SERIALIZER2::FROB)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a COMPLEX, not a (COMPLEX RATIONAL).
; (IMAGPART ELEPHANT-SERIALIZER2::FROB)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a COMPLEX, not a (COMPLEX RATIONAL).
; (ARRAY-RANK ELEPHANT-SERIALIZER2::FROB)
;
; note: unable to optimize because: The array rank is not known at
compile time: *
; (ARRAY-TOTAL-SIZE ELEPHANT-SERIALIZER2::FROB)
;
; note: unable to optimize because: can't tell the rank at compile time
; (ROW-MAJOR-AREF ELEPHANT-SERIALIZER2::FROB ELEPHANT-
SERIALIZER2::I)
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:%CHECK-BOUND
; ==>
; (ARRAY-TOTAL-SIZE ARRAY)
;
; note: unable to optimize because: can't tell the rank at compile time
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
; (SB-KERNEL:%CHECK-BOUND ARRAY
; (ARRAY-
TOTAL-SIZE
; ARRAY)
; SB-
INT:INDEX))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a ARRAY, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ARRAY-DIMENSION ELEPHANT-SERIALIZER2::FROB ELEPHANT-
SERIALIZER2::I)
;
; note: unable to optimize because: The axis is not constant.
; (INCF ELEPHANT-SERIALIZER2::LISP-OBJ-ID)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER2::LISP-OBJ-ID #:G175)
;
; 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).
; (LENGTH ELEPHANT-SERIALIZER2::SVS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (INCF ELEPHANT-SERIALIZER2::LISP-OBJ-ID)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER2::LISP-OBJ-ID #:G101)
;
; 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).
; (LABELS ((ELEPHANT-SERIALIZER2::%NEXT-OBJECT-ID ()
; (INCF ELEPHANT-SERIALIZER2::LISP-OBJ-ID))
; (ELEPHANT-SERIALIZER2::%SERIALIZE (ELEPHANT-
SERIALIZER2::FROB)
; (TYPECASE ELEPHANT-SERIALIZER2::FROB
; (FIXNUM #)
; (NULL #)
; (SYMBOL #)
; (STRING #)
; (ELEPHANT:PERSISTENT # # # #)
; (SINGLE-FLOAT # #)
; (DOUBLE-FLOAT # #)
; (STANDARD-OBJECT # #)
; (INTEGER #)
; (RATIONAL # # #)
; ...)))
; (ELEPHANT-SERIALIZER2::%SERIALIZE ELEPHANT-SERIALIZER2::FROB)
; (ELEPHANT-SERIALIZER2::RELEASE-CIRCULARITY-HASH
; ELEPHANT-SERIALIZER2::CIRCULARITY-HASH)
; ELEPHANT-SERIALIZER2::BS)
;
; note: Return type not fixed values, so can't use known return
convention:
; *
; (INCF ELEPHANT-SERIALIZER2::LISP-OBJ-ID)
; --> LET*
; ==>
; (+ ELEPHANT-SERIALIZER2::LISP-OBJ-ID #:G101)
;
; 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.
; ==>
; (+ ELEPHANT-SERIALIZER2::LISP-OBJ-ID #:G175)
;
; 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.
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER2::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+FILL-POINTER-P+ 0)
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+ADJUSTABLE-P+ 0))
; --> LOGIOR
; ==>
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER2::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+FILL-POINTER-P+ 0))
;
; 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 T, 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 T, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (SIGNED-
BYTE 32) &REST
; T).
; etc.
; ==>
; (LOGIOR
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER2::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+FILL-POINTER-P+ 0))
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+ADJUSTABLE-P+ 0))
;
; 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 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).
; etc.
; (REALPART ELEPHANT-SERIALIZER2::FROB)
;
; note: forced to do full call
; unable to do complex float realpart (cost 3) because:
; The first argument is a COMPLEX, not a (COMPLEX SINGLE-FLOAT).
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-
FLOAT &REST
; T).
; unable to do complex float realpart (cost 3) because:
; The first argument is a COMPLEX, not a (COMPLEX DOUBLE-FLOAT).
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-
FLOAT &REST
; T).
; (IMAGPART ELEPHANT-SERIALIZER2::FROB)
;
; note: forced to do full call
; unable to do complex float imagpart (cost 3) because:
; The first argument is a COMPLEX, not a (COMPLEX SINGLE-FLOAT).
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-
FLOAT &REST
; T).
; unable to do complex float imagpart (cost 3) because:
; The first argument is a COMPLEX, not a (COMPLEX DOUBLE-FLOAT).
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-
FLOAT &REST
; T).
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+FIXNUM32+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-108)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::FROB
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-112)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+FIXNUM32+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+NIL+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-348)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+SYMBOL+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-341)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+NIL+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-334)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+SYMBOL+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+PERSISTENT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-327)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32
; (ELEPHANT::OID ELEPHANT-SERIALIZER2::FROB) ELEPHANT-
SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-232)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+PERSISTENT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+SINGLE-FLOAT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-320)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT ELEPHANT-SERIALIZER2::FROB
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-124)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+SINGLE-FLOAT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+DOUBLE-FLOAT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-313)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE ELEPHANT-SERIALIZER2::FROB
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-130)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+DOUBLE-FLOAT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+RATIONAL+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-299)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+CHAR+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-292)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+CONS+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-285)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::IDP
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-220)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-216)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+CONS+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+COMPLEX+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-271)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+ARRAY+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-257)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::IDP
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-204)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-200)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER2::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+FILL-POINTER-P+ 0)
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+ADJUSTABLE-P+ 0))
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-250)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::RANK
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-196)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; (LOGIOR
; (ELEPHANT::BYTE-FROM-ARRAY-TYPE
; (ARRAY-ELEMENT-TYPE ELEPHANT-SERIALIZER2::FROB))
; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+FILL-POINTER-P+ 0)
; (IF (ADJUSTABLE-ARRAY-P ELEPHANT-SERIALIZER2::FROB)
; ELEPHANT-SERIALIZER2::+ADJUSTABLE-P+ 0))
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+ARRAY+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+STRUCT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-243)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::IDP
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-192)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 (INCF ELEPHANT-
SERIALIZER2::LISP-OBJ-ID)
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-188)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+STRUCT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+HASH-
TABLE+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-264)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::IDP
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-212)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-208)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-SERIALIZER2::%SERIALIZE
; (HASH-TABLE-REHASH-THRESHOLD ELEPHANT-SERIALIZER2::FROB))
;
; note: doing float to pointer coercion (cost 13) to FROB
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+HASH-
TABLE+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+PATHNAME+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-278)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+OBJECT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-306)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::IDP
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-228)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-SERIALIZER2::ID
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {13075649}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-224)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+OBJECT+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFUN SERIALIZE-BIGNUM ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN SERIALIZE-BIGNUM
; (ABS ELEPHANT-SERIALIZER2::FROB)
; --> IF
; ==>
; (< SB-C::X 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; --> IF -
; ==>
; (SB-KERNEL:%NEGATE SB-C::X)
;
; note: forced to do GENERIC-NEGATE (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER * -1), not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 2)
because:
; The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
; (SIGNED-
BYTE 32)
; &REST T).
; (INTEGER-LENGTH ELEPHANT-SERIALIZER2::NUM)
;
; note: forced to do full call
; unable to do inline (unsigned-byte 32) integer-length (cost
26) because:
; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
; (CEILING (/ (INTEGER-LENGTH ELEPHANT-SERIALIZER2::NUM) 32))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
; --> VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL 0 536870911/32), not a FIXNUM.
; The result is a (VALUES (RATIONAL -16777215 536870911/32)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The first argument is a (RATIONAL 0 536870911/32), not a
(SIGNED-BYTE 32).
; The result is a (VALUES (RATIONAL -16777215 536870911/32)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
; --> AND IF AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a (RATIONAL 0 536870911/32), not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (RATIONAL 0 536870911/32), not a FIXNUM.
; etc.
; (< ELEPHANT-SERIALIZER2::FROB 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; (LDB (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::NUM)
; --> SB-KERNEL:%LDB LOGAND
; ==>
; (ASH INT (- SB-C::POSN))
;
; note: forced to do full call
; unable to do inline ASH (cost 3) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The second argument is a (INTEGER -536870880 0), not a
(UNSIGNED-BYTE 29).
; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a
(VALUES FIXNUM
; &REST
T).
; unable to do inline ASH (cost 3) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The second argument is a (INTEGER -536870880 0), not a
(UNSIGNED-BYTE 29).
; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a
(VALUES FIXNUM
; &REST
T).
; etc.
; --> SB-KERNEL:%LDB
; ==>
; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2)
because:
; The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
; etc.
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+NEGATIVE-BIGNUM+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11811611}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-477)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT32 ELEPHANT-SERIALIZER2::NEEDED
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11811611}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-481)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT32
; (LDB (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::NUM)
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11811611}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-493)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT32 ELEPHANT-SERIALIZER2::NEEDED
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+NEGATIVE-BIGNUM+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-
SERIALIZER2::+POSITIVE-BIGNUM+
; ELEPHANT-SERIALIZER2::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {11811611}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-500)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFPARAMETER *TRACE-DESERIALIZER* ...)
; compiling (DEFPARAMETER *TAG-TABLE* ...)
; compiling (DEFUN ENABLE-DESERIALIZER-TRACING ...)
; compiling (DEFUN DISABLE-DESERIALIZER-TRACING ...)
; compiling (DEFUN PRINT-PRE-DESERIALIZE-TAG ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN PRINT-PRE-DESERIALIZE-TAG
; (ASSOC ELEPHANT-SERIALIZER2::TAG ELEPHANT-SERIALIZER2::*TAG-
TABLE*)
; --> BLOCK LET COND IF COND IF COND PROGN IF SB-IMPL::ASSOC-GUTS DO
BLOCK
; --> LET TAGBODY TAGBODY WHEN IF AND IF AND
; ==>
; (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.
;
; 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.
; compiling (DEFUN PRINT-POST-DESERIALIZE-TAG ...)
; compiling (DEFUN DESERIALIZE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN DESERIALIZE
; (>= ELEPHANT-SERIALIZER2::ID
; (FILL-POINTER ELEPHANT-SERIALIZER2::CIRCULARITY-VECTOR))
; --> OR LET IF OR = IF
; ==>
; (= SB-C::X SB-C::Y)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the
same type.
; --> OR LET > IF
; ==>
; (> SB-C::X SB-C::Y)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10) ELEPHANT-SERIALIZER2::REHASH-
THRESHOLD))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
; --> AND IF NOT IF ZEROP
; ==>
; (= REM 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the
same type.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
; --> AND IF AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (+ ELEPHANT-SERIALIZER2::SIZE 10)
;
; 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).
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10) ELEPHANT-
SERIALIZER2::REHASH-THRESHOLD)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second 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 SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10) ELEPHANT-SERIALIZER2::REHASH-
THRESHOLD))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
; --> VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (*
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10)
; ELEPHANT-SERIALIZER2::REHASH-THRESHOLD))
; ELEPHANT-SERIALIZER2::REHASH-SIZE)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The second argument is a NUMBER, not a INTEGER.
; (CEILING
; (*
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10)
; ELEPHANT-SERIALIZER2::REHASH-THRESHOLD))
; ELEPHANT-SERIALIZER2::REHASH-SIZE))
; ==>
; (CEILING
; (*
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10)
; ELEPHANT-SERIALIZER2::REHASH-THRESHOLD))
; ELEPHANT-SERIALIZER2::REHASH-SIZE)
; 1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; (SETF (SLOT-VALUE ELEPHANT-SERIALIZER2::O
; (ELEPHANT-SERIALIZER2::%DESERIALIZE
; ELEPHANT-SERIALIZER2::BS))
; (ELEPHANT-SERIALIZER2::%DESERIALIZE ELEPHANT-
SERIALIZER2::BS))
; ==>
; (SB-PCL::SET-SLOT-VALUE ELEPHANT-SERIALIZER2::O
; (ELEPHANT-SERIALIZER2::%DESERIALIZE
; ELEPHANT-SERIALIZER2::BS)
; (ELEPHANT-SERIALIZER2::%DESERIALIZE
; ELEPHANT-SERIALIZER2::BS))
;
; note: unable to optimize because: Slot name is not constant.
; (MAKE-ARRAY
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I FIXNUM
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT-SERIALIZER2::BS)
; ELEPHANT-SERIALIZER2::COLLECT
; (ELEPHANT-SERIALIZER2::%DESERIALIZE ELEPHANT-
SERIALIZER2::BS))
; :ELEMENT-TYPE
; (ELEPHANT::ARRAY-TYPE-FROM-BYTE (LOGAND 31 ELEPHANT-
SERIALIZER2::FLAGS))
; :FILL-POINTER
; (/= 0
; (LOGAND ELEPHANT-SERIALIZER2::+FILL-POINTER-P+
; ELEPHANT-SERIALIZER2::FLAGS))
; :ADJUSTABLE
; (/= 0
; (LOGAND ELEPHANT-SERIALIZER2::+ADJUSTABLE-P+
; ELEPHANT-SERIALIZER2::FLAGS)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a
INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (ARRAY-TOTAL-SIZE ELEPHANT-SERIALIZER2::A)
;
; note: unable to optimize because: can't tell the rank at compile time
; (SETF (ROW-MAJOR-AREF ELEPHANT-SERIALIZER2::A ELEPHANT-
SERIALIZER2::I)
; (ELEPHANT-SERIALIZER2::%DESERIALIZE ELEPHANT-
SERIALIZER2::BS))
; --> SB-KERNEL:%SET-ROW-MAJOR-AREF SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> SB-KERNEL:%CHECK-BOUND
; ==>
; (ARRAY-TOTAL-SIZE ARRAY)
;
; note: unable to optimize because: can't tell the rank at compile time
; --> SB-KERNEL:%SET-ROW-MAJOR-AREF
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
; (SB-KERNEL:%CHECK-BOUND ARRAY
; (ARRAY-
TOTAL-SIZE
; ARRAY)
; SB-
INT:INDEX)
; SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a ARRAY, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (FUNCALL (ELEPHANT:STRUCT-CONSTRUCTOR ELEPHANT-
SERIALIZER2::TYPEDESIG))
; --> 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.
; (SETF (SLOT-VALUE ELEPHANT-SERIALIZER2::O ELEPHANT-
SERIALIZER2::NAME)
; ELEPHANT-SERIALIZER2::VALUE)
; ==>
; (SB-PCL::SET-SLOT-VALUE ELEPHANT-SERIALIZER2::O ELEPHANT-
SERIALIZER2::NAME
; ELEPHANT-SERIALIZER2::VALUE)
;
; note: unable to optimize because: Slot name is not constant.
; (AREF ELEPHANT-SERIALIZER2::CIRCULARITY-VECTOR ELEPHANT-
SERIALIZER2::ID)
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (LABELS ((ELEPHANT-SERIALIZER2::LOOKUP-ID (ELEPHANT-
SERIALIZER2::ID)
; (IF (>= ELEPHANT-SERIALIZER2::ID #) NIL
; (AREF ELEPHANT-SERIALIZER2::CIRCULARITY-VECTOR
; ELEPHANT-SERIALIZER2::ID)))
; (ELEPHANT-SERIALIZER2::ADD-OBJECT (ELEPHANT-
SERIALIZER2::OBJECT)
; (VECTOR-PUSH-EXTEND ELEPHANT-SERIALIZER2::OBJECT
; ELEPHANT-SERIALIZER2::CIRCULARITY-
VECTOR 50)
; (1- (FILL-POINTER ELEPHANT-SERIALIZER2::CIRCULARITY-
VECTOR)))
; (ELEPHANT-SERIALIZER2::%DESERIALIZE (ELEPHANT-
SERIALIZER2::BS)
; (DECLARE
; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-
SERIALIZER2::BS))
; (LET (#)
; (DECLARE # #)
; (COND # # # # # # # # # # # ...))))
; (ETYPECASE ELEPHANT-SERIALIZER2::BUF-STR
; (NULL (RETURN-FROM ELEPHANT-SERIALIZER2::DESERIALIZE NIL))
; (ELEPHANT-MEMUTIL:BUFFER-STREAM
; (LET (#)
; (ELEPHANT-SERIALIZER2::RELEASE-CIRCULARITY-VECTOR
; ELEPHANT-SERIALIZER2::CIRCULARITY-VECTOR)
; ELEPHANT-SERIALIZER2::RESULT))))
;
; note: Return type not fixed values, so can't use known return
convention:
; *
; (>= ELEPHANT-SERIALIZER2::ID
; (FILL-POINTER ELEPHANT-SERIALIZER2::CIRCULARITY-VECTOR))
; --> OR LET > IF
; ==>
; (> SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (+ ELEPHANT-SERIALIZER2::SIZE 10)
;
; 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.
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10) ELEPHANT-
SERIALIZER2::REHASH-THRESHOLD)
;
; note: forced to do static-fun Two-arg-/ (cost 53)
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
DOUBLE-FLOAT
; &REST
T).
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
SINGLE-FLOAT
; &REST
T).
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10) ELEPHANT-SERIALIZER2::REHASH-
THRESHOLD))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
; ==>
; (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
;
; note: forced to do full call
; unable to do inline float truncate (cost 5) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-
BYTE 32)
; &REST T).
; unable to do inline float truncate (cost 5) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (SIGNED-
BYTE 32) &REST
; T).
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
; --> VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM
&REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The first argument is a REAL, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-
BYTE 32)
; &REST T).
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
; --> AND IF AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
; --> VALUES
; ==>
; (+ SB-KERNEL::TRU 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (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 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).
; etc.
; (*
; (CEILING
; (/ (+ ELEPHANT-SERIALIZER2::SIZE 10)
; ELEPHANT-SERIALIZER2::REHASH-THRESHOLD))
; ELEPHANT-SERIALIZER2::REHASH-SIZE)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a T, not a (SIGNED-BYTE 32).
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
(SIGNED-BYTE 32)
; &REST
T).
; etc.
; (COMPLEX ELEPHANT-SERIALIZER2::RPART ELEPHANT-SERIALIZER2::IPART)
;
; note: forced to do full call
; unable to do inline complex single-float creation (cost 5)
because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES
; (OR RATIONAL (COMPLEX RATIONAL) (COMPLEX
DOUBLE-FLOAT)
; (COMPLEX SINGLE-FLOAT))
; &OPTIONAL), not a (VALUES (COMPLEX SINGLE-
FLOAT) &REST
; T).
; unable to do inline complex double-float creation (cost 5)
because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES
; (OR RATIONAL (COMPLEX RATIONAL) (COMPLEX
DOUBLE-FLOAT)
; (COMPLEX SINGLE-FLOAT))
; &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-
FLOAT) &REST
; T).
; (ELEPHANT-MEMUTIL:BUFFER-READ-BYTE ELEPHANT-SERIALIZER2::BS)
; --> BLOCK LET INCF LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12748BC1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-671)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ELEPHANT-SERIALIZER2::BS)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12748BC1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-606)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK LET ELEPHANT-MEMUTIL::READ-FLOAT BLOCK THE DEREF
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; ==>
; ALIEN
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; (ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ELEPHANT-SERIALIZER2::BS)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12748BC1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-610)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; --> BLOCK LET ELEPHANT-MEMUTIL::READ-DOUBLE BLOCK THE DEREF
; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-
INTERNALS:NATURALIZE
; ==>
; ALIEN
;
; note: doing float to pointer coercion (cost 13) to "<return value>"
; (ELEPHANT-MEMUTIL:BUFFER-READ-BYTE ELEPHANT-SERIALIZER2::BS)
; --> BLOCK LET INCF LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12748BC1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-652)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT-SERIALIZER2::BS)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12748BC1}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-647)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFUN DESERIALIZE-BIGNUM ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/serializer2.lisp
; in: DEFUN DESERIALIZE-BIGNUM
; (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT-SERIALIZER2::BS)
; ELEPHANT-SERIALIZER2::BYTE-SPEC ELEPHANT-SERIALIZER2::NUM)
; --> LET
; ==>
; (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT-
SERIALIZER2::BS)
; (BYTE-SIZE #:G769) (BYTE-POSITION #:G769)
; ELEPHANT-SERIALIZER2::NUM)
;
; note: unable to
; convert to inline logical operations
; due to type uncertainty:
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
(UNSIGNED-BYTE 32)
; &REST T).
;
; note: unable to
; convert to inline logical operations
; due to type uncertainty:
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-
BYTE 32)
; &REST T).
; (DEFUN ELEPHANT-SERIALIZER2::DESERIALIZE-BIGNUM
; (ELEPHANT-SERIALIZER2::BS LENGTH ELEPHANT-
SERIALIZER2::POSITIVE)
; (DECLARE (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-
SERIALIZER2::BS)
; (TYPE FIXNUM LENGTH) (TYPE BOOLEAN ELEPHANT-
SERIALIZER2::POSITIVE))
; (LET ((ELEPHANT::INT-BYTE-SPEC (BYTE 32 0)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::INT-BYTE-SPEC)
; (IGNORABLE ELEPHANT::INT-BYTE-SPEC))
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW
; (/ LENGTH 4) ELEPHANT-SERIALIZER2::FOR
; ELEPHANT-SERIALIZER2::BYTE-SPEC =
; (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::WITH
; ...)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL
; --> MULTIPLE-VALUE-BIND LET UNLESS IF TYPEP IF MEMBER BLOCK LET DO
BLOCK
; --> LET TAGBODY TAGBODY LET WHEN IF SB-IMPL::SATISFIES-THE-TEST LET
COND
; --> IF COND IF COND PROGN FUNCALL
; ==>
; (SB-C::%FUNCALL FUNCTION #:G804 #:G805)
;
; 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.
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW (/
LENGTH 4)
; ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::BYTE-SPEC =
; (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::WITH ...)
; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN IF >= IF
; ==>
; (< SB-C::X SB-C::Y)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The second argument is a (RATIONAL -134217728 536870911/4),
not a FIXNUM.
; (- ELEPHANT-SERIALIZER2::NUM)
; ==>
; (SB-KERNEL:%NEGATE ELEPHANT-SERIALIZER2::NUM)
;
; note: forced to do GENERIC-NEGATE (cost 10)
; unable to do inline fixnum arithmetic (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 (signed-byte 32) arithmetic (cost 2)
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).
; (* 32 ELEPHANT-SERIALIZER2::I)
; --> *
; ==>
; (ASH SB-C::X 5)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a
(VALUES FIXNUM
; &REST
T).
; unable to do inline ASH (cost 3) because:
; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;
(UNSIGNED-BYTE
; 32)
; &REST
T).
; etc.
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW (/
LENGTH 4)
; ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::BYTE-SPEC =
; (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::WITH ...)
; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY
; --> SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 1+
; ==>
; (+ ELEPHANT-SERIALIZER2::I 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
FIXNUM
;
&REST T).
; etc.
; (DEFUN ELEPHANT-SERIALIZER2::DESERIALIZE-BIGNUM
; (ELEPHANT-SERIALIZER2::BS LENGTH ELEPHANT-
SERIALIZER2::POSITIVE)
; (DECLARE (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-
SERIALIZER2::BS)
; (TYPE FIXNUM LENGTH) (TYPE BOOLEAN ELEPHANT-
SERIALIZER2::POSITIVE))
; (LET ((ELEPHANT::INT-BYTE-SPEC (BYTE 32 0)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::INT-BYTE-SPEC)
; (IGNORABLE ELEPHANT::INT-BYTE-SPEC))
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW
; (/ LENGTH 4) ELEPHANT-SERIALIZER2::FOR
; ELEPHANT-SERIALIZER2::BYTE-SPEC =
; (BYTE 32 (* 32 ELEPHANT-SERIALIZER2::I)) ELEPHANT-
SERIALIZER2::WITH
; ...)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL
; --> MULTIPLE-VALUE-BIND LET UNLESS IF TYPEP IF MEMBER BLOCK LET DO
BLOCK
; --> LET TAGBODY TAGBODY LET WHEN IF SB-IMPL::SATISFIES-THE-TEST LET
COND
; --> IF COND IF COND PROGN FUNCALL
; ==>
; (SB-C::%FUNCALL FUNCTION #:G804 #:G805)
;
; 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.
; /Users/jensteich/Lisp/elephant/src/elephant/serializer2.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
unicode2.lisp" (written 04 JUN 2007 11:14:04 PM):
; compiling (IN-PACKAGE :ELEPHANT-SERIALIZER2)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFUN SERIALIZE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFUN SERIALIZE-STRING
; (CHAR STRING 0)
; --> AREF
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEFUN SERIALIZE-TO-UTF8 ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFUN SERIALIZE-TO-UTF8
; (CHAR STRING ELEPHANT-SERIALIZER2::I)
; --> AREF
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF8-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12AB5729}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-55)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12AB5729}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-59)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (LET ((ELEPHANT-SERIALIZER2::NEEDED
; (+ ELEPHANT-SERIALIZER2::SIZE ELEPHANT-
SERIALIZER2::CHARACTERS)))
; (DECLARE (TYPE FIXNUM ELEPHANT-SERIALIZER2::NEEDED))
; (WHEN (> ELEPHANT-SERIALIZER2::NEEDED ELEPHANT-
SERIALIZER2::ALLOCATED)
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-
SERIALIZER2::BSTREAM
; ELEPHANT-
SERIALIZER2::NEEDED))
; (ETYPECASE STRING
; (SIMPLE-STRING
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I FIXNUM
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW
; ELEPHANT-SERIALIZER2::CHARACTERS DO
; (LET #
; #
; #
; #)))
; (STRING
; (LOOP ELEPHANT-SERIALIZER2::FOR ELEPHANT-SERIALIZER2::I FIXNUM
; ELEPHANT-SERIALIZER2::FROM 0 ELEPHANT-SERIALIZER2::BELOW
; ELEPHANT-SERIALIZER2::CHARACTERS DO
; (LET #
; #
; #
; #))))
; (SETF (ELEPHANT-MEMUTIL:BUFFER-STREAM-SIZE ELEPHANT-
SERIALIZER2::BSTREAM)
; ELEPHANT-SERIALIZER2::NEEDED)
; (ELEPHANT-SERIALIZER2::SUCCEED))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (SETF (UFFI:DEREF-ARRAY ELEPHANT-SERIALIZER2::BUFFER
'(:ARRAY :UNSIGNED-CHAR)
; (+ ELEPHANT-SERIALIZER2::I
; ELEPHANT-SERIALIZER2::SIZE))
; ELEPHANT-SERIALIZER2::CODE)
; --> LET* MULTIPLE-VALUE-BIND LET
; ==>
; (SB-ALIEN-INTERNALS:%SET-DEREF #:G67 #:G69 #:G68)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; ==>
; (SB-ALIEN-INTERNALS:%SET-DEREF #:G63 #:G65 #:G64)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF8-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFUN SERIALIZE-TO-UTF16LE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFUN SERIALIZE-TO-UTF16LE
; (CHAR-CODE (SCHAR STRING ELEPHANT-SERIALIZER2::I))
;
; note: deleting unreachable code
; (* ELEPHANT-SERIALIZER2::I 2)
; ==>
; ELEPHANT-SERIALIZER2::I
;
; note: deleting unreachable code
; (ELEPHANT-SERIALIZER2::FAIL)
;
; note: deleting unreachable code
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF16-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12CC0951}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-102)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12CC0951}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-106)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-
SERIALIZER2::BSTREAM
; ELEPHANT-SERIALIZER2::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from NEEDED
; (INCF ELEPHANT-SERIALIZER2::SIZE (* ELEPHANT-
SERIALIZER2::CHARACTERS 2))
; --> LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12CC0951}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-130)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (SETF (UFFI:DEREF-ARRAY ELEPHANT-SERIALIZER2::BUFFER
'(:ARRAY :UNSIGNED-CHAR)
; (+ (* ELEPHANT-SERIALIZER2::I 2)
; ELEPHANT-SERIALIZER2::SIZE))
; (LDB (BYTE 8 8) ELEPHANT-SERIALIZER2::CODE))
; --> LET* MULTIPLE-VALUE-BIND LET
; ==>
; (SB-ALIEN-INTERNALS:%SET-DEREF #:G110 #:G112 #:G111)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (SETF (UFFI:DEREF-ARRAY ELEPHANT-SERIALIZER2::BUFFER
'(:ARRAY :UNSIGNED-CHAR)
; (+ (* ELEPHANT-SERIALIZER2::I 2)
; ELEPHANT-SERIALIZER2::SIZE 1))
; (LDB (BYTE 8 0) ELEPHANT-SERIALIZER2::CODE))
; --> LET* MULTIPLE-VALUE-BIND LET
; ==>
; (SB-ALIEN-INTERNALS:%SET-DEREF #:G114 #:G116 #:G115)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF16-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFUN SERIALIZE-TO-UTF32LE ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFUN SERIALIZE-TO-UTF32LE
; (ERROR "Invalid unicode code type")
; ==>
; "Invalid unicode code type"
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; (CHAR-CODE (SCHAR STRING ELEPHANT-SERIALIZER2::I))
;
; note: deleting unreachable code
; (+ ELEPHANT-SERIALIZER2::SIZE (* 4 ELEPHANT-
SERIALIZER2::CHARACTERS))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (MOD 2147483641), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354551)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354551)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (> ELEPHANT-SERIALIZER2::NEEDED ELEPHANT-SERIALIZER2::ALLOCATED)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (INTEGER -536870912 2684354551), not a
FIXNUM.
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 0)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 1)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE) 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870911 2684354556)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870911 2684354556)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 2)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE) 2)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870910 2684354557)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870910 2684354557)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 3)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE) 3)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870909 2684354558)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870909 2684354558)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (INCF ELEPHANT-SERIALIZER2::SIZE (* ELEPHANT-
SERIALIZER2::CHARACTERS 4))
; --> LET*
; ==>
; (+ (ELEPHANT-MEMUTIL:BUFFER-STREAM-SIZE #:G203) #:G204)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (MOD 2147483641), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354551)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354551)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF32-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12F98001}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-161)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET SETF
; --> SETQ SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL:BUFFER-
STREAM-SIZE) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12F98001}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-165)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (+ ELEPHANT-SERIALIZER2::SIZE (* 4 ELEPHANT-
SERIALIZER2::CHARACTERS))
;
; note: doing signed word to integer coercion (cost 20), for:
; the second argument of GENERIC-+
; (INCF ELEPHANT-SERIALIZER2::SIZE (* ELEPHANT-
SERIALIZER2::CHARACTERS 4))
; --> LET*
; ==>
; (+ (ELEPHANT-MEMUTIL:BUFFER-STREAM-SIZE #:G203) #:G204)
;
; note: doing signed word to integer coercion (cost 20), for:
; the second argument of GENERIC-+
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 0)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 1)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 2)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE 3)
; --> +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::SIZE)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32 ELEPHANT-
SERIALIZER2::CHARACTERS
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT-SERIALIZER2::+UTF32-
STRING+
; ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> IF PROGN
; ==>
; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
; ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20) from ELEPHANT-
MEMUTIL::NEEDED
; compiling (DEFPARAMETER NATIVE-STRING-TYPE ...)
; compiling (DEFUN COMPATIBLE-UNICODE-SUPPORT-P ...)
; compiling (DEFGENERIC DESERIALIZE-STRING ...)
; compiling (DEFMETHOD DESERIALIZE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFMETHOD DESERIALIZE-STRING :AROUND (T T)
; (DEFMETHOD ELEPHANT-SERIALIZER2::DESERIALIZE-STRING :AROUND
; ((TYPE T) ELEPHANT-SERIALIZER2::BSTREAM &OPTIONAL
; ELEPHANT-SERIALIZER2::TEMP-STRING)
; (CALL-NEXT-METHOD))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN
; --> SB-PCL::LOAD-DEFMETHOD SYMBOL-MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET
; --> SB-PCL::BIND-ARGS
; ==>
; (LET* ((SB-PCL::.ARGS-TAIL. SB-PCL::.REST-ARG.)
; (ELEPHANT-SERIALIZER2::TEMP-STRING
; (WHEN SB-PCL::.ARGS-TAIL. (POP SB-PCL::.ARGS-TAIL.)))
; (SB-PCL::.DUMMY0.
; (UNLESS (NULL SB-PCL::.ARGS-TAIL.)
; (ERROR 'SB-INT:SIMPLE-PROGRAM-ERROR :FORMAT-CONTROL
; "surplus arguments: ~S" :FORMAT-ARGUMENTS #))))
; (DECLARE (IGNORABLE SB-PCL::.ARGS-TAIL. SB-PCL::.DUMMY0.))
; (LOCALLY
; (DECLARE (DISABLE-PACKAGE-LOCKS SB-PCL::%PARAMETER-BINDING-
MODIFIED))
; (SYMBOL-MACROLET ((SB-PCL::%PARAMETER-BINDING-MODIFIED #))
; (DECLARE (ENABLE-PACKAGE-LOCKS SB-PCL::%PARAMETER-BINDING-
MODIFIED))
; (BLOCK ELEPHANT-SERIALIZER2::DESERIALIZE-STRING (CALL-NEXT-
METHOD)))))
;
; caught STYLE-WARNING:
; The variable TEMP-STRING is defined but never used.
; compiling (DEFMETHOD DESERIALIZE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFMETHOD DESERIALIZE-STRING ((EQL :UTF8) T)
; (SETF (CHAR STRING ELEPHANT-SERIALIZER2::I)
; (CODE-CHAR
; (UFFI:DEREF-ARRAY
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER
; ELEPHANT-SERIALIZER2::BSTREAM)
; '(:ARRAY :UNSIGNED-BYTE)
; (+ ELEPHANT-SERIALIZER2::POS ELEPHANT-SERIALIZER2::I))))
; --> SB-KERNEL:%CHARSET SB-KERNEL:%ASET
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
; SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (INCF
; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
SERIALIZER2::BSTREAM)
; LENGTH)
; --> LET*
; ==>
; (+ (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION #:G302) #:G303)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (SIGNED-BYTE 32), not a FIXNUM.
; The result is a (VALUES (INTEGER -2684354560 2684354558)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -2684354560 2684354558)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {134BAB81}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-313)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (UFFI:DEREF-ARRAY
; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-
SERIALIZER2::BSTREAM)
; '(:ARRAY :UNSIGNED-BYTE)
; (+ ELEPHANT-SERIALIZER2::POS ELEPHANT-SERIALIZER2::I))
; ==>
; (DEREF (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-
SERIALIZER2::BSTREAM)
; (+ ELEPHANT-SERIALIZER2::POS ELEPHANT-SERIALIZER2::I))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFMETHOD DESERIALIZE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFMETHOD DESERIALIZE-STRING ((EQL :UTF16LE) T)
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1175D659}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-402)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 0)
; --> UFFI:DEREF-ARRAY
; ==>
; (DEREF (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-
SERIALIZER2::BSTREAM)
; (+ (* ELEPHANT-SERIALIZER2::I 2) ELEPHANT-SERIALIZER2::POS
0))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 1)
; --> UFFI:DEREF-ARRAY
; ==>
; (DEREF (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-
SERIALIZER2::BSTREAM)
; (+ (* ELEPHANT-SERIALIZER2::I 2) ELEPHANT-SERIALIZER2::POS
1))
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (INCF
; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
SERIALIZER2::BSTREAM)
; (* LENGTH 2))
; --> LET* FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {1175D659}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-397)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; compiling (DEFMETHOD DESERIALIZE-STRING ...)
; file: /Users/jensteich/Lisp/elephant/src/elephant/unicode2.lisp
; in: DEFMETHOD DESERIALIZE-STRING ((EQL :UTF32LE) T)
; (SETF (CHAR STRING ELEPHANT-SERIALIZER2::I)
; (CODE-CHAR ELEPHANT-SERIALIZER2::CODE))
; --> SB-KERNEL:%CHARSET SB-KERNEL:%ASET
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
; SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 0)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 1)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; --> UFFI:DEREF-ARRAY DEREF +
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS) 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870911 2684354556)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870911 2684354556)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 2)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; --> UFFI:DEREF-ARRAY DEREF +
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS) 2)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870910 2684354557)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870910 2684354557)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 3)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (MOD 2147483645), not a FIXNUM.
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -536870912 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; --> UFFI:DEREF-ARRAY DEREF +
; ==>
; (+ (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS) 3)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870909 2684354558)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER -536870912 2684354555), not a
FIXNUM.
; The result is a (VALUES (INTEGER -536870909 2684354558)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; etc.
; (INCF
; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
SERIALIZER2::BSTREAM)
; (* LENGTH 4))
; --> LET*
; ==>
; (+ (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION #:G487) #:G488)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (INTEGER -2147483648 2147483644), not
a FIXNUM.
; The result is a (VALUES (INTEGER -2684354560 2684354555)
; &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5)
because:
; The result is a (VALUES (INTEGER -2684354560 2684354555)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE
32) &REST
; T).
; etc.
; (ELEPHANT-MEMUTIL:BUFFER-READ-INT32 ELEPHANT-SERIALIZER2::BSTREAM)
; --> BLOCK LET SETF LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF ELEPHANT-MEMUTIL::BUFFER-
STREAM-POSITION) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (FIXNUM ELEPHANT-
MEMUTIL:BUFFER-STREAM) (VALUES FIXNUM &OPTIONAL))> :WHERE-
FROM :DECLARED :KIND :GLOBAL-FUNCTION {12F41DA9}>
; --> LET LET SB-KERNEL:%INSTANCE-SET
; ==>
; (THE FIXNUM #:ONCE-ONLY-494)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 0)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (SETF ELEPHANT-SERIALIZER2::CODE
; (DPB (ELEPHANT-SERIALIZER2::NEXT-BYTE 0) (BYTE 8 24) 0))
; --> SETQ
; ==>
; (THE #<SB-KERNEL:NUMERIC-TYPE FIXNUM>
; (DPB (ELEPHANT-SERIALIZER2::NEXT-BYTE 0) (BYTE 8 24) 0))
;
; note: doing unsigned word to integer coercion (cost 20), for:
; the first argument of CHECK-FIXNUM
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 1)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 2)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (ELEPHANT-SERIALIZER2::NEXT-BYTE 3)
; --> UFFI:DEREF-ARRAY DEREF + +
; ==>
; (+ (* ELEPHANT-SERIALIZER2::I 4) ELEPHANT-SERIALIZER2::POS)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of GENERIC-+
; (INCF
; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-
SERIALIZER2::BSTREAM)
; (* LENGTH 4))
; --> LET*
; ==>
; (+ (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION #:G487) #:G488)
;
; note: doing signed word to integer coercion (cost 20), for:
; the second argument of GENERIC-+
; /Users/jensteich/Lisp/elephant/src/elephant/unicode2.fasl written
; compilation finished in 0:00:01
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {1221BDF1}> on
#<CL-SOURCE-FILE "unicode2" {11B47FD9}>.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/
migrate.lisp" (written 12 APR 2007 04:47:33 AM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFGENERIC MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFUN COPY-CINDEX-CONTENTS ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFVAR *INHIBIT-SLOT-COPY* ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFUN COPY-PERSISTENT-OBJECT ...)
; compiling (DEFUN INHIBIT-INDEXED-SLOT-COPY? ...)
; compiling (DEFUN COPY-PERSISTENT-SLOTS ...)
; compiling (DEFMACRO WITH-INHIBITED-SLOT-COPY ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD COPY-BTREE-CONTENTS ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFVAR *OID-HASH* ...)
; compiling (DEFVAR *OID-STORE* ...)
; compiling (DEFVAR *OID-SPEC* ...)
; compiling (DEFVAR *OID-BTREE* ...)
; compiling (DEFUN SET-OID-SPEC ...)
; compiling (DEFUN INITIALIZE-MIGRATE-DUPLICATE-DETECTION ...)
; compiling (DEFUN CLEAR-MIGRATE-DUPLICATE-DETECTION ...)
; compiling (DEFUN OBJECT-WAS-COPIED-P ...)
; compiling (DEFUN REGISTER-COPIED-OBJECT ...)
; compiling (DEFUN RETRIEVE-COPIED-OBJECT ...)
; /Users/jensteich/Lisp/elephant/src/elephant/migrate.fasl written
; compilation finished in 0:00:00
STYLE-WARNING:
Implicitly creating new generic function COPY-BTREE-CONTENTS.
; compiling file "/Users/jensteich/Lisp/elephant/src/elephant/data-
store-api.lisp" (written 21 APR 2007 07:22:50 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFMACRO DEFPACKAGE-IMPORT-EXPORTED ...)
; compiling (DEFPACKAGE-IMPORT-EXPORTED :ELEPHANT-DATA-STORE ...)
; /Users/jensteich/Lisp/elephant/src/elephant/data-store-api.fasl
written
; compilation finished in 0:00:00
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFMETHOD ELEPHANT:MAP-BTREE (T ELEPHANT:BTREE)
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::KEY ELEPHANT::VALUE)
; (COND
; (ELEPHANT::VALUE-SET-P
; (ELEPHANT:CURSOR-SET ELEPHANT::CURS ELEPHANT::VALUE))
; ((AND (NOT ELEPHANT::FROM-END) (NULL ELEPHANT::START))
; (ELEPHANT:CURSOR-FIRST ELEPHANT::CURS))
; ((AND ELEPHANT::FROM-END (NULL ELEPHANT::END))
; (ELEPHANT:CURSOR-LAST ELEPHANT::CURS))
; (T
; (IF ELEPHANT::FROM-END
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS ELEPHANT::END)
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS
ELEPHANT::START))))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS? (FUNCALL ELEPHANT::FN ELEPHANT::KEY
ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
; --> MULTIPLE-VALUE-CALL
; ==>
; #'(LAMBDA
; (&OPTIONAL (ELEPHANT::EXISTS?) (ELEPHANT::KEY)
(ELEPHANT::VALUE)
; &REST #:G232)
; (DECLARE (IGNORE #:G232))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS?
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV
ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
;
; caught WARNING:
; undefined variable: ELEPHANT::K
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFUN ELEPHANT:MAP-CLASS
; (FLET ((ELEPHANT::MAP-FN (ELEPHANT::K ELEPHANT::V)
; (DECLARE (IGNORE ELEPHANT::K))
; (FUNCALL ELEPHANT::FN ELEPHANT::V)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::MAP-FN))
; (ELEPHANT:MAP-BTREE #'ELEPHANT::MAP-FN ELEPHANT::CLASS-
IDX :COLLECT
; ELEPHANT::COLLECT))
;
; caught WARNING:
; undefined variable: ELEPHANT::MAP-FN
; file: /Users/jensteich/Lisp/elephant/src/elephant/controller.lisp
; in: DEFUN ELEPHANT:ADD-TO-ROOT
; (DEFUN ELEPHANT:ADD-TO-ROOT
; (ELEPHANT::KEY ELEPHANT::VALUE
; &KEY (ELEPHANT::SC ELEPHANT:*STORE-CONTROLLER*))
; "Add an arbitrary persistent thing to the root, so you can
; retrieve it in a later session. Anything referenced by an
; object added to the root is considered reachable and thus live"
; (DECLARE (TYPE ELEPHANT:STORE-CONTROLLER ELEPHANT:STORE-
CONTROLLER))
; (ASSERT (NOT (EQ ELEPHANT::KEY ELEPHANT::*ELEPHANT-PROPERTIES-
LABEL*)))
; (SETF (ELEPHANT:GET-VALUE ELEPHANT::KEY
; (ELEPHANT:CONTROLLER-ROOT ELEPHANT::SC))
; ELEPHANT::VALUE))
; --> PROGN EVAL-WHEN
; ==>
; (SB-IMPL::%DEFUN 'ELEPHANT:ADD-TO-ROOT
; (SB-INT:NAMED-LAMBDA ELEPHANT:ADD-TO-ROOT
; (ELEPHANT::KEY
ELEPHANT::VALUE &KEY
; (ELEPHANT::SC
; ELEPHANT:*STORE-
CONTROLLER*))
; (DECLARE
; (TYPE ELEPHANT:STORE-
CONTROLLER
; ELEPHANT:STORE-CONTROLLER))
; (BLOCK ELEPHANT:ADD-TO-ROOT
; (ASSERT (NOT #))
; (SETF (ELEPHANT:GET-VALUE
; ELEPHANT::KEY #)
; ELEPHANT::VALUE)))
; "Add an arbitrary persistent thing to the root,
so you can
; retrieve it in a later session. Anything referenced by an
; object added to the root is considered reachable and thus live"
; 'NIL (SB-C:SOURCE-LOCATION))
;
; caught WARNING:
; undefined variable: ELEPHANT:STORE-CONTROLLER
; file: /Users/jensteich/Lisp/elephant/src/elephant/collections.lisp
; in: DEFMETHOD ELEPHANT:MAP-BTREE (T ELEPHANT:BTREE)
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::KEY ELEPHANT::VALUE)
; (COND
; (ELEPHANT::VALUE-SET-P
; (ELEPHANT:CURSOR-SET ELEPHANT::CURS ELEPHANT::VALUE))
; ((AND (NOT ELEPHANT::FROM-END) (NULL ELEPHANT::START))
; (ELEPHANT:CURSOR-FIRST ELEPHANT::CURS))
; ((AND ELEPHANT::FROM-END (NULL ELEPHANT::END))
; (ELEPHANT:CURSOR-LAST ELEPHANT::CURS))
; (T
; (IF ELEPHANT::FROM-END
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS ELEPHANT::END)
; (ELEPHANT:CURSOR-SET-RANGE ELEPHANT::CURS
ELEPHANT::START))))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS? (FUNCALL ELEPHANT::FN ELEPHANT::KEY
ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
; --> MULTIPLE-VALUE-CALL
; ==>
; #'(LAMBDA
; (&OPTIONAL (ELEPHANT::EXISTS?) (ELEPHANT::KEY)
(ELEPHANT::VALUE)
; &REST #:G232)
; (DECLARE (IGNORE #:G232))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF ELEPHANT::EXISTS?
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)
; (RETURN-FROM ELEPHANT:MAP-BTREE NIL))
; (LOOP
; (MULTIPLE-VALUE-BIND
; (ELEPHANT::EXISTS? ELEPHANT::K ELEPHANT::V)
; (IF ELEPHANT::FROM-END (ELEPHANT:CURSOR-PREV
ELEPHANT::CURS)
; (ELEPHANT:CURSOR-NEXT ELEPHANT::CURS))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::EXISTS? ELEPHANT::K
ELEPHANT::V))
; (IF (AND ELEPHANT::EXISTS? #)
; (FUNCALL ELEPHANT::FN ELEPHANT::K ELEPHANT::V) (RETURN
NIL)))))
;
; caught WARNING:
; undefined variable: ELEPHANT::V
; file: /Users/jensteich/Lisp/elephant/src/elephant/classindex.lisp
; in: DEFUN ELEPHANT:MAP-INVERTED-INDEX
; (FLET ((ELEPHANT::WRAPPER (ELEPHANT::KEY ELEPHANT::VALUE
ELEPHANT::PKEY)
; (DECLARE (IGNORE ELEPHANT::PKEY))
; (FUNCALL ELEPHANT::FN ELEPHANT::KEY ELEPHANT::VALUE)))
; (DECLARE (DYNAMIC-EXTENT ELEPHANT::WRAPPER))
; (IF ELEPHANT::VALUE-P
; (ELEPHANT:MAP-INDEX #'ELEPHANT::WRAPPER ELEPHANT::INDEX :VALUE
; ELEPHANT::VALUE :COLLECT
ELEPHANT::COLLECT)
; (ELEPHANT:MAP-INDEX #'ELEPHANT::WRAPPER ELEPHANT::INDEX :START
; ELEPHANT::START :END ELEPHANT::END :FROM-
END
; ELEPHANT::FROM-END :COLLECT
ELEPHANT::COLLECT)))
;
; caught WARNING:
; undefined variable: ELEPHANT::WRAPPER
;
; caught WARNING:
; These variables are undefined:
; ELEPHANT::K ELEPHANT::MAP-FN ELEPHANT:STORE-CONTROLLER
ELEPHANT::V ELEPHANT::WRAPPER
;
; compilation unit finished
; caught 6 WARNING conditions
; caught 7 STYLE-WARNING conditions
; printed 505 notes
NIL
CL-USER> (use-package :elephant)
T
CL-USER> (in-package :elephant-user)
#<PACKAGE "ELEPHANT-USER">
ELE-USER>
More information about the elephant-devel
mailing list