[elephant-devel] Re: SBCL exits abnormally when compiling sleepycat.lisp

Howard Yeh hayeah at gmail.com
Thu Jun 22 18:35:02 UTC 2006


I am using Kubuntu Dapper 6.06.


Where my files are at:

----------------------------------------------------------------------
/usr/local/BerkeleyDB.4.3/include:
total 0
lrwxrwxrwx 1 root root 17 Jun 21 20:58 db.h -> /usr/include/db.h

/usr/local/BerkeleyDB.4.3/lib:
total 0
lrwxrwxrwx 1 root root 17 Jun 21 21:10 libdb-4.3.so -> /usr/lib/libdb.so
lrwxrwxrwx 1 root root 17 Jun 21 20:58 libdb.so -> /usr/lib/libdb.so


lrwxrwxrwx 1 root root 12 Jun 18 02:14 /usr/lib/libdb.so -> libdb-4.3.so
----------------------------------------------------------------------


Warnings I get when make:

----------------------------------------------------------------------
~/wisp/src/libs/elephant > make bdb
gcc -shared -Wall -L/usr/local/BerkeleyDB.4.3//lib/
-I/usr/local/BerkeleyDB.4.3//include/ -fPIC -O3 -o
src/db-bdb/libsleepycat.so src/db-bdb/libsleepycat.c -ldb -lm
src/db-bdb/libsleepycat.c: In function 'lisp_compare':
src/db-bdb/libsleepycat.c:291: warning: implicit declaration of
function 'wcs_cmp'
src/db-bdb/libsleepycat.c: In function 'db_multiple_key_next':
src/db-bdb/libsleepycat.c:721: warning: pointer targets in assignment
differ in signedness
src/db-bdb/libsleepycat.c:721: warning: pointer targets in assignment
differ in signedness
----------------------------------------------------------------------

(require :elephant)
(require :elephant-tests)

----------------------------------------------------------------------
Compile Notes at the end of this post under the headings
'require.elephant' and 'require.elephant-tests'

----------------------------------------------------------------------

~/wisp/src/libs/elephant > ls tests/testdb
CVS  README

(in-package "ELEPHANT-TESTS")
(setf *default-spec* *testbdb-spec*)
(do-backend-tests)

----------------------------------------------------------------------
(do-backend-tests)
; loading system definition from /home/howard/lisp/libs/asd/ele-bdb.asd
; into #<PACKAGE "ASDF0">
; registering #<SYSTEM ELE-BDB {B5FDD91}> as ELE-BDB
; compiling file
"/home/howard/lisp/libs/elephant/src/db-bdb/package.lisp" (written 18
FEB 2006 08:53:00 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE SLEEPYCAT ...)
----------------------------------------------------------------------

Then SBCL exits abnormally.


Try again with the compiled .fasl

----------------------------------------------------------------------
CL-USER> (require :elephant)
; loading system definition from /home/howard/lisp/libs/asd/uffi.asd into
; #<PACKAGE "ASDF1">
; registering #<SYSTEM UFFI {A8C92D9}> as UFFI
; loading system definition from /home/howard/lisp/libs/asd/cl-base64.asd
; into #<PACKAGE "ASDF0">
; registering #<SYSTEM CL-BASE64 {B803D71}> as CL-BASE64
; registering #<SYSTEM CL-BASE64-TESTS {BAF0AF1}> as CL-BASE64-TESTS
; loading system definition from /home/howard/lisp/libs/asd/kmrcl.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM KMRCL {AA5BAC1}> as KMRCL
NIL
CL-USER> (require :elephant-tests)
; loading system definition from /home/howard/lisp/libs/asd/rt.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM :RT {BD89271}> as RT
NIL
CL-USER> (in-package "ELEPHANT-TESTS")
#<PACKAGE "ELEPHANT-TESTS">
ELE-TESTS> (setf *default-spec* *testbdb-spec*)
(:BDB "/home/howard/lisp/libs/elephant/tests/testdb/")
ELE-TESTS> (do-backend-tests)

; loading system definition from /home/howard/lisp/libs/asd/ele-bdb.asd
; into #<PACKAGE "ASDF0">
; registering #<SYSTEM ELE-BDB {AAAE8F1}> as ELE-BDB

; compiling file
"/home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp" (written
10 MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE "SLEEPYCAT")
; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...))
; compiling (UNLESS (LOAD-FOREIGN-LIBRARY
ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...)
; compiling (UNLESS (LOAD-FOREIGN-LIBRARY
ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...)
; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...)
; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...)
; compiling (DEFUN DB-STRERROR ...)
; compiling (DEFINE-CONDITION DB-ERROR ...)
; compiling (DEFCONSTANT DB-BTREE ...)
; compiling (DEFCONSTANT DB-HASH ...)
; compiling (DEFCONSTANT DB-RECNO ...)
; compiling (DEFCONSTANT DB-QUEUE ...)
; compiling (DEFCONSTANT DB-UNKNOWN ...)
; compiling (DEFCONSTANT DB_AUTO_COMMIT ...)
; compiling (DEFCONSTANT DB_JOINENV ...)
; compiling (DEFCONSTANT DB_INIT_CDB ...)
; compiling (DEFCONSTANT DB_INIT_LOCK ...)
; compiling (DEFCONSTANT DB_INIT_LOG ...)
; compiling (DEFCONSTANT DB_INIT_MPOOL ...)
; compiling (DEFCONSTANT DB_INIT_REP ...)
; compiling (DEFCONSTANT DB_INIT_TXN ...)
; compiling (DEFCONSTANT DB_RECOVER ...)
; compiling (DEFCONSTANT DB_RECOVER_FATAL ...)
; compiling (DEFCONSTANT DB_LOCKDOWN ...)
; compiling (DEFCONSTANT DB_PRIVATE ...)
; compiling (DEFCONSTANT DB_SYSTEM_MEM ...)
; compiling (DEFCONSTANT DB_THREAD ...)
; compiling (DEFCONSTANT DB_FORCE ...)
; compiling (DEFCONSTANT DB_DEGREE_2 ...)
; compiling (DEFCONSTANT DB_DIRTY_READ ...)
; compiling (DEFCONSTANT DB_CREATE ...)
; compiling (DEFCONSTANT DB_EXCL ...)
; compiling (DEFCONSTANT DB_NOMMAP ...)
; compiling (DEFCONSTANT DB_RDONLY ...)
; compiling (DEFCONSTANT DB_TRUNCATE ...)
; compiling (DEFCONSTANT DB_TXN_NOSYNC ...)
; compiling (DEFCONSTANT DB_TXN_NOWAIT ...)
; compiling (DEFCONSTANT DB_TXN_SYNC ...)
; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...)
; compiling (DEFCONSTANT DB_DUP ...)
; compiling (DEFCONSTANT DB_DUPSORT ...)
; compiling (DEFCONSTANT DB_CURRENT ...)
; compiling (DEFCONSTANT DB_FIRST ...)
; compiling (DEFCONSTANT DB_GET_BOTH ...)
; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...)
; compiling (DEFCONSTANT DB_LAST ...)
; compiling (DEFCONSTANT DB_NEXT ...)
; compiling (DEFCONSTANT DB_NEXT_DUP ...)
; compiling (DEFCONSTANT DB_NEXT_NODUP ...)
; compiling (DEFCONSTANT DB_PREV ...)
; compiling (DEFCONSTANT DB_PREV_NODUP ...)
; compiling (DEFCONSTANT DB_SET ...)
; compiling (DEFCONSTANT DB_SET_RANGE ...)
; compiling (DEFCONSTANT DB_AFTER ...)
; compiling (DEFCONSTANT DB_BEFORE ...)
; compiling (DEFCONSTANT DB_KEYFIRST ...)
; compiling (DEFCONSTANT DB_KEYLAST ...)
; compiling (DEFCONSTANT DB_NODUPDATA ...)
; compiling (DEFCONSTANT DB_NOOVERWRITE ...)
; compiling (DEFCONSTANT DB_NOSYNC ...)
; compiling (DEFCONSTANT DB_POSITION ...)
; compiling (DEFCONSTANT DB_SEQ_DEC ...)
; compiling (DEFCONSTANT DB_SEQ_INC ...)
; compiling (DEFCONSTANT DB_SEQ_WRAP ...)
; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...)
; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...)
; compiling (DEFCONSTANT DB_KEYEMPTY ...)
; compiling (DEFCONSTANT DB_KEYEXIST ...)
; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...)
; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...)
; compiling (DEFCONSTANT DB_NOTFOUND ...)
; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...)
; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...)
; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...)
; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...)
; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...)
; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...)
; compiling (DEFCONSTANT DB_LOCK_OLDEST ...)
; compiling (DEFCONSTANT DB_LOCK_RANDOM ...)
; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...)
; compiling (DEF-ENUM DB-LOCKOP ...)
; compiling (DEF-ENUM DB-LOCKMODE ...)
; compiling (DEF-STRUCT DB-LOCK ...)
; compiling (DEF-STRUCT DB-LOCKREQ ...)
; compiling (DEFCONSTANT +2^32+ ...)
; compiling (DEFCONSTANT +2^64+ ...)
; compiling (DEFCONSTANT +2^32-1+ ...)
; compiling (DEFMACRO MAKE-64-BIT-INTEGER ...)
; compiling (DEFMACRO HIGH32 ...)
; compiling (DEFMACRO LOW32 ...)
; compiling (DEFMACRO SPLIT-64-BIT-INTEGER ...)
; compiling (DEFVAR *ERRNO-BUFFER* ...)

