* (software-version)
"Linux version 2.4.18-686-smp (herbert@gondolin) (gcc version 2.95.4 20011002 (Debian prerelease)) #1 SMP Sun Apr 14 12:07:19 EST 2002"
NIL
* (machine-version)
"X86"
* (lisp-implementation-version)
"18e 2003-03-28--17-00-33 src-head"
* (setq *load-verbose* t)
T
* (setq *compile-verbose* nil)
NIL
* "CMU Common Lisp 18e 2003-03-28--17-00-33 src-head, running on spe140
With core: /house/janson/cmucl-20030328T172037-i686/lib/cmucl/lib/lisp.core
Dumped on: Fri, 2003-03-28 11:14:05-05:00 on debian
See for support information.
Loaded subsystems:
Python 1.1, target Intel x86
CLOS based on Gerd's PCL 2003/03/22 16:15:17
"
"CMU Common Lisp 18e 2003-03-28--17-00-33 src-head, running on spe140
With core: /house/janson/cmucl-20030328T172037-i686/lib/cmucl/lib/lisp.core
Dumped on: Fri, 2003-03-28 11:14:05-05:00 on debian
See for support information.
Loaded subsystems:
Python 1.1, target Intel x86
CLOS based on Gerd's PCL 2003/03/22 16:15:17
"
* (setq *compile-print* nil)
NIL
*
(require :gray-streams)
; Loading #p"/house/janson/cmucl-20030328T172037-i686/lib/cmucl/lib/subsystems/gray-streams-library.x86f".
T
* (setq EXTENSIONS:*GC-VERBOSE* nil)
NIL
* (setq EXTENSIONS:*INLINE-EXPANSION-LIMIT* 2)
2
* (load "load")
; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/load.lisp".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/library/define-system.lisp".
; In: DEFMETHOD EXECUTE-SYSTEM-OPERATIONS (CONS CONS)
; (DEFMETHOD EXECUTE-SYSTEM-OPERATIONS
; (# # &AUX EFFECTIVE-SYSTEMS EFFECTIVE-COMPONENTS ...)
; (DECLARE #)
; (WHEN # #)
; ...)
; --> PROGN PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *SYSTEMS* *OPERATIONS*)
; (DECLARE #)
; (DECLARE #)
; (DECLARE #)
; ...)
; Note: Declaring special variable *OPERATIONS* to be ignored.
;
; Note: Declaring special variable *SYSTEMS* to be ignored.
;
; In:
; LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *SYSTEMS* *OPERATIONS*)
; #'(LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *SYSTEMS* *OPERATIONS*)
; (DECLARE #)
; (DECLARE #)
; (DECLARE #)
; ...)
; Note: Declaring special variable *OPERATIONS* to be ignored.
;
; Note: Declaring special variable *SYSTEMS* to be ignored.
;
; Compilation unit finished.
; 2 notes
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/sysdcl.lisp".
;;; Loading #p"/house/janson/cmucl-20030328T172037-i686/lib/cmucl/lib/subsystems/gray-streams-library.x86f".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/patch/cmucl.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/library/de/setf/utility/package.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/library/de/setf/utility/string.lisp
; In: DEFUN CONCATENATE-STRING*
; (COND (# # # # STRING) (T ""))
; --> IF COND IF PROGN
; ==>
; ""
; Note: Deleting unreachable code.
;
; (DEFUN CONCATENATE-STRING* (LIST &AUX # STRING #)
; (DECLARE # # #)
; (COND # #))
; Warning: The binding of STRING is not a (VALUES &OPTIONAL BASE-STRING &REST T):
; NIL
;
; Note: Deleting unreachable code.
;
; (MAKE-STRING LENGTH)
; ==>
; LENGTH
; Note: Deleting unreachable code.
;
; --> MAKE-ARRAY EXTENSIONS:TRULY-THE KERNEL:ALLOCATE-VECTOR
; ==>
; LENGTH
; Note: Deleting unreachable code.
;
; (COND (# # # # STRING) (T ""))
; --> IF PROGN
; ==>
; STRING
; Note: Deleting unreachable code.
;
; (STRINGP ELT)
; Note: Deleting unreachable code.
;
; (LENGTH ELT)
; ==>
; ELT
; Note: Deleting unreachable code.
;
; (DOTIMES (I #) (DECLARE #) (SETF # #) (INCF INDEX))
; --> DO BLOCK LET TAGBODY UNLESS COND IF NOT IF >= IF <
; ==>
; I
; Note: Deleting unreachable code.
;
; (SETF (SCHAR STRING INDEX) (CHAR ELT I))
; --> COMMON-LISP::%SCHARSET COMMON-LISP::%ASET THE
; ==>
; STRING
; Note: Deleting unreachable code.
;
; #'(LAMBDA (REST &AUX #) (ETYPECASE ELT # # #) (WHEN ELT #))
; Note: Deleting unreachable code.
;
; (CONCATENATE-STRING* ELT)
; Note: Deleting unreachable code.
;
; (WHEN ELT (INCF LENGTH #))
; --> COND IF
; ==>
; ELT
; Note: Deleting unreachable code.
;
; (INCF LENGTH (LENGTH ELT))
; --> LET* +
; ==>
; LENGTH
; Note: Deleting unreachable code.
;
; In: DEFUN STRING+
; (SETF (FIRST DESIGNATOR) (MAKE-STRING 1 :INITIAL-ELEMENT DESIGNATOR))
; --> COMMON-LISP::%RPLACA
; ==>
; DESIGNATOR
; Warning: Result is a BASE-CHAR, not a (VALUES &OPTIONAL CONS &REST T).
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/library/de/setf/utility/string.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/library/de/setf/utility/conditions.fasl".
Warning: redefining SIMPLE-CONDITION-FORMAT-ARGUMENTS
Warning: redefining SIMPLE-CONDITION-FORMAT-CONTROL
; In: LAMBDA (#:G1557 #:G1558 #:MEMF1559)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/library/de/setf/utility/test.lisp
; In: DEFUN TEST-OUTPUT
; (DEFUN TEST-OUTPUT (&KEY #)
; (DECLARE #)
; (FLET #
; #))
; Note: Variable WINDOW-TITLE-P defined but never used.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/library/de/setf/utility/test.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/package.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/clifs/inference-system-classes.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/clifs/inference-units.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-parameters.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/atn-parser/atn-classes.lisp
; In: DEFMETHOD BIND-NET (ATN)
; (ETYPECASE EDGE (PUSH-ATN-EDGE #) (JUMP-ATN-EDGE #) (OR-ATN-EDGE #) ...)
; --> LET COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-classes.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-macros.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/ebnf-tokenizer.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/atn-parser/ebnf-to-atn-translator.lisp
; In: DEFMETHOD PRINT-OBJECT (BNF-QEXPR T)
; (TYPECASE OBJECT
; (BNF-ONE-EXPR NIL)
; (BNF-PLUS-EXPR "+")
; (BNF-OPT-EXPR "?")
; ...)
; --> LET COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN RECLASSIFY-BNF-SYMBOLS
; (TYPEP BNF-SYMBOL 'BNF-CELL-SYMBOL)
; --> C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN ENSURE-CATEGORY-OBJECTS
; (TYPECASE EDGE (CAT-ATN-EDGE #) (OR-ATN-EDGE #))
; --> LET COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN BUILD-ATN-LEXICON
; (TYPEP LHS 'BNF-INDIRECT-CAT-SYMBOL)
; --> C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/ebnf-to-atn-translator.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/atn-parser/atn-macro-to-canonic-form.lisp
; In: DEFMETHOD ATN-CANONIC-FORM ((EQL 'DEFLEXICON) T)
; (TYPEP X 'BNF-TABLE-CELL)
; --> C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN ENSURE-DEF-OBJECT
; (TYPEP DEF 'BNF-TABLE-CELL)
; --> C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-macro-to-canonic-form.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/ebnf-grammar.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/atn-parser/atn-runtime.lisp
; In: DEFUN COLLECT-ASSOCIATION-LIST
; (DECF COUNT)
; --> LET*
; ==>
; (SETQ COUNT #:G6)
; Note: Doing signed word to integer coercion (cost 20), for:
; The first argument of CHECK-FIXNUM.
;
; In: DEFUN COLLECT-ASSOCIATION-VECTOR
; (DECF COUNT)
; --> LET*
; ==>
; (SETQ COUNT #:G6)
; Note: Doing signed word to integer coercion (cost 20), for:
; The first argument of CHECK-FIXNUM.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-runtime.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/conditions.fasl".
; In: LAMBDA (#:G4195 #:G4196 #:MEMF4197)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN #))
; Note: Variable CONDITION defined but never used.
;
; Note: Variable STREAM defined but never used.
;
; In: LAMBDA (#:G4212 #:G4213 #:MEMF4214 #:MEMF4215)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/atn-parser/atn-lisp-compiler.lisp
; In: DEFMETHOD COMPILE-ATN-SYSTEM (ATN-SYSTEM)
; (DEFMETHOD COMPILE-ATN-SYSTEM
; (# &KEY COMPILE # LOAD ...)
; "compile an atn system. may be directly evaluated oremitted to a file and compiled from there."
; (DECLARE #)
; ...)
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA
; (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *GRAMMAR-SYSTEM
; PCL::.REST-ARG.)
; (DECLARE #)
; (DECLARE #) ..)
; Note: Declaring special variable *GRAMMAR-SYSTEM to be ignored.
;
; In: DEFMETHOD COMPILE-ATN-SYSTEM (STRING)
; (DEFMETHOD COMPILE-ATN-SYSTEM
; (# &REST KEYS &KEY # ...)
; "compile a bnf grammar to an atn system and from there to a lisp parser implementation."
; (DECLARE #)
; ...)
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *GRAMMAR PCL::.REST-ARG.)
; (DECLARE #)
; (DECLARE #)
; (DECLARE #)
; ...)
; Note: Declaring special variable *GRAMMAR to be ignored.
;
; In: DEFMETHOD COMPILE-ATN-SYSTEM (PATHNAME)
; (DEFMETHOD COMPILE-ATN-SYSTEM
; (# &REST KEYS &KEY &ALLOW-OTHER-KEYS)
; "read a bnf grammar from a file and compile it to a parser."
; (DECLARE #)
; ...)
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA
; (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *GRAMMAR-PATHNAME
; PCL::.REST-ARG.)
; (DECLARE #)
; (DECLARE #) ..)
; Note: Declaring special variable *GRAMMAR-PATHNAME to be ignored.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-lisp-compiler.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/atn-parser/atn-regex.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/parameters.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/cllib.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/base/utils.lisp
; In: DEFUN MAKE-FILE-URL
; (ETYPECASE DEFAULTS (# # #) (STRING #) (PATHNAME #) ...)
; --> LET COND IF TYPEP LET OR LET IF OR TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN MAKE-URI
; (ETYPECASE BASE (FILE-URL #) (NULL #) (PATHNAME #) ...)
; --> LET COND IF COND IF COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/utils.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/parsetable.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/vector-stream.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/base/www-utils-ersatz.lisp
; In: DEFUN HTTP::COPY-VECTOR-PORTION
; (LOOP FOR IDX1 UPFROM FROM-START ...)
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF
; ==>
; (< IDX1 #:G0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; ==>
; (< IDX2 #:G1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; ==>
; (< IDX1 #:G0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; (SETF (AREF TO-VECTOR IDX2) (AREF FROM-VECTOR IDX1))
; --> COMMON-LISP::%ASET LET*
; ==>
; (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; (AREF FROM-VECTOR IDX1)
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; (LOOP FOR IDX1 UPFROM FROM-START ...)
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF
; ==>
; (< IDX1 #:G0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; ==>
; (< IDX2 #:G1)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; (AREF FROM-VECTOR IDX1)
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; (SETF (AREF TO-VECTOR IDX2) (AREF FROM-VECTOR IDX1))
; --> COMMON-LISP::%ASET LET*
; ==>
; (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
; Note: Forced to do full call.
; Unable to do inline array store (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The third argument is a T, not a (COMPLEX SINGLE-FLOAT).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array store (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The third argument is a T, not a SINGLE-FLOAT.
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; (LOOP FOR IDX1 UPFROM FROM-START ...)
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF
; ==>
; (< IDX1 #:G0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; Unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/www-utils-ersatz.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/base/tokenizer.lisp
; In: DEFUN HASH-STRING
; (WITH-STACK-SUBSTRING (STR STRING :START START :END ...)
; (NSTRING-UPCASE STR) (SXHASH STR))
; --> LET* OR LET IF OR LENGTH
; ==>
; STRING
; Note: Deleting unreachable code.
;
; (WITH-STACK-SUBSTRING (STR STRING :START START :END ...) (SXHASH STR))
; --> LET* OR LET IF OR LENGTH
; ==>
; STRING
; Note: Deleting unreachable code.
;
; (DEFUN HASH-STRING (STRING &OPTIONAL # END #)
; (DECLARE #)
; (ECASE HASH-MASK # #))
; ==>
; (C::%FUNCALL
; #
; STRING
; START
; NIL)
; Warning: A possible binding of END is not a (VALUES &OPTIONAL FIXNUM &REST T):
; NIL
;
; In: LAMBDA (MAX-SIZE)
; (MOD PRIME+2 FACTOR)
; --> BLOCK LET
; ==>
; (REM NUMBER KERNEL::DIVISOR)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/base/tokenizer.lisp
; In: DEFUN PRIME-NUMBERS-FOR-TOKENIZER-SYSTEM
; (MOD PRIME+2 FACTOR)
; --> BLOCK LET
; ==>
; (REM NUMBER KERNEL::DIVISOR)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN SELECT-TABLE-SIZE
; (ERROR
; "Attempt to create a tokenizer table larger than the maximum implementation size, ~D."
; *TOKENIZER-MAXIMUM-SIZE*)
; Note: Deleting unreachable code.
;
; In: DEFUN MAP-TOKENS
; (ENTRY-VALID-P ENTRY)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN %REHASH-TOKENIZER
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+ + MOD BLOCK LET
; ==>
; (REM NUMBER KERNEL::DIVISOR)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; --> 1+ + MOD BLOCK LET IF AND IF NOT IF ZEROP
; ==>
; (= REM 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; Note: Unable to open code because:
; Operands might not be the same type.
;
; --> 1+ + MOD BLOCK LET IF
; ==>
; (+ REM KERNEL::DIVISOR)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (LOOP WITH HASH = (ENTRY-HASH ENTRY) ...)
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP <
; --> DECF LET*
; ==>
; (- #:G2 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G2) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (LOOP WITH COUNT FIXNUM = ...)
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY SETQ LENGTH
; ==>
; (C::VECTOR-LENGTH VECTOR)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY * (*)).
;
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ
; --> SETQ AREF LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+ + MOD BLOCK LET IF
; ==>
; (+ REM KERNEL::DIVISOR)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a REAL, not a (SIGNED-BYTE 32).
; The result is a REAL, not a (SIGNED-BYTE 32).
; etc.
;
; (LOOP WITH COUNT FIXNUM = ...)
; --> BLOCK LET LET ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ
; --> SETQ AREF LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; (LOOP WITH HASH = (ENTRY-HASH ENTRY) ...)
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP <
; --> DECF LET*
; ==>
; (- #:G2 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G2) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; In: DEFUN %TOKENIZE
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (VALUES # NIL) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+ +
; ==>
; (MOD (THE FIXNUM HASH) (THE FIXNUM #))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G27 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G27) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G27 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G27) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN TOKENIZE
; (%TOKENIZE TOKENIZER (TOKENIZER-MASK TOKENIZER) STRING START ...)
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WHEN COND IF AND IF
; ==>
; (MULTIPROCESSING::ERROR-CHECK-LOCK-P LOCK)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G27 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G27) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G27 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G27) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN %GET-TOKEN
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (VALUES # NIL) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+ +
; ==>
; (MOD (THE FIXNUM HASH) (THE FIXNUM #))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN GET-TOKEN
; (%GET-TOKEN TOKENIZER (TOKENIZER-MASK TOKENIZER) STRING START ...)
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WHEN COND IF AND IF
; ==>
; (MULTIPROCESSING::ERROR-CHECK-LOCK-P (TOKENIZER-LOCK TOKENIZER))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET WITH-LOCK-HELD MULTIPROCESSING:WITH-LOCK-HELD LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> C::%WITHIN-CLEANUP RETURN-FROM PROGN WITH-TOKENIZING LET*
; --> WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN INSERT-TOKEN
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (SETF # TOKEN) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+ +
; ==>
; (MOD (THE FIXNUM HASH) (THE FIXNUM #))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; (SETF (ENTRY-VALUE ENTRY) TOKEN)
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL
; ==>
; (C::%FUNCALL #'(SETF ENTRY-VALUE) #:G16 #:G17)
; Warning: Result is a T, not a (VALUES T T).
;
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (SETF # TOKEN) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (SUBSEQ STRING START END)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR VECTOR CONS NULL), not a SIMPLE-BASE-STRING.
;
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (SETF # TOKEN) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G11 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G11) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN REMOVE-TOKEN
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (MULTIPLE-VALUE-PROG1 # # #) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+ +
; ==>
; (MOD (THE FIXNUM HASH) (THE FIXNUM #))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; (VALUES NIL)
; --> PROG1 LET
; ==>
; #:G23
; Warning: This is not a (VALUES T T):
; NIL
;
; (WITH-TOKENIZING (TOKENIZER HASH-MASK HASH STRING START ...) :ENTRY-FOUND
; (MULTIPLE-VALUE-PROG1 # # #) :ENTRY-NOT-FOUND ...)
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G19 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G19) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY PROGN WHEN COND IF AND IF AND IF AND IF
; --> AND %%TOKEN-EQUAL ECASE LET COND IF COND IF PROGN %%TOKEN-EQUAL STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR NULL BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP < DECF LET*
; ==>
; (- #:G19 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G19) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY IF ANSI-LOOP::LOOP-REALLY-DESETQ SETQ
; --> COMPUTE-NEXT-INDEX LET + THE OR LET IF OR SETQ COMPUTE-SECONDARY-OFFSET
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> LET* WITH-FAST-ARRAY-REFERENCES LET LOCALLY LOOP BLOCK LET LET LET
; --> ANSI-LOOP::LOOP-BODY LET TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN COLLISION-MAP
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+ +
; ==>
; (MOD (THE FIXNUM HASH) (THE FIXNUM #))
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; (LOOP WITH NUM-COLLISIONS FIXNUM = ...)
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP <
; --> DECF LET*
; ==>
; (- #:G16 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G16) 0)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; (INCF TOTAL-COLLISIONS NUM-COLLISIONS)
; --> LET*
; ==>
; (+ TOTAL-COLLISIONS NUM-COLLISIONS)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; (INCF DELETED-ENTRY-COLLISIONS)
; --> LET*
; ==>
; (+ DELETED-ENTRY-COLLISIONS 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; (AREF TABLE INDEX)
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-ARRAY.
;
; (LOOP WITH NUM-COLLISIONS FIXNUM = ...)
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP <
; --> DECF LET*
; ==>
; (- #:G16 1)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; --> BLOCK LET LET LET ANSI-LOOP::LOOP-BODY LET TAGBODY WHEN COND IF MINUSP
; ==>
; (< (DECF #:G16) 0)
; Note: Forced to do GENERIC-< (cost 10).
; Unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; Unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; (COMPUTE-SECONDARY-OFFSET HASH MODULUS)
; --> 1+
; ==>
; (+ (MOD # #) 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a REAL, not a FIXNUM.
; etc.
;
; (AREF TABLE INDEX)
; --> LET*
; ==>
; (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
; Note: Forced to do full call.
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY
; (COMPLEX SINGLE-FLOAT) (*)).
; The result is a T, not a (COMPLEX SINGLE-FLOAT).
; Unable to do inline array access (cost 5) because:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a T, not a SINGLE-FLOAT.
; etc.
;
; (INCF TOTAL-COLLISIONS NUM-COLLISIONS)
; --> LET*
; ==>
; (+ TOTAL-COLLISIONS NUM-COLLISIONS)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a NUMBER, not a FIXNUM.
; Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a NUMBER, not a (SIGNED-BYTE 32).
; The result is a NUMBER, not a (SIGNED-BYTE 32).
; etc.
;
; (INCF DELETED-ENTRY-COLLISIONS)
; --> LET*
; ==>
; (+ DELETED-ENTRY-COLLISIONS 1)
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a NUMBER, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a NUMBER, not a FIXNUM.
; etc.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/tokenizer.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/base/conditions.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xqdm-namespaces.lisp
; In: DEFGENERIC QNAME-EQUAL
; (DEFGENERIC QNAME-EQUAL
; (Q1 Q2)
; (:DOCUMENTATION
; "compare qualified names: values are equal if eq or, if not yet interned, they can be
; literally equal and in the same qualified name context.
..))
; --> PROGN PUSH LET* LET* DEFMETHOD PROGN PCL::LOAD-DEFMETHOD LIST* LAMBDA
; --> FUNCTION MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS LET*
; --> PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET BLOCK IF IF IF
; --> STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
; ; [Last message occurs 2 times]
; --> PROGN PUSH LET* LET* DEFMETHOD PROGN PCL::LOAD-DEFMETHOD LIST* LAMBDA
; --> FUNCTION MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS LET*
; --> PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET BLOCK IF IF LET IF
; --> STRING=
; ==>
; (COMMON-LISP::STRING=* C::STRING1 C::STRING2 C::START1 C::END1 ...)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
; The second argument is a (OR SYMBOL
; BASE-CHAR
; BASE-STRING), not a SIMPLE-BASE-STRING.
; ;
; Warning: KEYWORD also exports the following symbols:
; (:STOPPED :MAKE-OLD-FP-SAVE-LOCATION :PROMPT :DEFINITION-SOURCE
; :WAIT-FUNCTION-ARGS ...)
; ;
; Warning: KEYWORD also exports the following symbols:
; (:STOPPED :MAKE-OLD-FP-SAVE-LOCATION :PROMPT :DEFINITION-SOURCE
; :WAIT-FUNCTION-ARGS ...)
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-namespaces.fasl".
Warning: KEYWORD also exports the following symbols:
(:STOPPED :MAKE-OLD-FP-SAVE-LOCATION :PROMPT :DEFINITION-SOURCE
:WAIT-FUNCTION-ARGS :WARN :IN-OUT :? :C :E :H :L :FOREIGN-FUNCTION :SIGSEGV
:TRANSLATION :THRESHOLD :NUMBER-STACK-P :NORMAL :RELATIVEP :LAST-OFFSET
:ISO8601 :INFINITY-DATA := :UNDEFINED-FUNCTION :FASL-FILE-IMPLEMENTATION :D
:QUALITY :SGI :N :SHLVL :S :SIMPLE :LINUX :LINES :ARGLIST :STORAGE-INFO
:CONSTRAINTS :UTF-16-21 :DATE-FIRST :CONDITION-REPORT :VERIFY-EXISTANCE
:COMPLEX-ARG1 :INOUT :CONS-ENTRIES :O :DE.SETF.UTILITY.CONDITIONS
:STANDARD-ARGUMENT-LOCATION :Q :ENTRIES-INFO :U :HELP :B :COSTS :INITARG :G
:MINIMAL :IGNORE-TYPES :BOTH :VERBOSE :ENCAPSULATE :SAVE :ENUM :DOTTED :R :A
:HIS :PROCEDURES :CLASS :TAB :Z :BREAKPOINT :ENTRY-POINTS :VALUATION
:LOGNAME :IMMEDIATE-CONSTANT-SC :LABELLERS :HASH1 :UNTRUENAME :HASH5
:SUPPORT-ROUTINES :INDEX-VECTOR :HASH-VECTOR :USER :SAP-MAKER :EARLY-METHOD
:ERROR-ON-MISMATCH :GENERATOR-COST :READ :ACLPC :NOP :FOLLOW-LINKS
:ROOT-STRUCTURES :RUNTIME :GENERAL-ENTITY-DEFINITION :RETURN :DIR-STRUCT
:COUNTS :TABLE :COLNUM :ALTERNATE-SCS :%NAME :SLOT-NAME :GEN :METHOD-CLASS
:OPTIMIZE :THEN :PREFIX-NAMESPACE :DEFAULT-MINUTES :SIGINT :VARS :ESCAPE
:PROGRESS :ID-ATTR-NODE-P :P :%STATUS :PREFILTER :ACCESSOR :PRIMITIVE
:ENVIRONMENT-NAME :LAMBDAS :SETF.CONDITIONS :DE.SETF.UTILITY.TEST :CATCH
:HASH-FUNCTION :NUM-ARGS :OPTIMIZER :ALL :OVERWRITE :SUPER
:DE.SETF.UTILITY.IMPLEMENTATION :REAL :RESUMER :FRESH-LINE-P
:DIRECT-ANNOTATION-MODEL :UNPARSED :TEST-CONSTRAINT :SPACE :INTERESTING
:PRINT-HERALD :LAST-LOCATION-RETRIEVED :EFFECTS :ITERATION-KEYWORDS :PRIN1
:NON-PACKED :TYPES :PRINC :PRINT-MERIDIAN :DOWNFROM :PRINT :TOP-N :DEFINER
:DEBUG-VARIABLES :MV-CALL :COMPILER :FILL-POINTER :IF-INPUT-DOES-NOT-EXIST
:ALLOW :PV-TABLE :INFO-ARGS :UNINTERNED :LOAD-OBJECT :MORE-ARGS :ATHLON
:AFFECTED :NODE :SIGPROF :PLACE :COMPILER-MACRO :INTERACTIVE-P :WRITES
:UNLESS :VALUE2 :DEBUG-INFO :BY :UTF8 :PLIST :DISPLACED-INDEX-OFFSET
:XML-WARN :EQ-TEST :SCHEDULED-REAL-TIME :NEXT* :SHELL :SIGIO :ITS :OUT
:ORIGINAL-SOURCE :COMPILE-FROM :PRINT-FUNCTION :ALLEGRO :X86 :LE :CIRCLE
:LOCATIONS :CASE :OPERANDS :SIGVTALRM :DEFAULT-DEFAULT :EVAL-STACK-TOP
:XPATH :MATCH :SETS :PARAMETERS :HOUR :SLOT-NAMES :TRANSLATIONS :USE-BY
:CONSTANT-SCS :NO-CHANCE :STACK-GROUP :PARSED-VOPS :ISO88591 :SYMBOL-TYPES
:REPORT-RECURSION :%USE-LIST :SINGLE-CHAR-WILD :|VC: ID|
:REANALYZE-FUNCTIONS :MORE-ARGS-TYPE :ALTERNATIVE :ARG-TYPES :DEBUG-VARS :DO
:IGNORE-IT :LOAD-TOPLEVEL :CALL-SITE :PV-SIZE :%FUNCTION :ADDR-TYPE
:COMMON-LISP-USER :VERBOSITY :GENERATOR :ALLOC-TRANS :ATSIGNP :PAGES
:READABLY :PRINT-BANNER :FRAME :RFC1123 :EXPORT :ABSOLUTE :FORM :BACKLOG
:EXITS :TABLE-VAR :NEAREST :FILE-NAME :TRANSLATE :OUTPUT-STATE :XML-ERROR
:CONSTRUCTOR :SIZE :SAVE-P :DE.SETF.XML.NAMES.IMPLEMENTATION :EXECUTE-TESTS
:SIGN-EXTEND :THE :MOVE-ARGUMENT :STRICT :VALUE3 :LABELLED
:INPUT-EOF-FUNCTION :VERBOSE-P :DEPENDENCIES :RESET-TIME :SYSTEM-DESCRIPTION
:INTERRUPTS :POSN :CMU :INIT-FORM :SPECIAL-BIND :PATCH-TABLE :DEBUG-VARIABLE
:DEBUG-FUNCTION :UNPARSE-HOST :IN-INDEX :FORCE :INPUT-VARIABLES :VERSION>=
:TEST-NOT :CLOSUREP :DOCUMENT :LISTEN :TOP-LEVEL-FORM-INDEX :%RUN-TIME
:IBUF-TAIL :CAPITALIZE-FIRST :INITIAL-FUNCTION :FOR-KEYWORDS :DOWNTO :CHECK
:UTF1612 :STACK-SLOT :CONFIRM-COMPILE :KEYWORDS :UNKNOWN-KEYWORD
:INVALID-OBJECT :MCL :INITIALIZE-CONDITION :INTERN-ONLY :NOTES :TYPE-NAME
:ATTRIBUTES :EXCLUDE :NAMESET-TOKENIZER :VALUE1 :MISER-WIDTH :CPL :MOK
:CONDITION-VECTOR :TERMS :CIRCULARITY-TABLE :STRICT-RESULT :COMMON-LISP
:*CLASS.TEST-UNIT* :BLOCK-COMPILE :SUCC :SC-NAMES :STEP :START-COLUMN
:FIND-PACKAGES :SUFFIX :BLOCK-END :EVER-USED :LAMBDA-LIST :ELSE :BACKEND
:GOVERNMENT :RETURNS :EXPORT-ONLY :NO-CLM :IEEE-FLOATING-POINT
:PER-LINE-PREFIX :NUM-RESULTS :EXTENDED :SPECIAL-FORM :WHERE-FROM
:ALLEGRO-VERSION>= :GID :NO-COMPILER :PID :UID :WINDOW-TITLE :RECURSE
:TEMP-VARIABLE :SPILLED-VOPS :CONTENTS :SIGNALED :ALIEN-REP :SVSET
:DE.SETF.XML.CONDITIONS :ARG-TEMPS :FLAG :LOCK :UNBINDABLE-PREFIX-P
:BYTE-COMPILED-ENTRY :IGNORE :SIMPLE-CONTINUABLE-CONDITION :TOTAL-CONSUMES
:VOID :EXTENSIONS :HIGH :INEXACT :FIN-FUNCTION :FUNCTIONAL :FUNCTION-END
:KIND :FULL :PARTIALLY :NULL :SAVE-SP :COLONP :PREFILTERS :FROM-DEFCLASS-P
:CODE-COMPONENT :PARSE-STATE-ACTIVE-P :DEFAULT :CURRENT :DELETE-ORIGINAL
:|NSC: Prefix Immutable| :CLOSURE :SIGWINCH :RESTRICTED-TNS :REHASH-SIZE
:DERIVED-TYPE :VIRTUAL-LOCATION :SORT :KNOWN-VOLATILE :CONSTANT-VALUE
:NAMESPACE-DECLARATION :SIGTERM :DEFAULT-MONTH :ENCAPSULATED :INITIAL-VALUE
:COUNT-SPACES :IBMRT :CONTEXT-DECLARATIONS :LOAD-TIME-VALUE :NATURALIZE-GEN
:WHILE :OUTPUT-TERMS :RETURN-LIST :IF-OUTPUT-EXISTS :ASSEMBLY-ROUTINE
:RESULT-TEST :AMOUNT :EQUAL-TABLE :SUPPRESS :UTF-16 :ACCESSORS :WAIT-TIMEOUT
:QUERY :BREAK :WARNING-FUNCTION :ENDS :SC-NUMBERS :MOST-SPECIFIC-LAST
:*VERSION* :CONDITION-ACTION :SIGTTIN :FAST-FUNCTION :LIVE :COMPLEX-UNION
:ARG-DOCUMENTATION :DOWN :HZ :NEXT :NZ :LIVE-TNS :CONFLICTS :CCL
:QUERY-COMPILE :LIBRARIES :BINDING-STACK :PROCEDURES-TABLE :PATH :ENUMERABLE
:VALUE4 :EQUAL-FUNCTION-NAME :IN-BUFFER :PRINT-WEEKDAY :QUALIFIERS :FUN
:ERROR :EACH :COMPLEXP :SIGUSR2 :UNDEFINED :TYPE-SYMBOLS :ERGEBNIS :NAME
:OBUF-TAIL :WILD :ARG-TN :QUERY-LOAD :BREVITY :MAX-ARGS :DATA
:FUNCTION-END-COOKIE :PARSE-STATE-SOURCE :ANSI :NO-ERROR :WORD :LAST
:ARGS-LAMBDA-LIST :SLOT-DEFINITION :INSTANCE-SLOTS-LAYOUT :SITE-INIT
:PREDICATE-TYPES :PRINT-PARSE-STATE :%SHADOWING-SYMBOLS
:CONDITION-CONTINUE-FORMAT-CONTROL :REPORT-CONDITION :REFERENCES :FORCE-P
:GERDS-PCL :WARNINGS :BOGUS-LRA :VALUE5 :ALWAYS :GENERATE-CALL-SEQUENCE
:ALIST :INTERN :SIZE-FUNCTION :PARAMETER-ENTITY-DEFINITION :NEXT-METHOD-CALL
:SCALE :SIGCHLD :UNADJUSTED :MAKE-LOAD-FORM-FUN :PCL-STRUCTURES :ELEMENT-P
:FLAVOR :NEW-VERSION :RESULT-TN :FILE-LENGTH
:DE.SETF.XML.PROCESS.IMPLEMENTATION :DE.SETF.XML.CODEC.IMPLEMENTATION
:NATIVE :HASH-TABLE :SHORT :DIRECT-SUPERCLASSES :FORMAT-ARGUMENTS :EXIT-CODE
:FROM :SIGHUP :FASL-PATHNAME :CACHE :ENTRY-FOUND :I486 :PRIMITIVE-TYPE-OF
:ALIAS-TNS :INTERACTIVE :CONTINUE :PREPOSITION-GROUPS :NOTE :NLE :EOF
:MORE-RESULT-COSTS :RECOMPILE :LOAD-TN :DUPLICATE
:LISPWORKS-PERSONAL-EDITION :MULTIPLE-READER-LOCKS :NOT
:MAKE-OLD-FP-PASSING-LOCATION :INITIATE :IMPORTANT :SELF-P
:DIRECT-DEFAULT-INITARGS :BINDS :SINGLE :SIGXCPU :LEVEL :FIELD
:ALLOW-OTHER-KEYS :END-BREAKPOINT :UTF16LE :SPECIALP :UNFILTERED :PRIORITY
:NEW-COMPILER :SPECIFIED :NUM-MORE-ARGS :XML-WARNING :PRETTY :SPECIFIER
:SYSTEM-CLASS :TARGET-FUNCTION :UTF16 :FULL-CALL :OLD-PCL :RPLACD :ATN-WFST
:EXPORT-FROM :MAIN-ENTRY :RULES :AND :END :INITFORM-P :PRESERVE :PYTHON
:EXTRACT-GEN :METHOD-COMBINATION :IS-STATIC :BYTE-COMPILE :LIST-FIRST
:REGISTER-WORDS :SOURCE-FORM-CACHE :INPUT :DEFAULT-HOURS :SIGUSR1 :COERCE
:RESERVE-LOCATIONS :PWD :LEXICAL-VARIABLES :TAGS :PTY :ARGUMENTS
:SPECIAL-ARG-TYPES :NO-HEMLOCK :FLUSH :CONDITIONAL-P :DE.SETF.XML
:CONDITIONAL :PRINT-SECONDS :ALTERNATE-METACLASS :DEBUG-LIVE-TNS
:INSTRUCTION-FORMATS :WIRE :ZERO :EXTERN :FAST-MODE :WHICH :REANALYZE
:ORIGINAL-SOURCE-PATH :PROCESS-GROUP :BEFORE-ADDRESS :FILE :DEBUG-SOURCE
:PACKAGE :ACCRUED-EXCEPTIONS :RENAME-AND-DELETE :ARG :NUMBER :KILLED
:EXPRESSIONS :PRODUCER :CONDITION-NAME :SYSTEM-FILES :ELSEWHERE-PC
:VARIABLES :YEAR :IMPORT-FROM :BLOCK-BOUNDARY :FLAG-VARIABLE :NREQ
:RANDOM-MT19937 :CONDITION :C-TYPE :COND :IBUF-HEAD :LISPWORKS4
:PRINTER-LIST :MACTCP-COMPATIBILITY :MULTIPLE :BORN :WORD-PREDICATE :SPECIAL
:ALLOCATION-CLASS :SEALED :TEST :TEMPORARY :BODY :EXPRESSION :SIGABRT :RHS
:NAMESPACE :WALK-FORM :CREATED :OBSOLETE :CONTINUE-FORMAT-CONTROL :MSG
:NO-PCL :GENERIC-FUNCTION-CLASS :DISPLAY :COMPILE-ALWAYS :NEEDING-REHASH
:SVAR :FORMAT-LENGTH :SEGMENT-SAP :NUMERIC :DELETED-BLOCK-START :OVERRIDE
:CAR-TYPE :METHOD-SPEC :COMPLAINT :FAILED-OPTIMIZATIONS :VALUES
:SIMPLE-UNION :PRINTNAME :FOR :|WFC: Legal Character| :CONSUMES :APPEND
:INITIALLY :KEYWORDS-P :IDENTITY :INTERNAL-XML-ERROR :OPTIMIZE-INTERFACE
:START :PTY-PROCESS-GROUP :CUR-LABELS :NEGATION :EXTERNAL-SYMBOLS :KEYP
:OBUF-LENGTH :ENCLOSING-SOURCE :OLD-FP :PPC :MAXIMUM :REQUIRED :ACTIONS
:ANONYMOUS :SPARC :META-SB-NAMES :EDGES :NON-LOCAL-ENTRY :TEXT/PLAIN
:CONDITION-ALL :OUTPUT-LATER :IMPORT-ONLY :GECOS :ALPHA :DOCUMENT-ELEMENT
:BOUNDP :DYNAMIC-STATE :RELATIVE-PACKAGE-NAMES :ASSIGNMENT
:METHOD-NAME-DECLARATION :HASH2 :MEMBER :MODULUS :HASH6 :PREV :PREREQUISITES
:FILTERED :PRINT-LEVEL :REGISTER-SAVE-PENALTY :RESULT-TYPES :RESULT
:ENTRY-NOT-FOUND :WALK-CALL :STRING+ :COMPONENTS :COLINC :COMPILE
:INCLUDE-ARGS :ASSOC :SIGNED :ALIEN-INTERNALS :AUXS :CHOOSE
:REHASH-THRESHOLD :CHARACTER :SAVE-ONCE :POST-MORE :BINDING-STACK-SIZE
:BASE-FILE :TEMPLATE-NAMES :USE :INTERRUPT-CONTEXTS :TEST-FUN :TEST-FUNCTION
:CHARACTER-SET :INITIAL-BINDINGS :HEAD :POSITIVE-INFINITY :BNFP-JAVA
:ODD-LENGTH :SAFE :REMOTEHOST :UNPARSE-DIRECTORY :|VC: Notation Attributes|
:BUFFER :CONTINUABLE-ERROR :META-SC-NAMES :HEADER :GENERATE-RETURN-SEQUENCE
:LINE :MIN-ARGS :MODIFY-PACKAGE :OLD-DEFINITION :%REAL-TIME :AFTER :MISER
:ELEMENT-TYPE :PREFIX-LENGTH :UTF-16-12 :ASSEMBLER-RESOURCES :GENGC
:PORTABLE-COMMONLOOPS :SIGFPE :CACHED-CONSTANT :UNKNOWN-RETURN-PARTNER
:RETURN-PC :MORE-ARGUMENT :PRINT-OBJECT :INVALIDATE :DEFTESTS
:CYCLE-FUNCTION :CHAR-POS :INST-SPACE :GENERATOR-LAMBDA :UNSPECIFIC
:CONDITION-AFTER :DAY :VALID :FUNCTIONS :FOREIGN-DATA :SAME-AS
:MAKE-NLX-SP-TN :INCLUSIVE :WILD-ARGS :ROW :UTF1621 :ALIGNMENT
:DENORMALIZED-OPERAND :REFS :NON-LOCAL-GO :PRINTERS :SIGQUIT :USING :TIME
:BUFFERING :VERSION :STATIC :REVERSE :ERROR-CHECK
:MAKE-INITIALIZED-CONDITION :SEQUENCE-TYPE :USASCII :LIST :BREAK-AFTER
:FUNCTION :LANGUAGE :COMPONENT :MOVE-ARGS :SHADOWING-IMPORT-TO :START2
:DWORD :PARSETABLE :STACK-SIZE :SIGKILL :SUPERSEDE :RAW :WHEREIN :OVERFLOW
:UNTIL :CONSTANTS :LOCAL-LEXICAL-EXIT :FILES :PACKAGE-VERSION :HAIRY
:NEW-FUNCTIONS :STRUCT :STACK-CHECKING :MULTIPLE-READER-SINGLE-WRITER
:SIGTSTP :MOST-SPECIFIC-FIRST :SECTION :DEFEXCEPTION :FROM-END :OPTIONAL
:TYPE-RESTRICTIONS :POST-REST :LINE-RELATIVE :UNBOUND :SB-NAMES
:COMPILE-LOAD :CACHE-NAME :INHERITS :COMPILE-TOPLEVEL :CODE-OBJECT
:EXPECTED-TYPE :MORE :CONTEXT :TOKENIZER :EXTERNAL :START-PC :PURGE-PACKAGE
:USE-LABEL :PATH-KEYWORDS :DELAY :SEGMENT :LEXICAL-VAR :NLX-ENTRY
:CATEGORIES :DEFAULT-SECONDS :DEPORT-GEN :DEFAULT-INITARGS :HASH-FUN
:SIGXFSZ :ONE-FUNCTION :TERM :MAKE-TEST-UNIT :PREDICATE-NAME
:SHADOWING-IMPORT-FROM :READS :LOCATION-PRINT-NAME :EVAL :LOCAL :M68K
:BATCH-MODE :CONSED :WHEN :PREDICATE-FORM :IGNORE-THIS-ARG :STATUS-HOOK
:ENTRY :LIKE :WAIT :START-POSITIONS :EVAL-STACK :FLAGS :NEW-DEFINITION
:GUARD :NEWEST :MANDATORY :FUNCTION-NAME :CLEAR-INPUT :MAYBE-INLINE :SIGALRM
:NEXT-FREE-KV :TRAPS :COMPUTING-CACHE-P :PROFILE :NE :RESET-FUNCTION
:COMPLEX :CHECK-FOR-SUBDIRS :SMALLER :MAKE-RETURN-PC-SAVE-LOCATION :RPLACA
:|VC: Name Token| :ATN-SOURCE :TYPE-PREDICATES :UNREAD :LINE-LENGTH
:XML-CONDITION :REST-ARG-P :PRED :DE.SETF.UTILITY.STRING :PPRINT-DISPATCH
:HASH-CODE :XQDM :SXHASH-TOKENIZATION :IF-ERROR-EXISTS :PLUS-INTEGER
:WITH-NAMESPACES :PRINT-ALL :BITS :NOPE :MEMBERS :BYTE-ORDER
:*DEFAULT-PREFIX-STRING* :VIRTUAL :KNOWN-RETURN :MAKE-PARSE-STATE
:CONSTRAINT :CONSTANT-TNS :INTERNAL-WRITER-FUNCTION
:MAKE-RETURN-PC-PASSING-LOCATION :FETCH-FUNCTION :LOADABLE-PCL :SIMPLE-=
:PACKAGE-NOT-FOUND :START1 :REGISTER :*PACKAGE-OPERATIONS* :SCHEDULER-P
:SYSTEM-LOAD-TIME :ANSI-CL :FORM-NUMBER-MAPPING-TABLE :INLINE-EXPANSIONS
:VALUE :NCONC :WHERE :INPUT-VECTOR :NODE-VAR :FLOAT :PCL-CLASS :WARNING
:PRINT-AFTER :WFST :REALLY-ASSERT :VARIANT :ANNOTATION-MODEL :NGE :WRITER
:FUN-HOOKS :INVALID-VALUE-FOR-UNESCAPED-REGISTER-STORAGE :NONE
:FUNCTION-START :DECLARE :SIGNAL :LETS :FAILED :CMU18E :MOVE-VOPS :TK1
:MINIMUM :TRANSFORMS :CALL-WALK :STRUCT-SET :CORMANLISP :BOUT :UPTO
:CHARACTER-ATTRIBUTE-TABLE :SOUT :DEFAULT-YEAR :SPECIALIZERS
:ENVIRONMENT-START :INTERNAL-ERROR :LOAD-INIT-FILE :FORMAT-CONTROL
:PROPERTIES :METHODS :POSITIONS :META-SC-NUMBERS :DELAYED :NA
:INPUT-BUFFER-P :DELETED :SIMPLE-INTERSECTION :XPARSER :DEFAULT-NAMESPACE
:CURRENT-CATCH-BLOCK :INITIAL-ARGS :TARGET :IGNORES :UTF-8 :DIES
:INSTRUCTION-FLAVORS :ITEM :BIG-ENDIAN :PROCEDURE :EDIT :SINGLE-VALUE-RETURN
:XML-UTILS :TYPE-DEFINITION :LARGER :PRINT-SPACES :WRITE-DATE :UNTRACED
:ZONE :DESTRUCT-LAYOUT :UNWIND-PROTECT :NO-CLX :TRACE :PRODUCES
:INTERPRETER-FUNCTION :CONSEQUENT :STANDARD :SAFETY :TYPE= :BYTE-ANNOTATE
:IBUF-LENGTH :REPEAT :FORMAT :DE.SETF.XML.INTERFACE :TYPEP :DTYPE :NB :SB
:INTERN-TEST :FASL-FILE-VERSION :END1 :INACTIVE :INITIALIZING :CONT :SB-LIST
:INTERPRETED-CLOSURE :EXPORTN :LOAD-TIME-CODE-FIXUP :PARSE :TLF-NUMBER
:ENABLE :CONDITION-CONTINUE-FORMAT-ARGUMENTS :HOME :OPTIONS
:OPCODE-COLUMN-WIDTH :STRUCTURE :CONSED-L :READER :MULTI-CHAR-WILD
:ABBREVIATED :COST :PPRO :HOST :INITIAL-OFFSET :FORCE-TO-STACK
:CONDITION-NAMESPACE :CLOSURE-P :EXECUTE :PRINTED :OUTPUT-VARIABLES
:FELL-THROUGH :PRINT-TIMEZONE :MORE-RESULT :SECTION-END :MORE-ARG-COSTS
:ARGUMENT :PRINT-SUMMARY :NC :DIVIDE-BY-ZERO :COMPLEX-SUBTYPEP-ARG2
:DEFAULTS :READ-ONLY :FORMS :READ-TIME :ANSWER-VARIABLE :HASH-BITS :IGNOREP
:PRODUCTION :IR2-CONVERT :NET :NAMESPACE-PRINTNAME :STYLE
:AUTO-COMPILE-DEFAULT :INITFUNCTION :INTERNAL-SYMBOLS :SPECIFITY :AROUND
:*TEST-OUTPUT* :CODE-LOCATION :PROCESS-COMMAND-LINE :MINUTE
:COERCE-TO-GENERIC-FUNCTION :SLOT :BEGINNING :CDR-TYPE :PURE :LISP :BYTES
:PORT :MORE-RESULTS-TYPE :FINISH-OUTPUT :HUSHLOGIN :US-ASCII :CGC
:DRAFT-ANSI-CL-2 :UNINTERN-TEST :PATHNAME :FASL-FILE-TYPE :CHOICES :FD
:MACROS :INSTRUCTIONS :VARIABLE :CAT :INITFORM :DEFUN-ONLY :INST-HOOK
:CONTINUE-FORMAT-ARGUMENTS :24-BIT :FINITE :GRAY-STREAMS
:*TERMINAL-PARSER-ERROR-ACTION* :LTN-ANNOTATE :CSPEED :COMPLEX-INTERSECTION
:ARREST-REASONS :DEPOSIT-GEN :DE.SETF.XML.BASE.IMPLEMENTATION :SET-KNOWN
:INVALID :KEY :MAKE-UNKNOWN-VALUES-LOCATIONS :CONDITION-PARSE-STATE :UNIX
:BOOTABLE-PCL :LOCATION-COLUMN-WIDTH :REMAINING :GLOBAL :SIMPLE-SUBTYPEP
:%LAMBDA-LIST :64-BIT :AUTO-CLOSE :ENTRY-POINT :FAST :ERROR-FUN :DATE
:NO-LAMBDA-LIST :SOURCE-ANALYSIS :PREREQUISITE :RECOMPILE-SOME
:INITIAL-CONTENTS :LABELS :MAC :BREAK-ALL :LAYOUT :ARG-COSTS
:COMPILE-LOAD-ALWAYS :BE :GE :%ARREST-REASONS :COUNT :PE :COMPILED
:MOVE-ARG-VOPS :XQUERY :FILE-POSITION :LOAD :PARSE-STATE :DERIVE-TYPE
:CURRENT-CONFLICT :ALIASES :CURRENT-UNWIND-PROTECT-BLOCK :OFFSET-VAR :ARITY
:ATN-SYSTEM :NP :TYPE-PREDICATE :CUR-OFFS :HIERARCHICAL :CLEAR-OUTPUT
:NEGATIVE-INFINITY :NAMESPACE-EQUAL :CALL-LEXENV :PREDICATE-TYPE :POSITIVE
:ASSEMBLER-PARAMS :RESULT-LOAD-SCS :RUNNING :INITIAL-ELEMENT :CMUCLLIB
:CUTOFF :SIGBUS :JUST-DUMP-IT-NORMALLY :SPLIT-SEQUENCE :INSERTION-P
:FORCE-TO-MEMORY-P :RECURSIVE :SOURCES :IF :OF :PEEK-CHAR :%WHOSTATE :COMMON
:RENAME :CACHE-TYPES :VALID-MASK :XML-SYMBOLS :CONSTRUCTOR-SPECIALIZER
:LITTLE-ENDIAN :CONFIRM :VECTOR :MAKE-NLX-ENTRY-ARGUMENT-START-LOCATION
:DOC-STRING :OBJECT :MAKE-NFP-TN :LABEL :SOURCE-ROOT :BASE :TOKENS :LINK
:CMU18D :SUBCLASSES :DIRECT-SLOTS :%USED-BY-LIST :CODE-LOCATION-NUMBER
:SPLIT-STRING :SIGURG :TOKENIZER-NAME :ERROR-FUNCTION :SYSTEM-CONSTANT
:SPILLED-TNS :PREFIX :TN :EMITTER :INVERT :FINAL :TAGBODY :UNBOUNDED
:START-NAME :IF-SOURCE-NEWER :TOO-HAIRY :EXECUTE-TEST :PUNCTUATION-P :NG
:MAX-LOCATIONS :REF-ORDERING :SIZE-TEST :CLASS-SLOTS
:MODIFY-PACKAGE-OPERATION :TRACE-FILE :ANY-PRIMITIVE-TYPE :TRACE-NETS :VAR
:DATUM :UNPARSE :INLINEP :CONSTANT :MOVE :POLICY :TIMEZONE :USER-DATA
:INHERITED :HOOKS :FINALLY :XCONFORMANCE :HPPA :RUN-SCHEDULER :INDIRECT
:WRITE :COPY :BLOW-IT-OFF :ADJUSTED :BINARY :EXPORT-THROUGH :MODPACKAGE
:ELEMENT-DEFINITION :PASSED :LOCAL-PART :|VC: No Duplicate Types| :DIGITOOL
:READERS :PCL-FUNCALLABLE-INSTANCE-SLOTS :LOAD-PACKAGE :INIT-FUNCTION
:PASSWORD :BNFP :DEBUG :TOP-LEVEL :INPUT-TERMS :OPENMCL :%NICKNAMES
:KEY-SIZE :RECURSION :TRUENAMEP :DIRECTORY :GCS :BIND :SCS :UNARY-COERCE
:SIGILL :ARGS :EQ-TABLE :NOTINLINE :FILTERING :SYSTEM-KEYWORD :TEMPVARS
:CODES :DIRECTION :COLUMN :HASH3 :CURRENT-VALID-LOCATIONS :DEFAULT-DAY
:HASH7 :MACRO :HASH0 :HASH4 :PO :ADJUSTABLE :SPECIFIED-SAVE
:GENERIC-FUNCTION :UPFROM :AE :ELSEWHERE-P :EXITED :INCLUSIVE-PERMITTED
:DEFAULT-PRINTER :AMBIGUOUS :ABORTED :UNUSED :SAVE-TN :EMIT-NOP
:IDENTITY-WITH-ONE-ARGUMENT :COMMON-ID :BACK :SIGCONT :NEEDS-NEXT-METHODS-P
:SAP :DOCS :LINKAGE-TABLE :LOCAL-CONFLICTS :GLIBC2 :EMIT-FUNCTION
:NEXT-VECTOR :TEMP-TEMP :%RUN-REASONS :SMALL :CURRENT-EXCEPTIONS :XRELEASE
:CHECK-CONSTRAINT :PRINTFUNCTION :DESCRIPTION :DYNCOUNT-INFO :WRITERS :HASH
:CONTENT-NAMES :LOCAL-CALL :TYPE :GENERA :ARG-CHECK :PROBE :WEAK-P :CALLTIME
:ABOVE :|VC: Element Content| :DOUBLE :UNSPECIFIED :ABORT :BYTE
:UNKNOWN-RETURN :DISPLACED-TO :VARIABLE-LENGTH :DATA-GRAM :MORE-ENTRY :CLEAR
:FOREIGN :ALIEN-STACK :TYPE-NUMBER :ERROR-STREAM :FIELDS
:DE.SETF.XML.MODEL.IMPLEMENTATION :LENGTH :LISP-REP :NICKNAMES :LOAD-SOURCE
:NEW-METHOD :SECTION-START-LINE :MAKE-NUMBER-STACK-POINTER-TN :CANON-TRANSLS
:VOP-VAR :COMMENT :ALWAYS-LIVE :LOAD-COSTS :SEALS :USE-LABELS :+DELETED+
:ARGUMENT-PRECEDENCE-ORDER :DISPATCH-TABLES :CALLS :FIXED :WIRED-TNS
:SUBSPACE :|VC: No Duplicate Tokens| :INLINE-EXPANSION :DEFINE-SYSTEM :MP
:SIGN-EXTEND-P :DECLARED :SLOT-NAME-LISTS :ACTION :INSTANCE :NAMED
:TEMPLATES :NAMES :VARIANT-COST :DE.SETF.XML.MODEL :FUNNY
:GENERATOR-FUNCTION :END2 :WHAT :DEFINED :CODE :INTERNAL/CALLS :LOCAL-NUMBER
:MODE :PMAX :SOURCE :CUR-OFFS-HOOKS :SECTION-COLUMN :INLINE :PURGE :BUGS
:ISO-8859-1 :EVAL-NAME :INIT :TRACE-STREAM :SPEED :ENSURE-PACKAGE :RAW-TYPE
:VALID-STRUCTURES :STREAM :CALLERS-P :NEGATIVE :CONSED-H :N-BIN
:SCHEDULED-RUN-TIME :CACHE-INDEX :INSTRUCTION-ALIGNMENT :SOURCE-INFO
:CALL-LIST :MIME-TYPE :OPERATION :PREDICATE-FUNCTION :EDIT-PACKAGE
:LOCAL-CONSTANT :LOAD-TIME-VALUE-FIXUP :ENTRY-TABLE :REF-KNOWN :MAYBE :CL
:CONTROL :ACTIVE :NL :IBUF-SAP :FILTERED-VALUES :LOCAL-PART-EQUAL
:ALLOCATION :CALLERS :|VC: Enumeration| :INITIAL :ID :SIGTTOU
:MAKE-ARGUMENT-COUNT-LOCATION :LITERAL :INFO :COLLECT :MAIL :EXPANSIONS
:TAIL :QNAME-EXTENT :BEFORE :CL-HTTP :READTABLE-CASE :DYNAMIC :INITIAL-P
:PV-TABLE-SYMBOL :NON-LOCAL-EXIT :LEXENV :EQ :PATHNAME-TYPE :RESULT-TYPE
:CONTROL-CYCLE-FUNCTION-NAME :CONC-NAME :UNION :MONTH :OBUF-SAP :NAMESTRING
:SEQUENCE :BLOCK-START :PROPERTY-LIST :PURIFY :MCASE :SYNONYMS
:SECTION-RELATIVE :LET :DEBUG-ENVIRONMENT :LEAF :AUTO-COMPILE :SYSTEM
:REST-P :BEEP :GLOBAL-TN-COUNTER :LHS :CLASSES :CONCATENATE-STRING
:INITIALIZE :CORE-DUMPED :ARRAY :CELL :NLX-INFO :ASSUMED :PERCENT :SIGIOT
:BREAKPOINT-NUMBER :|VC: Entity Name| :CODESIZE :CONTINUATION
:SPECIALIZED-ELEMENT-TYPE :LAST-FORM-RETRIEVED :DISASSEM-PARAMS :ORIGINAL
:SUPPLIED-P :PARSER-NAME :DEVICE :VALUES-RECEIVERS :PREDICATE
:SOURCE-PATHNAME :UPPER :UNLABELLED :TABLE-FREE :MESS-UP :GENSYM :IN
:KEYWORD :MORE-ARGS-ENTRY-POINT :ARG-INFO :%FEATURES :INSIDE-BLOCK :BLOCKS
:NFP :CLEAN-PACKAGE :ALIEN-STACK-POINTER :ALIEN-STACK-SIZE :ARGP
:PRIMITIVE-TYPE-ALIASES :EMPTY :NEXT-OFFS :PENTIUM :LAST-BLOCK-COUNT :BELOW
:CONTROL-STRING :META-PRIMITIVE-TYPE-NAMES :PINNED :UNDERFLOW :CREATE
:ERROR-OUTPUT :PRINT-LENGTH :FAIL :SLOTS :CUSTOMARY-CASE :START-TIME :ALIEN
:TAIL-P :SOCKET :PAGE-SIZE :ALIAS :GENSYMS :REOPTIMIZE :UPCASE :TIMEOUT
:INTERNAL-ERRORS :DE.SETF.XML.NODE.IMPLEMENTATION :TAIL-SET :PATHNAME-NAME
:IO :NO :NORMAL-TNS :TO :PCL :RADIX :DEPTH :RIGHT-MARGIN :ALLOW-OTHERS
:EXTERNAL-FORMAT :XTESTS :DIR :OUTPUT-FILE :SIGN-EXTENDED :WILD-INFERIORS
:SOFT :CONVERTED-ONCE :LISP-STREAM :LISPWORKS :CL-USER :SC :AFPA :TEST-FN
:OPERATIONS :MISC :PARSE-STATE-CONDITION :HASH-NEW :PROBLEM :STUB :ADDR-LIST
:TARGETS :IMPLICIT-FOR-REQUIRED :MASK :FUNCALLABLE-INSTANCE
:PRECISION-CONTROL :ENTRY-FUNCTION :BUFFER-INDEX :MOVE-COSTS :UNARY-TYPEP
:UP :HAIRY-SLOTS :GET-COMMAND :IF-DOES-NOT-EXIST :ENTRIES
:FUNCALLABLE-INSTANCE-NAME :PRIMITIVE-TYPE-NAMES :XUTIL :VANILLA
:ENVIRONMENT :REDUCE :ENV :53-BIT :HOW :LOW :REST :MORE-RESULTS :HER
:PRINT-NAME :HISTORY :RESULT-COSTS :FLAG-ID :CLASS-INFO :MV-LET :WITH
:DATAGRAM :TABLES :SET :GLOBAL-FUNCTION :UNPARSE-ENOUGH :ARGUMENT-TEST
:WALK-FUNCTION :BLOCK :VARIANT-VARS :SAP-FORM :OPTIONALS :SOURCE-PATH
:POSITION :FAST-SAFE :OUTPUT :CLOSE :RELATIVE :DOWNCASE
:CHARACTER-MACRO-TABLE :CAPITALIZE :SIGSTOP :METACLASS :ELEMENTS :CHECKER
:CMU17 :SPECIFIED-SAVE-TNS :CMU18 :LOWTAG :NLX-ENTRIES :MAKE-CALL-OUT-TNS
:MAKE-DYNAMIC-STATE-TNS :FILL :KILL :CLEANUP :DOCUMENTATION :NLX-ENTRY-P
:ELEMENT-SIZE :PV-CELL :CONSERVATIVE-FLOAT-TYPE :USE-ONLY :STRING
:LABEL-HASH :DOC-STRING-ALLOWED :MORE-CONTEXT :SUFFIX-LENGTH :FAILURE
:REHASH-TRIGGER :FINISHED :LOAD-IF :FIND-TEST :METHOD :DOTW :TOP-LEVEL-XEP
:FDEFINITION :SECTIONP :INFO-ARG-COUNT :SELECT-COMPONENT-FORMAT :LOOP
:DEFINITION :OR :SUCCESSORS :UNKNOWN :SHADOW :ELSEWHERE-START :WORDS :MODULE
:DISP :WAIT-RETURN-VALUE :ADDRESS-SIZE :UNPARSE-FILE :SPECVAR :ANNONYMOUSP
:COMPILED-CLOSURE :TYPE-KEYWORDS :NODES :HANDLER :LINEAR :CONTROL-STACK-ID
:SUBTYPEP :PRINTER :MAKE-STACK-POINTER-TN :DEFAULT-WEEKDAY :TEST-UNIT
:APPLYP :DEFAULT-ZONE :WAIT-FUNCTION :LAMBDA :NEW-ASSEM :REUSE-ADDRESS
:COMPLEX-= :FUNCTION-MAP :OFFSET :TOP-LEVEL-FORM :UNEXPORT :GLOBAL-CONFLICTS
:COPIER :EXTENSION :TEMPS :PRESERVE-WHITESPACE :GROUPS :START-USES :VERSION<
:REPORT-FUNCTION :STACK-FRAME-SIZE :PREDICATES :DIMENSIONS :ALLOWP :CHARPOS
:NS :OPTIONAL-DISPATCH :BIN :NEXT-METHOD-P-P :ARGUMENT-COLUMN :NO-CHECK
:CONSTANT-PREFIX-P :SBCL :INTERFACE-COOKIE :REPORT :PRIMITIVE-TYPE
:COMPLEX-SUBTYPEP-ARG1 :INTERNAL-READER-FUNCTION :STATE :ENCLOSING-OBJECT
:UNSURE :RUN-REASONS :PARSE-STATE-STACK :COMPLEX-TOP-LEVEL :LONG
:SLOT-ACCESS :PACKAGES :DE.SETF.UTILITY.PACKAGE :DOTTED-LIST :DONT-KNOW
:CALL-METHOD-ARGS :INHERITANCE-DEPTH :EVAL-WHEN :SET-TRANS :CHECK-FEATURE
:PARSE-STATE-TERM :COMPONENT-TNS :OPERATOR :NUMBER-ENTRIES :NAE :SIGPIPE
:COOKIE :XML-CHECK-CHAR-CODES :IN-SUPERS :GENCGC :PATTERNS :REF-TRANS :RT
:SYSTEM-PATHNAME :XEP :LEXEMS :INTERACTIVE-FUNCTION :UTF16BE :RETURN-PC-PASS
:SUBSTRUCTURE :START-BREAKPOINT :RESULTS :DECLARATIONS :LOCATION-NUMBER
:DEFTEST :FORCE-OUTPUT :ORDER :PACKAGE-PATHNAME :T-OK :PRODUCES-SSET
:ADDR-PRINT-LEN :INPUT-FUNCTION :ARG-LOAD-SCS :INDEX :CLASS-NAME :INDEX-VAR
:SIGSTKFLT :INCLUDE :ROUNDING-MODE :CURRENT-FILE :LOWER :TEMP :KEYS
:PARSE-STATE-NON-TERMINAL :POSSIBILITIES :SECOND :NBE :INITARGS
:NON-LOCAL-LEXICAL-EXIT :ERROR-FILE :INTERPRETED :MOVE-FUNCTIONS :ASCII
:CURRENT-SIZE :NU :DEFSTRUCT-ACCESSOR-SYMBOL :IF-EXISTS :ALIGN :SIGTRAP
:TITLE :COMPUTE-ONLY :INFO-ENVIRONMENT :MISFEATURES :CALL-NEXT-METHOD-P
:JUNK-ALLOWED :MORE-COUNT :FUNSTATE :PARAMS :PER-LINE-PREFIX-END :INTERNAL
:RESTART-P)
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-parameters.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-character-classes.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xqdm-classes.lisp
; In: DEFMETHOD MAKE-INSTANCE (ABSTRACT-CLASS)
; (XML-ERROR "instantiation precluded for class: ~s." CLASS)
; Warning: Function has an odd number of arguments in the keyword portion.
;
; In: DEFMETHOD PRINT-OBJECT (|*-content| T)
; (DEFMETHOD PRINT-OBJECT
; (# STREAM &AUX EXPR NAME)
; (SETF NAME #)
; (COND # # # #))
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA FUNCTION
; --> MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::CALL-NEXT-METHOD-BIND LET FLET
; --> PCL::BIND-ARGS LET* PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET
; --> BLOCK SETQ IF IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFMETHOD (SETF CHILDREN) (SEQUENCE DOC-NODE)
; (DEFMETHOD (SETF CHILDREN) (# #) (WITH-SLOTS # DOC # #))
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA FUNCTION
; --> MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::CALL-NEXT-METHOD-BIND LET FLET
; --> PCL::BIND-ARGS LET* PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET
; --> BLOCK LET SYMBOL-MACROLET PCL::PV-SET-SLOT-VALUE LET MULTIPLE-VALUE-BIND
; --> LET UNLESS COND IF NOT IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-classes.fasl".
; In: LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. SPEC)
; (TYPEP #:G93 'ABSTRACT-NAME)
; --> C::%INSTANCE-TYPEP AND IF AND KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. TYPE)
; (ETYPECASE SUPERTYPE (XML-SCHEMA-DATATYPES::TYPE-SPECIFIER) (NAME #))
; --> LET COND IF COND IF TYPEP LET OR LET TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xsd-types.lisp
; In:
; DEFMETHOD TYPE.ELEMENT-TYPE (XML-SCHEMA-DATATYPES::LIST-TYPE-SPECIFIER)
; (DEFMETHOD TYPE.ELEMENT-TYPE (#) (WITH-SLOTS # SPEC #))
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA FUNCTION
; --> MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS LET*
; --> PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET BLOCK LET
; --> SYMBOL-MACROLET LET IF IF IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In:
; DEFMETHOD TYPE.DIRECT-SUPERTYPES (XML-SCHEMA-DATATYPES::TYPE-SPECIFIER)
; (ETYPECASE SUPERTYPE (XML-SCHEMA-DATATYPES::TYPE-SPECIFIER) (NAME #))
; --> LET COND IF COND IF TYPEP LET OR LET TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xsd-types.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/conditions/names/conditions.fasl".
; In: LAMBDA (#:G6375 #:G6376 #:MEMF6377 #:MEMF6378 #:MEMF6379)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6386 #:G6387 #:MEMF6388 #:MEMF6389 #:MEMF6390)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6397 #:G6398 #:MEMF6399 #:MEMF6400 #:MEMF6401)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6408 #:G6409 #:MEMF6410 #:MEMF6411 #:MEMF6412 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6420 #:G6421 #:MEMF6422 #:MEMF6423 #:MEMF6424 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6432 #:G6433 #:MEMF6434 #:MEMF6435 #:MEMF6436)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/conditions/node/conditions.fasl".
; In: LAMBDA (#:G6443 #:G6444 #:MEMF6445 #:MEMF6446 #:MEMF6447)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6454 #:G6455 #:MEMF6456 #:MEMF6457 #:MEMF6458)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/conditions/model/conditions.fasl".
; In: LAMBDA (#:G6465 #:G6466 #:MEMF6467 #:MEMF6468 #:MEMF6469 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6477 #:G6478 #:MEMF6479 #:MEMF6480 #:MEMF6481 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6489 #:G6490 #:MEMF6491 #:MEMF6492 #:MEMF6493 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6501 #:G6502 #:MEMF6503 #:MEMF6504 #:MEMF6505 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6513 #:G6514 #:MEMF6515 #:MEMF6516 #:MEMF6517)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6524 #:G6525 #:MEMF6526 #:MEMF6527 #:MEMF6528 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6536 #:G6537 #:MEMF6538 #:MEMF6539 #:MEMF6540 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6548 #:G6549 #:MEMF6550 #:MEMF6551 #:MEMF6552 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6560 #:G6561 #:MEMF6562 #:MEMF6563 #:MEMF6564 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6572 #:G6573 #:MEMF6574 #:MEMF6575 #:MEMF6576 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6584 #:G6585 #:MEMF6586 #:MEMF6587 #:MEMF6588 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6596 #:G6597 #:MEMF6598 #:MEMF6599 #:MEMF6600 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6608 #:G6609 #:MEMF6610 #:MEMF6611 #:MEMF6612 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6620 #:G6621 #:MEMF6622 #:MEMF6623 #:MEMF6624 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6632 #:G6633 #:MEMF6634 #:MEMF6635 #:MEMF6636 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6644 #:G6645 #:MEMF6646 #:MEMF6647 #:MEMF6648 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6656 #:G6657 #:MEMF6658 #:MEMF6659 #:MEMF6660 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6668 #:G6669 #:MEMF6670 #:MEMF6671 #:MEMF6672 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6680 #:G6681 #:MEMF6682 #:MEMF6683 #:MEMF6684)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6691 #:G6692 #:MEMF6693 #:MEMF6694 #:MEMF6695 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6703 #:G6704 #:MEMF6705 #:MEMF6706 #:MEMF6707 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6715 #:G6716 #:MEMF6717 #:MEMF6718 #:MEMF6719)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6726 #:G6727 #:MEMF6728 #:MEMF6729 #:MEMF6730 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6738 #:G6739 #:MEMF6740 #:MEMF6741 #:MEMF6742 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6750 #:G6751 #:MEMF6752 #:MEMF6753 #:MEMF6754 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6762 #:G6763 #:MEMF6764 #:MEMF6765 #:MEMF6766 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6774 #:G6775 #:MEMF6776 #:MEMF6777 #:MEMF6778)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6785 #:G6786 #:MEMF6787 #:MEMF6788 #:MEMF6789 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6797 #:G6798 #:MEMF6799 #:MEMF6800 #:MEMF6801 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6809 #:G6810 #:MEMF6811 #:MEMF6812 #:MEMF6813 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6821 #:G6822 #:MEMF6823 #:MEMF6824 #:MEMF6825 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6833 #:G6834 #:MEMF6835 #:MEMF6836 #:MEMF6837)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6844 #:G6845 #:MEMF6846 #:MEMF6847 #:MEMF6848)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6855 #:G6856 #:MEMF6857 #:MEMF6858 #:MEMF6859 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6867 #:G6868 #:MEMF6869 #:MEMF6870 #:MEMF6871)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6878 #:G6879 #:MEMF6880 #:MEMF6881 #:MEMF6882 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6890 #:G6891 #:MEMF6892 #:MEMF6893 #:MEMF6894 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6902 #:G6903 #:MEMF6904 #:MEMF6905 #:MEMF6906 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6914 #:G6915 #:MEMF6916 #:MEMF6917 #:MEMF6918 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6927 #:G6928 #:MEMF6929 #:MEMF6930 #:MEMF6931 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G6939 #:G6940 #:MEMF6941 #:MEMF6942 #:MEMF6943 ...)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xqdm-operators.lisp
; In: DEFMETHOD PREFIX (ELEM-NODE)
; (DEFMETHOD PREFIX (#) (DECLARE #) (WITH-SLOTS # NODE #))
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA FUNCTION
; --> MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS LET*
; --> PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET BLOCK LET
; --> SYMBOL-MACROLET LET MULTIPLE-VALUE-BIND LET UNLESS COND IF NOT IF TYPEP
; --> LET OR LET IF OR TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFMETHOD PREFIX (ATTR-NODE)
; (DEFMETHOD PREFIX (#) (DECLARE #) (WITH-SLOTS # NODE #))
; --> PROGN PCL::LOAD-DEFMETHOD PCL::LOAD-DEFMETHOD LIST* LAMBDA FUNCTION
; --> MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS LET*
; --> PCL::PV-BINDING PCL::PV-BINDING1 PCL::PV-ENV LET LET BLOCK LET
; --> SYMBOL-MACROLET LET MULTIPLE-VALUE-BIND LET UNLESS COND IF NOT IF TYPEP
; --> LET OR LET IF OR TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFGENERIC NODE-EQUAL
; #'NODE-EQUAL
; Note: Deleting unreachable code.
;
; In: DEFGENERIC WALK-NODE
; (DEFGENERIC WALK-NODE
; (NODE PREDICATE FUNCTION)
; (:METHOD :AROUND # # #)
; (:METHOD # #)
; ...)
; --> PROGN PUSH LET* LET* DEFMETHOD PROGN PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. *NODE PREDICATE FUNCTION)
; (DECLARE #)
; (DECLARE #)
; (DECLARE #)
; ...)
; Note: Declaring special variable *NODE to be ignored.
;
; In: DEFUN WALK-ELEMENT-DEFINITIONS
; (TYPEP NODE '(OR DOC-NODE HASH-TABLE DEF-ELEM-TYPE))
; --> LET OR LET IF OR LET TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFUN WALK-ELEMENTS
; (TYPEP NODE '(OR DOC-NODE ABSTRACT-ELEM-NODE))
; --> LET OR LET IF OR TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-operators.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xqdm-validation.lisp
; In: DEFMETHOD COMPUTE-VALIDATION-FUNCTION (|content-model|)
; (TYPECASE NAME (SYMBOL #) (ABSTRACT-NAME #) (T # #))
; --> LET COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFMETHOD BIND-NET (ATN)
; (TYPECASE X (STRING T) (PI-NODE T) (COMMENT-NODE T))
; --> LET COND IF COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
; In: DEFMETHOD VALIDATE-CONTENT (ELEMENT-ATN T)
; (ETYPECASE DATUM (# #) (STRING #) (PI-NODE #) ...)
; --> LET COND IF COND IF COND IF TYPEP C::%INSTANCE-TYPEP AND IF AND
; --> KERNEL:CLASS-CELL-TYPEP
; ==>
; (KERNEL:LAYOUT-OF C::OBJECT)
; Note: *Inline-Expansion-Limit* (2) exceeded, probably trying to
; inline a recursive function.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-validation.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/qname-resolution.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xquerydatamodel/xqdm-graph.lisp
; In: DEFGENERIC WRITE-NODE-GRAPH
; (DEFGENERIC WRITE-NODE-GRAPH (NODE STREAM) (:METHOD # #) (:METHOD # #) ...)
; --> PROGN PUSH LET* LET* DEFMETHOD PROGN PCL::LOAD-DEFMETHOD LIST* LAMBDA
; ==>
; #'(LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. NODE *STANDARD-OUTPUT*)
; (DECLARE #)
; (DECLARE #)
; (DECLARE #)
; ...)
; Note: Declaring special variable *STANDARD-OUTPUT* to be ignored.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-graph.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/node-path-walk.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-walk.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xquerydatamodel/xqdm-walk-accessors.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xparser/xml-parameters.lisp
; In: DEFUN BUFFER-STRING-SUBSEQ
; (- END START)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a NUMBER, not a DOUBLE-FLOAT.
; Unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a NUMBER, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN ADJUSTABLE-STRING-SUBSEQ
; (- END START)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; (REPLACE RESULT STRING :START2 START ...)
; Note: Unable to optimize due to type uncertainty:
; The second argument is a BASE-STRING, not a SIMPLE-BASE-STRING.
;
; (LENGTH STRING)
; ==>
; (C::VECTOR-LENGTH VECTOR)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a BASE-STRING, not a (SIMPLE-ARRAY * (*)).
;
; (- END START)
; Note: Forced to do GENERIC-- (cost 10).
; Unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a NUMBER, not a DOUBLE-FLOAT.
; Unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a NUMBER, not a SINGLE-FLOAT.
; etc.
;
; In: DEFUN RETURN-BUFFER-STRING
; (LENGTH STRING)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR VECTOR CONS NULL), not a (SIMPLE-ARRAY * (*)).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR VECTOR CONS NULL), not a VECTOR.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xparser/xml-parameters.fasl".
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xparser/conditions/codec/conditions.fasl".
; In: LAMBDA (#:G6989 #:G6990 #:MEMF6991 #:MEMF6992 #:MEMF6993)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
; In: LAMBDA (#:G7000 #:G7001 #:MEMF7002 #:MEMF7003 #:MEMF7004)
; (LET* (# # #)
; (DECLARE #)
; NIL
; (PROGN # #))
; Note: Variable CONDITION defined but never used.
;
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xparser/xml-stream-coding.lisp
; In: DEFMETHOD DECODING-STREAM-READER (STREAM (EQL :UTF-8))
; (XML-ERROR "unsupported unicode datum: ~s." (LIST BYTE1 BYTE2 BYTE3 BYTE4))
; Warning: Function has an odd number of arguments in the keyword portion.
;
; (XML-ERROR "illegal UTF-8 data: x~2,'0x." BYTE1)
; Warning: Function has an odd number of arguments in the keyword portion.
;
; (LOGAND (READ-BYTE-CODE) 63)
; Note: Forced to do static-function Two-arg-and (cost 53).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; ; [Last message occurs 3 times]
; In: DEFMETHOD ENCODING-STREAM-WRITER (STREAM (EQL :UTF-8))
; (XML-ERROR "unsupported unicode datum: ~s." CODE)
; Warning: Function has an odd number of arguments in the keyword portion.
;
; (LET (#)
; (DOTIMES # #))
; Note: Deleting unreachable code.
; ; [Last message occurs 2 times]
; (<= CODE 1023)
; --> IF >
; ==>
; CODE
; Note: Deleting unreachable code.
;
; (FUNCALL-FUNCTION.ARG FUNCTION.ARG (LOGIOR 192 #))
; --> FUNCALL FIRST CAR
; ==>
; FUNCTION.ARG
; Note: Deleting unreachable code.
;
; (<= CODE 65535)
; --> IF >
; ==>
; CODE
; Note: Deleting unreachable code.
;
; (FUNCALL-FUNCTION.ARG FUNCTION.ARG (LOGIOR 224 #))
; --> FUNCALL FIRST CAR
; ==>
; FUNCTION.ARG
; Note: Deleting unreachable code.
;
; (XML-ERROR "unsupported unicode datum: ~s." CODE)
; Note: Deleting unreachable code.
;
; (DOTIMES (X #) (FUNCALL-FUNCTION.ARG FUNCTION.ARG #))
; --> DO BLOCK LET TAGBODY PSETQ PSETF LET* MULTIPLE-VALUE-BIND LET 1+ +
; ==>
; X
; Note: Deleting unreachable code.
;
; (FUNCALL-FUNCTION.ARG FUNCTION.ARG (CHAR STRING X))
; --> FUNCALL FIRST CAR
; ==>
; FUNCTION.ARG
; Note: Deleting unreachable code.
;
; In: DEFMETHOD DECODING-STREAM-READER (STREAM (EQL :UTF-16-12))
; (FUNCALL-FUNCTION.ARG FUNCTION.ARG)
; --> FUNCALL C::%FUNCALL IF
; ==>
; (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
; Note: Unable to optimize because:
; Might be a symbol, so must call FDEFINITION at runtime.
;
; (LSH (READ-BYTE-CODE) 8)
; ==>
; (ASH (READ-BYTE-CODE) 8)
; Note: Forced to do full call.
; Unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a INTEGER, not a FIXNUM.
; Unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
;
; (+ (LSH # 8) (READ-BYTE-CODE))
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a INTEGER, not a FIXNUM.
; Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a INTEGER, not a (SIGNED-BYTE 32).
; etc.
;
; In: DEFMETHOD DECODING-STREAM-READER (STREAM (EQL :UTF-16-21))
; (FUNCALL-FUNCTION.ARG FUNCTION.ARG)
; --> FUNCALL C::%FUNCALL IF
; ==>
; (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
; Note: Unable to optimize because:
; Might be a symbol, so must call FDEFINITION at runtime.
;
; (LSH (READ-BYTE-CODE) 8)
; ==>
; (ASH (READ-BYTE-CODE) 8)
; Note: Forced to do full call.
; Unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a INTEGER, not a FIXNUM.
; Unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
;
; (+ (READ-BYTE-CODE) (LSH # 8))
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a INTEGER, not a FIXNUM.
; Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a INTEGER, not a (SIGNED-BYTE 32).
; etc.
;
;; Loading #p"/house/janson/XML-0-949-20030408T1846-CRLF/bin/cmuclfasl/code/xparser/xml-stream-coding.fasl".
;
;
; File: /house/janson/XML-0-949-20030408T1846-CRLF/code/xparser/xml-operators.lisp
; In: DEFUN MAKE-UNAME
; (SUBSEQ STRING 0 END)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR VECTOR CONS NULL), not a SIMPLE-BASE-STRING.
;
; (POSITION #\: NAMESTRING)
; Note: Unable to open code due to type uncertainty:
; The second argument is a (OR VECTOR CONS NULL), not a LIST.
;
; Note: Unable to open code due to type uncertainty:
; The second argument is a (OR VECTOR CONS NULL), not a SIMPLE-ARRAY.
;
; Note: Unable to optimize due to type uncertainty:
; The second argument is a (OR VECTOR CONS NULL), not a SIMPLE-BASE-STRING.
;
; (1+ COLON-POSITION)
; ==>
; (+ COLON-POSITION 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; (SUBSEQ NAMESTRING (1+ COLON-POSITION))
; Note: Unable to optimize due to type uncertainty:
; The first argument is a (OR VECTOR CONS NULL), not a SIMPLE-BASE-STRING.
;
; (1+ COLON-POSITION)
; ==>
; (+ COLON-POSITION 1)
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; Note: Unable to optimize due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a NUMBER, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a NUMBER, not a FIXNUM.
; etc.
;
; Note: Forced to do GENERIC-+ (cost 10).
; Unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; Unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; etc.
; ; [Last message occurs 2 times]
; In: DEFGENERIC (SETF PREFIX-VALUE)
; (XML-ERROR "prefix value not bindable: ~s." VALUE)
; Warning: Function has an odd number of arguments in the keyword portion.
;
; In: DEFUN EOL-NORMALIZE-INPUT
; (INCF *INPUT-LINE*)
; --> LET*
; ==>
; (+ *INPUT-LINE* 1)
; Note: