REPL Output
;;; ASDF-INSTALL: Downloading 55164 bytes from http://constantly.at/lisp/acl-compat.tar.gz to /Users/gwking/temporary/asdf-test/ACL-COMPAT.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/ACL-COMPAT.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/
acl-compat/
acl-compat/acl-compat-cmu.system
acl-compat/acl-compat-common-lisp-lw.lisp
acl-compat/acl-compat-corman.lisp
acl-compat/acl-compat.asd
acl-compat/acl-excl-common.lisp
acl-compat/acl-excl-corman.lisp
acl-compat/acl-mp-corman.lisp
acl-compat/acl-mp-package.lisp
acl-compat/acl-socket-corman.lisp
acl-compat/acl-ssl-streams.lisp
acl-compat/acl-ssl.lisp
acl-compat/allegro/
acl-compat/allegro/acl-excl.lisp
acl-compat/allegro/acl-mp.lisp
acl-compat/allegro/acl-socket.lisp
acl-compat/allegro/acl-sys.lisp
acl-compat/ChangeLog
acl-compat/chunked-stream-mixin.lisp
acl-compat/chunked.lisp
acl-compat/clisp/
acl-compat/clisp/acl-excl.lisp
acl-compat/clisp/acl-mp.lisp
acl-compat/clisp/acl-socket.lisp
acl-compat/clisp/acl-sys.lisp
acl-compat/cmucl/
acl-compat/cmucl/acl-excl.lisp
acl-compat/cmucl/acl-mp.lisp
acl-compat/cmucl/acl-socket.lisp
acl-compat/cmucl/acl-sys.lisp
acl-compat/CREDITS
acl-compat/defsys.lisp
acl-compat/lispworks/
acl-compat/lispworks/acl-excl.lisp
acl-compat/lispworks/acl-mp.lisp
acl-compat/lispworks/acl-socket.lisp
acl-compat/lispworks/acl-sys.lisp
acl-compat/lw-buffering.lisp
acl-compat/mcl/
acl-compat/mcl/acl-excl.lisp
acl-compat/mcl/acl-mp.lisp
acl-compat/mcl/acl-socket-mcl.lisp
acl-compat/mcl/acl-socket-openmcl.lisp
acl-compat/mcl/acl-sys.lisp
acl-compat/mcl/mcl-stream-fix.lisp
acl-compat/mcl/mcl-timers.lisp
acl-compat/packages.lisp
acl-compat/README
acl-compat/sbcl/
acl-compat/sbcl/acl-excl.lisp
acl-compat/sbcl/acl-mp.lisp
acl-compat/sbcl/acl-socket.lisp
acl-compat/sbcl/acl-sys.lisp
acl-compat/scl/
acl-compat/scl/acl-excl.lisp
acl-compat/scl/acl-mp.lisp
acl-compat/scl/acl-socket.lisp
acl-compat/scl/acl-sys.lisp
acl-compat/test-acl-socket.lisp
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/" ;;; ASDF-INSTALL: Downloading package CL-PPCRE, required by acl-compat
;;; 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:01
; 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:00
; 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:02
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:00
; 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 {10A5E561}>
; #: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:04
; 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:
; Th