; file: /home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp
; in: DEFVAR *ERRNO-BUFFER*
;     (UFFI:ALLOCATE-FOREIGN-OBJECT :INT 1)
; --> MAKE-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-ALIEN::%MAKE-ALIEN (* 32 1))
;                                  '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (*
;
      (SIGNED
;
       32))>)
;
; note: unable to
;   optimize
; because:
;   could not optimize away %SAP-ALIEN: forced to do runtime
; allocation of alien-value structure
----------------------------------------------------------------------

SBCL exits. There was once I somehow managed to compile sleepycat
without SBCL dying. But that time SBCL died when compiling
bdb-controller.lisp.

Sorry I can't give any more intelligent description.

-Howard



****************************************
Compiled Notes
****************************************

(require :elephant)
; loading system definition from /home/howard/lisp/libs/asd/uffi.asd into
; #<PACKAGE "ASDF1">
; registering #<SYSTEM UFFI {A8C2D51}> as UFFI
; compiling file
"/home/howard/lisp/libs/elephant/src/memutil/memutil.lisp" (written 26
APR 2006 06:27:51 PM):
; compiling (DEFPACKAGE ELEPHANT-MEMUTIL ...)
; compiling (IN-PACKAGE "ELEPHANT-MEMUTIL")
; compiling (DEFPARAMETER *C-LIBRARY-EXTENSION* ...)
; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...)
; 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 (DECLAIM (INLINE READ-INT ...))
; compiling (DEFVAR +NULL-VOID+ ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFVAR +NULL-VOID+
;     (UFFI:MAKE-NULL-POINTER :VOID)
; --> SAP-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-SYS:INT-SAP 0)
;                                  '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (*
;
      T)>)
;
; note: unable to
;   optimize
; because:
;   could not optimize away %SAP-ALIEN: forced to do runtime
; allocation of alien-value structure

; compiling (DEFVAR +NULL-CHAR+ ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFVAR +NULL-CHAR+
;     (UFFI:MAKE-NULL-POINTER :CHAR)
; --> SAP-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-SYS:INT-SAP 0)
;                                  '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (*
;
      (SIGNED
;
       8))>)
;
; note: unable to
;   optimize
; because:
;   could not optimize away %SAP-ALIEN: forced to do runtime
; allocation of alien-value structure

; compiling (DEFVAR *BUFFER-STREAMS* ...)
; compiling (DEFSTRUCT BUFFER-STREAM ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFSTRUCT BUFFER-STREAM
;     (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR 10)
; --> MAKE-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-ALIEN::%MAKE-ALIEN (* 8 10))
;                                  '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (*
;
      (SIGNED
;
       8))>)
;
; note: unable to
;   optimize
; because:
;   could not optimize away %SAP-ALIEN: forced to do runtime
; allocation of alien-value structure

; compiling (DEFUN GRAB-BUFFER-STREAM ...)

