REPL Output
;;; ASDF-INSTALL: Downloading 21677 bytes from http://common-lisp.net/project/cl-peg/cl-peg_0.02.tar.gz to /Users/gwking/temporary/asdf-test/CL-PEG.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/CL-PEG.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-peg_0.02/
cl-peg_0.02/cl-peg.asd
cl-peg_0.02/dot.lisp
cl-peg_0.02/load.lisp
cl-peg_0.02/matcher.lisp
cl-peg_0.02/pegobjects.lisp
cl-peg_0.02/pegreader.lisp
cl-peg_0.02/regression.lisp
cl-peg_0.02/setup.lisp
cl-peg_0.02/testhash.lisp
cl-peg_0.02/test.lisp
cl-peg_0.02/yacc.lisp
cl-peg_0.02/README
cl-peg_0.02/example.peg
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/" ;;; ASDF-INSTALL: Downloading package GENHASH, required by cl-peg
;;; ASDF-INSTALL: Downloading 3597 bytes from http://src.hexapodia.net/genhash.tar.gz to /Users/gwking/temporary/asdf-test/genhash.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/genhash.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
genhash_1.5/CHANGES
genhash_1.5/README
genhash_1.5/benchtests.lisp
genhash_1.5/genhash.asd
genhash_1.5/genhash.lisp
genhash_1.5/newhashes.lisp
genhash_1.5/packages.lisp
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/"
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/packages.lisp" (written 19 OCT 2004 01:43:33 AM):
; compiling (DEFPACKAGE "NET.HEXAPODIA.HASHTABLES" ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/genhash.lisp" (written 26 SEP 2005 11:46:06 AM):
; compiling (IN-PACKAGE "NET.HEXAPODIA.HASHTABLES")
; compiling (DEFVAR *HASH-NICKNAME-MAP* ...)
; compiling (DEFVAR *INITIALIZED* ...)
; compiling (DEFINE-CONDITION HASH-EXISTS ...)
; compiling (DEFINE-CONDITION UNKNOWN-HASH ...)
; compiling (DEFCLASS HASH-NICKNAME ...)
; compiling (DEFCLASS HASH-CONTAINER ...)
; compiling (DEFUN REGISTER-HASH-FUNCTION ...)
; compiling (DEFUN REGISTER-BUILTIN ...)
; compiling (DEFUN MAKE-GENERIC-HASHTABLE ...)
; compiling (DEFGENERIC HASHREF ...)
; compiling (DEFGENERIC (SETF HASHREF) ...)
; compiling (DEFGENERIC HASHREM ...)
; compiling (DEFGENERIC MAP-GENERIC-HASH ...)
; compiling (DEFUN EXPAND-HASH-TABLE ...)
; compiling (DEFMETHOD HASHREF ...)
; compiling (DEFMETHOD HASHREF ...)
; compiling (DEFMETHOD (SETF HASHREF) ...)
; compiling (DEFMETHOD (SETF HASHREF) ...)
; compiling (DEFMETHOD HASHREM ...)
; compiling (DEFMETHOD HASHREM ...)
; compiling (DEFMETHOD HASHCLR ...)
; compiling (DEFMETHOD HASHCLR ...)
; compiling (DEFMETHOD ALL-HASH-KEYS ...)
; compiling (DEFMETHOD ALL-HASH-KEYS ...)
; compiling (DEFMETHOD MAP-GENERIC-HASH ...)
; compiling (DEFMETHOD MAP-GENERIC-HASH ...)
; compiling (DEFMACRO WITH-GENERIC-HASH-TABLE-ITERATOR ...)
; compiling (DEFGENERIC GENERIC-HASH-TABLE-COUNT ...)
; compiling (DEFGENERIC GENERIC-HASH-TABLE-SIZE ...)
; compiling (DEFGENERIC GENERIC-HASH-TABLE-P ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-COUNT ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-COUNT ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-SIZE ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-SIZE ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-P ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-P ...)
; compiling (DEFMETHOD GENERIC-HASH-TABLE-P ...)
; compiling (UNLESS *INITIALIZED* ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/genhash_1.5/genhash.fasl written
; compilation finished in 0:00:03
STYLE-WARNING: implicitly creating new generic function HASHCLR
STYLE-WARNING: implicitly creating new generic function ALL-HASH-KEYS
;;; ASDF-INSTALL: Downloading package CL-PPCRE, required by cl-peg
;;; ASDF-INSTALL: Downloading 166573 bytes from http://weitz.de/files/cl-ppcre.tar.gz to /Users/gwking/temporary/asdf-test/cl-ppcre.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/cl-ppcre.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-ppcre-1.2.13/
cl-ppcre-1.2.13/doc/
cl-ppcre-1.2.13/doc/benchmarks.2002-12-22.txt
cl-ppcre-1.2.13/doc/index.html
cl-ppcre-1.2.13/CHANGELOG
cl-ppcre-1.2.13/README
cl-ppcre-1.2.13/api.lisp
cl-ppcre-1.2.13/cl-ppcre-test.asd
cl-ppcre-1.2.13/cl-ppcre-test.system
cl-ppcre-1.2.13/cl-ppcre.asd
cl-ppcre-1.2.13/cl-ppcre.system
cl-ppcre-1.2.13/closures.lisp
cl-ppcre-1.2.13/convert.lisp
cl-ppcre-1.2.13/errors.lisp
cl-ppcre-1.2.13/lexer.lisp
cl-ppcre-1.2.13/lispworks-defsystem.lisp
cl-ppcre-1.2.13/load.lisp
cl-ppcre-1.2.13/optimize.lisp
cl-ppcre-1.2.13/packages.lisp
cl-ppcre-1.2.13/parser.lisp
cl-ppcre-1.2.13/perltest.pl
cl-ppcre-1.2.13/ppcre-tests.lisp
cl-ppcre-1.2.13/regex-class.lisp
cl-ppcre-1.2.13/repetition-closures.lisp
cl-ppcre-1.2.13/scanner.lisp
cl-ppcre-1.2.13/specials.lisp
cl-ppcre-1.2.13/testdata
cl-ppcre-1.2.13/testinput
cl-ppcre-1.2.13/util.lisp
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/"
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/packages.lisp" (written 01 APR 2005 04:29:10 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:CL-PPCRE ...)
; compiling (DEFPACKAGE #:CL-PPCRE-TEST ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/specials.lisp" (written 01 APR 2005 04:29:10 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFVAR *STANDARD-OPTIMIZE-SETTINGS* ...)
; compiling (DEFVAR *SPECIAL-OPTIMIZE-SETTINGS* ...)
; compiling (DEFVAR *EXTENDED-MODE-P* ...)
; compiling (DECLAIM (TYPE BOOLEAN ...))
; compiling (DEFVAR *STRING* ...)
; compiling (DECLAIM (TYPE SIMPLE-STRING ...))
; compiling (DEFVAR *START-POS* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REAL-START-POS* ...)
; compiling (DECLAIM (TYPE # ...))
; compiling (DEFVAR *END-POS* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REG-STARTS* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *REGS-MAYBE-START* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *REG-ENDS* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *END-STRING-POS* ...)
; compiling (DEFVAR *REP-NUM* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *ZERO-LENGTH-NUM* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REPEAT-COUNTERS* ...)
; compiling (DECLAIM (TYPE # ...))
; compiling (DEFVAR *LAST-POS-STORES* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *USE-BMH-MATCHERS* ...)
; compiling (DEFVAR *ALLOW-QUOTING* ...)
; compiling (PUSHNEW :CL-PPCRE ...)
; compiling (DEFVAR *HYPERDOC-BASE-URI* ...)
; compiling (LET (#) ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/specials.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp" (written 23 AUG 2005 06:32:30 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO WITH-UNIQUE-NAMES ...)
; compiling (DEFMACRO WITH-REBINDING ...)
; compiling (DEFVAR *REGEX-CHAR-CODE-LIMIT* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFUN MAKE-CHAR-HASH ...); in: LAMBDA NIL
; (FUNCALL CL-PPCRE::TEST CL-PPCRE::CHR)
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN MAKE-CHAR-HASH
; (FUNCALL CL-PPCRE::TEST CL-PPCRE::CHR)
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DECLAIM (INLINE WORD-CHAR-P))
; compiling (DEFUN WORD-CHAR-P ...); in: LAMBDA NIL
; (ALPHANUMERICP CL-PPCRE::CHR)
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN WORD-CHAR-P
; (ALPHANUMERICP CL-PPCRE::CHR)
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; compiling (UNLESS (BOUNDP #) ...)
; compiling (DEFUN WHITESPACEP ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (DEFUN MERGE-HASH ...)
; compiling (DEFUN MERGE-INVERTED-HASH ...)
; compiling (DEFUN CREATE-RANGES-FROM-HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN CREATE-RANGES-FROM-HASH
; (CHAR-DOWNCASE CL-PPCRE::CHR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; compiling (DEFMACRO MAYBE-COERCE-TO-SIMPLE-STRING ...)
; compiling (DECLAIM (INLINE NSUBSEQ))
; compiling (DEFUN NSUBSEQ ...)
; compiling (DEFUN NORMALIZE-VAR-LIST ...)
; compiling (DEFUN STRING-LIST-TO-SIMPLE-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN STRING-LIST-TO-SIMPLE-STRING
; (REPLACE CL-PPCRE::RESULT-STRING STRING :START1 CL-PPCRE::CURR-POS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining MAKE-CHAR-HASH in DEFUN
STYLE-WARNING: redefining WORD-CHAR-P in DEFUN
STYLE-WARNING: redefining WHITESPACEP in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/errors.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFVAR *SYNTAX-ERROR-STRING* ...)
; compiling (DEFINE-CONDITION PPCRE-ERROR ...)
; compiling (DEFINE-CONDITION PPCRE-SYNTAX-ERROR ...)
; compiling (SETF (DOCUMENTATION # ...) ...)
; compiling (SETF (DOCUMENTATION # ...) ...)
; compiling (DEFINE-CONDITION PPCRE-INVOCATION-ERROR ...)
; compiling (DEFMACRO SIGNAL-PPCRE-SYNTAX-ERROR* ...)
; compiling (DEFMACRO SIGNAL-PPCRE-SYNTAX-ERROR ...)
; compiling (DEFMACRO SIGNAL-PPCRE-INVOCATION-ERROR ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/errors.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DECLAIM (INLINE MAP-CHAR-TO-SPECIAL-CLASS))
; compiling (DEFUN MAP-CHAR-TO-SPECIAL-CHAR-CLASS ...)
; compiling (DEFSTRUCT (LEXER #) ...)
; compiling (DEFUN MAKE-LEXER ...)
; compiling (DECLAIM (INLINE END-OF-STRING-P))
; compiling (DEFUN END-OF-STRING-P ...)
; compiling (DECLAIM (INLINE LOOKING-AT-P))
; compiling (DEFUN LOOKING-AT-P ...)
; compiling (DECLAIM (INLINE NEXT-CHAR-NON-EXTENDED))
; compiling (DEFUN NEXT-CHAR-NON-EXTENDED ...)
; compiling (DEFUN NEXT-CHAR ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN NEXT-CHAR
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
; "Comment group not closed")
; ==>
; (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
; :POS
; CL-PPCRE::ERROR-POS
; :FORMAT-CONTROL
; "Comment group not closed"
; :FORMAT-ARGUMENTS
; (LIST))
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DECLAIM (INLINE FAIL))
; compiling (DEFUN FAIL ...)
; compiling (DEFUN GET-NUMBER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN GET-NUMBER
; (IF (< CL-PPCRE::END-POS CL-PPCRE::LEXER-LEN)
; CL-PPCRE::END-POS
; CL-PPCRE::LEXER-LEN)
; ==>
; CL-PPCRE::END-POS
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DECLAIM (INLINE TRY-NUMBER))
; compiling (DEFUN TRY-NUMBER ...)
; compiling (DECLAIM (INLINE MAKE-CHAR-FROM-CODE))
; compiling (DEFUN MAKE-CHAR-FROM-CODE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
; "No character for hex-code ~X"
; NUMBER)
; --> ERROR
; ==>
; CL-PPCRE::ERROR-POS
;
; note: deleting unreachable code
; compiling (DEFUN UNESCAPE-CHAR ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
; "No character for hex-code ~X"
; NUMBER)
; --> ERROR
; ==>
; "No character for hex-code ~X"
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; in: DEFUN UNESCAPE-CHAR
; (CHAR-UPCASE CL-PPCRE::NEXT-CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; compiling (DEFUN COLLECT-CHAR-CLASS ...)
; compiling (DEFUN MAYBE-PARSE-FLAGS ...)
; compiling (DEFUN GET-QUANTIFIER ...)
; compiling (DEFUN GET-TOKEN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
; "No character for hex-code ~X"
; NUMBER)
; --> ERROR
; ==>
; "No character for hex-code ~X"
;
; note: deleting unreachable code
; ==>
; CL-PPCRE::ERROR-POS
;
; note: deleting unreachable code
; in: DEFUN GET-TOKEN
; (SUBSEQ (CL-PPCRE::LEXER-STR CL-PPCRE::LEXER)
; (CAR CL-PPCRE::THIS-LAST-POS)
; (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (SUBSEQ (CL-PPCRE::LEXER-STR CL-PPCRE::LEXER)
; (CAR (CL-PPCRE::LEXER-LAST-POS CL-PPCRE::LEXER))
; (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; "Character '~A' may not follow '(?<'"
; CL-PPCRE::NEXT-CHAR)
; ==>
; (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
; :POS
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; :FORMAT-CONTROL
; "Character '~A' may not follow '(?<'"
; :FORMAT-ARGUMENTS
; (LIST CL-PPCRE::NEXT-CHAR))
;
; note: doing signed word to integer coercion (cost 20)
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; "Character '~A' may not follow '(?'"
; CL-PPCRE::NEXT-CHAR)
; ==>
; (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
; :POS
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; :FORMAT-CONTROL
; "Character '~A' may not follow '(?'"
; :FORMAT-ARGUMENTS
; (LIST CL-PPCRE::NEXT-CHAR))
;
; note: doing signed word to integer coercion (cost 20)
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; "Quantifier '~A' not allowed"
; CL-PPCRE::NEXT-CHAR)
; ==>
; (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
; :POS
; (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; :FORMAT-CONTROL
; "Quantifier '~A' not allowed"
; :FORMAT-ARGUMENTS
; (LIST CL-PPCRE::NEXT-CHAR))
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DECLAIM (INLINE UNGET-TOKEN))
; compiling (DEFUN UNGET-TOKEN ...)
; compiling (DECLAIM (INLINE START-OF-SUBEXPR-P))
; compiling (DEFUN START-OF-SUBEXPR-P ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp" (written 03 AUG 2005 05:11:27 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFUN GROUP ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp
; in: DEFUN GROUP
; (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* (+ CL-PPCRE::OPEN-PAREN-POS 2)
; "Opening paren has no matching closing paren")
; ==>
; (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
; :POS
; (+ CL-PPCRE::OPEN-PAREN-POS 2)
; :FORMAT-CONTROL
; "Opening paren has no matching closing paren"
; :FORMAT-ARGUMENTS
; (LIST))
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN GREEDY-QUANT ...)
; compiling (DEFUN QUANT ...)
; compiling (DEFUN SEQ ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp
; in: DEFUN SEQ
; (SETF (AREF STRING 0) CL-PPCRE::CHAR1)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR CHARACTER), not a SIMPLE-ARRAY.
; (SETF (AREF STRING 1) CL-PPCRE::CHAR2)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR CHARACTER), not a SIMPLE-ARRAY.
; (CL-PPCRE::START-OF-SUBEXPR-P CL-PPCRE::LEXER)
; --> BLOCK LET* NOT IF OR LET IF OR PROG1 LET MEMBER BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> BLOCK LET* NOT IF OR LET IF OR PROG1 LET MEMBER BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFUN REG-EXPR ...)
; compiling (DEFUN REVERSE-STRINGS ...)
; compiling (DEFUN PARSE-STRING ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp" (written 10 JUN 2005 06:23:42 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFCLASS REGEX ...)
; compiling (DEFCLASS SEQ ...)
; compiling (DEFCLASS ALTERNATION ...)
; compiling (DEFCLASS LOOKAHEAD ...)
; compiling (DEFCLASS LOOKBEHIND ...)
; compiling (DEFCLASS REPETITION ...)
; compiling (DEFCLASS REGISTER ...)
; compiling (DEFCLASS STANDALONE ...)
; compiling (DEFCLASS BACK-REFERENCE ...)
; compiling (DEFCLASS CHAR-CLASS ...)
; compiling (DEFCLASS STR ...)
; compiling (DEFCLASS ANCHOR ...)
; compiling (DEFCLASS EVERYTHING ...)
; compiling (DEFCLASS WORD-BOUNDARY ...)
; compiling (DEFCLASS BRANCH ...)
; compiling (DEFCLASS FILTER ...)
; compiling (DEFCLASS VOID ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (CHAR-CLASS)
; (> (HASH-TABLE-COUNT CL-PPCRE::HASH) (/ CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* 2))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a (RATIONAL -268435456 536870911/2), not a FIXNUM.
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (STR)
; (LENGTH (CL-PPCRE::STR CL-PPCRE::STR))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFMETHOD LEN ...)
; compiling (DEFMETHOD STR ...)
; compiling (DEFMETHOD SKIP ...)
; compiling (DEFMETHOD START-OF-END-STRING-P ...)
; compiling (DEFGENERIC CASE-MODE ...)
; compiling (DEFMETHOD CASE-MODE ...)
; compiling (DEFMETHOD CASE-MODE ...)
; compiling (DEFGENERIC COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFGENERIC REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFGENERIC EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFGENERIC REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFGENERIC REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFGENERIC COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.fasl written
; compilation finished in 0:00:09
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO CASE-INSENSITIVE-MODE-P ...)
; compiling (DEFMACRO MULTI-LINE-MODE-P ...)
; compiling (DEFMACRO SINGLE-LINE-MODE-P ...)
; compiling (DEFUN SET-FLAG ...)
; compiling (DEFUN ADD-RANGE-TO-HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN ADD-RANGE-TO-HASH
; (CHAR-UPCASE CL-PPCRE::CHR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-DOWNCASE CL-PPCRE::CHR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; compiling (DEFUN CONVERT-CHAR-CLASS-TO-HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN CONVERT-CHAR-CLASS-TO-HASH
; (CEILING (EXPT CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* (/ 1 4)))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FLOAT.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF
; --> NOT IF ZEROP
; ==>
; (= REM 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR RATIONAL SINGLE-FLOAT), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF
; --> AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FLOAT.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
; ==>
; (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
;
; note: forced to do full call
; unable to do inline float truncate (cost 5) because:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a SINGLE-FLOAT.
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES (OR RATIONAL SINGLE-FLOAT)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES (OR RATIONAL SINGLE-FLOAT)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF
; --> AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
; etc.
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES
; ==>
; (+ SB-KERNEL::TRU 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (FLOAT (EXPT CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* (/ 1 4)))
; --> IF
; ==>
; (SB-KERNEL:%SINGLE-FLOAT SB-C::N)
;
; note: forced to do full call
; unable to do inline float coercion (cost 5) because:
; The first argument is a RATIONAL, not a (UNSIGNED-BYTE 32).
; unable to do inline float coercion (cost 5) because:
; The first argument is a RATIONAL, not a (SIGNED-BYTE 32).
; compiling (DEFUN MAYBE-SPLIT-REPETITION ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN MAYBE-SPLIT-REPETITION
; (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM)
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN MAYBE-ACCUMULATE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN MAYBE-ACCUMULATE
; (SETF (SUBSEQ (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR)
; (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
; (CL-PPCRE::LEN CL-PPCRE::STR)))
; (CL-PPCRE::STR CL-PPCRE::STR)
; (CL-PPCRE::SKIP CL-PPCRE::STR)
; T)
; --> PROGN SETF LET* MULTIPLE-VALUE-BIND LET PROGN
; ==>
; (REPLACE #:G77 #:G79 :START1 #:G78 :END1 NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY SINGLE-FLOAT (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The second argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The result is a (VALUES SEQUENCE
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 32)
; (*))
; &REST
; T).
; (SETF (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
; (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
; (CL-PPCRE::LEN CL-PPCRE::STR)))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL
; ==>
; (#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME (SETF CL-PPCRE::LEN)
; :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION # *)>
; :WHERE-FROM :DECLARED
; :KIND :GLOBAL-FUNCTION {107AE9C9}>
; #:G75 #:G76)
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN CONVERT-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN CONVERT-AUX
; (EVERY (LAMBDA (CL-PPCRE::ITEM) (EQ CL-PPCRE::ITEM :NON-WORD-CHAR-CLASS))
; CL-PPCRE::ITEM-LIST)
; --> LET BLOCK MAP TRULY-THE
; ==>
; (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G234)
;
; note: unable to open code because: can't determine sequence argument type
; (CHAR-EQUAL (FIRST CL-PPCRE::HASH-KEYS) (SECOND CL-PPCRE::HASH-KEYS))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (MEMBER CL-PPCRE::PARSE-TREE
; '(:NON-DIGIT-CLASS :NON-WORD-CHAR-CLASS :NON-WHITESPACE-CHAR-CLASS)
; :TEST
; #'EQ)
; --> BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; (LENGTH (CL-PPCRE::CHOICES CL-PPCRE::ALTERNATIONS))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (ZEROP LENGTH)
; --> = IF
; ==>
; (= LENGTH 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; 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 open code because: The operands might not be the same type.
; (EVERY (LAMBDA (CL-PPCRE::ITEM) (EQ CL-PPCRE::ITEM :WORD-CHAR-CLASS))
; CL-PPCRE::ITEM-LIST)
; --> LET BLOCK MAP TRULY-THE
; ==>
; (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G244)
;
; note: unable to open code because: can't determine sequence argument type
; (1- (THE FIXNUM CL-PPCRE::TEST-CANDIDATE))
; ==>
; (- (THE FIXNUM CL-PPCRE::TEST-CANDIDATE) 1)
;
; note: doing signed word to integer coercion (cost 20)
; (1- CL-PPCRE::MAXIMUM)
; ==>
; (- CL-PPCRE::MAXIMUM 1)
;
; note: doing signed word to integer coercion (cost 20)
; compiling (DEFUN CONVERT ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/optimize.lisp" (written 13 APR 2005 11:35:57 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFGENERIC FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFGENERIC GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFGENERIC START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFGENERIC END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFGENERIC END-STRING ...)
; compiling (DEFMETHOD END-STRING ...)
; compiling (DEFGENERIC COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/optimize.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp" (written 16 MAY 2005 12:29:23 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DECLAIM (INLINE *STRING*= ...))
; compiling (DEFUN *STRING*= ...)
; compiling (DEFUN *STRING*-EQUAL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; compiling (DEFGENERIC CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMACRO INSERT-CHAR-CLASS-TESTER ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (CHAR-CLASS T)
; (FUNCALL CL-PPCRE::NEXT-FN (1+ CL-PPCRE::START-POS))
; ==>
; CL-PPCRE::NEXT-FN
;
; note: deleting unreachable code
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::CHAR-CLASS (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::CHAR-CLASS)
; (LAMBDA (CL-PPCRE::START-POS)
; (DECLARE (TYPE FIXNUM CL-PPCRE::START-POS))
; (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
; (NOT #)
; (FUNCALL CL-PPCRE::NEXT-FN #)))
; (LAMBDA (CL-PPCRE::START-POS)
; (DECLARE (TYPE FIXNUM CL-PPCRE::START-POS))
; (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
; (CL-PPCRE::CHAR-CLASS-TEST)
; (FUNCALL CL-PPCRE::NEXT-FN #)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR =
; --> IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; compiling (DECLAIM (INLINE WORD-BOUNDARY-P))
; compiling (DEFUN WORD-BOUNDARY-P ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN WORD-BOUNDARY-P
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN WORD-BOUNDARY-P
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp" (written 13 APR 2005 11:35:58 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO INCF-AFTER ...)
; compiling (DEFMACRO GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFUN CREATE-GREEDY-EVERYTHING-MATCHER ...)
; compiling (DEFGENERIC CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMACRO GREEDY-CONSTANT-LENGTH-CLOSURE
; (INCF CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; --> LET*
; ==>
; CL-PPCRE::LEN
;
; note: deleting unreachable code
; --> LET* +
; ==>
; CL-PPCRE::CURR-POS
;
; note: deleting unreachable code
; (GO CL-PPCRE::FORWARD-LOOP)
;
; note: deleting unreachable code
; (INCF CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; --> LET*
; ==>
; CL-PPCRE::LEN
;
; note: deleting unreachable code
; --> LET* +
; ==>
; CL-PPCRE::CURR-POS
;
; note: deleting unreachable code
; (GO CL-PPCRE::FORWARD-LOOP)
;
; note: deleting unreachable code
; in: DEFMETHOD CREATE-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T)
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR
; --> LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR
; --> LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
; CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; 0
; CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; compiling (DEFGENERIC CREATE-GREEDY-NO-ZERO-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; compiling (DEFGENERIC CREATE-GREEDY-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-GREEDY-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 0
; (SVREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
; NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; compiling (DEFMACRO NON-GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFGENERIC CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T)
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET
; --> < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET
; --> IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET
; --> < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET
; --> IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET
; --> OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET
; --> OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET
; --> OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET
; --> OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
; CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; 0
; CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET
; --> OR LET < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET
; --> < IF
; ==>
; (< GC 5)
;
; 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.
;
; 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.
; compiling (DEFGENERIC CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; compiling (DEFGENERIC CREATE-NON-GREEDY-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 0
; (SVREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
; NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; compiling (DEFMACRO CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFGENERIC CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in:
; DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER (REPETITION T)
; (1+ CL-PPCRE::CURR-POS)
; --> +
; ==>
; CL-PPCRE::CURR-POS
;
; note: deleting unreachable code
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (NOT #) (1+ CL-PPCRE::CURR-POS)))
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET
; --> ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET
; --> ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK
; --> OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK
; --> OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
; CL-PPCRE::CURR-POS
; CL-PPCRE::NEXT-POS
; 0
; CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
; (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (NOT #) (1+ CL-PPCRE::CURR-POS)))
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK
; --> OR LET ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET
; --> ALPHANUMERICP BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; compiling (DEFGENERIC CREATE-CONSTANT-REPETITION-MATCHER ...)
; compiling (DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 0
; (AREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
; NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (ZEROP (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; ==>
; (= (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; 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 open code because: The operands might not be the same type.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.fasl written
; compilation finished in 0:00:11
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp" (written 19 JUL 2005 07:18:15 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO BMH-MATCHER-AUX ...)
; compiling (DEFUN CREATE-BMH-MATCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFUN CREATE-BMH-MATCHER
; (CL-PPCRE::BMH-MATCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION IF LOOP BLOCK LET SB-LOOP::LOOP-BODY TAGBODY LOOP BLOCK
; --> LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF AND IF AND
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I)
; (SCHAR CL-PPCRE::PATTERN CL-PPCRE::J))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (LENGTH CL-PPCRE::PATTERN)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CHAR-UPCASE (SCHAR CL-PPCRE::PATTERN CL-PPCRE::K))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-DOWNCASE (SCHAR CL-PPCRE::PATTERN CL-PPCRE::K))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (SEARCH CL-PPCRE::PATTERN
; CL-PPCRE::*STRING*
; :START2
; CL-PPCRE::START-POS
; :END2
; CL-PPCRE::*END-POS*
; :TEST
; CL-PPCRE::TEST)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-STRING.
; compiling (DEFMACRO CHAR-SEARCHER-AUX ...)
; compiling (DEFUN CREATE-CHAR-SEARCHER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFUN CREATE-CHAR-SEARCHER
; (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION AND IF AND LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY
; --> WHEN COND IF SETQ THE AND IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I) CL-PPCRE::CHR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; compiling (DECLAIM (INLINE NEWLINE-SKIPPER))
; compiling (DEFUN NEWLINE-SKIPPER ...)
; compiling (DEFMACRO INSERT-ADVANCE-FN ...)
; compiling (DEFUN CREATE-SCANNER-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFMACRO INSERT-ADVANCE-FN
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G274)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G264)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G254)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G244)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G234)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G224)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G214)
;
; 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).
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
; CL-PPCRE::*START-POS*
; (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
; 0
; CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF
; ==>
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
; (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; The second argument is a CHARACTER, not a BASE-CHAR.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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).
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G200)
;
; 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).
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G214)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G200)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G224)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G234)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G244)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G254)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G264)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF
; ==>
; (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET*
; ==>
; (+ CL-PPCRE::*END-STRING-POS* #:G274)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD5C9}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G607)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
; (IF
; (<= (THE FIXNUM CL-PPCRE::POS)
; (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS
; (SETQ CL-PPCRE::*END-STRING-POS*
; (FUNCALL CL-PPCRE::END-STRING-TEST
; CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD641}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G854)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (UNLESS
; (SETQ CL-PPCRE::POS
; (CL-PPCRE::NEWLINE-SKIPPER CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD6B9}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G1101)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (TYPE FUNCTION CL-PPCRE::START-STRING-TEST))
; (UNLESS
; (SETQ CL-PPCRE::POS
; (FUNCALL CL-PPCRE::START-STRING-TEST
; CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD731}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G1348)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
; (UNLESS
; (SETQ CL-PPCRE::POS
; (CL-PPCRE::NEWLINE-SKIPPER CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF
; (<= (THE FIXNUM CL-PPCRE::POS)
; (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS
; (SETQ CL-PPCRE::*END-STRING-POS*
; (FUNCALL CL-PPCRE::END-STRING-TEST
; CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD7A9}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G1596)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE
; (TYPE FUNCTION
; CL-PPCRE::START-STRING-TEST
; CL-PPCRE::END-STRING-TEST))
; (UNLESS
; (SETQ CL-PPCRE::POS
; (FUNCALL CL-PPCRE::START-STRING-TEST
; CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF
; (<= (THE FIXNUM CL-PPCRE::POS)
; (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS
; (SETQ CL-PPCRE::*END-STRING-POS*
; (FUNCALL CL-PPCRE::END-STRING-TEST
; CL-PPCRE::POS))
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD821}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G1845)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (TYPE FIXNUM CL-PPCRE::END-STRING-OFFSET)
; (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
; (LOOP
; (UNLESS (SETQ CL-PPCRE::POS #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD899}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; (SETQ CL-PPCRE::TRY-POS (1+ CL-PPCRE::*END-STRING-POS*))
;
; note: doing signed word to integer coercion (cost 20) to TRY-POS
;
; note: doing signed word to integer coercion (cost 20) to TRY-POS
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G2094)
;
; note: doing signed word to integer coercion (cost 20)
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE
; (TYPE FIXNUM
; CL-PPCRE::END-STRING-OFFSET
; CL-PPCRE::STARTS-WITH-LEN)
; (TYPE FUNCTION
; CL-PPCRE::START-STRING-TEST
; CL-PPCRE::END-STRING-TEST))
; (LOOP
; (UNLESS (SETQ CL-PPCRE::POS #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET*
; ==>
; (SB-C::%SPECIAL-BIND
; '#<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}>
; #<SB-C::LAMBDA-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :SPECVAR #<SB-C::GLOBAL-VAR
; :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
; :KIND :SPECIAL {100B26D1}> {109BD911}>)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first argument of BIND
; (FUNCALL CL-PPCRE::END-STRING-TEST CL-PPCRE::TRY-POS)
; ==>
; (SB-C::%FUNCALL FUNCTION #:G2348)
;
; note: doing signed word to integer coercion (cost 20) from TRY-POS
; ==>
; (SB-C::%FUNCALL FUNCTION #:G2100)
;
; note: doing signed word to integer coercion (cost 20) from TRY-POS
; in: DEFMACRO INSERT-ADVANCE-FN
; (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
; (SB-C::%FUNCALL FUNCTION #:G2343)
;
; note: doing signed word to integer coercion (cost 20)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.fasl written
; compilation finished in 0:00:06
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp" (written 06 DEC 2005 11:50:50 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFGENERIC CREATE-SCANNER ...)
; compiling (DEFMETHOD CREATE-SCANNER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD CREATE-SCANNER (STRING)
; (COPY-SEQ CL-PPCRE::QUOTED-REGEX-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY SINGLE-FLOAT (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 32)
; (*))
; &REST
; T).
; compiling (DEFMETHOD CREATE-SCANNER ...)
; compiling (DEFMETHOD CREATE-SCANNER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD CREATE-SCANNER (T)
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; ==>
; (> (CL-PPCRE::LEN CL-PPCRE::END-STRING) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (= 1 (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; --> = IF
; ==>
; (= SB-C::Y 1)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; 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 open code because: The operands might not be the same type.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; ==>
; (> (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (= 1 (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; --> = IF
; ==>
; (= SB-C::Y 1)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; 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 open code because: The operands might not be the same type.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; ==>
; (> (CL-PPCRE::LEN CL-PPCRE::END-STRING) 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.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; ==>
; (> (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) 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.
; compiling (DEFGENERIC SCAN ...)
; compiling (DEFMETHOD SCAN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN (STRING T)
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::REGEX-STRING)
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; CL-PPCRE::START
; CL-PPCRE::END)
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFMETHOD SCAN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN #'T
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFMETHOD SCAN ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN (T T)
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::PARSE-TREE)
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; CL-PPCRE::START
; CL-PPCRE::END)
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFINE-COMPILER-MACRO SCAN ...)
; compiling (DEFUN SCAN-TO-STRINGS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN SCAN-TO-STRINGS
; (MAP 'VECTOR
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (IF CL-PPCRE::REG-START
; (FUNCALL CL-PPCRE::SUBSTR-FN
; CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; NIL))
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS)
; --> TRULY-THE
; ==>
; (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G235 #:G236)
;
; note: unable to open code because: can't determine sequence argument type
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFINE-COMPILER-MACRO SCAN-TO-STRINGS ...)
; compiling (DEFMACRO REGISTER-GROUPS-BIND ...)
; compiling (DEFMACRO DO-SCANS ...)
; compiling (DEFMACRO DO-MATCHES ...)
; compiling (DEFMACRO DO-MATCHES-AS-STRINGS ...)
; compiling (DEFMACRO DO-REGISTER-GROUPS ...)
; compiling (DEFUN ALL-MATCHES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN ALL-MATCHES
; (CL-PPCRE:DO-MATCHES
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST)
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::RESULT-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::RESULT-LIST))
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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).
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-MATCHES
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST)
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::RESULT-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::RESULT-LIST))
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF OR
; ==>
; (LENGTH #:TARGET-STRING334)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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 (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFINE-COMPILER-MACRO ALL-MATCHES ...)
; compiling (DEFUN ALL-MATCHES-AS-STRINGS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN ALL-MATCHES-AS-STRINGS
; (CL-PPCRE:DO-MATCHES-AS-STRINGS
; (CL-PPCRE::MATCH CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST)
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END
; :SHAREDP
; CL-PPCRE::SHAREDP)
; (PUSH CL-PPCRE::MATCH CL-PPCRE::RESULT-LIST))
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= #:MATCH-START382 #:MATCH-END383)
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+
; ==>
; (+ #:MATCH-END383 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).
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-MATCHES-AS-STRINGS
; (CL-PPCRE::MATCH CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST)
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END
; :SHAREDP
; CL-PPCRE::SHAREDP)
; (PUSH CL-PPCRE::MATCH CL-PPCRE::RESULT-LIST))
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF OR
; ==>
; (LENGTH #:TARGET-STRING387)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= #:MATCH-START382 #:MATCH-END383)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+
; ==>
; (+ #:MATCH-END383 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 (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFINE-COMPILER-MACRO ALL-MATCHES-AS-STRINGS ...)
; compiling (DEFUN SPLIT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN SPLIT
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (LOOP CL-PPCRE::FOR
; CL-PPCRE::REG-START
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR
; CL-PPCRE::REG-END
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-ENDS
; IF
; CL-PPCRE::REG-START
; DO
; ...)
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SETQ THE
; ==>
; (LENGTH #:LOOP-ACROSS-VECTOR-449)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a VECTOR.
; ==>
; (LENGTH #:LOOP-ACROSS-VECTOR-452)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a VECTOR.
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ
; --> THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CL-PPCRE:DO-SCANS
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; NIL
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR
; CL-PPCRE::REG-START
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR
; CL-PPCRE::REG-END
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-ENDS
; IF
; CL-PPCRE::REG-START
; DO
; ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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).
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-SCANS
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; NIL
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR
; CL-PPCRE::REG-START
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR
; CL-PPCRE::REG-END
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-ENDS
; IF
; CL-PPCRE::REG-START
; DO
; ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* OR LET IF OR
; ==>
; (LENGTH #:TARGET-STRING436)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; (INCF CL-PPCRE::COUNTER)
; --> LET*
; ==>
; (+ CL-PPCRE::COUNTER #:G446)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (>= (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
; --> IF
; ==>
; (< (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (INTEGER 1), not a FIXNUM.
; The second argument is a REAL, not a FIXNUM.
; (CL-PPCRE:DO-SCANS
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; NIL
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR
; CL-PPCRE::REG-START
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR
; CL-PPCRE::REG-END
; CL-PPCRE::ACROSS
; CL-PPCRE::REG-ENDS
; IF
; CL-PPCRE::REG-START
; DO
; ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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 (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
;
; note: forced to do GENERIC-> (cost 10)
; 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.
; 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.
; etc.
; compiling (DEFINE-COMPILER-MACRO SPLIT ...)
; compiling (DEFUN STRING-CASE-MODIFIER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN STRING-CASE-MODIFIER
; (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CHAR CL-PPCRE::STR CL-PPCRE::FROM)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::FROM))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CHAR CL-PPCRE::STR CL-PPCRE::TO)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (CHAR CL-PPCRE::STR CL-PPCRE::INDEX)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::TO))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (BOTH-CASE-P CL-PPCRE::CHR)
; --> BLOCK < IF
; ==>
; (< (SB-IMPL::UCD-VALUE-0 CHAR) 2)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (UPPER-CASE-P CL-PPCRE::CHR)
; --> BLOCK = IF
; ==>
; (= (SB-IMPL::UCD-VALUE-0 CHAR) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; 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 open code because: The operands might not be the same type.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::FROM))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::TO))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; 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.
; (BOTH-CASE-P CL-PPCRE::CHR)
; --> BLOCK < IF
; ==>
; (< (SB-IMPL::UCD-VALUE-0 CHAR) 2)
;
; 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.
; compiling (DEFGENERIC BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (LET* (# #) ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD BUILD-REPLACEMENT-TEMPLATE (STRING)
; (SUBSEQ CL-PPCRE::REPLACEMENT-STRING CL-PPCRE::FROM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (SUBSEQ CL-PPCRE::REPLACEMENT-STRING CL-PPCRE::FROM CL-PPCRE::MATCH-START)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (POSITION-IF #'DIGIT-CHAR-P
; CL-PPCRE::REPLACEMENT-STRING
; :START
; CL-PPCRE::MATCH-START
; :END
; CL-PPCRE::MATCH-END)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%FIND-POSITION-IF
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
; SEQUENCE
; SB-C::FROM-END
; SB-C::START
; SB-C::END
; (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; (CHAR CL-PPCRE::REPLACEMENT-STRING (1+ CL-PPCRE::MATCH-START))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (SUBSEQ CL-PPCRE::REPLACEMENT-STRING
; CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (< CL-PPCRE::FROM CL-PPCRE::MATCH-START)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (1-
; (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING
; :START
; CL-PPCRE::PARSE-START
; :JUNK-ALLOWED
; T))
; ==>
; (-
; (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING
; :START
; CL-PPCRE::PARSE-START
; :JUNK-ALLOWED
; T)
; 1)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (< CL-PPCRE::TOKEN 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFUN BUILD-REPLACEMENT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN BUILD-REPLACEMENT
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::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: 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).
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::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: 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).
; (ARRAY-DIMENSION CL-PPCRE::REG-STARTS 0)
;
; note: unable to
; optimize
; because:
; The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.
; (MAP 'LIST
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (AND CL-PPCRE::REG-START
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START
; CL-PPCRE::REG-END)))
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS)
; --> TRULY-THE
; ==>
; (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G738 #:G739)
;
; note: unable to open code because: can't determine sequence argument type
; ==>
; (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G747 #:G748)
;
; note: unable to open code because: can't determine sequence argument type
; (>= CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
; --> IF
; ==>
; (< CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; (1+ CL-PPCRE::TOKEN)
; ==>
; (+ CL-PPCRE::TOKEN 1)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
;
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 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 (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; compiling (DEFUN REPLACE-AUX ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REPLACE-AUX
; (FUNCALL
; (CL-PPCRE::STRING-CASE-MODIFIER CL-PPCRE::TARGET-STRING
; CL-PPCRE::FROM
; CL-PPCRE::TO
; CL-PPCRE::START
; CL-PPCRE::END)
; CL-PPCRE::CURR-REPLACEMENT)
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR NULL FUNCTION), not a FUNCTION.
; compiling (DEFUN REGEX-REPLACE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-REPLACE
; (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY SINGLE-FLOAT (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 32)
; (*))
; &REST
; T).
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFINE-COMPILER-MACRO REGEX-REPLACE ...)
; compiling (DEFUN REGEX-REPLACE-ALL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-REPLACE-ALL
; (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY SINGLE-FLOAT (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 32)
; (*))
; &REST
; T).
; (CL-PPCRE:DO-SCANS
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; NIL
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
; (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; 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
; open-code FLOAT to RATIONAL comparison
; 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 (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: unable to open code because: The operands might not be the same type.
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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).
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-SCANS
; (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; NIL
; :START
; CL-PPCRE::START
; :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
; (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* OR LET IF OR
; ==>
; (LENGTH #:TARGET-STRING839)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; --> FUNCTION SETQ THE IF 1+
; ==>
; (+ CL-PPCRE::MATCH-END 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 (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFINE-COMPILER-MACRO REGEX-REPLACE-ALL ...)
; compiling (DEFMACRO REGEX-APROPOS-AUX ...)
; compiling (DEFUN REGEX-APROPOS-LIST ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-APROPOS-LIST
; (DEFUN CL-PPCRE:REGEX-APROPOS-LIST
; (CL-PPCRE::REGEX
; &OPTIONAL CL-PPCRE::PACKAGES
; &KEY (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE
; (OPTIMIZE SPEED (SAFETY 0) (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; "Similar to the standard function APROPOS-LIST but returns a list of
; all symbols which match the regular expression REGEX. If
; CASE-INSENSITIVE is true and REGEX isn't already a scanner, a
; case-insensitive scanner is used."
; (LET ((CL-PPCRE::COLLECTOR 'NIL))
; (CL-PPCRE::REGEX-APROPOS-AUX
; (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE
; CL-PPCRE::COLLECTOR)
; (PUSH SYMBOL CL-PPCRE::COLLECTOR))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS-LIST
; (CL-PPCRE::REGEX &OPTIONAL
; CL-PPCRE::PACKAGES
; &KEY
; (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE
; (OPTIMIZE SPEED
; (SAFETY 0)
; (SPACE 0)
; (DEBUG 1)
; (COMPILATION-SPEED 0)))
; (BLOCK CL-PPCRE:REGEX-APROPOS-LIST
; (LET ((CL-PPCRE::COLLECTOR 'NIL))
; (CL-PPCRE::REGEX-APROPOS-AUX
; (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE
; CL-PPCRE::COLLECTOR)
; (PUSH SYMBOL CL-PPCRE::COLLECTOR)))))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL
; PACKAGES
; &KEY
; (CASE-INSENSITIVE T))
; in: LAMBDA (#:WHOLE919 #:ENVIRONMENT920)
; (MEMBER SB-IMPL::THIS-KIND '(:INTERNAL :EXTERNAL :INHERITED))
; --> BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET IF SB-IMPL::SATISFIES-THE-TEST
; --> LET COND IF COND IF COND IF PROGN FUNCALL
; ==>
; (SB-C::%FUNCALL FUNCTION #:G26 #:G27)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; compiling (DEFUN PRINT-SYMBOL-INFO ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN PRINT-SYMBOL-INFO
; (FORMAT T "~&~S ~<~;~^~A~@{~:@_~A~}~;~:>" SYMBOL CL-PPCRE::OUTPUT-LIST)
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO
; --> FLET COND IF AND IF AND IF AND >= IF
; ==>
; (< SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* *PRINT-LEVEL*)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO
; --> FLET COND IF COND IF PROGN LET 1+
; ==>
; (+ SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* 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).
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM
; ==>
; (FLET ((#:WITH-PRETTY-STREAM-1399 (STREAM)
; (LET (#)
; (IF # # #))))
; (LET ((STREAM
; (LET #
; #)))
; (IF (SB-PRETTY:PRETTY-STREAM-P STREAM)
; (#:WITH-PRETTY-STREAM-1399 STREAM)
; (CATCH 'SB-PRETTY::LINE-LIMIT-ABBREVIATION-HAPPENED
; (LET #
; #
; #))))
; NIL)
;
; note: Return type not fixed values, so can't use known return convention:
; *
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO
; --> FLET BLOCK LET BLOCK FLET BLOCK WHEN COND IF AND IF AND
; ==>
; (EQL #:PPRINT-LOGICAL-BLOCK-LENGTH-1397 *PRINT-LENGTH*)
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a (OR UNSIGNED-BYTE NULL), not a FIXNUM.
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO
; --> FLET COND IF AND IF AND IF AND >= IF
; ==>
; (< SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* *PRINT-LEVEL*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; The second argument is a UNSIGNED-BYTE, not a FIXNUM.
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO
; --> FLET COND IF COND IF PROGN LET 1+
; ==>
; (+ SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* 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 (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFUN REGEX-APROPOS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-APROPOS
; (DEFUN CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX
; &OPTIONAL CL-PPCRE::PACKAGES
; &KEY (CL-PPCRE::CASE-INSENSITIVE T))
; "Similar to the standard function APROPOS but returns a list of all
; symbols which match the regular expression REGEX. If CASE-INSENSITIVE
; is true and REGEX isn't already a scanner, a case-insensitive scanner
; is used."
; (DECLARE
; (OPTIMIZE SPEED (SAFETY 0) (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; (CL-PPCRE::REGEX-APROPOS-AUX
; (CL-PPCRE::REGEX CL-PPCRE::PACKAGES CL-PPCRE::CASE-INSENSITIVE)
; (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
; (VALUES))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX &OPTIONAL
; CL-PPCRE::PACKAGES
; &KEY
; (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE
; (OPTIMIZE SPEED
; (SAFETY 0)
; (SPACE 0)
; (DEBUG 1)
; (COMPILATION-SPEED 0)))
; (BLOCK CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX-APROPOS-AUX
; (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE)
; (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
; (VALUES)))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL
; PACKAGES
; &KEY
; (CASE-INSENSITIVE T))
; in: LAMBDA (#:WHOLE1465 #:ENVIRONMENT1466)
; (MEMBER SB-IMPL::THIS-KIND '(:INTERNAL :EXTERNAL :INHERITED))
; --> BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET IF SB-IMPL::SATISFIES-THE-TEST
; --> LET COND IF COND IF COND IF PROGN FUNCALL
; ==>
; (SB-C::%FUNCALL FUNCTION #:G26 #:G27)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; compiling (LET* (# #) ...)
; compiling (LET* (# # ...) ...)
; compiling (LET* (# # ...) ...)
; compiling (DEFUN PARSE-TREE-SYNONYM ...)
; compiling (DEFUN (SETF PARSE-TREE-SYNONYM) ...)
; compiling (DEFMACRO DEFINE-PARSE-TREE-SYNONYM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.fasl written
; compilation finished in 0:00:04
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {10007E51}> on
#<CL-SOURCE-FILE "api" {10007E61}>.
;
; compilation unit finished
; caught 2 STYLE-WARNING conditions
; printed 713 notes
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.lisp" (written 09 JAN 2006 05:48:46 AM):
; compiling (DEFPACKAGE #:YACC ...)
; compiling (IN-PACKAGE #:YACC)
; compiling (DEFUN REQUIRED-ARGUMENT ...)
; compiling (DECLAIM (INLINE MEMQ))
; compiling (DEFUN MEMQ ...)
; compiling (DEFTYPE INDEX ...)
; compiling (DEFTYPE SIGNED-INDEX ...)
; compiling (DEFSTRUCT (PRODUCTION # ...) ...)
; compiling (DEFUN PRINT-PRODUCTION ...)
; compiling (DECLAIM (INLINE PRODUCTION-EQUAL-P))
; compiling (DEFUN PRODUCTION-EQUAL-P ...)
; compiling (DECLAIM (INLINE PRODUCTION<))
; compiling (DEFUN PRODUCTION< ...)
; compiling (DEFSTRUCT (GRAMMAR #) ...)
; compiling (DEFUN MAKE-GRAMMAR ...)
; compiling (DEFUN GRAMMAR-DISCARD-MEMOS ...)
; compiling (DEFUN TERMINAL-P ...)
; compiling (DEFUN GRAMMAR-SYMBOLS ...)
; compiling (DEFUN GRAMMAR-EPSILON-PRODUCTIONS ...)
; compiling (DEFUN DERIVES-EPSILON ...)
; compiling (DEFUN DERIVES-EPSILON* ...)
; compiling (DEFUN SEQUENCE-DERIVES-EPSILON ...)
; compiling (DEFUN PRINT-DERIVES-EPSILON ...)
; compiling (DEFUN DERIVES-FIRST ...)
; compiling (DEFUN SEQUENCE-DERIVES-FIRST ...)
; compiling (DEFUN DERIVES-FIRST-TERMINAL ...)
; compiling (DEFUN SEQUENCE-DERIVES-FIRST-TERMINAL ...)
; compiling (DEFUN FIRST-TERMINALS ...)
; compiling (DEFUN SEQUENCE-FIRST-TERMINALS ...)
; compiling (DEFUN PRINT-FIRST-TERMINALS ...)
; compiling (DEFUN SEQUENCE-FIRST ...)
; compiling (DEFUN COMBINE-FIRST ...)
; compiling (DEFUN RELATIVE-FIRST ...)
; compiling (DEFUN RELATIVE-FIRST-SEQUENCE ...)
; compiling (DEFSTRUCT (ITEM # ...) ...)
; compiling (DEFSTRUCT (LR0-ITEM # ...) ...)
; compiling (DEFSTRUCT (LR1-ITEM # ...) ...)
; compiling (DEFUN PRINT-ITEM ...)
; compiling (DECLAIM (INLINE ITEM-DERIVES ...))
; compiling (DEFUN ITEM-DERIVES ...)
; compiling (DEFUN ITEM-SYMBOL ...)
; compiling (DEFUN ITEM-ACTION ...)
; compiling (DEFUN ITEM-ACTION-FORM ...)
; compiling (DEFUN ITEM-LR1-EQUAL-P ...)
; compiling (DEFUN ITEM-EQUAL-P ...)
; compiling (DEFUN ITEM-LR1-HASH-VALUE ...)
; compiling (DEFUN ITEM< ...)
; compiling (DEFUN ITEM-SET-EQUAL-P ...)
; compiling (DEFUN ITEM-DOT-RIGHT-P ...)
; compiling (DEFUN ITEM-DOT-SYMBOL ...)
; compiling (DEFUN ITEM-DOT-LEFT ...)
; compiling (DEFUN ITEM-DOT-RIGHT ...)
; compiling (DEFUN ITEM-SHIFT ...)
; compiling (DEFUN LR1-ITEM-SHIFT ...)
; compiling (DEFSTRUCT (KERNEL # ...) ...)
; compiling (DEFUN PRINT-KERNEL ...)
; compiling (DEFUN MAKE-KERNEL ...)
; compiling (DEFUN KERNEL-ITEM ...)
; compiling (DEFPARAMETER *ITEMS-CLOSURE-HASH-THRESHOLD* ...)
; compiling (DECLAIM (TYPE INDEX ...))
; compiling (DEFTYPE LR1-COLLECTION ...)
; compiling (DEFUN MAKE-LR1-COLLECTION ...)
; compiling (DEFUN LR1-COLLECTION-EMPTY-P ...)
; compiling (DEFUN CLEAR-LR1-COLLECTION ...)
; compiling (DEFUN MAKE-HASH-TABLE-FROM-LR1-LIST ...)
; compiling (DECLAIM (INLINE LR1-FIND))
; compiling (DEFUN LR1-FIND ...)
; compiling (DEFUN MAP-LR1-COLLECTION ...)
; compiling (DECLAIM (INLINE LR1-ADD))
; compiling (DEFUN LR1-ADD ...)
; compiling (DEFUN LR1-ADD-COLLECTION ...)
; compiling (DEFUN ITEMS-CLOSURE ...)
; compiling (DEFSTRUCT (GOTO #) ...)
; compiling (DECLAIM (INLINE GOTO-EQUAL-P ...))
; compiling (DEFUN GOTO-EQUAL-P ...)
; compiling (DEFUN FIND-GOTO ...)
; compiling (DEFUN COMPUTE-GOTO ...)
; compiling (DEFUN COMPUTE-KERNELS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.lisp
; in: DEFUN MEMQ
; (MEMBER YACC::ITEM LIST :TEST #'EQ)
; --> BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFUN COMPUTE-LOOKAHEADS ...)
; compiling (DEFUN COMPUTE-ALL-LOOKAHEADS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.lisp
; in: DEFUN MEMQ
; (MEMBER YACC::ITEM LIST :TEST #'EQ)
; --> BLOCK LET AND IF AND
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; --> BLOCK LET IF
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFUN PRINT-STATES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.lisp
; in: DEFUN PRINT-STATES
; (PPRINT-LOGICAL-BLOCK (STREAM (YACC::KERNEL-ITEMS YACC::K))
; (LOOP (PPRINT-EXIT-IF-LIST-EXHAUSTED)
; (LET* ((YACC::ITEM #))
; (IF YACC::LOOKAHEADS
; (FORMAT STREAM "~S ~_~S~:@_" YACC::ITEM #)
; (FORMAT STREAM "~S~:@_" YACC::ITEM)))))
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET LET IF CATCH BLOCK
; --> SB-C::%WITHIN-CLEANUP LET SB-PRETTY::MAKE-PRETTY-STREAM
; ==>
; STREAM
;
; note: deleting unreachable code
; compiling (DEFUN NUMBER-KERNELS ...)
; compiling (DEFUN PRINT-GOTO-GRAPH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.lisp
; in: DEFUN PRINT-GOTO-GRAPH
; (PPRINT-LOGICAL-BLOCK (STREAM (YACC::KERNEL-GOTOS YACC::K))
; (LOOP (PPRINT-EXIT-IF-LIST-EXHAUSTED)
; (LET ((YACC::G #))
; (FORMAT STREAM
; "~S -> ~S ~@:_"
; (YACC::GOTO-SYMBOL YACC::G)
; (YACC::KERNEL-ID #)))))
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET LET IF CATCH BLOCK
; --> SB-C::%WITHIN-CLEANUP LET SB-PRETTY::MAKE-PRETTY-STREAM
; ==>
; STREAM
;
; note: deleting unreachable code
; compiling (DEFSTRUCT (ACTION # ...))
; compiling (DEFSTRUCT (ACCEPT-ACTION #))
; compiling (DEFSTRUCT (REDUCE-ACTION # ...) ...)
; compiling (DEFSTRUCT (SHIFT-ACTION # ...) ...)
; compiling (DEFSTRUCT (ERROR-ACTION #))
; compiling (DEFUN ACTION-EQUAL-P ...)
; compiling (DEFUN PRINT-ACTION ...)
; compiling (DEFINE-CONDITION CONFLICT-WARNING ...)
; compiling (DEFINE-CONDITION CONFLICT-SUMMARY-WARNING ...)
; compiling (DEFSTRUCT (PARSER #) ...)
; compiling (DEFUN FIND-PRECEDENCE ...)
; compiling (DEFUN FIND-SINGLE-TERMINAL ...)
; compiling (DEFUN HANDLE-CONFLICT ...)
; compiling (DEFUN COMPUTE-PARSING-TABLES ...)
; compiling (DEFUN MAKE-PARSER ...)
; compiling (DEFINE-CONDITION YACC-PARSE-ERROR ...)
; compiling (DEFUN PARSE-WITH-LEXER ...)
; compiling (DEFUN PARSE-PRODUCTION ...)
; compiling (DEFUN PARSE-GRAMMAR ...)
; compiling (DEFMACRO DEFINE-GRAMMAR ...)
; compiling (DEFMACRO DEFINE-PARSER ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/yacc.fasl written
; compilation finished in 0:00:06
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp" (written 09 JAN 2006 05:48:46 AM):
; compiling (IN-PACKAGE :CL-PEG)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFCLASS PARSE-ELEMENT ...)
; compiling (DEFCLASS GROUPING-ELEMENT ...)
; compiling (DEFCLASS PARSE-ELEMENT-WITH-SLOT ...)
; compiling (DEFCLASS MAGIC-DOT ...)
; compiling (DEFCLASS EOF ...)
; compiling (DEFCLASS TRIVIAL-MATCH ...)
; compiling (DEFCLASS CALL-RULE ...)
; compiling (DEFCLASS CHARACTER-CLASS ...)
; compiling (DEFCLASS QUOTED-CHAR ...)
; compiling (DEFCLASS QUOTED-STRING ...)
; compiling (DEFCLASS NAMED-NON-TERMINAL ...)
; compiling (DEFCLASS GRAMMAR ...)
; compiling (DEFCLASS EXPRESSION-LIST ...)
; compiling (DEFCLASS ORDERED-EXPR-LIST ...)
; compiling (DEFCLASS ZERO-OR-MORE ...)
; compiling (DEFCLASS OPTIONAL ...)
; compiling (DEFCLASS NEGATED ...)
; compiling (DEFCLASS FOLLOWED-BY ...)
; compiling (DEFCLASS AT-LEAST-ONE ...)
; compiling (DEFCLASS BRACKETED-RULE ...)
; compiling (DEFGENERIC PREPARE-MATCHING-STRUCTURES ...)
; compiling (DEFGENERIC CLEAR-MATCH-RESULTS ...)
; compiling (DEFGENERIC PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFMETHOD PRINT-OBJECT (NAMED-NON-TERMINAL T)
; (DEFMETHOD PRINT-OBJECT
; ((CL-PEG::NT CL-PEG::NAMED-NON-TERMINAL) STREAM)
; (FORMAT STREAM "NT: ~S" (SLOT-VALUE CL-PEG::NT 'CL-PEG::NAME)))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST*
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET*
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK
; --> FORMAT
; ==>
; (FORMAT SB-C::DEST (FORMATTER "NT: ~S") #:G33)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER T NIL)
; STREAM
; (VECTOR CHARACTER)
; (VECTOR NIL)
; BASE-STRING), not a STREAM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MEMBER T NIL)
; STREAM
; (VECTOR CHARACTER)
; (VECTOR NIL)
; BASE-STRING), not a (MEMBER T).
; compiling (DEFGENERIC COMPARE ...)
; compiling (DEFGENERIC HASH ...)
; compiling (DEFUN PE-COMPARE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFUN PE-COMPARE
; (TYPEP CL-PEG::A 'CL-PEG::PARSE-ELEMENT)
;
; note: can't open-code test of unknown type PARSE-ELEMENT
; compiling (DEFUN PE-HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFUN PE-HASH
; (TYPECASE CL-PEG::A
; (CL-PEG::PARSE-ELEMENT
; (IF (NULL (SLOT-VALUE CL-PEG::A 'CL-PEG::HASH-VAL))
; (PROGN (SETF # #) (SLOT-VALUE CL-PEG::A 'CL-PEG::HASH-VAL))
; (SLOT-VALUE CL-PEG::A 'CL-PEG::HASH-VAL)))
; (T (SXHASH CL-PEG::A)))
; --> LET COND IF
; ==>
; (TYPEP #:G59 'CL-PEG::PARSE-ELEMENT)
;
; note: can't open-code test of unknown type PARSE-ELEMENT
; (SXHASH CL-PEG::A)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; compiling (REMHASH (QUOTE PEHASH1) ...)
; compiling (NET.HEXAPODIA.HASHTABLES:REGISTER-HASH-FUNCTION (QUOTE PEHASH1) ...)
; compiling (DEFVAR *PE-MAP*)
; compiling (SETF *PE-MAP* ...)
; compiling (DEFUN MEMOIZE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFMETHOD HASH (PARSE-ELEMENT-WITH-SLOT)
; (SXHASH (CLASS-OF CL-PEG::PE))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; (DEFMETHOD CL-PEG::HASH
; ((CL-PEG::PE CL-PEG::PARSE-ELEMENT-WITH-SLOT))
; (LOGXOR (SXHASH (CLASS-OF CL-PEG::PE))
; (SXHASH (SLOT-VALUE CL-PEG::PE 'CL-PEG::FEATURE))))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST*
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET*
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK
; --> LOGXOR
; ==>
; (SXHASH
; (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 1)
; CL-PEG::PE
; 0
; 'CL-PEG::FEATURE
; 'CL-PEG::PARSE-ELEMENT-WITH-SLOT))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; compiling (DEFMETHOD HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFMETHOD HASH (GROUPING-ELEMENT)
; (SXHASH (CLASS-OF CL-PEG::GE))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; (DEFMETHOD CL-PEG::HASH
; ((CL-PEG::GE CL-PEG::GROUPING-ELEMENT))
; (LOGXOR (SXHASH (CLASS-OF CL-PEG::GE))
; (CL-PEG::HASH (SLOT-VALUE CL-PEG::GE 'CL-PEG::EXPR))))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST*
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET*
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK
; ==>
; (LOGXOR (SXHASH (CLASS-OF CL-PEG::GE))
; (CL-PEG::HASH
; (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 1)
; CL-PEG::GE
; 0
; 'CL-PEG::EXPR
; 'CL-PEG::GROUPING-ELEMENT)))
;
; note: forced to do static-fun Two-arg-xor (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; compiling (DEFMETHOD HASH ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.lisp
; in: DEFMETHOD HASH (NAMED-NON-TERMINAL)
; (SXHASH (CLASS-OF CL-PEG::NT))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; (DEFMETHOD CL-PEG::HASH
; ((CL-PEG::NT CL-PEG::NAMED-NON-TERMINAL))
; (LOGXOR (SXHASH (CLASS-OF CL-PEG::NT))
; (SXHASH (SLOT-VALUE CL-PEG::NT 'CL-PEG::NAME))
; (CL-PEG::HASH (SLOT-VALUE CL-PEG::NT 'CL-PEG::EXPR))))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST*
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET*
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK
; --> LOGXOR LOGXOR LOGXOR
; ==>
; (SXHASH
; (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 2)
; CL-PEG::NT
; 0
; 'CL-PEG::NAME
; 'CL-PEG::NAMED-NON-TERMINAL))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a FIXNUM.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-BIT-VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SIMPLE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SYMBOL.
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST*
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET*
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK
; --> LOGXOR
; ==>
; (LOGXOR
; (LOGXOR (SXHASH (CLASS-OF CL-PEG::NT))
; (SXHASH
; (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 2)
; CL-PEG::NT
; 0
; 'CL-PEG::NAME
; 'CL-PEG::NAMED-NON-TERMINAL)))
; (CL-PEG::HASH
; (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 1)
; CL-PEG::NT
; 0
; 'CL-PEG::EXPR
; 'CL-PEG::NAMED-NON-TERMINAL)))
;
; note: forced to do static-fun Two-arg-xor (cost 53)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 3) because:
; The second argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; compiling (DEFMETHOD HASH ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFMETHOD COMPARE ...)
; compiling (DEFCLASS PARSE-TABLE ...)
; compiling (DEFUN MAKE-PARSE-TABLE ...)
; compiling (DEFVAR *PARSE-RESULT-TABLE*)
; compiling (DEFUN LOOKUP-PARSE-RESULT ...)
; compiling (DEFUN EXPAND-ARRAY ...)
; compiling (DEFUN SET-PARSE-RESULT ...)
; compiling (DEFMETHOD PREPARE-MATCHING-STRUCTURES ...)
; compiling (DEFMETHOD CLEAR-MATCH-RESULTS ...)
; compiling (DEFUN DUMP-PE-MAP ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegobjects.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.lisp" (written 09 JAN 2006 10:28:34 AM):
; compiling (IN-PACKAGE :CL-PEG)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFUN STR2LIST ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.lisp
; in: DEFUN STR2LIST
; (LOOP CL-PEG::FOR
; CL-PEG::I
; CL-PEG::ACROSS
; CL-PEG::STR
; CL-PEG::COLLECT
; CL-PEG::I)
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* SB-LOOP::LOOP-BODY
; --> TAGBODY SETQ THE
; ==>
; (LENGTH #:LOOP-ACROSS-VECTOR-6)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a VECTOR.
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* SB-LOOP::LOOP-BODY
; --> TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEFUN PRELEX ...)
; compiling (DEFUN MAKESTRINGTOKEN ...)
; compiling (DEFPARAMETER OPERATORSUBSTITUTIONS ...)
; compiling (DEFUN STRIP-COMMENTS ...)
; compiling (DEFUN LEX ...)
; compiling (DEFUN MAKEIDS ...)
; compiling (DEFUN PEG-LEXER ...)
; compiling (DEFUN STRIP-QUOTES ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.lisp
; in: DEFUN STRIP-QUOTES
; (LOOP CL-PEG::FOR
; CL-PEG::C
; CL-PEG::ACROSS
; CL-PEG::STR
; WHEN
; (NOT (OR (EQ CL-PEG::C #\') (EQ CL-PEG::C #\")))
; CL-PEG::COLLECT
; CL-PEG::C)
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* SB-LOOP::LOOP-BODY
; --> TAGBODY SETQ THE
; ==>
; (LENGTH #:LOOP-ACROSS-VECTOR-94)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR NULL VECTOR), not a VECTOR.
; (LENGTH CL-PEG::FILTERED-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (LOOP CL-PEG::FOR
; CL-PEG::C
; CL-PEG::ACROSS
; CL-PEG::STR
; WHEN
; (NOT (OR (EQ CL-PEG::C #\') (EQ CL-PEG::C #\")))
; CL-PEG::COLLECT
; CL-PEG::C)
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* SB-LOOP::LOOP-BODY
; --> TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEFUN DIDRULESET ...)
; compiling (DEFUN GRAMMAR ...)
; compiling (DEFUN RULESET ...)
; compiling (DEFUN EXPRESSION-LIST ...)
; compiling (DEFUN EXPRESSION-LIST2 ...)
; compiling (DEFUN ORDERED-EXPR-LIST ...)
; compiling (DEFUN TAIL-EXPRESSION-LIST ...)
; compiling (DEFUN CHARACTER-CLASS ...)
; compiling (DEFUN QUOTED-CHAR ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.lisp
; in: DEFUN QUOTED-CHAR
; (ELT CL-PEG::QC 0)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
; compiling (DEFUN QUOTED-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.lisp
; in: DEFUN QUOTED-STRING
; (LENGTH CL-PEG::FEATURE)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; compiling (DEFUN ZERO-OR-MORE ...)
; compiling (DEFUN NEGATED ...)
; compiling (DEFUN FOLLOWED-BY ...)
; compiling (DEFUN MAGIC-DOT ...)
; compiling (DEFUN EOF ...)
; compiling (DEFUN AT-LEAST-ONE ...)
; compiling (DEFUN OPTIONAL ...)
; compiling (DEFUN BRACKETED-RULE ...)
; compiling (DEFUN CALL-RULE ...)
; compiling (DEFUN NT1 ...)
; compiling (DEFUN RULESETS ...)
; compiling (DEFUN TRIVIAL-MATCH ...)
; compiling (YACC:DEFINE-PARSER *PEG-GRAMMAR-PARSER* ...)
; compiling (DEFUN CREATE-PEG-PARSER ...)
; compiling (DEFUN COLLECT-NON-TERMINALS ...)
; compiling (DEFUN FIND-NON-TERMINAL ...)
; compiling (EXPORT (QUOTE #))
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/pegreader.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining DIDRULESET in DEFUN
STYLE-WARNING: redefining GRAMMAR in DEFUN
STYLE-WARNING: redefining RULESET in DEFUN
STYLE-WARNING: redefining EXPRESSION-LIST in DEFUN
STYLE-WARNING: redefining EXPRESSION-LIST2 in DEFUN
STYLE-WARNING: redefining ORDERED-EXPR-LIST in DEFUN
STYLE-WARNING: redefining TAIL-EXPRESSION-LIST in DEFUN
STYLE-WARNING: redefining CHARACTER-CLASS in DEFUN
STYLE-WARNING: redefining QUOTED-CHAR in DEFUN
STYLE-WARNING: redefining QUOTED-STRING in DEFUN
STYLE-WARNING: redefining ZERO-OR-MORE in DEFUN
STYLE-WARNING: redefining NEGATED in DEFUN
STYLE-WARNING: redefining FOLLOWED-BY in DEFUN
STYLE-WARNING: redefining MAGIC-DOT in DEFUN
STYLE-WARNING: redefining EOF in DEFUN
STYLE-WARNING: redefining AT-LEAST-ONE in DEFUN
STYLE-WARNING: redefining OPTIONAL in DEFUN
STYLE-WARNING: redefining BRACKETED-RULE in DEFUN
STYLE-WARNING: redefining CALL-RULE in DEFUN
STYLE-WARNING: redefining NT1 in DEFUN
STYLE-WARNING: redefining RULESETS in DEFUN
STYLE-WARNING: redefining TRIVIAL-MATCH in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/matcher.lisp" (written 09 JAN 2006 05:48:46 AM):
; compiling (IN-PACKAGE :CL-PEG)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFVAR *NT-LOOKUP* ...)
; compiling (DEFVAR *KEEP-PARSE-RESULT* ...)
; compiling (DEFUN PARSE-AND-MATCH-SPECIAL ...)
; compiling (DEFSTRUCT (PV #) ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFSTRUCT (PR #) ...)
; compiling (DEFUN PR-START-OFFSET ...)
; compiling (DEFUN PR-END-OFFSET ...)
; compiling (DEFVAR *PARSE-FAILURE-SENTINEL* ...)
; compiling (DECLAIM (INLINE PARSE-FAIL))
; compiling (DEFUN PARSE-FAIL ...)
; compiling (DEFUN SAVE-PR ...)
; compiling (DECLAIM (INLINE GET-INPUT-EL))
; compiling (DEFUN GET-INPUT-EL ...)
; compiling (DECLAIM (INLINE GET-INPUT-ELEMENTS))
; compiling (DEFUN GET-INPUT-ELEMENTS ...)
; compiling (DEFUN PARSE ...)
; compiling (DEFUN P ...)
; compiling (DEFVAR *INPUT-STRING* ...)
; compiling (DEFUN PP ...)
; compiling (DEFUN PV-INPUT-STRING ...)
; compiling (DEFUN MATCHED-REGION ...)
; compiling (DEFUN MATCHED-ALL ...)
; compiling (DEFUN BUILD-PV-RESULT-TREE ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFINE-CONDITION MISSING-NON-TERMINAL ...)
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (EXPORT (QUOTE #))
; compiling (DEFMETHOD PARSE-AND-MATCH ...)
; compiling (DEFUN COLLAPSE-TREE ...)
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFUN FIND-TERM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-peg_0.02/matcher.fasl written
; compilation finished in 0:00:16
;
; compilation unit finished
; printed 68 notes