[elephant-devel] 13 Warnings when loading elephant (SBCL, Mac OS X)
Ian Eslick
eslick at media.mit.edu
Sat May 3 14:33:06 UTC 2008
You shouldn't need to worry. Does it pass all the regression tests?
On Apr 7, 2008, at 1:50 AM, Jens Teich wrote:
> 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>_______________________________________________
> elephant-devel site list
> elephant-devel at common-lisp.net
> http://common-lisp.net/mailman/listinfo/elephant-devel
More information about the elephant-devel
mailing list