; file: /home/howard/lisp/libs/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-INT ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-INT
;     (DEFUN ELEPHANT-MEMUTIL::READ-INT
;          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;     "Read a 32-bit signed integer from a foreign char buffer."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF)
;              (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;     (THE (SIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* INTEGER)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-INT
;                          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE (ALIEN (* CHAR))
ELEPHANT-MEMUTIL::BUF)
;                                   (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;                          (BLOCK ELEPHANT-MEMUTIL::READ-INT
;                            (THE (SIGNED-BYTE 32) (DEREF (CAST # #)))))
;
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; compiling (DEFUN READ-UINT ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN READ-UINT
;     (DEFUN ELEPHANT-MEMUTIL::READ-UINT
;          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;     "Read a 32-bit unsigned integer from a foreign char buffer."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF)
;              (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;     (THE (UNSIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-UINT
;                          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE (ALIEN (* CHAR))
ELEPHANT-MEMUTIL::BUF)
;                                   (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;                          (BLOCK ELEPHANT-MEMUTIL::READ-UINT
;                            (THE (UNSIGNED-BYTE 32) (DEREF (CAST # #)))))
;
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; compiling (DEFUN READ-FLOAT ...)

; file: /home/howard/lisp/libs/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 (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF)
;              (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;     (THE SINGLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* SINGLE-FLOAT)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-FLOAT
;                          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE (ALIEN (* CHAR))
ELEPHANT-MEMUTIL::BUF)
;                                   (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;                          (BLOCK ELEPHANT-MEMUTIL::READ-FLOAT
;                            (THE SINGLE-FLOAT (DEREF (CAST # #)))))
;
; note: doing float to pointer coercion (cost 13) to "<return value>"

; compiling (DEFUN READ-DOUBLE ...)

; file: /home/howard/lisp/libs/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 (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF)
;              (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;     (THE DOUBLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* DOUBLE-FLOAT)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-DOUBLE
;                          (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE (ALIEN (* CHAR))
ELEPHANT-MEMUTIL::BUF)
;                                   (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET))
;                          (BLOCK ELEPHANT-MEMUTIL::READ-DOUBLE
;                            (THE DOUBLE-FLOAT (DEREF (CAST # #)))))
;
; note: doing float to pointer coercion (cost 13) to "<return value>"

; compiling (DEFUN WRITE-INT ...)
; compiling (DEFUN WRITE-UINT ...)
; compiling (DEFUN WRITE-FLOAT ...)
; compiling (DEFUN WRITE-DOUBLE ...)
; compiling (DEFUN OFFSET-CHAR-POINTER ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN OFFSET-CHAR-POINTER
;     (SAP-ALIEN
;    (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-MEMUTIL::OFFSET)
;    (* CHAR))
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN
;    (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-MEMUTIL::OFFSET)
;    '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (* (SIGNED 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: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN RESIZE-BUFFER-STREAM
;     (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR ELEPHANT-MEMUTIL::NEWLEN)
; --> MAKE-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN
;    (SB-ALIEN::%MAKE-ALIEN (* 8 ELEPHANT-MEMUTIL::NEWLEN))
;    '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (* (SIGNED 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 (DEFUN RESIZE-BUFFER-STREAM-NO-COPY ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN RESIZE-BUFFER-STREAM-NO-COPY
;     (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR ELEPHANT-MEMUTIL::NEWLEN)
; --> MAKE-ALIEN
; ==>
;   (SB-ALIEN-INTERNALS:%SAP-ALIEN
;    (SB-ALIEN::%MAKE-ALIEN (* 8 ELEPHANT-MEMUTIL::NEWLEN))
;    '#<SB-ALIEN-INTERNALS:ALIEN-POINTER-TYPE (* (SIGNED 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 (DEFUN RESET-BUFFER-STREAM ...)
; compiling (DEFUN BUFFER-WRITE-BYTE ...)
; compiling (DEFUN BUFFER-WRITE-INT ...)
; compiling (DEFUN BUFFER-WRITE-UINT ...)
; compiling (DEFUN BUFFER-WRITE-FLOAT ...)
; compiling (DEFUN BUFFER-WRITE-DOUBLE ...)
; compiling (DEFUN BUFFER-WRITE-STRING ...)
; compiling (DEFUN BUFFER-READ-BYTE ...)
; compiling (DEFUN BUFFER-READ-BYTE-VECTOR ...)
; compiling (DEFUN BUFFER-WRITE-BYTE-VECTOR ...)

; file: /home/howard/lisp/libs/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)
; --> LET*
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, 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.

; compiling (DEFUN BUFFER-READ-FIXNUM ...)
; compiling (DEFUN BUFFER-READ-INT ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-INT
;     (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-INT (ELEPHANT-MEMUTIL::BS)
;     "Read a 32-bit signed integer."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS))
;     (LET ((POSITION
;            (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)))
;       (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)
;               (+ POSITION 4))
;       (THE (SIGNED-BYTE 32)
;            (ELEPHANT-MEMUTIL::READ-INT
;             (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
;             POSITION))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-INT
;                          (ELEPHANT-MEMUTIL::BS)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM
;                                         ELEPHANT-MEMUTIL::BS))
;                          (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-INT
;                            (LET ((POSITION #))
;                              (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION
;                                     ELEPHANT-MEMUTIL::BS)
;                                      (+ POSITION 4))
;                              (THE (SIGNED-BYTE 32)
;                                   (ELEPHANT-MEMUTIL::READ-INT # POSITION)))))
;
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; compiling (DEFUN BUFFER-READ-UINT ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-UINT
;     (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-UINT (ELEPHANT-MEMUTIL::BS)
;     "Read a 32-bit unsigned integer."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS))
;     (LET ((POSITION
;            (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)))
;       (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)
;               (+ POSITION 4))
;       (THE (UNSIGNED-BYTE 32)
;            (ELEPHANT-MEMUTIL::READ-UINT
;             (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
;             POSITION))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-UINT
;                          (ELEPHANT-MEMUTIL::BS)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM
;                                         ELEPHANT-MEMUTIL::BS))
;                          (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-UINT
;                            (LET ((POSITION #))
;                              (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION
;                                     ELEPHANT-MEMUTIL::BS)
;                                      (+ POSITION 4))
;                              (THE (UNSIGNED-BYTE 32)
;                                   (ELEPHANT-MEMUTIL::READ-UINT # POSITION)))))
;
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; compiling (DEFUN BUFFER-READ-FLOAT ...)

; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-FLOAT
;     (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT (ELEPHANT-MEMUTIL::BS)
;     "Read a single-float."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS))
;     (LET ((POSITION
;            (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)))
;       (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)
;               (+ POSITION 4))
;       (ELEPHANT-MEMUTIL::READ-FLOAT
;        (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
;        POSITION)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT
;                          (ELEPHANT-MEMUTIL::BS)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM
;                                         ELEPHANT-MEMUTIL::BS))
;                          (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT
;                            (LET ((POSITION #))
;                              (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION
;                                     ELEPHANT-MEMUTIL::BS)
;                                      (+ POSITION 4))
;                              (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: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp
; in: DEFUN BUFFER-READ-DOUBLE
;     (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE (ELEPHANT-MEMUTIL::BS)
;     "Read a double-float."
;     (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;              (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS))
;     (LET ((POSITION
;            (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)))
;       (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS)
;               (+ POSITION 8))
;       (ELEPHANT-MEMUTIL::READ-DOUBLE
;        (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
;        POSITION)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
;   #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE
;                          (ELEPHANT-MEMUTIL::BS)
;                          (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0))
;                                   (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM
;                                         ELEPHANT-MEMUTIL::BS))
;                          (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE
;                            (LET ((POSITION #))
;                              (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION
;                                     ELEPHANT-MEMUTIL::BS)
;                                      (+ POSITION 8))
;                              (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 ...)
; compiling (DEFUN BUFFER-READ-UCS4-STRING ...)

; /home/howard/lisp/libs/elephant/src/memutil/memutil.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/package.lisp" (written
26 APR 2006 10:53:44 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE ELEPHANT ...)
; compiling (IN-PACKAGE "ELE")

; /home/howard/lisp/libs/elephant/src/elephant/package.fasl written
; compilation finished in 0:00:00
; compiling file "/home/howard/lisp/libs/elephant/config.lisp"
(written 10 MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE :ELEPHANT)
; compiling (DEFPARAMETER *CLSQL-FOREIGN-LIB-PATH* ...)
; compiling (DEFPARAMETER *SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...)
; compiling (DEFPARAMETER *SLEEPYCAT-PTHREADS-PATH* ...)

; /home/howard/lisp/libs/elephant/src/elephant/../../config.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/variables.lisp" (written
26 APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DECLAIM (TYPE FIXNUM ...) ...)
; compiling (DEFVAR *CACHESIZE* ...)
; compiling (DEFVAR *ELEPHANT-CODE-VERSION* ...)
; compiling (DEFVAR *ELEPHANT-UNMARKED-CODE-VERSION* ...)
; compiling (DEFVAR *ELEPHANT-PROPERTIES-LABEL* ...)
; compiling (DEFPARAMETER *STORE-CONTROLLER* ...)
; compiling (DEFVAR *AUTO-COMMIT* ...)
; compiling (DEFVAR *TRANSACTION-STACK* ...)
; compiling (DEFVAR *CURRENT-TRANSACTION* ...)
; compiling (DEFVAR *LISP-OBJ-ID* ...)
; compiling (DEFVAR *CIRCULARITY-HASH* ...)
; compiling (DEFVAR *RESOURCED-BYTE-SPEC* ...)
; compiling (DEFUN REMOVE-INDEXED-ELEMENT-AND-ADJUST ...)

; /home/howard/lisp/libs/elephant/src/elephant/variables.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/transactions.lisp"
(written 26 APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFGENERIC EXECUTE-TRANSACTION ...)
; compiling (DEFMACRO WITH-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-START-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-COMMIT-TRANSACTION ...)
; compiling (DEFGENERIC CONTROLLER-ABORT-TRANSACTION ...)
; compiling (DEFUN START-ELE-TRANSACTION ...)
; compiling (DEFUN COMMIT-TRANSACTION ...)
; compiling (DEFUN ABORT-TRANSACTION ...)

; /home/howard/lisp/libs/elephant/src/elephant/transactions.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/metaclasses.lisp"
(written 26 APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFCLASS PERSISTENT ...)
; 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 (DEFMETHOD TRANSIENT ...)
; compiling (DEFMETHOD TRANSIENT ...)
; compiling (DEFCLASS INDEXING-RECORD ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; 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 ...)
; 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 PERSISTENT-P ...)
; compiling (DEFMETHOD PERSISTENT-P ...)
; compiling (DEFMETHOD 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 ...)

; /home/howard/lisp/libs/elephant/src/elephant/metaclasses.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/classes.lisp" (written
26 APR 2006 06:43:53 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFVAR *DEBUG-SI* ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS PERSISTENT-OBJECT ...)
; compiling (DEFMETHOD ENSURE-CLASS-USING-CLASS ...)
; compiling (DEFMETHOD ENSURE-CLASS-USING-CLASS ...)
; compiling (DEFUN REMOVE-INDEX-KEYWORD ...)
; compiling (DEFMETHOD SHARED-INITIALIZE ...)
; compiling (DEFMETHOD FINALIZE-INHERITANCE ...)
; compiling (DEFMETHOD REINITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD SHARED-INITIALIZE ...)
; compiling (DEFUN INITIALIZE-PERSISTENT-SLOTS ...)
; compiling (DEFMETHOD UPDATE-INSTANCE-FOR-REDEFINED-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 MAKE-PERSISTENT-READER ...)
; compiling (DEFUN MAKE-PERSISTENT-WRITER ...)
; compiling (DEFUN MAKE-PERSISTENT-SLOT-BOUNDP ...)
; compiling (DEFMETHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS ...)

; /home/howard/lisp/libs/elephant/src/elephant/classes.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/serializer.lisp"
(written 10 MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; 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 +FILL-POINTER-P+ ...)
; compiling (DEFCONSTANT +ADJUSTABLE-P+ ...)
; compiling (DEFUN CLEAR-CIRCULARITY-HASH ...)
; compiling (DEFUN SERIALIZE ...)

; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp
; in: DEFUN SERIALIZE
;     (CEILING (/ (INTEGER-LENGTH ELEPHANT::NUM) 32))
; ==>
;   (CEILING (/ (INTEGER-LENGTH ELEPHANT::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.

;     (LENGTH ELEPHANT::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.

;     (ARRAY-RANK ELEPHANT::FROB)
;
; note: unable to optimize because: The array rank is not known at
compile time: *

;     (ARRAY-TOTAL-SIZE ELEPHANT::FROB)
;
; note: unable to optimize because: can't tell the rank at compile time

;     (ROW-MAJOR-AREF ELEPHANT::FROB ELEPHANT::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::FROB ELEPHANT::I)
;
; note: unable to optimize because: The axis is not constant.

;     (ABS ELEPHANT::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::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::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.

;     (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE
ELEPHANT::FROB))
;           (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB)
;               ELEPHANT::+FILL-POINTER-P+
;               0)
;           (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB) ELEPHANT::+ADJUSTABLE-P+ 0))
; --> LOGIOR
; ==>
;   (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE ELEPHANT::FROB))
;           (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB)
;               ELEPHANT::+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::FROB))
;            (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB)
;                ELEPHANT::+FILL-POINTER-P+
;                0))
;    (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB) ELEPHANT::+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.

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::FROB ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+FIXNUM+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+NIL+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT-MEMUTIL:BYTE-LENGTH
ELEPHANT::S)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
;    (ETYPECASE ELEPHANT::S
;      (BASE-STRING ELEPHANT::+UCS1-SYMBOL+)
;      (STRING ELEPHANT::+UCS4-SYMBOL+))
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT ELEPHANT::FROB ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+SINGLE-FLOAT+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE ELEPHANT::FROB ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+DOUBLE-FLOAT+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT (CHAR-CODE ELEPHANT::FROB)
ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+CHAR+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+RATIONAL+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+CONS+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (FILL-POINTER ELEPHANT::FROB)
ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT
;    (ARRAY-DIMENSION ELEPHANT::FROB ELEPHANT::I)
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::RANK ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
;    (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE
ELEPHANT::FROB))
;            (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB)
;                ELEPHANT::+FILL-POINTER-P+
;                0)
;            (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB)
ELEPHANT::+ADJUSTABLE-P+ 0))
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+ARRAY+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+OBJECT+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT::%SERIALIZE (HASH-TABLE-REHASH-THRESHOLD ELEPHANT::FROB))
;
; note: doing float to pointer coercion (cost 13) to FROB

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+HASH-TABLE+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT
;    (SB-BIGNUM:%BIGNUM-REF ELEPHANT::NUM ELEPHANT::I)
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::NEEDED ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+NEGATIVE-BIGNUM+
ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+POSITIVE-BIGNUM+
ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT-MEMUTIL:BYTE-LENGTH
ELEPHANT::S)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
;    (ETYPECASE ELEPHANT::S
;      (BASE-STRING ELEPHANT::+UCS1-PATHNAME+)
;      (STRING ELEPHANT::+UCS4-PATHNAME+))
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT::OID ELEPHANT::FROB)
;                                      ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+PERSISTENT+ ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT
;    (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT::FROB)
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

;     (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
;    (ETYPECASE ELEPHANT::FROB
;      (BASE-STRING ELEPHANT::+UCS1-STRING+)
;      (STRING ELEPHANT::+UCS4-STRING+))
;    ELEPHANT::BS)
; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN
; --> COND IF PROGN
; ==>
;   (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS
;                                          ELEPHANT-MEMUTIL::NEEDED)
;
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN SLOTS-AND-VALUES ...)
; compiling (DEFUN DESERIALIZE ...)

; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp
; in: DEFUN DESERIALIZE
;     (OR
;    (ELEPHANT-MEMUTIL:BUFFER-READ-UCS1-STRING ELEPHANT::BS
;
(ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM
;                                               ELEPHANT::BS))
;    "")
; --> LET IF OR
; ==>
;   ""
;
; note: deleting unreachable code

;     (OR
;    (ELEPHANT-MEMUTIL:BUFFER-READ-UCS4-STRING ELEPHANT::BS
;
(ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM
;                                               ELEPHANT::BS))
;    "")
; --> LET IF OR
; ==>
;   ""
;
; note: deleting unreachable code

;     (MAKE-ARRAY
;    (LOOP ELEPHANT::FOR
;          ELEPHANT::I
;          FIXNUM
;          ELEPHANT::FROM
;          0
;          ELEPHANT::BELOW
;          (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS)
;          ELEPHANT::COLLECT
;          (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS))
;    :ELEMENT-TYPE
;    (ELEPHANT::ARRAY-TYPE-FROM-BYTE (LOGAND 63 ELEPHANT::FLAGS))
;    :FILL-POINTER
;    (/= 0 (LOGAND ELEPHANT::+FILL-POINTER-P+ ELEPHANT::FLAGS))
;    :ADJUSTABLE
;    (/= 0 (LOGAND ELEPHANT::+ADJUSTABLE-P+ ELEPHANT::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::A)
;
; note: unable to optimize because: can't tell the rank at compile time

;     (SETF (ROW-MAJOR-AREF ELEPHANT::A ELEPHANT::I)
;           (ELEPHANT::%DESERIALIZE ELEPHANT::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-FIXNUM ELEPHANT::BS)
; --> BLOCK LET
; ==>
;   (THE FIXNUM
;        (ELEPHANT-MEMUTIL::READ-INT
;         (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS)
;         POSITION))
;
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ELEPHANT::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) to "<return value>"

;     (ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ELEPHANT::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) to "<return value>"

;     (LOOP ELEPHANT::FOR
;         ELEPHANT::I
;         FIXNUM
;         ELEPHANT::FROM
;         0
;         ELEPHANT::BELOW
;         (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS)
;         ELEPHANT::COLLECT
;         (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS))
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET*
; --> SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-COLLECT-RPLACD RPLACD LET
; --> PROGN SETF SB-KERNEL:%RPLACD SETQ THE
; ==>
;   (LIST (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS))
;
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN DESERIALIZE-BIGNUM ...)

; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp
; in: DEFUN DESERIALIZE-BIGNUM
;     (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS)
;        ELEPHANT::BYTE-SPEC
;        ELEPHANT::NUM)
; --> LET
; ==>
;   (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS)
;                   (BYTE-SIZE #:G898)
;                   (BYTE-POSITION #:G898)
;                   ELEPHANT::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::FOR
;         ELEPHANT::I
;         ELEPHANT::FROM
;         0
;         ELEPHANT::BELOW
;         (/ LENGTH 4)
;         ELEPHANT::FOR
;         ELEPHANT::BYTE-SPEC
;         =
;         (ELEPHANT::INT-BYTE-SPEC ELEPHANT::I)
;         ELEPHANT::WITH
;         ...)
; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF
; ==>
;   (< ELEPHANT::I #:LOOP-LIMIT-897)
;
; 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.

; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY
; --> SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 1+
; ==>
;   (+ 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.

;     (- ELEPHANT::NUM)
; ==>
;   (SB-KERNEL:%NEGATE ELEPHANT::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).

;     (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS)
;        ELEPHANT::BYTE-SPEC
;        ELEPHANT::NUM)
; --> LET
; ==>
;   (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS)
;                   (BYTE-SIZE #:G898)
;                   (BYTE-POSITION #:G898)
;                   ELEPHANT::NUM)
;
; note: doing unsigned word to integer coercion (cost 20)

; 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 ...)
; compiling (ASDF:OPERATE (QUOTE ASDF:LOAD-OP) ...)
; loading system definition from /home/howard/lisp/libs/asd/cl-base64.asd
; into #<PACKAGE "ASDF0">
; registering #<SYSTEM CL-BASE64 {A70ADD9}> as CL-BASE64
; registering #<SYSTEM CL-BASE64-TESTS {A9ED471}> as CL-BASE64-TESTS
; loading system definition from /home/howard/lisp/libs/asd/kmrcl.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM KMRCL {B9D0081}> as KMRCL
; compiling (DEFUN SER-DESER-EQUAL ...)
; compiling (DEFUN SERIALIZE-TO-BASE64-STRING ...)
; compiling (DEFUN DESERIALIZE-FROM-BASE64-STRING ...)

; /home/howard/lisp/libs/elephant/src/elephant/serializer.fasl written
; compilation finished in 0:00:02
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/cache.lisp" (written 18
FEB 2006 08:53:00 PM):
; 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 ...)

; /home/howard/lisp/libs/elephant/src/elephant/cache.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/controller.lisp"
(written 10 MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFPARAMETER *ELEPHANT-BACKENDS* ...)
; compiling (DEFVAR *ELEPHANT-CONTROLLER-INIT* ...)
; compiling (DEFUN REGISTER-BACKEND-CON-INIT ...)
; compiling (DEFUN LOOKUP-BACKEND-CON-INIT ...)
; compiling (DEFVAR *DBCONNECTION-SPEC* ...)
; compiling (DEFMETHOD GET-CON ...)
; compiling (DEFUN GET-CONTROLLER ...)
; compiling (DEFUN BUILD-CONTROLLER ...)
; compiling (DEFUN LOAD-BACKEND ...)
; compiling (DEFUN SATISFY-ASDF-DEPENDENCIES ...)
; compiling (DEFUN OPEN-STORE ...)
; compiling (DEFUN CLOSE-STORE ...)
; compiling (DEFMACRO WITH-OPEN-STORE ...)
; compiling (DEFCLASS STORE-CONTROLLER ...)
; compiling (DEFVAR *RESTRICTED-PROPERTIES* ...)
; compiling (DEFMETHOD CONTROLLER-PROPERTIES ...)
; compiling (DEFMETHOD SET-ELE-PROPERTY ...)
; compiling (DEFMETHOD GET-ELE-PROPERTY ...)
; compiling (DEFMETHOD ENSURE-MARKED-VERSION ...)
; compiling (DEFMETHOD CONTROLLER-VERSION ...)
; compiling (DEFMETHOD UP-TO-DATE-P ...)
; compiling (DEFPARAMETER *ELEPHANT-UPGRADE-TABLE* ...)
; compiling (DEFUN PRIOR-VERSION-P ...)
; compiling (DEFMETHOD UPGRADABLE-P ...)
; compiling (DEFMETHOD UPGRADE ...)
; compiling (DEFUN CACHE-INSTANCE ...)
; compiling (DEFUN GET-CACHED-INSTANCE ...)
; compiling (DEFMETHOD FLUSH-INSTANCE-CACHE ...)
; compiling (DEFPARAMETER *LEGACY-CONVERSIONS-DB* ...)
; compiling (DEFUN HANDLE-LEGACY-CLASSES ...)
; compiling (DEFUN SYMBOL->STRING-PAIR ...)
; compiling (DEFUN STRING-PAIR->SYMBOL ...)
; compiling (DEFGENERIC OPEN-CONTROLLER ...)
; compiling (DEFGENERIC CLOSE-CONTROLLER ...)
; compiling (DEFGENERIC CONNECTION-IS-INDEED-OPEN ...)
; compiling (DEFMETHOD CONNECTION-IS-INDEED-OPEN ...)
; compiling (DEFGENERIC NEXT-OID ...)
; compiling (DEFMETHOD CLOSE-CONTROLLER ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-READER ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-WRITER ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-BOUNDP ...)
; compiling (DEFGENERIC PERSISTENT-SLOT-MAKUNBOUND ...)
; compiling (DEFUN ADD-TO-ROOT ...)
; compiling (DEFUN GET-FROM-ROOT ...)
; compiling (DEFUN ROOT-EXISTSP ...)
; compiling (DEFUN REMOVE-FROM-ROOT ...)
; compiling (DEFUN MAP-ROOT ...)
; compiling (DEFMETHOD DROP-POBJECT ...)

; /home/howard/lisp/libs/elephant/src/elephant/controller.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/collections.lisp"
(written 26 APR 2006 06:27:51 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 (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 ...)
; 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 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-PREV-NODUP ...)
; compiling (DEFGENERIC CURSOR-PNEXT-DUP ...)
; compiling (DEFGENERIC CURSOR-PNEXT-NODUP ...)
; compiling (DEFGENERIC CURSOR-PPREV-NODUP ...)
; compiling (DEFMACRO WITH-BTREE-CURSOR ...)
; compiling (DEFMETHOD MAP-BTREE ...)
; compiling (DEFMETHOD EMPTY-BTREE-P ...)
; compiling (DEFUN DUMP-BTREE ...)
; compiling (DEFUN BTREE-DIFFER ...)

; /home/howard/lisp/libs/elephant/src/elephant/collections.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/classindex-utils.lisp"
(written 26 APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE :ELEPHANT)
; 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? ...)
; compiling (DEFUN GET-DERIVED-NAME-ROOT ...)
; 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 ...)
; compiling (DEFCLASS SYNCH-RULE ...)
; compiling (DEFUN MAKE-SYNCH-RULE ...)
; 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 ...)

; /home/howard/lisp/libs/elephant/src/elephant/classindex-utils.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/classindex.lisp"
(written 10 MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; 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 INDEXED-SLOT-WRITER ...)
; compiling (DEFUN NO-INDEXING-NEEDED? ...)
; compiling (DEFMETHOD FIND-CLASS-INDEX ...)
; compiling (DEFMETHOD CLASS-INDEXEDP-BY-NAME ...)
; compiling (DEFMETHOD FIND-CLASS-INDEX ...)
; compiling (DEFUN ENSURE-FINALIZED ...)
; compiling (DEFUN CACHE-EXISTING-CLASS-INDEX ...)
; compiling (DEFINE-CONDITION PERSISTENT-CLASS-NOT-INDEXED ...)
; 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 ENABLE-CLASS-INDEXING ...)
; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...)
; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...)

; file: /home/howard/lisp/libs/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 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 (DEFMACRO WITH-INVERTED-CURSOR ...)
; compiling (DEFMETHOD MAKE-CLASS-CURSOR ...)
; compiling (DEFMACRO WITH-CLASS-CURSOR ...)
; 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 (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 (DEFMACRO DO-SUBSETS ...)
; compiling (DEFUN DROP-INSTANCES ...)

; /home/howard/lisp/libs/elephant/src/elephant/classindex.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/migrate.lisp" (written
26 APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE "ELEPHANT")
; compiling (DEFGENERIC MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFVAR *MIGRATE-COPIED-OIDS* ...)
; compiling (DEFVAR *MIGRATING* ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFUN COPY-CINDEX-CONTENTS ...)
; compiling (DEFVAR *INHIBIT-SLOT-COPY* ...)
; compiling (DEFMACRO WITH-INHIBITED-SLOT-COPY ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFUN RESET-MIGRATE-DUPLICATE-DETECTION ...)
; compiling (DEFUN OBJECT-WAS-COPIED-P ...)
; compiling (DEFUN REGISTER-COPIED-OBJECT ...)
; compiling (DEFUN RETRIEVE-COPIED-OBJECT ...)
; compiling (DEFUN COPY-PERSISTENT-OBJECT ...)
; compiling (DEFUN INHIBIT-INDEXED-SLOT-COPY? ...)
; compiling (DEFUN COPY-PERSISTENT-SLOTS ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD COPY-BTREE-CONTENTS ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)
; compiling (DEFMETHOD MIGRATE ...)

; /home/howard/lisp/libs/elephant/src/elephant/migrate.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/src/elephant/backend.lisp" (written
20 FEB 2006 07:45:37 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE :ELEPHANT-BACKEND ...)

; /home/howard/lisp/libs/elephant/src/elephant/backend.fasl written
; compilation finished in 0:00:00
;
; compilation unit finished
;   printed 94 notes
NIL


****************************************
'require.elephant-tests'
****************************************
(require :elephant-tests)
; loading system definition from /home/howard/lisp/libs/asd/rt.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM :RT {AF8A271}> as RT
; compiling file
"/home/howard/lisp/libs/elephant/tests/elephant-tests.lisp" (written
27 MAR 2006 12:22:47 PM):
; compiling (DEFPACKAGE ELEPHANT-TESTS ...)
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFTYPE ARRAY-OR-POINTER-CHAR ...)
; compiling (DEFVAR *TESTBDB-SPEC* ...)
; compiling (DEFVAR *TESTBDB-SPEC2* ...)
; compiling (DEFVAR *TESTPG-SPEC* ...)
; compiling (DEFVAR *TESTSQLITE3-SPEC* ...)
; compiling (DEFVAR *TESTSQLITE3-SPEC2* ...)
; compiling (DEFVAR *TESTSQLITE3-MEMORY-SPEC* ...)
; compiling (DEFVAR *DEFAULT-SPEC* ...)
; compiling (DEFUN DO-BACKEND-TESTS ...)
; compiling (DEFUN DO-TEST-SPEC ...)
; compiling (DEFUN DO-MIGRATION-TESTS ...)
; compiling (DEFUN DO-MIGRATION-TEST-SPEC ...)
; compiling (DEFUN DO-INDEXING-TESTS ...)
; compiling (DEFUN DO-CRAZY-PG-TESTS ...)
; compiling (DEFUN FIND-SLOT-DEF ...)
; compiling (DEFVAR *SLEEPYCATDB-SPEC* ...)
; compiling (DEFMACRO FINISHES ...)
; compiling (DEFMACRO SIGNALS-CONDITION ...)
; compiling (DEFMACRO SIGNALS-ERROR ...)
; compiling (DEFMACRO IS-NOT-NULL ...)
; compiling (DEFMACRO ARE-NOT-NULL ...)

; /home/howard/lisp/libs/elephant/tests/elephant-tests.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/tests/testserializer.lisp" (written
18 FEB 2006 08:53:02 PM):
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFUN IN-OUT-VALUE ...)
; compiling (DEFUN IN-OUT-EQ ...)
; compiling (DEFUN IN-OUT-EQUAL ...)
; compiling (DEFUN IN-OUT-EQUALP ...)
; compiling (DEFTEST FIXNUMS ...)
; compiling (DEFTEST FIXNUM-TYPE-1 ...)
; compiling (DEFTEST BIGNUMS ...)
; compiling (DEFTEST FLOATS ...)
; compiling (DEFTEST RATIONALS ...)
; compiling (DEFTEST BASE-STRINGS ...)
; compiling (DEFTEST STRINGS ...)
; compiling (DEFUN IN-OUT-UNINTERNED-EQUAL ...)
; compiling (DEFTEST SYMBOLS ...)
; compiling (DEFTEST CHARS ...)
; compiling (DEFTEST PATHNAMES ...)
; compiling (DEFTEST CONSES ...)
; compiling (DEFTEST HASH-TABLES-1 ...)
; compiling (DEFTEST HASH-TABLES-2 ...)
; compiling (DEFUN TYPE= ...)
; compiling (DEFTEST ARRAYS-1 ...)
; compiling (DEFTEST ARRAYS-2 ...)
; compiling (DEFUN DEEP-EQUALP ...)
; compiling (DEFCLASS FOO ...)
; compiling (DEFCLASS BAR ...)
; compiling (DEFTEST TEST-DEEP-EQUALP ...)
; compiling (DEFUN IN-OUT-DEEP-EQUALP ...)
; compiling (DEFTEST OBJECTS ...)
; compiling (DEFTEST CIRCULAR ...)
; compiling (DEFCLASS PFOO ...)
; compiling (DEFCLASS PBAR ...)
; compiling (DEFTEST PERSISTENT ...)

; /home/howard/lisp/libs/elephant/tests/testserializer.fasl written
; compilation finished in 0:00:01
; compiling file
"/home/howard/lisp/libs/elephant/tests/mop-tests.lisp" (written 18 FEB
2006 08:53:02 PM):
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFTEST NON-TRANSIENT-CLASS-SLOT-1 ...)
; compiling (DEFTEST NON-TRANSIENT-CLASS-SLOT-2 ...)
; compiling (DEFTEST TRANSIENT-CLASS-SLOT ...)
; compiling (DEFTEST CLASS-DEFINERS ...)
; compiling (DEFTEST BAD-INHERITENCE ...)
; compiling (DEFTEST MIXES ...)
; compiling (DEFTEST MIXES-RIGHT-SLOTS ...)
; compiling (DEFTEST INHERIT ...)
; compiling (DEFTEST INHERIT-RIGHT-SLOTS ...)
; compiling (DEFTEST INITFORM-CLASSES ...)
; compiling (DEFTEST INITFORM-TEST ...)
; compiling (DEFTEST INITARG-TEST ...)
; compiling (DEFTEST NO-EVAL-INITFORM ...)
; compiling (DEFTEST REDEFCLASS ...)
; compiling (DEFTEST MAKUNBOUND ...)
; compiling (DEFTEST UPDATE-CLASS ...)
; compiling (DEFTEST CHANGE-CLASS ...)
; compiling (DEFTEST CHANGE-CLASS3 ...)

; /home/howard/lisp/libs/elephant/tests/mop-tests.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/tests/testcollections.lisp" (written
19 APR 2006 07:07:15 PM):
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFTEST BASICPERSISTENCE ...)
; compiling (DEFTEST TESTOID ...)
; compiling (DEFCLASS BLOB ...)
; compiling (DEFVAR KEYS ...)
; compiling (DEFVAR OBJS ...)
; compiling (DEFVAR BT)
; compiling (DEFTEST BTREE-MAKE ...)
; compiling (DEFTEST BTREE-PUT ...)
; compiling (DEFTEST BTREE-GET ...)
; compiling (DEFVAR FIRST-KEY ...)
; compiling (DEFTEST REMOVE-KV ...)
; compiling (DEFTEST REMOVED ...)
; compiling (DEFTEST MAP-BTREE ...)
; compiling (DEFVAR INDEXED)
; compiling (DEFVAR INDEX1)
; compiling (DEFVAR INDEX2)
; compiling (DEFTEST INDEXED-BTREE-MAKE ...)
; compiling (DEFUN KEY-MAKER ...)
; compiling (DEFTEST ADD-INDICES ...)
; compiling (DEFTEST TEST-INDICES ...)
; compiling (DEFTEST INDEXED-PUT ...)
; compiling (DEFTEST INDEXED-GET ...)
; compiling (DEFTEST SIMPLE-SLOT-GET ...)
; compiling (DEFTEST INDEXED-GET-FROM-SLOT1 ...)
; compiling (DEFTEST INDEXED-GET-FROM-SLOT2 ...)
; compiling (DEFTEST REMOVE-KV-INDEXED ...)
; compiling (DEFTEST NO-KEY-NOR-INDICES ...)
; compiling (DEFTEST REMOVE-KV-FROM-SLOT1 ...)
; compiling (DEFTEST NO-KEY-NOR-INDICES-SLOT1 ...)
; compiling (DEFTEST REMOVE-KV-FROM-SLOT2 ...)
; compiling (DEFTEST NO-KEY-NOR-INDICES-SLOT2 ...)
; compiling (DEFTEST MAP-INDEXED ...)
; compiling (DEFTEST GET-FIRST ...)
; compiling (DEFTEST GET-FIRST2 ...)
; compiling (DEFTEST GET-LAST ...)
; compiling (DEFTEST GET-LAST2 ...)
; compiling (DEFTEST SET ...)
; compiling (DEFTEST SET2 ...)
; compiling (DEFTEST SET-RANGE ...)
; compiling (DEFTEST SET-RANGE2 ...)
; compiling (DEFTEST REM-KV ...)
; compiling (DEFUN ODD ...)
; compiling (DEFTEST REM-IDEXKV ...)
; compiling (DEFVAR INDEXED2)
; compiling (DEFVAR INDEX3)
; compiling (DEFTEST MAKE-INDEXED2 ...)
; compiling (DEFUN CRUNCH ...)
; compiling (DEFTEST ADD-INDICES2 ...)
; compiling (DEFTEST PUT-INDEXED2 ...)
; compiling (DEFTEST GET-INDEXED2 ...)
; compiling (DEFTEST GET-FROM-INDEX3 ...)
; compiling (DEFTEST DUP-TEST ...)
; compiling (DEFTEST NODUP-TEST ...)
; compiling (DEFTEST PREV-NODUP-TEST ...)
; compiling (DEFTEST PNODUP-TEST ...)
; compiling (DEFTEST PPREV-NODUP-TEST ...)
; compiling (DEFTEST CUR-DEL1 ...)
; compiling (DEFTEST INDEXED-DELETE ...)
; compiling (DEFTEST TEST-DELETED ...)
; compiling (DEFTEST INDEXED-DELETE2 ...)
; compiling (DEFTEST TEST-DELETED2 ...)
; compiling (DEFTEST CUR-DEL2 ...)
; compiling (DEFTEST GET-BOTH ...)
; compiling (DEFTEST PGET-BOTH ...)
; compiling (DEFTEST PGET-BOTH-RANGE ...)
; compiling (DEFMACRO PCURSOR-PKEY ...)
; compiling (DEFTEST PCURSOR ...)
; compiling (DEFVAR INDEX4)
; compiling (DEFTEST NEWINDEX ...)
; compiling (DEFTEST PCURSOR2 ...)
; compiling (DEFTEST ADD-GET-REMOVE ...)
; compiling (DEFTEST ADD-GET-REMOVE-SYMBOL ...)
; compiling (DEFTEST EXISTSP ...)

; /home/howard/lisp/libs/elephant/tests/testcollections.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/tests/testindexing.lisp" (written 10
MAY 2006 07:42:51 PM):
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFUN SETUP-TESTING ...)
; compiling (DEFVAR INST1)
; compiling (DEFVAR INST2)
; compiling (DEFVAR INST3)
; compiling (DEFTEST DISABLE-CLASS-INDEXING-TEST ...)
; compiling (DEFTEST INDEXING-BASIC-TRIVIAL ...)
; compiling (DEFTEST INDEXING-BASIC ...)
; compiling (DEFTEST INDEXING-INHERIT ...)
; compiling (DEFTEST INDEXING-RANGE ...)
; compiling (DEFTEST INDEXING-WIPE-INDEX ...)
; compiling (DEFTEST INDEXING-RECONNECT-DB ...)
; compiling (DEFTEST INDEXING-CHANGE-CLASS ...)
; compiling (DEFTEST INDEXING-REDEF-CLASS ...)
; compiling (DEFVAR NORMAL-INDEX ...)
; compiling (DEFUN MAKE-STRESS-CLASSES ...)
; compiling (DEFUN NORMAL-STRESS-SETUP ...)
; compiling (DEFUN INDEXED-STRESS-SETUP ...)
; compiling (DEFUN NORMAL-RANGE-LOOKUP ...)

; file: /home/howard/lisp/libs/elephant/tests/testindexing.lisp
; in: DEFUN NORMAL-RANGE-LOOKUP
;     (ELEPHANT:WITH-BTREE-CURSOR
;    (ELEPHANT-TESTS::CUR ELEPHANT-TESTS::NORMAL-INDEX)
;    (LOOP
;     (MULTIPLE-VALUE-BIND
;         (ELEPHANT-TESTS::VALUE? ELEPHANT-TESTS::KEY ELEPHANT-TESTS::VAL)
;         (ELEPHANT:CURSOR-NEXT ELEPHANT-TESTS::CUR)
;       (DECLARE (IGNORE ELEPHANT-TESTS::KEY))
;       (COND (# #) (# #))))
;    ELEPHANT-TESTS::OBJECTS)
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; ==>
;   ELEPHANT-TESTS::OBJECTS
;
; note: deleting unreachable code

; compiling (DEFUN INDEXED-RANGE-LOOKUP ...)
; compiling (DEFPARAMETER *STRESS-COUNT* ...)
; compiling (DEFPARAMETER *RANGE-SIZE* ...)
; compiling (DEFTEST INDEXING-TIMING ...)

; /home/howard/lisp/libs/elephant/tests/testindexing.fasl written
; compilation finished in 0:00:00
; compiling file
"/home/howard/lisp/libs/elephant/tests/testmigration.lisp" (written 26
APR 2006 06:27:51 PM):
; compiling (IN-PACKAGE :ELE-TESTS)
; compiling (DEFTEST REMOVE-ELEMENT ...)
; compiling (DEFTEST MIGRATE-BASIC ...)
; compiling (DEFTEST MIGRATE-BTREE ...)
; compiling (DEFTEST MIGRATE-IDX-BTREE ...)
; compiling (DEFTEST MIGRATE-PCLASS ...)
; compiling (DEFPCLASS IPFOO ...)
; compiling (DEFTEST MIGRATE-IPCLASS ...)

; /home/howard/lisp/libs/elephant/tests/testmigration.fasl written
; compilation finished in 0:00:00
;
; compilation unit finished
;   printed 1 note
NIL

On 6/22/06, Ian Eslick <eslick at csail.mit.edu> wrote:
> What OS are you running on?  Did you get a compile error?  The trace
> looks ok.
>
> Ian
>
> Howard Yeh wrote:
> > Hi,
> >
> > I am trying to get Elephant to work.
> >
> > (require :elephant)
> > (require :elephant-tests)
> > (in-package "ELEPHANT-TESTS")
> > (setf *default-spec* *testbdb-spec*)
> > (do-backend-tests)
> >
> > ASDF seems to compile and load :elephant and :elephant-tests ok.
> > But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp
> > and causes SBCL to exit abnormally (code 256).
> >
> > Then I tried to compile sleepycat.lisp individually to see what happens.
> >
> > (require :elephant)
> > (compile-file
> > #p"/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp"
> > :verbose t)
> >
> > Same thing, abnormal exit 256. I did a lot of fiddling around, but
> > still can't get it to work. I have no idea what's going on.
> >
> > I am using Elephant 0.6.0 and SBCL 0.9.12.
> >
> >
> > -Howard
> >
> >
> > ; compiling file
> > "/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp"
> > (written 10 MAY 2006 07:42:51 PM):
> > ; compiling (IN-PACKAGE "SLEEPYCAT")
> > ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...))
> > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY
> > ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...)
> > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY
> > ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...)
> > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...)
> > ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...)
> > ; compiling (DEFUN DB-STRERROR ...)
> > ; compiling (DEFINE-CONDITION DB-ERROR ...)
> > ; compiling (DEFCONSTANT DB-BTREE ...)
> > ; compiling (DEFCONSTANT DB-HASH ...)
> > ; compiling (DEFCONSTANT DB-RECNO ...)
> > ; compiling (DEFCONSTANT DB-QUEUE ...)
> > ; compiling (DEFCONSTANT DB-UNKNOWN ...)
> > ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...)
> > ; compiling (DEFCONSTANT DB_JOINENV ...)
> > ; compiling (DEFCONSTANT DB_INIT_CDB ...)
> > ; compiling (DEFCONSTANT DB_INIT_LOCK ...)
> > ; compiling (DEFCONSTANT DB_INIT_LOG ...)
> > ; compiling (DEFCONSTANT DB_INIT_MPOOL ...)
> > ; compiling (DEFCONSTANT DB_INIT_REP ...)
> > ; compiling (DEFCONSTANT DB_INIT_TXN ...)
> > ; compiling (DEFCONSTANT DB_RECOVER ...)
> > ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...)
> > ; compiling (DEFCONSTANT DB_LOCKDOWN ...)
> > ; compiling (DEFCONSTANT DB_PRIVATE ...)
> > ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...)
> > ; compiling (DEFCONSTANT DB_THREAD ...)
> > ; compiling (DEFCONSTANT DB_FORCE ...)
> > ; compiling (DEFCONSTANT DB_DEGREE_2 ...)
> > ; compiling (DEFCONSTANT DB_DIRTY_READ ...)
> > ; compiling (DEFCONSTANT DB_CREATE ...)
> > ; compiling (DEFCONSTANT DB_EXCL ...)
> > ; compiling (DEFCONSTANT DB_NOMMAP ...)
> > ; compiling (DEFCONSTANT DB_RDONLY ...)
> > ; compiling (DEFCONSTANT DB_TRUNCATE ...)
> > ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...)
> > ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...)
> > ; compiling (DEFCONSTANT DB_TXN_SYNC ...)
> > ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...)
> > ; compiling (DEFCONSTANT DB_DUP ...)
> > ; compiling (DEFCONSTANT DB_DUPSORT ...)
> > ; compiling (DEFCONSTANT DB_CURRENT ...)
> > ; compiling (DEFCONSTANT DB_FIRST ...)
> > ; compiling (DEFCONSTANT DB_GET_BOTH ...)
> > ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...)
> > ; compiling (DEFCONSTANT DB_LAST ...)
> > ; compiling (DEFCONSTANT DB_NEXT ...)
> > ; compiling (DEFCONSTANT DB_NEXT_DUP ...)
> > ; compiling (DEFCONSTANT DB_NEXT_NODUP ...)
> > ; compiling (DEFCONSTANT DB_PREV ...)
> > ; compiling (DEFCONSTANT DB_PREV_NODUP ...)
> > ; compiling (DEFCONSTANT DB_SET ...)
> > ; compiling (DEFCONSTANT DB_SET_RANGE ...)
> > ; compiling (DEFCONSTANT DB_AFTER ...)
> > ; compiling (DEFCONSTANT DB_BEFORE ...)
> > ; compiling (DEFCONSTANT DB_KEYFIRST ...)
> > ; compiling (DEFCONSTANT DB_KEYLAST ...)
> > ; compiling (DEFCONSTANT DB_NODUPDATA ...)
> > ; compiling (DEFCONSTANT DB_NOOVERWRITE ...)
> > ; compiling (DEFCONSTANT DB_NOSYNC ...)
> > ; compiling (DEFCONSTANT DB_POSITION ...)
> > ; compiling (DEFCONSTANT DB_SEQ_DEC ...)
> > ; compiling (DEFCONSTANT DB_SEQ_INC ...)
> > ; compiling (DEFCONSTANT DB_SEQ_WRAP ...)
> > ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...)
> > ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...)
> > ; compiling (DEFCONSTANT DB_KEYEMPTY ...)
> > ; compiling (DEFCONSTANT DB_KEYEXIST ...)
> > ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...)
> > ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...)
> > ; compiling (DEFCONSTANT DB_NOTFOUND ...)
> > ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...)
> > ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...)
> > ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...)
> > ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...)
> > ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...)
> > ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...)
> > ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...)
> > ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...)
> > ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...)
> > ; compiling (DEF-ENUM DB-LOCKOP ...)
> > _______________________________________________
> > elephant-devel site list
> > elephant-devel at common-lisp.net
> > http://common-lisp.net/mailman/listinfo/elephant-devel
> _______________________________________________
> 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