[elephant-devel] Elephant won't compile under Lispworks for Linux 5.1

Sun Jan 25 21:30:36 UTC 2009

This appears to be similar to the error reported back in April 08
(http://common-lisp.net/pipermail/elephant-devel/2008-April/003925.html).

Search below for "++++ Error".

-- Larry

CL-USER 1 > (asdf :elephant)
; loading system definition from /home/lmc/lisp/systems/elephant.asd into
; #<The ASDF0 package, 0/16 internal, 0/16 external>
; Loading text file /home/lmc/lisp/elephant/elephant-1.0/elephant.asd
; registering #<SYSTEM ELEPHANT 21FE099F> as ELEPHANT
;; Creating system COMMON-LISP-USER::ELEPHANT->SRC->UTILS
;; Creating system COMMON-LISP-USER::ELEPHANT->SRC->MEMUTIL
;; Creating system COMMON-LISP-USER::ELEPHANT->SRC->ELEPHANT
;; Creating system COMMON-LISP-USER::ELEPHANT->SRC
;; Creating system COMMON-LISP-USER::ELEPHANT
; loading system definition from /home/lmc/lisp/systems/cl-base64.asd into
; #<The ASDF0 package, 0/16 internal, 0/16 external>
; Loading text file /home/lmc/lisp/cl-base64/cl-base64.asd
; registering #<SYSTEM CL-BASE64 2215982B> as CL-BASE64
;; Creating system COMMON-LISP-USER::CL-BASE64
; registering #<SYSTEM CL-BASE64-TESTS 200C8253> as CL-BASE64-TESTS
;; Creating system COMMON-LISP-USER::CL-BASE64-TESTS
; loading system definition from /home/lmc/lisp/systems/uffi.asd into
; #<The ASDF0 package, 0/16 internal, 0/16 external>
; Loading text file /usr/share/common-lisp/source/uffi/uffi.asd
; registering #<SYSTEM UFFI 200F68EF> as UFFI
;; Creating system COMMON-LISP-USER::UFFI->SRC
;; Creating system COMMON-LISP-USER::UFFI
; Loading fasl file /usr/share/common-lisp/source/uffi/src/package.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/primitives.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/objects.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/aggregates.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/functions.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/strings.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/libraries.ufasl
; Loading fasl file /usr/share/common-lisp/source/uffi/src/os.ufasl
; Loading fasl file /home/lmc/lisp/cl-base64/package.ufasl
; Loading fasl file /home/lmc/lisp/cl-base64/encode.ufasl
; Loading fasl file /home/lmc/lisp/cl-base64/decode.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/utils/package.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFPACKAGE "ELEPHANT-UTILS")
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/utils/package.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/utils/convenience.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; ELEPHANT-UTILS:WITH-GENSYMS
; ELEPHANT-UTILS:DO-SUBSETS
; ELEPHANT-UTILS:SUBSETS
; ELEPHANT-UTILS:REMOVE-KEYWORDS
; ELEPHANT-UTILS::CONCAT-SEPARATED-STRINGS
; ELEPHANT-UTILS::APPEND-SUBLISTS
; ELEPHANT-UTILS:IFRET
; ELEPHANT-UTILS:AIF
; ELEPHANT-UTILS:AWHEN
; ELEPHANT-UTILS:MKLIST
; ELEPHANT-UTILS:REMOVE-INDEXED-ELEMENT-AND-ADJUST
; ELEPHANT-UTILS:CURRY
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/utils/convenience.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/utils/locks.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; ELEPHANT-UTILS:ELE-MAKE-LOCK
; ELEPHANT-UTILS:ELE-WITH-LOCK
; ELEPHANT-UTILS:ELE-MAKE-FAST-LOCK
; ELEPHANT-UTILS:ELE-WITH-FAST-LOCK
; ELEPHANT-UTILS:ELE-THREAD-HASH-KEY
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/utils/locks.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/utils/os.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; ELEPHANT-UTILS::IN-DIRECTORY
; ELEPHANT-UTILS:LAUNCH-BACKGROUND-PROGRAM
;;;*** Warning in ELEPHANT-UTILS:KILL-BACKGROUND-PROGRAM: PROCESS-HANDLE is bound but not referenced
; ELEPHANT-UTILS:KILL-BACKGROUND-PROGRAM
; ELEPHANT-UTILS:CREATE-TEMP-FILENAME
; ELEPHANT-UTILS:CREATE-TEMP-DIRNAME
; ELEPHANT-UTILS:COPY-DIRECTORY
; ELEPHANT-UTILS:COPY-FILE-TO-DIR
; ELEPHANT-UTILS:COPY-FILE
; (TOP-LEVEL-FORM 0)
Warning: COMPILE-FILE warned while performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
         #<ASDF:CL-SOURCE-FILE "os" 22000E8B>.
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/utils/os.ufasl
Attempting to load libmemutil.so...
Loaded /home/lmc/lisp/elephant/elephant-1.0/src/memutil/libmemutil.so
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/memutil/memutil.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (DEFPACKAGE "ELEPHANT-MEMUTIL")
; (TOP-LEVEL-FORM 2)
;;;*** Warning in (DEFTYPE ELEPHANT-MEMUTIL:POINTER-INT): (DEFTYPE ELEPHANT-MEMUTIL:POINTER-INT) defined more than once in /home/lmc/lisp/elephant/elephant-1.0/src/memutil/memutil.lisp.
; (DEFTYPE ELEPHANT-MEMUTIL:POINTER-INT)
;;;*** Warning in (DEFTYPE ELEPHANT-MEMUTIL:POINTER-VOID): (DEFTYPE ELEPHANT-MEMUTIL:POINTER-VOID) defined more than once in /home/lmc/lisp/elephant/elephant-1.0/src/memutil/memutil.lisp.
; (DEFTYPE ELEPHANT-MEMUTIL:POINTER-VOID)
; (FLI:DEFINE-FOREIGN-TYPE ELEPHANT-MEMUTIL:ARRAY-OR-POINTER-CHAR)
;;;*** Warning in (DEFTYPE ELEPHANT-MEMUTIL:ARRAY-OR-POINTER-CHAR): (DEFTYPE ELEPHANT-MEMUTIL:ARRAY-OR-POINTER-CHAR) defined more than once in /home/lmc/lisp/elephant/elephant-1.0/src/memutil/memutil.lisp.
; (DEFTYPE ELEPHANT-MEMUTIL:ARRAY-OR-POINTER-CHAR)
; (SUBFUNCTION ELEPHANT-MEMUTIL::COPY-BUFS (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-BUFS))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-BUFS)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-BUFS)
; (DEFVAR ELEPHANT-MEMUTIL:+NULL-VOID+)
; (DEFVAR ELEPHANT-MEMUTIL:+NULL-CHAR+)
; (DEFVAR ELEPHANT-MEMUTIL::*BUFFER-STREAMS*)
; (DEFVAR ELEPHANT-MEMUTIL::*BUFFER-STREAMS-LOCK*)
; (SUBFUNCTION (DEFSETF ELEPHANT-MEMUTIL:BUFFER-STREAM-LENGTH) (DEFSTRUCT ELEPHANT-MEMUTIL:BUFFER-STREAM))
; (SUBFUNCTION (DEFSETF ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION) (DEFSTRUCT ELEPHANT-MEMUTIL:BUFFER-STREAM))
; (SUBFUNCTION (DEFSETF ELEPHANT-MEMUTIL:BUFFER-STREAM-SIZE) (DEFSTRUCT ELEPHANT-MEMUTIL:BUFFER-STREAM))
; (SUBFUNCTION (DEFSETF ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER) (DEFSTRUCT ELEPHANT-MEMUTIL:BUFFER-STREAM))
; (SUBFUNCTION ELEPHANT-MEMUTIL:MAKE-BUFFER-STREAM (DEFSTRUCT ELEPHANT-MEMUTIL:BUFFER-STREAM))
; ELEPHANT-MEMUTIL::GRAB-BUFFER-STREAM
; ELEPHANT-MEMUTIL::RETURN-BUFFER-STREAM
; ELEPHANT-MEMUTIL:WITH-BUFFER-STREAMS
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-INT32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-FIXNUM32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FIXNUM32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FIXNUM32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FIXNUM32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-UINT32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-INT64 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT64))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT64)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-INT64)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-UINT64 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT64))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT64)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-UINT64)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-FLOAT (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FLOAT))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FLOAT)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-FLOAT)
; (SUBFUNCTION ELEPHANT-MEMUTIL::READ-DOUBLE (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-DOUBLE))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-DOUBLE)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::READ-DOUBLE)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-INT32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-UINT32 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT32))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT32)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT32)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-INT64 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT64))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT64)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-INT64)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM64 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM64))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM64)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FIXNUM64)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-UINT64 (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT64))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT64)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-UINT64)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-FLOAT (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FLOAT))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FLOAT)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-FLOAT)
; (SUBFUNCTION ELEPHANT-MEMUTIL::WRITE-DOUBLE (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-DOUBLE))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-DOUBLE)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::WRITE-DOUBLE)
; (SUBFUNCTION ELEPHANT-MEMUTIL::OFFSET-CHAR-POINTER (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::OFFSET-CHAR-POINTER))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::OFFSET-CHAR-POINTER)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::OFFSET-CHAR-POINTER)
; ELEPHANT-MEMUTIL:BYTE-LENGTH
; (SUBFUNCTION ELEPHANT-MEMUTIL::COPY-STR-TO-BUF (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-STR-TO-BUF))
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-STR-TO-BUF)
; (FLI:DEFINE-FOREIGN-FUNCTION ELEPHANT-MEMUTIL::COPY-STR-TO-BUF)
; ELEPHANT-MEMUTIL::PROCESS-STRUCT-SLOT-DEFS
; ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS
;;;*** Warning in ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM
;;;*** Warning in ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM-NO-COPY: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
;;;*** Warning in ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM-NO-COPY: symbol-macro SIZE is bound but not referenced
; ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM-NO-COPY
; ELEPHANT-MEMUTIL:RESET-BUFFER-STREAM
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE
; ELEPHANT-MEMUTIL:BUFFER-WRITE-INT32
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-FIXNUM32: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-FIXNUM32
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT32: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT32
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-INT64: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-INT64
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-FIXNUM64: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-FIXNUM64
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT64: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT64
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE
;;;*** Warning in ELEPHANT-MEMUTIL:BUFFER-WRITE-STRING: Ignoring type declaration with illegal type (ELEPHANT-MEMUTIL::ALIEN (* ELEPHANT-MEMUTIL::UNSIGNED-CHAR))
; ELEPHANT-MEMUTIL:BUFFER-WRITE-STRING
; ELEPHANT-MEMUTIL:BUFFER-READ-BYTE
; ELEPHANT-MEMUTIL::BUFFER-READ-BYTE-VECTOR
; ELEPHANT-MEMUTIL::BUFFER-WRITE-BYTE-VECTOR
; ELEPHANT-MEMUTIL:BUFFER-READ-TO-ARRAY-OFFSET
; ELEPHANT-MEMUTIL:BUFFER-WRITE-FROM-ARRAY-OFFSET
; ELEPHANT-MEMUTIL:BUFFER-WRITE-OID
; ELEPHANT-MEMUTIL:BUFFER-READ-OID
; ELEPHANT-MEMUTIL:BUFFER-READ-INT
; ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM
; ELEPHANT-MEMUTIL:BUFFER-WRITE-INT
; ELEPHANT-MEMUTIL:BUFFER-READ-UINT
; ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT
; (DEFCONSTANT ELEPHANT-MEMUTIL::+2^32+)
; (DEFCONSTANT ELEPHANT-MEMUTIL::+2^64+)
; ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM32
; ELEPHANT-MEMUTIL:BUFFER-READ-INT32
; ELEPHANT-MEMUTIL:BUFFER-READ-UINT32
; ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM64
; ELEPHANT-MEMUTIL:BUFFER-READ-INT64
; ELEPHANT-MEMUTIL:BUFFER-READ-UINT64
; ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT
; ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE
; ELEPHANT-MEMUTIL:BUFFER-READ-UCS1-STRING
; ELEPHANT-MEMUTIL:BUFFER-READ-UCS2-STRING
; (DEFPARAMETER ELEPHANT-MEMUTIL::+LITTLE-ENDIAN+)
; ELEPHANT-MEMUTIL:LITTLE-ENDIAN-P
; (TOP-LEVEL-FORM 0)
Warning: COMPILE-FILE warned while performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
         #<ASDF:CL-SOURCE-FILE "memutil" 22000D0B>.
Warning: COMPILE-FILE failed while performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
         #<ASDF:CL-SOURCE-FILE "memutil" 22000D0B>.
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/memutil/memutil.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/package.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFPACKAGE "ELEPHANT")
; (TOP-LEVEL-FORM 3)
; (DEFPACKAGE "ELEPHANT-USER")
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/package.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/variables.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFVAR ELEPHANT::*ELEPHANT-CODE-VERSION*)
; (DEFVAR ELEPHANT::*ELEPHANT-CODE-VERSION-INT*)
; (DEFVAR ELEPHANT::*ELEPHANT-UNMARKED-CODE-VERSION*)
; (DEFVAR ELEPHANT::*ELEPHANT-PROPERTIES-LABEL*)
; (DEFVAR ELEPHANT::*USER-CONFIGURABLE-PARAMETERS*)
; (DEFVAR ELEPHANT::*ENABLE-MULTI-STORE-INDEXING*)
; (DEFCONSTANT ELEPHANT::+NONE+)
; (DEFCONSTANT ELEPHANT::+TXN+)
; (DEFCONSTANT ELEPHANT::+CHECKOUT+)
; (DEFPARAMETER ELEPHANT::*CACHED-INSTANCE-DEFAULT-MODE*)
; (DEFVAR ELEPHANT::*CIRCULARITY-INITIAL-HASH-SIZE*)
; (DEFPARAMETER ELEPHANT::*MAP-USING-DEGREE2*)
; (DEFVAR ELEPHANT::*BERKELEY-DB-CACHESIZE*)
; (DEFVAR ELEPHANT::*BERKELEY-DB-MAX-LOCKS*)
; (DEFVAR ELEPHANT::*BERKELEY-DB-MAX-OBJECTS*)
; (DEFVAR ELEPHANT::*DEFAULT-MVCC*)
; (DEFVAR ELEPHANT:*STORE-CONTROLLER*)
; (DEFVAR ELEPHANT::*CURRENT-TRANSACTION*)
; (DEFVAR ELEPHANT:*DEFAULT-RETRIES*)
; (DEFVAR ELEPHANT::*SERIALIZER-MARK-LIST*)
; (DEFVAR ELEPHANT::*SERIALIZER-INST-LIST*)
; (DEFPARAMETER ELEPHANT:*WARN-ON-MANUAL-CLASS-FINALIZATION*)
; (DEFPARAMETER ELEPHANT::*MIGRATE-MESSAGES*)
; (DEFPARAMETER ELEPHANT::*MIGRATE-VERBOSE*)
; (DEFPARAMETER ELEPHANT:*WARN-WHEN-DROPPING-PERSISTENT-SLOTS*)
; (DEFPARAMETER ELEPHANT::*RETURN-NULL-ON-MISSING-INSTANCE*)
; ELEPHANT:WITH-INHIBITED-WARNINGS
; (TOP-LEVEL-FORM 29)
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/variables.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/transactions.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFGENERIC ELEPHANT::EXECUTE-TRANSACTION)
; ELEPHANT::MAKE-TRANSACTION-RECORD
; ELEPHANT::TRANSACTION-STORE
; ELEPHANT::TRANSACTION-OBJECT
; ELEPHANT::TRANSACTION-PRIOR
; ELEPHANT::TRANSACTION-OBJECT-P
; ELEPHANT::PRIOR-OWNED-TXN
; ELEPHANT::OWNED-TXN-P
; (SUBFUNCTION (DEFCLASS ELEPHANT:TRANSACTION-RETRY-COUNT-EXCEEDED) (DEFINE-CONDITION ELEPHANT:TRANSACTION-RETRY-COUNT-EXCEEDED))
; (DEFINE-CONDITION ELEPHANT:TRANSACTION-RETRY-COUNT-EXCEEDED)
; ELEPHANT:WITH-TRANSACTION
; ELEPHANT:ENSURE-TRANSACTION
; ELEPHANT::WITH-BATCH-TRANSACTION
; (DEFGENERIC ELEPHANT:CONTROLLER-START-TRANSACTION)
; (DEFGENERIC ELEPHANT:CONTROLLER-COMMIT-TRANSACTION)
; (DEFGENERIC ELEPHANT:CONTROLLER-ABORT-TRANSACTION)
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/transactions.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/schemas.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFCLASS ELEPHANT::SCHEMA)
; (METHOD PRINT-OBJECT (ELEPHANT::SCHEMA T))
; (SUBFUNCTION (DEFSETF ELEPHANT::SLOT-REC-ARGS) (DEFSTRUCT ELEPHANT::SLOT-REC))
; (SUBFUNCTION (DEFSETF ELEPHANT::SLOT-REC-NAME) (DEFSTRUCT ELEPHANT::SLOT-REC))
; (SUBFUNCTION (DEFSETF ELEPHANT::SLOT-REC-TYPE) (DEFSTRUCT ELEPHANT::SLOT-REC))
; (SUBFUNCTION ELEPHANT::MAKE-SLOT-REC (DEFSTRUCT ELEPHANT::SLOT-REC))
; (SUBFUNCTION ELEPHANT::MAKE-SLOT-REC (DEFSTRUCT ELEPHANT::SLOT-REC))
; ELEPHANT::SLOT-REC-EQ
; ELEPHANT::INDEXED-SLOT-REC-EQ
; ELEPHANT::GET-SLOT-RECS-BY-TYPE
; ELEPHANT::COMPUTE-SCHEMA
; ELEPHANT::COMPUTE-TRANSIENT-SCHEMA
; (DEFPARAMETER ELEPHANT::*SLOT-DEF-TYPE-TAGS*)
; ELEPHANT::COMPUTE-SLOT-RECS
; ELEPHANT::COMPUTE-TRANSIENT-SLOT-RECS
; (METHOD ELEPHANT::COMPUTE-SLOT-RECS-BY-TYPE (T T T))
; (METHOD ELEPHANT::COMPUTE-SLOT-RECS-BY-TYPE ((EQL :INDEXED) T T))
; (DEFCLASS ELEPHANT::DB-SCHEMA)
; (METHOD PRINT-OBJECT (ELEPHANT::DB-SCHEMA T))
; ELEPHANT::MAKE-DB-SCHEMA
; ELEPHANT::LOGICAL-COPY-SCHEMA
; ELEPHANT::COPY-SCHEMA
; (METHOD ELEPHANT::MATCH-SCHEMAS (NULL T))
; (METHOD ELEPHANT::MATCH-SCHEMAS (T NULL))
; (METHOD ELEPHANT::MATCH-SCHEMAS (ELEPHANT::SCHEMA ELEPHANT::SCHEMA))
; ELEPHANT::SYMBOL<
; ELEPHANT::SORTED-SLOTS
; (METHOD ELEPHANT::SCHEMA-DIFF (T T))
; ELEPHANT::DIFF-TYPE
; ELEPHANT::DIFF-RECS
; (METHOD ELEPHANT::DEFAULT-CLASS-CONSTRUCTOR (ELEPHANT::DB-SCHEMA))
; ELEPHANT::SLOT-DEFS-FROM-SCHEMA
; ELEPHANT::COMPUTE-READER
; ELEPHANT::COMPUTE-WRITER
; ELEPHANT::DEFAULT-TEMPLATE
; ELEPHANT::DUMP-SCHEMA
; ELEPHANT::DUMP-SLOTS
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/schemas.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/metaclasses.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFCLASS ELEPHANT:PERSISTENT)
; (METHOD PRINT-OBJECT (ELEPHANT:PERSISTENT T))
; (DEFCLASS ELEPHANT:PERSISTENT-METACLASS)
; (METHOD ELEPHANT::GET-CLASS-SCHEMA (T))
; (METHOD ELEPHANT::SET-CLASS-SCHEMA (T T))
; (DEFSETF ELEPHANT::GET-CLASS-SCHEMA)
; (METHOD ELEPHANT::GET-STORE-SCHEMAS (T))
; (METHOD ELEPHANT::SET-STORE-SCHEMAS (T T))
; (DEFSETF ELEPHANT::GET-STORE-SCHEMAS)
; (METHOD ELEPHANT::GET-CLASS-INDEXING (T))
; (DEFSETF ELEPHANT::GET-CLASS-INDEXING)
; (METHOD ELEPHANT::GET-CACHE-STYLE (T))
; (DEFSETF ELEPHANT::GET-CACHE-STYLE)
; (METHOD ELEPHANT::HAS-CLASS-SCHEMA-P (ELEPHANT:PERSISTENT-METACLASS))
; (METHOD ELEPHANT::HAS-CLASS-CONTROLLER-SCHEMA-P (T ELEPHANT:PERSISTENT-METACLASS))
; (METHOD ELEPHANT::GET-CLASS-CONTROLLER-SCHEMA (T ELEPHANT:PERSISTENT-METACLASS))
; (METHOD ELEPHANT::ADD-CLASS-CONTROLLER-SCHEMA (T ELEPHANT:PERSISTENT-METACLASS T))
; (METHOD ELEPHANT::REMOVE-CLASS-CONTROLLER-SCHEMA (T ELEPHANT:PERSISTENT-METACLASS))
; (METHOD ELEPHANT::CLASS-INDEXING-ENABLED-P (ELEPHANT:PERSISTENT-METACLASS))
; ELEPHANT::MIGRATE-CLASS-INDEX-P
; ELEPHANT:DEFPCLASS
; ELEPHANT::ADD-PERSISTENT-METACLASS-ARGUMENT
; (DEFCLASS ELEPHANT::PERSISTENT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::PERSISTENT-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::PERSISTENT-EFFECTIVE-SLOT-DEFINITION)
; (DEFGENERIC ELEPHANT::PERSISTENT-P)
; ELEPHANT::PERSISTENT-SLOT-DEFS
; ELEPHANT::PERSISTENT-SLOT-NAMES
; ELEPHANT::ALL-PERSISTENT-SLOT-NAMES
; ELEPHANT::ALL-SINGLE-VALUED-SLOT-DEFS
; (DEFCLASS ELEPHANT::CACHED-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::CACHED-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::CACHED-EFFECTIVE-SLOT-DEFINITION)
; ELEPHANT::CACHED-SLOT-DEFS
; ELEPHANT::CACHED-SLOT-NAMES
; (DEFCLASS ELEPHANT::TRANSIENT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::TRANSIENT-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::TRANSIENT-EFFECTIVE-SLOT-DEFINITION)
; (DEFGENERIC ELEPHANT::TRANSIENT-P)
; ELEPHANT::ENSURE-TRANSIENT-CHAIN
; ELEPHANT::TRANSIENT-SLOT-DEFS
; ELEPHANT::TRANSIENT-SLOT-NAMES
; (DEFCLASS ELEPHANT::INDEXED-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::INDEXED-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::INDEXED-EFFECTIVE-SLOT-DEFINITION)
; (METHOD ELEPHANT::INDEXED-P (T))
; (METHOD ELEPHANT::GET-SLOT-DEF-INDEX (ELEPHANT::INDEXED-EFFECTIVE-SLOT-DEFINITION T))
; (METHOD ELEPHANT::ADD-SLOT-DEF-INDEX (T ELEPHANT::INDEXED-EFFECTIVE-SLOT-DEFINITION T))
; (METHOD ELEPHANT::CLEAR-SLOT-DEF-INDEX (ELEPHANT::INDEXED-EFFECTIVE-SLOT-DEFINITION T))
; (METHOD ELEPHANT::INDEXED-SLOT-DEFS (T))
; (METHOD ELEPHANT::INDEXED-SLOT-NAMES (T))
; (DEFCLASS ELEPHANT::DERIVED-INDEX-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::DERIVED-INDEX-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::DERIVED-INDEX-EFFECTIVE-SLOT-DEFINITION)
; (METHOD ELEPHANT::DERIVED-INDEX-SLOT-DEFS (T))
; (METHOD ELEPHANT::DERIVED-INDEX-SLOT-NAMES (T))
; ELEPHANT::COMPILE-DERIVED-FN
; ELEPHANT::GEN-DERIVED-SYM-WRAPPER
; ELEPHANT::GEN-DERIVED-FN-WRAPPER
; (DEFCLASS ELEPHANT::SET-VALUED-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::SET-VALUED-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::SET-VALUED-EFFECTIVE-SLOT-DEFINITION)
; ELEPHANT::SET-VALUED-SLOT-DEFS
; ELEPHANT::SET-VALUED-SLOT-NAMES
; (DEFCLASS ELEPHANT::ASSOCIATION-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::ASSOCIATION-DIRECT-SLOT-DEFINITION)
; (DEFCLASS ELEPHANT::ASSOCIATION-EFFECTIVE-SLOT-DEFINITION)
; (METHOD INITIALIZE-INSTANCE :AFTER (ELEPHANT::ASSOCIATION-EFFECTIVE-SLOT-DEFINITION))
; ELEPHANT::ASSOCIATION-END-P
; ELEPHANT::ASSOCIATION-SLOT-DEFS
; ELEPHANT::ASSOCIATION-SLOT-NAMES
; ELEPHANT::ASSOCIATION-END-SLOT-NAMES
; ELEPHANT::GET-ASSOCIATION-SLOT-INDEX
; (METHOD ELEPHANT::GET-SLOT-DEF-INDEX (ELEPHANT::ASSOCIATION-EFFECTIVE-SLOT-DEFINITION T))
; ELEPHANT::ADD-ASSOCIATION-SLOT-INDEX
; ELEPHANT::REMOVE-ASSOCIATION-SLOT-INDEX
; (METHOD VALIDATE-SUPERCLASS (ELEPHANT:PERSISTENT-METACLASS STANDARD-CLASS))
; (METHOD VALIDATE-SUPERCLASS (STANDARD-CLASS ELEPHANT:PERSISTENT-METACLASS))
; (DEFGENERIC ELEPHANT::DATABASE-ALLOCATION-P)
; (METHOD SLOT-DEFINITION-ALLOCATION (ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; ELEPHANT::BIND-STANDARD-INIT-ARGUMENTS
; (METHOD CLOS:DIRECT-SLOT-DEFINITION-CLASS (ELEPHANT:PERSISTENT-METACLASS))
; (METHOD CLOS:EFFECTIVE-SLOT-DEFINITION-CLASS (ELEPHANT:PERSISTENT-METACLASS))
; (METHOD CLOS::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (ELEPHANT:PERSISTENT-METACLASS T T))
; ELEPHANT::FIND-CLASS-FOR-DIRECT-SLOT
; ELEPHANT::FIND-DIRECT-SLOT-DEF-BY-NAME
; ELEPHANT::FIND-SLOT-DEF-BY-NAME
; (METHOD ELEPHANT::FIND-SLOT-DEFS-BY-TYPE (ELEPHANT:PERSISTENT-METACLASS T))
; (METHOD ELEPHANT::FIND-SLOT-DEF-NAMES-BY-TYPE (ELEPHANT:PERSISTENT-METACLASS T))
; ELEPHANT::COUNT-TRUE
; (METHOD (SETF SLOT-DEFINITION-ALLOCATION) (T ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; (TOP-LEVEL-FORM 0)
; Loading fasl file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/metaclasses.ufasl
;;; Compiling file /home/lmc/lisp/elephant/elephant-1.0/src/elephant/classes.lisp ...
;;; Safety = 1, Speed = 3, Space = 1, Float = 1, Interruptible = 0
;;; Compilation speed = 0, Debug = 3, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on
; (TOP-LEVEL-FORM 0)
; (TOP-LEVEL-FORM 1)
; (DEFVAR ELEPHANT::*DEBUG-SI*)
; (METHOD INITIALIZE-INSTANCE :BEFORE (ELEPHANT:PERSISTENT))
; ELEPHANT::INITIAL-PERSISTENT-SETUP
; ELEPHANT::REGISTER-NEW-INSTANCE
; ELEPHANT::CHECK-VALID-STORE-CONTROLLER
; (DEFCLASS ELEPHANT:PERSISTENT-COLLECTION)
; (DEFCLASS ELEPHANT:PERSISTENT-OBJECT)

**++++ Error in (DEFCLASS ELEPHANT::CACHEABLE-PERSISTENT-OBJECT): 
  Invalid allocation type INSTANCE for slot-definition-allocation
; (METHOD SHARED-INITIALIZE :AROUND (ELEPHANT:PERSISTENT-METACLASS T))
; ELEPHANT::ENSURE-CLASS-INHERITS-FROM
; ELEPHANT::SUPERCLASS-MEMBER-P
; ELEPHANT::HAS-CACHED-SLOT-SPECIFICATION
; (METHOD CLOS:FINALIZE-INHERITANCE :AFTER (ELEPHANT:PERSISTENT-METACLASS))
; ELEPHANT::COMPUTE-DERIVED-INDEX-TRIGGERS
; (METHOD REINITIALIZE-INSTANCE :AROUND (ELEPHANT:PERSISTENT-METACLASS))
; ELEPHANT::BIND-SLOT-DEFS
; ELEPHANT::COMPUTE-BINDINGS
; (METHOD INITIALIZE-INSTANCE :AROUND (ELEPHANT:PERSISTENT-OBJECT))
; (METHOD SHARED-INITIALIZE :AROUND (ELEPHANT:PERSISTENT-OBJECT T))
;;;*** Warning in (METHOD SHARED-INITIALIZE :AROUND (ELEPHANT::CACHEABLE-PERSISTENT-OBJECT T)): Ignoring type declaration with illegal type ELEPHANT::CACHEABLE-PERSISTENT-OBJECT
; (METHOD SHARED-INITIALIZE :AROUND (ELEPHANT::CACHEABLE-PERSISTENT-OBJECT T))
; ELEPHANT::INITIALIZE-PERSISTENT-SLOTS
; ELEPHANT::INITIALIZE-SET-SLOTS
; ELEPHANT::INITIALIZE-FROM-INITARG
; ELEPHANT::GET-INIT-SLOTNAMES
; (SUBFUNCTION (DEFCLASS ELEPHANT:DROPPING-PERSISTENT-SLOT-DATA) (DEFINE-CONDITION ELEPHANT:DROPPING-PERSISTENT-SLOT-DATA))
; (DEFINE-CONDITION ELEPHANT:DROPPING-PERSISTENT-SLOT-DATA)
; (DEFINE-CONDITION ELEPHANT:DROPPING-PERSISTENT-SLOT-DATA)
; ELEPHANT::WARN-ABOUT-DROPPED-SLOTS
; (METHOD ELEPHANT::RECREATE-INSTANCE-USING-CLASS (T))
; (DEFGENERIC ELEPHANT::RECREATE-INSTANCE)
; (METHOD ELEPHANT::RECREATE-INSTANCE (ELEPHANT:PERSISTENT-OBJECT))
; (METHOD ELEPHANT::RECREATE-INSTANCE (ELEPHANT:PERSISTENT-COLLECTION))
; (METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS :AROUND (ELEPHANT:PERSISTENT-OBJECT T T T))
; (METHOD CHANGE-CLASS :BEFORE (ELEPHANT:PERSISTENT STANDARD-CLASS))
; (METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS :AFTER (ELEPHANT:PERSISTENT-OBJECT ELEPHANT:PERSISTENT-OBJECT))
; (METHOD CHANGE-CLASS :BEFORE (STANDARD-OBJECT ELEPHANT:PERSISTENT-METACLASS))
; (METHOD CLOS:SLOT-VALUE-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; (METHOD (SETF CLOS:SLOT-VALUE-USING-CLASS) (T ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; (METHOD CLOS:SLOT-BOUNDP-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; (METHOD CLOS:SLOT-BOUNDP-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT SYMBOL))
; (METHOD CLOS:SLOT-MAKUNBOUND-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT ELEPHANT::PERSISTENT-SLOT-DEFINITION))
; ELEPHANT::VALID-PERSISTENT-REFERENCE-P
; (SUBFUNCTION (DEFCLASS ELEPHANT:CROSS-REFERENCE-ERROR) (DEFINE-CONDITION ELEPHANT:CROSS-REFERENCE-ERROR))
; (DEFINE-CONDITION ELEPHANT:CROSS-REFERENCE-ERROR)
; (DEFINE-CONDITION ELEPHANT:CROSS-REFERENCE-ERROR)
; ELEPHANT::SIGNAL-CROSS-REFERENCE-ERROR
; (METHOD CLOS:SLOT-VALUE-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT T))
; (METHOD (SETF CLOS:SLOT-VALUE-USING-CLASS) (T ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT T))
; (METHOD CLOS:SLOT-MAKUNBOUND-USING-CLASS (ELEPHANT:PERSISTENT-METACLASS ELEPHANT:PERSISTENT-OBJECT T))
; (TOP-LEVEL-FORM 0)
; *** 1 error detected, no fasl file produced.
Warning: COMPILE-FILE warned while performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
         #<ASDF:CL-SOURCE-FILE "classes" 21A4D99B>.
Warning: COMPILE-FILE failed while performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
         #<ASDF:CL-SOURCE-FILE "classes" 21A4D99B>.
Error: erred while invoking #<ASDF:COMPILE-OP NIL 21A3A02F> on
       #<ASDF:CL-SOURCE-FILE "classes" 21A4D99B>
  1 (continue) Retry performing #<ASDF:COMPILE-OP NIL 21A3A02F> on
               #<ASDF:CL-SOURCE-FILE "classes" 21A4D99B>.
  2 Continue, treating #<ASDF:COMPILE-OP NIL 21A3A02F> on #<ASDF:CL-SOURCE-FILE "classes" 21A4D99B>
    as having been successful.
  3 (abort) Return to level 0.
  4 Return to top loop level 0.

Type :b for backtrace, :c <option number> to proceed,  or :? for other options

CL-USER 2 : 1 > 