starting phase `set-SOURCE-DATE-EPOCH'
phase `set-SOURCE-DATE-EPOCH' succeeded after 0.0 seconds
starting phase `set-paths'
environment variable `PATH' set to `/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/bin:/gnu/store/hqysqhh80g7qy8287b8p2gwz0379vh50-tar-1.34/bin:/gnu/store/8rvnivj15gmirawhikgbjaang5b4w779-gzip-1.10/bin:/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/bin:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/bin:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/bin:/gnu/store/49j4cjqc8sckyh4qhf9j9dmc6anc8wk9-diffutils-3.8/bin:/gnu/store/znjj5y98lvi46fll85qg22ngz966gx1d-patch-2.7.6/bin:/gnu/store/yq3xalg1p2p5p5hfpw4v5jx0v86qw45w-findutils-4.8.0/bin:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/bin:/gnu/store/dsldg7i4y6hxdknh7cv93rbxbp17xm93-sed-4.8/bin:/gnu/store/4znchc8whjbs50mvxgc0skmkvyhy9xk1-grep-3.6/bin:/gnu/store/wllq3y3sl5bldm9vsx2fcwhcmks4i9ar-coreutils-8.32/bin:/gnu/store/zyhbjfyqh10yiw1dw1x1i7n70jm9ygdn-make-4.3/bin:/gnu/store/2an4h5ndc22dv62q3l985ciq862q4bj7-bash-minimal-5.1.8/bin:/gnu/store/g58zxpycy64m790vwjlzpadmbn065fia-ld-wrapper-0/bin:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/bin:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/bin:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/bin:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/sbin'
environment variable `XDG_DATA_DIRS' set to `/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/share:/gnu/store/v0qv7zggz2s69inbafmwialz2lh4ligp-sbcl-flexi-streams-1.0.19/share:/gnu/store/hqysqhh80g7qy8287b8p2gwz0379vh50-tar-1.34/share:/gnu/store/8rvnivj15gmirawhikgbjaang5b4w779-gzip-1.10/share:/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/share:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/share:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/share:/gnu/store/49j4cjqc8sckyh4qhf9j9dmc6anc8wk9-diffutils-3.8/share:/gnu/store/znjj5y98lvi46fll85qg22ngz966gx1d-patch-2.7.6/share:/gnu/store/yq3xalg1p2p5p5hfpw4v5jx0v86qw45w-findutils-4.8.0/share:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/share:/gnu/store/dsldg7i4y6hxdknh7cv93rbxbp17xm93-sed-4.8/share:/gnu/store/4znchc8whjbs50mvxgc0skmkvyhy9xk1-grep-3.6/share:/gnu/store/wllq3y3sl5bldm9vsx2fcwhcmks4i9ar-coreutils-8.32/share:/gnu/store/zyhbjfyqh10yiw1dw1x1i7n70jm9ygdn-make-4.3/share:/gnu/store/2an4h5ndc22dv62q3l985ciq862q4bj7-bash-minimal-5.1.8/share:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/share:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/share:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/share:/gnu/store/88bdm10sayqjnggrxlbdmk3rv1qqdrvl-glibc-2.33-static/share:/gnu/store/k8xlwnnmhgmvzyxxfjq3z3fci73zx7x9-linux-libre-headers-5.10.35/share'
environment variable `XDG_CONFIG_DIRS' set to `/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/etc:/gnu/store/v0qv7zggz2s69inbafmwialz2lh4ligp-sbcl-flexi-streams-1.0.19/etc:/gnu/store/hqysqhh80g7qy8287b8p2gwz0379vh50-tar-1.34/etc:/gnu/store/8rvnivj15gmirawhikgbjaang5b4w779-gzip-1.10/etc:/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/etc:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/etc:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/etc:/gnu/store/49j4cjqc8sckyh4qhf9j9dmc6anc8wk9-diffutils-3.8/etc:/gnu/store/znjj5y98lvi46fll85qg22ngz966gx1d-patch-2.7.6/etc:/gnu/store/yq3xalg1p2p5p5hfpw4v5jx0v86qw45w-findutils-4.8.0/etc:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/etc:/gnu/store/dsldg7i4y6hxdknh7cv93rbxbp17xm93-sed-4.8/etc:/gnu/store/4znchc8whjbs50mvxgc0skmkvyhy9xk1-grep-3.6/etc:/gnu/store/wllq3y3sl5bldm9vsx2fcwhcmks4i9ar-coreutils-8.32/etc:/gnu/store/zyhbjfyqh10yiw1dw1x1i7n70jm9ygdn-make-4.3/etc:/gnu/store/2an4h5ndc22dv62q3l985ciq862q4bj7-bash-minimal-5.1.8/etc:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/etc:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/etc:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/etc'
environment variable `BASH_LOADABLES_PATH' unset
environment variable `C_INCLUDE_PATH' set to `/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/include:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/include:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/include:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/include:/gnu/store/zyhbjfyqh10yiw1dw1x1i7n70jm9ygdn-make-4.3/include:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/include:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/include:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/include:/gnu/store/k8xlwnnmhgmvzyxxfjq3z3fci73zx7x9-linux-libre-headers-5.10.35/include'
environment variable `CPLUS_INCLUDE_PATH' set to `/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/include:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/include:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/include:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/include:/gnu/store/zyhbjfyqh10yiw1dw1x1i7n70jm9ygdn-make-4.3/include:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/include:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/include/c++:/gnu/store/h88kd46c8br0wc4i6hq19cjby081ina4-gcc-10.3.0/include:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/include:/gnu/store/k8xlwnnmhgmvzyxxfjq3z3fci73zx7x9-linux-libre-headers-5.10.35/include'
environment variable `LIBRARY_PATH' set to `/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/lib:/gnu/store/v0qv7zggz2s69inbafmwialz2lh4ligp-sbcl-flexi-streams-1.0.19/lib:/gnu/store/64zk0izmaframq6cd0xlsmk0rxn3zc52-bzip2-1.0.8/lib:/gnu/store/z6bw81zw5b5jm3p02y906p0wnjbjqa7n-xz-5.2.5/lib:/gnu/store/jfmrxybjkd0nvh1n34hbzv0lwsnmxz1v-file-5.39/lib:/gnu/store/bgyr8c7bl1sqhpapm2kghiya0k6zvi51-gawk-5.1.0/lib:/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/lib:/gnu/store/mjdjgiz9k5rrbj440r16z6p5g33nr7d7-glibc-2.33/lib:/gnu/store/88bdm10sayqjnggrxlbdmk3rv1qqdrvl-glibc-2.33-static/lib:/gnu/store/y4x3whxg8i1p9w9vy67lz3cw8xfil8bh-glibc-utf8-locales-2.33/lib'
environment variable `GUIX_LOCPATH' set to `/gnu/store/y4x3whxg8i1p9w9vy67lz3cw8xfil8bh-glibc-utf8-locales-2.33/lib/locale'
phase `set-paths' succeeded after 0.0 seconds
starting phase `install-locale'
using 'en_US.utf8' locale for category "LC_ALL"
phase `install-locale' succeeded after 0.0 seconds
starting phase `unpack'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/specials.lisp' -> `./specials.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/charmap.lisp' -> `./charmap.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/parser.lisp' -> `./parser.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/charset.lisp' -> `./charset.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/regex-class-util.lisp' -> `./regex-class-util.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/lexer.lisp' -> `./lexer.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/convert.lisp' -> `./convert.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/CHANGELOG' -> `./CHANGELOG'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/errors.lisp' -> `./errors.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/closures.lisp' -> `./closures.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/repetition-closures.lisp' -> `./repetition-closures.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/util.lisp' -> `./util.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/README.md' -> `./README.md'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/chartest.lisp' -> `./chartest.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/cl-ppcre-unicode.asd' -> `./cl-ppcre-unicode.asd'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/api.lisp' -> `./api.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/scanner.lisp' -> `./scanner.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/regex-class.lisp' -> `./regex-class.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/cl-ppcre.asd' -> `./cl-ppcre.asd'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/optimize.lisp' -> `./optimize.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/packages.lisp' -> `./packages.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/perltestinput' -> `./test/perltestinput'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/perltestdata' -> `./test/perltestdata'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/simple' -> `./test/simple'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/perltest.pl' -> `./test/perltest.pl'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/perl-tests.lisp' -> `./test/perl-tests.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/unicode-tests.lisp' -> `./test/unicode-tests.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/tests.lisp' -> `./test/tests.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/unicodetestdata' -> `./test/unicodetestdata'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/test/packages.lisp' -> `./test/packages.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/cl-ppcre-unicode/resolver.lisp' -> `./cl-ppcre-unicode/resolver.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/cl-ppcre-unicode/packages.lisp' -> `./cl-ppcre-unicode/packages.lisp'
`/gnu/store/mv9lln1dc4vabl4qgc4ia79x1fbxqzwb-cl-ppcre-2.1.1-checkout/docs/index.html' -> `./docs/index.html'
phase `unpack' succeeded after 0.1 seconds
starting phase `disable-ppcre-unicode'
phase `disable-ppcre-unicode' succeeded after 0.0 seconds
starting phase `patch-usr-bin-file'
phase `patch-usr-bin-file' succeeded after 0.0 seconds
starting phase `patch-source-shebangs'
patch-shebang: ./test/perltest.pl: warning: no binary for interpreter `perl' found in $PATH
phase `patch-source-shebangs' succeeded after 0.0 seconds
starting phase `copy-source'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/specials.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/specials.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/charmap.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/charmap.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/parser.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/parser.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/charset.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/charset.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/regex-class-util.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/regex-class-util.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/lexer.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/lexer.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/convert.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/convert.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/CHANGELOG' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/CHANGELOG'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/errors.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/errors.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/closures.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/closures.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/repetition-closures.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/repetition-closures.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/util.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/util.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/README.md' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/README.md'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/chartest.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/chartest.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/api.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/api.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/scanner.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/scanner.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/regex-class.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/regex-class.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/cl-ppcre.asd' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/cl-ppcre.asd'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/optimize.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/optimize.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/packages.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/packages.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/perltestinput' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/perltestinput'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/perltestdata' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/perltestdata'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/simple' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/simple'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/perltest.pl' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/perltest.pl'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/perl-tests.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/perl-tests.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/unicode-tests.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/unicode-tests.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/tests.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/tests.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/unicodetestdata' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/unicodetestdata'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/test/packages.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/test/packages.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/cl-ppcre-unicode/resolver.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/cl-ppcre-unicode/resolver.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/cl-ppcre-unicode/packages.lisp' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/cl-ppcre-unicode/packages.lisp'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/docs/index.html' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/source/cl-ppcre/docs/index.html'
phase `copy-source' succeeded after 0.0 seconds
starting phase `configure'
warning: collision encountered:
/gnu/store/g58zxpycy64m790vwjlzpadmbn065fia-ld-wrapper-0/bin/ld
/gnu/store/cr38d3gvf52ckns2b01lwgw86hk3mvcc-binutils-2.37/bin/ld
warning: choosing /gnu/store/g58zxpycy64m790vwjlzpadmbn065fia-ld-wrapper-0/bin/ld
phase `configure' succeeded after 0.6 seconds
starting phase `patch-generated-file-shebangs'
phase `patch-generated-file-shebangs' succeeded after 0.2 seconds
starting phase `build'
Invoking sbcl: "/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/bin/sbcl" "--non-interactive" "--eval" "(require :asdf)" "--eval" "(asdf:load-asd (truename \"/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/cl-ppcre.asd\"))" "--eval" "(asdf:compile-system \"cl-ppcre\")"
This is SBCL 2.1.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/packages.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-USER)
; processing (DEFPACKAGE :CL-PPCRE ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/packages-tmp7LQ0A0VI.fasl
; compilation finished in 0:00:00.012
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/specials.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFVAR *STANDARD-OPTIMIZE-SETTINGS* ...)
; processing (DEFVAR *SPECIAL-OPTIMIZE-SETTINGS* ...)
; processing (DEFVAR *EXTENDED-MODE-P* ...)
; processing (DECLAIM (BOOLEAN *EXTENDED-MODE-P*))
; processing (DEFVAR *REGEX-CHAR-CODE-LIMIT* ...)
; processing (DECLAIM (FIXNUM *REGEX-CHAR-CODE-LIMIT*))
; processing (DEFVAR *STRING* ...)
; processing (DECLAIM (SIMPLE-STRING *STRING*))
; processing (DEFVAR *START-POS* ...)
; processing (DECLAIM (FIXNUM *START-POS*))
; processing (DEFVAR *REAL-START-POS* ...)
; processing (DECLAIM (TYPE # ...))
; processing (DEFVAR *END-POS* ...)
; processing (DECLAIM (FIXNUM *END-POS*))
; processing (DEFVAR *REG-STARTS* ...)
; processing (DECLAIM (SIMPLE-VECTOR *REG-STARTS*))
; processing (DEFVAR *REGS-MAYBE-START* ...)
; processing (DECLAIM (SIMPLE-VECTOR *REGS-MAYBE-START*))
; processing (DEFVAR *REG-ENDS* ...)
; processing (DECLAIM (SIMPLE-VECTOR *REG-ENDS*))
; processing (DEFVAR *END-STRING-POS* ...)
; processing (DEFVAR *REP-NUM* ...)
; processing (DECLAIM (FIXNUM *REP-NUM*))
; processing (DEFVAR *ZERO-LENGTH-NUM* ...)
; processing (DECLAIM (FIXNUM *ZERO-LENGTH-NUM*))
; processing (DEFVAR *REPEAT-COUNTERS* ...)
; processing (DECLAIM (TYPE # ...))
; processing (DEFVAR *LAST-POS-STORES* ...)
; processing (DECLAIM (SIMPLE-VECTOR *LAST-POS-STORES*))
; processing (DEFVAR *USE-BMH-MATCHERS* ...)
; processing (DEFVAR *OPTIMIZE-CHAR-CLASSES* ...)
; processing (DEFVAR *PROPERTY-RESOLVER* ...)
; processing (DEFVAR *ALLOW-QUOTING* ...)
; processing (DEFVAR *ALLOW-NAMED-REGISTERS* ...)
; processing (PUSHNEW :CL-PPCRE ...)
; processing (DEFVAR *HYPERDOC-BASE-URI* ...)
; processing (LET (#) ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/specials-tmp74KGUNRZ.fasl
; compilation finished in 0:00:00.100
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/util.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFMACRO DEFCONSTANT ...)
; processing (DEFMACRO WITH-UNIQUE-NAMES ...)
; processing (DEFMACRO WITH-REBINDING ...)
; processing (DECLAIM (INLINE DIGIT-CHAR-P))
; processing (DEFUN DIGIT-CHAR-P ...)
; processing (DECLAIM (INLINE WORD-CHAR-P))
; processing (DEFUN WORD-CHAR-P ...)
; processing (DEFCONSTANT +WHITESPACE-CHAR-STRING+ ...)
; processing (DEFUN WHITESPACEP ...)
; processing (DEFMACRO MAYBE-COERCE-TO-SIMPLE-STRING ...)
; processing (DECLAIM (INLINE NSUBSEQ))
; processing (DEFUN NSUBSEQ ...)
; processing (DEFUN NORMALIZE-VAR-LIST ...)
; processing (DEFUN STRING-LIST-TO-SIMPLE-STRING ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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 * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a STRING, not a SIMPLE-BASE-STRING.
; processing (DEFUN COMPLEMENT* ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/util.lisp
; in: DEFUN COMPLEMENT*
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/util-tmpCEL1YIM2.fasl
; compilation finished in 0:00:00.048
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/errors.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFVAR *SYNTAX-ERROR-STRING* ...)
; processing (DEFINE-CONDITION PPCRE-ERROR ...)
; processing (DEFINE-CONDITION PPCRE-SYNTAX-ERROR ...)
; processing (SETF (DOCUMENTATION # ...) ...)
; processing (SETF (DOCUMENTATION # ...) ...)
; processing (DEFINE-CONDITION PPCRE-INVOCATION-ERROR ...)
; processing (DEFMACRO SIGNAL-SYNTAX-ERROR* ...)
; processing (DEFMACRO SIGNAL-SYNTAX-ERROR ...)
; processing (DEFMACRO SIGNAL-INVOCATION-ERROR ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/errors-tmpHAMQABTV.fasl
; compilation finished in 0:00:00.016
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFCONSTANT +PROBE-DEPTH+ ...)
; processing (DEFUN MAKE-CHAR-VECTOR ...)
; processing (DEFSTRUCT (CHARSET #) ...)
; processing (DEFMETHOD MAKE-LOAD-FORM ...)
; processing (DECLAIM (INLINE MIX))
; processing (DEFUN MIX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp
; in: DEFUN MIX
; (+ CL-PPCRE::CODE CL-PPCRE::HASH)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DECLAIM (INLINE COMPUTE-INDEX))
; processing (DEFUN COMPUTE-INDEX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp
; in: DEFUN COMPUTE-INDEX
; (LENGTH VECTOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; (1+ (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR))))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR FLOAT
; (RATIONAL (-536870907) (536870907))), not a FLOAT.
;
; note: unable to
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a (OR FLOAT
; (RATIONAL (-536870907)
; (536870907))), not a RATIONAL.
; (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR)))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR FLOAT
; (RATIONAL (-536870907) (536870907))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR FLOAT
; (RATIONAL (-536870907) (536870907))), not a FLOAT.
;
; 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 FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; 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.
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR FLOAT (RATIONAL (-536870907) (536870907))), not a FIXNUM.
; The result is a (VALUES (OR FLOAT (RATIONAL (-536870908) (1073741814)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a (OR FLOAT (RATIONAL (-536870907) (536870907))), not a (SIGNED-BYTE
; 32).
; The result is a (VALUES (OR FLOAT (RATIONAL (-536870908) (1073741814)))
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a (RATIONAL (-536870908) (1073741814)), not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (RATIONAL (-536870908) (1073741814)), 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 (RATIONAL (-536870907) (1073741814)), not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (RATIONAL (-536870907) (1073741814)), not a FIXNUM.
; etc.
; (1+ (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR))))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR FLOAT (RATIONAL (-536870907) (536870907))), not a FIXNUM.
; The result is a (VALUES (OR FLOAT (RATIONAL (-536870906) (536870908)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR FLOAT (RATIONAL (-536870907) (536870907))), not a FIXNUM.
; The result is a (VALUES (OR FLOAT (RATIONAL (-536870906) (536870908)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFUN IN-CHARSET-P ...)
; processing (DEFUN ADD-TO-CHARSET ...)
; processing (DEFUN %ADD-TO-CHARSET ...)
; processing (DEFUN %ADD-TO-CHARSET/EXPAND ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp
; in: DEFUN %ADD-TO-CHARSET/EXPAND
; (* 2 CL-PPCRE::NEW-SIZE)
;
; note: unable to
; recode as leas, shifts and adds
; due to type uncertainty:
; The first argument is a NUMBER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST T).
;
; note: unable to
; recode as leas, shifts and adds
; due to type uncertainty:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-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
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
;
; note: unable to
; associate */(* /) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (>= CL-PPCRE::NEW-SIZE 371370)
;
; 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 FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT * 371370.0d0)
; (SINGLE-FLOAT * 371370.0)
; (RATIONAL * 371370)), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (* 2 CL-PPCRE::NEW-SIZE)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 3) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (>= CL-PPCRE::NEW-SIZE 371370)
;
; 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* ((CL-PPCRE::OLD-VECTOR (CL-PPCRE::CHARSET-VECTOR SET))
; (CL-PPCRE::NEW-SIZE (* 2 (LENGTH CL-PPCRE::OLD-VECTOR))))
; (TAGBODY
; :RETRY
; (MULTIPLE-VALUE-BIND (CL-PPCRE::NEW-DEPTH CL-PPCRE::NEW-VECTOR)
; (IF (>= CL-PPCRE::NEW-SIZE 371370)
; (VALUES 0 #)
; (VALUES CL-PPCRE::+PROBE-DEPTH+ #))
; (SETF # CL-PPCRE::NEW-DEPTH
; # CL-PPCRE::NEW-VECTOR)
; (FLET (#)
; (CL-PPCRE::TRY-ADD CHAR)
; (DOTIMES # #))))
; (INCF (CL-PPCRE::CHARSET-COUNT SET))
; T)
;
; note: doing signed word to integer coercion (cost 20) to NEW-SIZE
; processing (DEFUN MAP-CHARSET ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp
; in: DEFUN MAP-CHARSET
; (DECF CL-PPCRE::N)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER * 536870911), not a FIXNUM.
; The result is a (VALUES (INTEGER * 536870910) &OPTIONAL), not a (VALUES
; FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER * 536870911), not a FIXNUM.
; The result is a (VALUES (INTEGER * 536870910) &OPTIONAL), not a (VALUES
; FIXNUM
; &REST T).
; etc.
; processing (DEFUN CREATE-CHARSET-FROM-TEST-FUNCTION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charset.lisp
; in: DEFUN CREATE-CHARSET-FROM-TEST-FUNCTION
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (LOOP CL-PPCRE::WITH CL-PPCRE::CHARSET = (CL-PPCRE::MAKE-CHARSET)
; CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
; CL-PPCRE::END
; CL-PPCRE::FOR ...)
; --> BLOCK LET LET LET TAGBODY WHEN IF
; ==>
; (>= CL-PPCRE::CODE #:LOOP-LIMIT-0)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/charset-tmpUPMG0IBO.fasl
; compilation finished in 0:00:00.076
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charmap.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFSTRUCT (CHARMAP #) ...)
; processing (DEFMETHOD MAKE-LOAD-FORM ...)
; processing (DECLAIM (INLINE IN-CHARMAP-P))
; processing (DEFUN IN-CHARMAP-P ...)
; processing (DEFUN CHARMAP-CONTENTS ...)
; processing (DEFUN MAKE-CHARMAP ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charmap.lisp
; in: DEFUN MAKE-CHARMAP
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; processing (DEFUN CREATE-CHARMAP-FROM-TEST-FUNCTION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/charmap.lisp
; in: DEFUN CREATE-CHARMAP-FROM-TEST-FUNCTION
; (1- CL-PPCRE::END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM (1-
; CL-PPCRE::END) CL-PPCRE::DOWNTO CL-PPCRE::START
; CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
; CL-PPCRE::UNTIL ...)
; --> BLOCK LET LET TAGBODY WHEN IF
; ==>
; (< CL-PPCRE::CODE #:LOOP-LIMIT-23)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
; CL-PPCRE::END
; CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
; CL-PPCRE::UNTIL ...)
; --> BLOCK LET LET TAGBODY WHEN IF
; ==>
; (>= CL-PPCRE::CODE #:LOOP-LIMIT-0)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (1- CL-PPCRE::END)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM (1-
; CL-PPCRE::END) CL-PPCRE::DOWNTO CL-PPCRE::START
; CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
; CL-PPCRE::UNTIL ...)
; --> BLOCK LET LET TAGBODY WHEN IF
; ==>
; (< CL-PPCRE::CODE #:LOOP-LIMIT-23)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/charmap-tmpAKM32D0F.fasl
; compilation finished in 0:00:00.060
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/chartest.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFUN CREATE-HASH-TABLE-FROM-TEST-FUNCTION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/chartest.lisp
; in: DEFUN CREATE-HASH-TABLE-FROM-TEST-FUNCTION
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (LOOP CL-PPCRE::WITH HASH-TABLE = (MAKE-HASH-TABLE)
; CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
; CL-PPCRE::END
; CL-PPCRE::FOR ...)
; --> BLOCK LET LET LET TAGBODY WHEN IF
; ==>
; (>= CL-PPCRE::CODE #:LOOP-LIMIT-0)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; processing (DEFUN CREATE-OPTIMIZED-TEST-FUNCTION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/chartest.lisp
; in: DEFUN CREATE-OPTIMIZED-TEST-FUNCTION
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
;
; note: unable to
; convert integer division to multiplication
; due to type uncertainty:
; The first argument is a REAL, not a (UNSIGNED-BYTE 32).
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR FLOAT (RATIONAL (-2) (2))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
;
; note: unable to
; convert integer division to multiplication
; due to type uncertainty:
; The first argument is a REAL, not a (UNSIGNED-BYTE 32).
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR FLOAT (RATIONAL (-2) (2))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; 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.
; (<= (HASH-TABLE-COUNT HASH-TABLE)
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a INTEGER, not a FIXNUM.
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (<= (CL-PPCRE::CHARSET-COUNT CL-PPCRE::CHARSET)
; (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a INTEGER, not a FIXNUM.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/chartest-tmp8UG37QJ5.fasl
; compilation finished in 0:00:00.028
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/lexer.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DECLAIM (INLINE MAP-CHAR-TO-SPECIAL-CLASS))
; processing (DEFUN MAP-CHAR-TO-SPECIAL-CHAR-CLASS ...)
; processing (DECLAIM (INLINE MAKE-LEXER-INTERNAL))
; processing (DEFSTRUCT (LEXER #) ...)
; processing (DEFUN MAKE-LEXER ...)
; processing (DECLAIM (INLINE END-OF-STRING-P))
; processing (DEFUN END-OF-STRING-P ...)
; processing (DECLAIM (INLINE LOOKING-AT-P))
; processing (DEFUN LOOKING-AT-P ...)
; processing (DECLAIM (INLINE NEXT-CHAR-NON-EXTENDED))
; processing (DEFUN NEXT-CHAR-NON-EXTENDED ...)
; processing (DEFUN NEXT-CHAR ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/lexer.lisp
; in: DEFUN NEXT-CHAR
; (CL-PPCRE::SIGNAL-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)
; processing (DECLAIM (INLINE FAIL))
; processing (DEFUN FAIL ...)
; processing (DEFUN GET-NUMBER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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)
; processing (DECLAIM (INLINE TRY-NUMBER))
; processing (DEFUN TRY-NUMBER ...)
; processing (DECLAIM (INLINE MAKE-CHAR-FROM-CODE))
; processing (DEFUN MAKE-CHAR-FROM-CODE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
; (CL-PPCRE::SIGNAL-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
; "No character for hex-code ~X." NUMBER)
; --> ERROR
; ==>
; CL-PPCRE::ERROR-POS
;
; note: deleting unreachable code
; processing (DEFUN UNESCAPE-CHAR ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/lexer.lisp
; 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.
; processing (DEFUN READ-CHAR-PROPERTY ...)
; processing (DEFUN COLLECT-CHAR-CLASS ...)
; processing (DEFUN MAYBE-PARSE-FLAGS ...)
; processing (DEFUN GET-QUANTIFIER ...)
; processing (DEFUN PARSE-REGISTER-NAME-AUX ...)
; processing (DECLAIM (INLINE UNGET-TOKEN))
; processing (DEFUN UNGET-TOKEN ...)
; processing (DEFUN GET-TOKEN ...)
; processing (DECLAIM (INLINE START-OF-SUBEXPR-P))
; processing (DEFUN START-OF-SUBEXPR-P ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/lexer-tmp65YV5VYW.fasl
; compilation finished in 0:00:00.184
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/parser.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFUN GROUP ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/parser.lisp
; in: DEFUN GROUP
; (CL-PPCRE::SIGNAL-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)
; processing (DEFUN GREEDY-QUANT ...)
; processing (DEFUN QUANT ...)
; processing (DEFUN SEQ ...)
; processing (DEFUN REG-EXPR ...)
; processing (DEFUN PARSE-STRING ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/parser-tmpGO4MNX7G.fasl
; compilation finished in 0:00:00.040
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFCLASS REGEX ...)
; processing (DEFCLASS SEQ ...)
; processing (DEFCLASS ALTERNATION ...)
; processing (DEFCLASS LOOKAHEAD ...)
; processing (DEFCLASS LOOKBEHIND ...)
; processing (DEFCLASS REPETITION ...)
; processing (DEFMETHOD PRINT-OBJECT ...)
; processing (DEFCLASS REGISTER ...)
; processing (DEFMETHOD PRINT-OBJECT ...)
; processing (DEFCLASS STANDALONE ...)
; processing (DEFCLASS BACK-REFERENCE ...)
; processing (DEFCLASS CHAR-CLASS ...)
; processing (DEFCLASS STR ...)
; processing (DEFMETHOD PRINT-OBJECT ...)
; processing (DEFCLASS ANCHOR ...)
; processing (DEFCLASS EVERYTHING ...)
; processing (DEFCLASS WORD-BOUNDARY ...)
; processing (DEFCLASS BRANCH ...)
; processing (DEFCLASS FILTER ...)
; processing (DEFCLASS VOID ...)
; processing (DEFMETHOD INITIALIZE-INSTANCE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (STR)
; (COERCE CL-PPCRE::STR-SLOT 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; (LENGTH (CL-PPCRE::STR CL-PPCRE::STR))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/regex-class-tmp9NXH2K1.fasl
; compilation finished in 0:00:00.024
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFMETHOD LEN ...)
; processing (DEFMETHOD STR ...)
; processing (DEFMETHOD SKIP ...)
; processing (DEFMETHOD START-OF-END-STRING-P ...)
; processing (DEFGENERIC CASE-MODE ...)
; processing (DEFMETHOD CASE-MODE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD CASE-MODE (STR T)
; (ZEROP (CL-PPCRE::LEN CL-PPCRE::STR))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
; processing (DEFMETHOD CASE-MODE ...)
; processing (DEFGENERIC COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFMETHOD COPY-REGEX ...)
; processing (DEFGENERIC REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFMETHOD REMOVE-REGISTERS ...)
; processing (DEFGENERIC EVERYTHINGP ...)
; processing (DEFMETHOD EVERYTHINGP ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD EVERYTHINGP (SEQ)
; (LENGTH CL-PPCRE::CLEANED-ELEMENTS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; processing (DEFMETHOD EVERYTHINGP ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD EVERYTHINGP (ALTERNATION)
; (AND (= 1 (LENGTH CL-PPCRE::CHOICES))
; (CL-PPCRE::EVERYTHINGP (FIRST CL-PPCRE::CHOICES)))
; --> IF =
; ==>
; (LENGTH
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::CHOICES)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::CHOICES)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; processing (DEFMETHOD EVERYTHINGP ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD EVERYTHINGP (REPETITION)
; (AND CL-PPCRE::MAXIMUM (= 1 CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; (CL-PPCRE::EVERYTHINGP CL-PPCRE::REGEX))
; --> IF IF
; ==>
; (= 1
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a (COMPLEX
; DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a (OR
; (COMPLEX
; SINGLE-FLOAT)
; (COMPLEX
; DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), 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 (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), 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 (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), 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 (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), 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 (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), 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 (OR (DOUBLE-FLOAT 1.0d0 1.0d0) (SINGLE-FLOAT 1.0 1.0)
; (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0)
; (SINGLE-FLOAT 1.0 1.0) (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR (DOUBLE-FLOAT 1.0d0 1.0d0)
; (SINGLE-FLOAT 1.0 1.0) (INTEGER 1 1)
; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))
; (COMPLEX (SINGLE-FLOAT 1.0 1.0))
; (COMPLEX (INTEGER 1 1))), not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; processing (DEFMETHOD EVERYTHINGP ...)
; processing (DEFMETHOD EVERYTHINGP ...)
; processing (DEFMETHOD EVERYTHINGP ...)
; processing (DEFMETHOD EVERYTHINGP ...)
; processing (DEFGENERIC REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-LENGTH (SEQ)
; (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::ELEMENTS
; CL-PPCRE::SEQ)
; CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-LENGTH
; CL-PPCRE::SUB-REGEX)
; IF (NOT CL-PPCRE::LEN)
; DO ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE
; ==>
; (+ #:LOOP-SUM-5 CL-PPCRE::LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD REGEX-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-LENGTH (ALTERNATION)
; (/= CL-PPCRE::LEN CL-PPCRE::OLD-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; processing (DEFMETHOD REGEX-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-LENGTH (BRANCH)
; (EQL CL-PPCRE::THEN-LENGTH
; (CL-PPCRE::REGEX-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (NOT NULL), not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; processing (DEFMETHOD REGEX-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-LENGTH (REPETITION)
; (AND CL-PPCRE::LEN (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM))
; --> IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; (WITH-SLOTS (CL-PPCRE::LEN CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; CL-PPCRE::REPETITION
; (IF (AND CL-PPCRE::LEN (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM))
; (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; NIL))
; --> LET SYMBOL-MACROLET IF
; ==>
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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 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 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 DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (AND CL-PPCRE::LEN (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM))
; --> IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; (WITH-SLOTS (CL-PPCRE::LEN CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; CL-PPCRE::REPETITION
; (IF (AND CL-PPCRE::LEN (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM))
; (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; NIL))
; --> LET SYMBOL-MACROLET IF
; ==>
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFMETHOD REGEX-LENGTH ...)
; processing (DEFGENERIC REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-MIN-LENGTH (SEQ)
; (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::ELEMENTS
; CL-PPCRE::SEQ)
; CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-MIN-LENGTH
; CL-PPCRE::SUB-REGEX)
; CL-PPCRE::SUM CL-PPCRE::LEN)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE
; ==>
; (+ #:LOOP-SUM-5 CL-PPCRE::LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-MIN-LENGTH (ALTERNATION)
; (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::CHOICES
; CL-PPCRE::ALTERNATION)
; CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-MIN-LENGTH
; CL-PPCRE::SUB-REGEX)
; CL-PPCRE::MINIMIZE CL-PPCRE::LEN)
; --> BLOCK LET LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF
; ==>
; (< #:LOOP-MAXMIN-TEMP-9 #:LOOP-MAXMIN-8)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-MIN-LENGTH (BRANCH)
; (MIN (CL-PPCRE::REGEX-MIN-LENGTH (CL-PPCRE::THEN-REGEX CL-PPCRE::BRANCH))
; (CL-PPCRE::REGEX-MIN-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD REGEX-MIN-LENGTH (REPETITION)
; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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 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 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 DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFMETHOD REGEX-MIN-LENGTH ...)
; processing (DEFGENERIC COMPUTE-OFFSETS ...)
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (ALTERNATION T)
; (/= CL-PPCRE::CURR-OFFSET CL-PPCRE::OLD-OFFSET)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (BRANCH T)
; (EQL CL-PPCRE::THEN-OFFSET
; (CL-PPCRE::COMPUTE-OFFSETS (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)
; CL-PPCRE::START-POS))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (NOT NULL), not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (REPETITION T)
; (WITH-SLOTS (CL-PPCRE::LEN CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; CL-PPCRE::REPETITION
; (IF (AND CL-PPCRE::LEN (EQ CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM))
; (+ CL-PPCRE::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::LEN))
; NIL))
; --> LET SYMBOL-MACROLET IF +
; ==>
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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 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 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 DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; --> LET SYMBOL-MACROLET IF
; ==>
; (+ CL-PPCRE::START-POS
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::LEN))))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LET SYMBOL-MACROLET IF +
; ==>
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; etc.
; --> LET SYMBOL-MACROLET IF
; ==>
; (+ CL-PPCRE::START-POS
; (*
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::LEN))))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (CHAR-CLASS T)
; (1+ CL-PPCRE::START-POS)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (EVERYTHING T)
; (1+ CL-PPCRE::START-POS)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (STR T)
; (+ CL-PPCRE::START-POS (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD COMPUTE-OFFSETS (FILTER T)
; (+ CL-PPCRE::START-POS CL-PPCRE::LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-OFFSETS ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/regex-class-util-tmp6B86GLV2.fasl
; compilation finished in 0:00:00.304
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFMACRO CASE-INSENSITIVE-MODE-P ...)
; processing (DEFMACRO MULTI-LINE-MODE-P ...)
; processing (DEFMACRO SINGLE-LINE-MODE-P ...)
; processing (DEFUN SET-FLAG ...)
; processing (DEFGENERIC RESOLVE-PROPERTY ...)
; processing (DEFUN CONVERT-CHAR-CLASS-TO-TEST-FUNCTION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFUN CONVERT-CHAR-CLASS-TO-TEST-FUNCTION
; (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-DOWNCASE CHAR))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-DOWNCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-UPCASE CHAR))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-UPCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-DOWNCASE CHAR))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-DOWNCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-UPCASE CHAR))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-UPCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-DOWNCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-UPCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-DOWN)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-UP)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (CHAR-DOWNCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (CHAR-UPCASE CHAR)
;
; note: unable to
; open code
; due to type uncertainty:
; The first argument is a CHARACTER, not a BASE-CHAR.
; (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-DOWN)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-UP)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; TEST-FUNCTION is not known to be a function
; processing (DEFUN MAYBE-SPLIT-REPETITION ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFUN MAYBE-SPLIT-REPETITION
; (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM)
;
; note: doing signed word to integer coercion (cost 20)
; processing (DEFUN MAYBE-ACCUMULATE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFUN MAYBE-ACCUMULATE
; (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; (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*
; ==>
; (REPLACE #:SEQUENCE #:NEW1 :START1 #:START :END1 NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY * (*))
; &REST T).
;
; 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-ARRAY CHARACTER (*)).
; 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-BASE-STRING.
; The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER
; (*))
; &REST T).
; (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DECLAIM (INLINE CONVERT-AUX))
; processing (DEFUN CONVERT-AUX ...)
; processing (DEFGENERIC CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :BRANCH) T)
; (LENGTH (CL-PPCRE::CHOICES CL-PPCRE::ALTERNATIONS))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :GREEDY-REPETITION) T)
; (ZEROP LENGTH)
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :NAMED-REGISTER) T)
; (COPY-SEQ (SECOND CL-PPCRE::PARSE-TREE))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :BACK-REFERENCE) T)
; (STRING= CL-PPCRE::NAME CL-PPCRE::BACKREF-NAME)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR STRING SYMBOL CHARACTER), not a STRING.
; The second argument is a (OR STRING (AND (NOT NULL) SYMBOL)
; CHARACTER), not a STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR STRING SYMBOL CHARACTER), not a SIMPLE-STRING.
; The second argument is a (OR STRING (AND (NOT NULL) SYMBOL)
; CHARACTER), not a SIMPLE-STRING.
; (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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).
; (1- CL-PPCRE::BACKREF-NUMBER)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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).
; (COPY-SEQ CL-PPCRE::BACKREF-NAME)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a T, not a (SIGNED-BYTE 32).
; The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST T).
; etc.
; (1- CL-PPCRE::BACKREF-NUMBER)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (LOOP CL-PPCRE::FOR CL-PPCRE::NAME CL-PPCRE::IN CL-PPCRE::REG-NAMES
; CL-PPCRE::FOR CL-PPCRE::REG-INDEX CL-PPCRE::FROM 0
; WHEN (STRING= CL-PPCRE::NAME CL-PPCRE::BACKREF-NAME)
; CL-PPCRE::COLLECT ...)
; --> BLOCK LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY
; --> SB-LOOP::LOOP-DESETQ SETQ THE
; ==>
; (1+ CL-PPCRE::REG-INDEX)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ...)
; processing (DEFGENERIC CONVERT-SIMPLE-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-SIMPLE-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-SIMPLE-PARSE-TREE ...)
; processing (DEFMETHOD CONVERT-SIMPLE-PARSE-TREE ...)
; processing (DEFUN CONVERT ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/convert.lisp
; in: DEFUN CONVERT
; (COERCE (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR) 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/convert-tmpZWLLOVAH.fasl
; compilation finished in 0:00:00.236
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFGENERIC FLATTEN ...)
; processing (DEFMETHOD FLATTEN ...)
; processing (DEFMETHOD FLATTEN ...)
; processing (DEFMETHOD FLATTEN ...)
; processing (DEFMETHOD FLATTEN ...)
; processing (DEFGENERIC GATHER-STRINGS ...)
; processing (DEFMETHOD GATHER-STRINGS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD GATHER-STRINGS (SEQ)
; (MAKE-ARRAY CL-PPCRE::COLLECTOR-LENGTH :INITIAL-CONTENTS CL-PPCRE::COLLECTOR
; :ELEMENT-TYPE 'CHARACTER :FILL-POINTER T :ADJUSTABLE T)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a VECTOR, not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a VECTOR, not a SIMPLE-BASE-STRING.
; (INCF CL-PPCRE::COLLECTOR-LENGTH (CL-PPCRE::LEN CL-PPCRE::ELEMENT))
; --> SETQ THE
; ==>
; (+ (CL-PPCRE::LEN CL-PPCRE::ELEMENT) CL-PPCRE::COLLECTOR-LENGTH)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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).
; (SETF (SUBSEQ CL-PPCRE::COLLECTOR CL-PPCRE::OLD-COLLECTOR-LENGTH)
; (CL-PPCRE::STR CL-PPCRE::ELEMENT)
; CL-PPCRE::SKIP (CL-PPCRE::SKIP CL-PPCRE::ELEMENT))
; --> PROGN SETF LET*
; ==>
; (REPLACE #:SEQUENCE #:NEW1 :START1 #:START :END1 NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY * (*)).
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; The result is a (VALUES VECTOR &OPTIONAL), not a (VALUES (SIMPLE-ARRAY * (*))
; &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-BASE-STRING.
; The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES VECTOR &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING
; &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a (SIMPLE-ARRAY CHARACTER (*)).
; The second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES VECTOR &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER
; (*))
; &REST T).
; (INCF CL-PPCRE::COLLECTOR-LENGTH (CL-PPCRE::LEN CL-PPCRE::ELEMENT))
; --> SETQ THE
; ==>
; (+ (CL-PPCRE::LEN CL-PPCRE::ELEMENT) CL-PPCRE::COLLECTOR-LENGTH)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a T, not a (SIGNED-BYTE 32).
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST T).
; etc.
; processing (DEFMETHOD GATHER-STRINGS ...)
; processing (DEFMETHOD GATHER-STRINGS ...)
; processing (DEFMETHOD GATHER-STRINGS ...)
; processing (DEFGENERIC START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD START-ANCHORED-P (REPETITION)
; (PLUSP (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; processing (DEFMETHOD START-ANCHORED-P ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD START-ANCHORED-P (REGEX)
; (ZEROP (CL-PPCRE::LEN CL-PPCRE::REGEX))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
; processing (DEFGENERIC END-STRING-AUX ...)
; processing (DEFMETHOD END-STRING-AUX ...)
; processing (DEFMETHOD END-STRING-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD END-STRING-AUX (SEQ)
; (ZEROP (CL-PPCRE::LEN CL-PPCRE::ELEMENT-END))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
; (MAKE-ARRAY CL-PPCRE::CONCATENATED-LENGTH :INITIAL-CONTENTS
; (REVERSE (CL-PPCRE::STR CL-PPCRE::CONCATENATED-START))
; :ELEMENT-TYPE 'CHARACTER :FILL-POINTER T :ADJUSTABLE T)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST (SIMPLE-ARRAY * (*))
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST (SIMPLE-ARRAY * (*))
; SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-BASE-STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; (CHAR CL-PPCRE::STR CL-PPCRE::I)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; processing (DEFMETHOD END-STRING-AUX ...)
; processing (DEFMETHOD END-STRING-AUX ...)
; processing (DEFMETHOD END-STRING-AUX ...)
; processing (DEFUN END-STRING ...)
; processing (DEFGENERIC COMPUTE-MIN-REST ...)
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (ALTERNATION T)
; (LOOP CL-PPCRE::FOR CL-PPCRE::CHOICE CL-PPCRE::IN (CL-PPCRE::CHOICES
; CL-PPCRE::ALTERNATION)
; CL-PPCRE::MINIMIZE (CL-PPCRE::COMPUTE-MIN-REST CL-PPCRE::CHOICE
; CL-PPCRE::CURRENT-MIN-REST))
; --> BLOCK LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF
; ==>
; (< #:LOOP-MAXMIN-TEMP-10 #:LOOP-MAXMIN-9)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (BRANCH T)
; (MIN
; (CL-PPCRE::COMPUTE-MIN-REST (CL-PPCRE::THEN-REGEX CL-PPCRE::BRANCH)
; CL-PPCRE::CURRENT-MIN-REST)
; (CL-PPCRE::COMPUTE-MIN-REST (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)
; CL-PPCRE::CURRENT-MIN-REST))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; etc.
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (STR T)
; (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::STR))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (FILTER T)
; (+ CL-PPCRE::CURRENT-MIN-REST (OR (CL-PPCRE::LEN CL-PPCRE::FILTER) 0))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (REPETITION T)
; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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 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 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 DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (+ CL-PPCRE::CURRENT-MIN-REST
; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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::MINIMUM CL-PPCRE::REPETITION)
; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 3) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; etc.
; (+ CL-PPCRE::CURRENT-MIN-REST
; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (LOOKBEHIND T)
; (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::LOOKBEHIND))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFMETHOD COMPUTE-MIN-REST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/optimize.lisp
; in: DEFMETHOD COMPUTE-MIN-REST (REGEX T)
; (1+ CL-PPCRE::CURRENT-MIN-REST)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/optimize-tmpS9M8BVBG.fasl
; compilation finished in 0:00:00.132
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DECLAIM (INLINE *STRING*= ...))
; processing (DEFUN *STRING*= ...)
; processing (DEFUN *STRING*-EQUAL ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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.
; processing (DEFGENERIC CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (LOOKBEHIND T)
; (FUNCALL CL-PPCRE::TEST-MATCHER (- CL-PPCRE::START-POS CL-PPCRE::LEN))
;
; note: doing signed word to integer coercion (cost 20)
;
; note: doing signed word to integer coercion (cost 20)
; processing (DEFMACRO INSERT-CHAR-CLASS-TESTER ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (CHAR-CLASS T)
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::CHAR-CLASS
; (SCHAR CL-PPCRE::*STRING*
; CL-PPCRE::START-POS))
; (LAMBDA (CL-PPCRE::START-POS)
; (DECLARE (FIXNUM CL-PPCRE::START-POS))
; (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
; (CL-PPCRE::CHAR-CLASS-TEST)
; (FUNCALL CL-PPCRE::NEXT-FN (1+ CL-PPCRE::START-POS)))))
; --> LET LET LAMBDA FUNCTION AND IF IF
; ==>
; (FUNCALL #:TEST-FUNCTION6 (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (STR T)
; (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS) 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.
; (LENGTH CL-PPCRE::END-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR CONS VECTOR
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::END-STRING CL-PPCRE::START-POS
; CL-PPCRE::TEST-END-POS 0 CL-PPCRE::END-STRING-LEN)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::START-POS
; CL-PPCRE::NEXT-POS 0 CL-PPCRE::LEN)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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.
; (FUNCALL CL-PPCRE::NEXT-FN (+ CL-PPCRE::START-POS CL-PPCRE::LEN))
;
; note: doing signed word to integer coercion (cost 20)
;
; note: doing signed word to integer coercion (cost 20)
;
; note: doing signed word to integer coercion (cost 20)
; processing (DECLAIM (INLINE WORD-BOUNDARY-P))
; processing (DEFUN WORD-BOUNDARY-P ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (BACK-REFERENCE T)
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::*STRING* CL-PPCRE::START-POS
; CL-PPCRE::NEXT-POS CL-PPCRE::REG-START CL-PPCRE::REG-END)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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.
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (FILTER T)
; (FUNCALL CL-PPCRE::FN CL-PPCRE::START-POS)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; FN is not known to be a function
; (FUNCALL CL-PPCRE::NEXT-FN CL-PPCRE::NEXT-POS)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; NEXT-FN is not known to be a function
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/closures-tmp205IFRLS.fasl
; compilation finished in 0:00:00.176
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFMACRO INCF-AFTER ...)
; processing (DEFMACRO GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; processing (DEFUN CREATE-GREEDY-EVERYTHING-MATCHER ...)
; processing (DEFGENERIC CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; processing (DEFMETHOD CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; 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))
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET
; --> BLOCK TAGBODY WHEN IF
; ==>
; (FUNCALL #:TEST-FUNCTION30 (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
; CL-PPCRE::LEN)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
; (SCHAR CL-PPCRE::*STRING*
; CL-PPCRE::CURR-POS))
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
; CL-PPCRE::LEN))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; processing (DEFGENERIC CREATE-GREEDY-NO-ZERO-MATCHER ...)
; processing (DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; in: DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*16 #:REP-NUM17)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*16 #:REP-NUM17)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*19 #:REP-NUM20)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*19 #:REP-NUM20)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; processing (DEFGENERIC CREATE-GREEDY-MATCHER ...)
; processing (DEFMETHOD CREATE-GREEDY-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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 LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*25 #:REP-NUM26)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*18 #:REP-NUM19)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*18 #:REP-NUM19)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; processing (DEFMACRO NON-GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; processing (DEFGENERIC CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; processing (DEFMETHOD CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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))
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION
; --> LET LOOP BLOCK LET LET TAGBODY UNLESS IF
; ==>
; (FUNCALL #:TEST-FUNCTION102 (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
; CL-PPCRE::LEN)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
; CL-PPCRE::LEN))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
; (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
; (SCHAR CL-PPCRE::*STRING*
; CL-PPCRE::CURR-POS))
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION
; --> LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T)
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
; (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> IF LAMBDA FUNCTION LET
; ==>
; (MIN (1+ (- CL-PPCRE::*END-POS* CL-PPCRE::LEN CL-PPCRE::MIN-REST))
; (+ CL-PPCRE::START-POS (THE FIXNUM (* CL-PPCRE::LEN CL-PPCRE::MAXIMUM))))
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; processing (DEFGENERIC CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)
; processing (DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*16 #:REP-NUM17)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*16 #:REP-NUM17)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*19 #:REP-NUM20)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*19 #:REP-NUM20)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; processing (DEFGENERIC CREATE-NON-GREEDY-MATCHER ...)
; processing (DEFMETHOD CREATE-NON-GREEDY-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/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 LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*25 #:REP-NUM26)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*18 #:REP-NUM19)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*18 #:REP-NUM19)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*21 #:REP-NUM22)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; processing (DEFMACRO CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE ...)
; processing (DEFGENERIC CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)
; processing (DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; in:
; DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER (REPETITION T)
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
; (SCHAR CL-PPCRE::*STRING*
; CL-PPCRE::CURR-POS))
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS))))
; --> LET LET CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE LAMBDA
; --> FUNCTION LET AND IF IF LOOP BLOCK LET TAGBODY UNLESS IF AND IF
; ==>
; (FUNCALL #:TEST-FUNCTION36 (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS CL-PPCRE::NEXT-POS
; 0 CL-PPCRE::LEN)
; --> SB-C::INLINED BLOCK LOOP BLOCK LET LET TAGBODY UNLESS 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::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (LET ((CL-PPCRE::NEXT-POS (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)))
; (DECLARE (FIXNUM CL-PPCRE::NEXT-POS))
; (AND
; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
; CL-PPCRE::NEXT-POS 0 CL-PPCRE::LEN)
; CL-PPCRE::NEXT-POS)))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (1+ CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND
; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (1+ CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (LET ((CL-PPCRE::NEXT-POS (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)))
; (DECLARE (FIXNUM CL-PPCRE::NEXT-POS))
; (AND
; (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS CL-PPCRE::NEXT-POS
; 0 CL-PPCRE::LEN)
; CL-PPCRE::NEXT-POS)))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
; (SCHAR CL-PPCRE::*STRING*
; CL-PPCRE::CURR-POS))
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS))))
; --> LET LET CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE LAMBDA
; --> FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (AND (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; (1+ CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
; (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> LAMBDA FUNCTION LET + THE
; ==>
; (* CL-PPCRE::LEN CL-PPCRE::REPETITIONS)
;
; note: forced to do GENERIC-* (cost 30)
; unable to do inline fixnum arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230376151711744)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST
; T).
; etc.
; processing (DEFGENERIC CREATE-CONSTANT-REPETITION-MATCHER ...)
; processing (DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T)
; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*40 #:REP-NUM41)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*35 #:REP-NUM36)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*35 #:REP-NUM36)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*38 #:REP-NUM39)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*38 #:REP-NUM39)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*30 #:REP-NUM31)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; (ZEROP (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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 #:*REPEAT-COUNTERS*23 #:REP-NUM24)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*23 #:REP-NUM24)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; 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* SB-IMPL::XSUBTRACT
; ==>
; (AREF #:*REPEAT-COUNTERS*26 #:REP-NUM27)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; --> LET*
; ==>
; (FUNCALL #'(SETF AREF) #:NEW1 #:*REPEAT-COUNTERS*26 #:REP-NUM27)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a (SIMPLE-ARRAY * (*)).
;
; note: unable to
; avoid runtime dispatch on array element type
; due to type uncertainty:
; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
; processing (DEFMETHOD CREATE-MATCHER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/repetition-closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (REPETITION T)
; (AND CL-PPCRE::MAXIMUM (ZEROP CL-PPCRE::MAXIMUM))
; --> IF
; ==>
; (ZEROP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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.
; (AND CL-PPCRE::MAXIMUM (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1))
; --> IF
; ==>
; (=
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM))
; 1)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (AND (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) CL-PPCRE::LEN
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; --> IF IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; (COND
; ((AND CL-PPCRE::MAXIMUM (ZEROP CL-PPCRE::MAXIMUM))
; (ERROR "Got REPETITION with MAXIMUM 0 (should not happen)"))
; ((AND CL-PPCRE::MAXIMUM (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1))
; (ERROR "Got REPETITION with MAXIMUM 1 and MINIMUM 1 (should not happen)"))
; ((AND (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) CL-PPCRE::LEN
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER
; CL-PPCRE::REPETITION CL-PPCRE::NEXT-FN))
; ((EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; (CL-PPCRE::CREATE-CONSTANT-REPETITION-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::GREEDYP CL-PPCRE::LEN (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-GREEDY-CONSTANT-LENGTH-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::GREEDYP
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1)))
; (CL-PPCRE::CREATE-GREEDY-NO-ZERO-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; (CL-PPCRE::GREEDYP
; (CL-PPCRE::CREATE-GREEDY-MATCHER CL-PPCRE::REPETITION CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::LEN (PLUSP CL-PPCRE::LEN)
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; (CL-PPCRE::CREATE-NON-GREEDY-NO-ZERO-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; (T
; (CL-PPCRE::CREATE-NON-GREEDY-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN)))
; --> IF IF IF IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; --> LET
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MIN-LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MIN-LEN)))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (AND CL-PPCRE::LEN (PLUSP CL-PPCRE::LEN) (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; --> IF IF
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; --> LET
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MIN-LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MIN-LEN)))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (AND CL-PPCRE::MAXIMUM (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1))
; --> IF
; ==>
; (=
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM))
; 1)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; (AND (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) CL-PPCRE::LEN
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; --> IF IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; (COND
; ((AND CL-PPCRE::MAXIMUM (ZEROP CL-PPCRE::MAXIMUM))
; (ERROR "Got REPETITION with MAXIMUM 0 (should not happen)"))
; ((AND CL-PPCRE::MAXIMUM (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1))
; (ERROR "Got REPETITION with MAXIMUM 1 and MINIMUM 1 (should not happen)"))
; ((AND (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) CL-PPCRE::LEN
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER
; CL-PPCRE::REPETITION CL-PPCRE::NEXT-FN))
; ((EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; (CL-PPCRE::CREATE-CONSTANT-REPETITION-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::GREEDYP CL-PPCRE::LEN (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-GREEDY-CONSTANT-LENGTH-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::GREEDYP
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1)))
; (CL-PPCRE::CREATE-GREEDY-NO-ZERO-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; (CL-PPCRE::GREEDYP
; (CL-PPCRE::CREATE-GREEDY-MATCHER CL-PPCRE::REPETITION CL-PPCRE::NEXT-FN))
; ((AND CL-PPCRE::LEN (PLUSP CL-PPCRE::LEN)
; (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; (CL-PPCRE::CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; ((OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; (CL-PPCRE::CREATE-NON-GREEDY-NO-ZERO-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN))
; (T
; (CL-PPCRE::CREATE-NON-GREEDY-MATCHER CL-PPCRE::REPETITION
; CL-PPCRE::NEXT-FN)))
; --> IF IF IF IF
; ==>
; (EQL
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MINIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MINIMUM))
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MAXIMUM)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MAXIMUM)))
;
; note: forced to do GENERIC-EQL (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; The second argument is a T, not a FIXNUM.
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; --> LET
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MIN-LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MIN-LEN)))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; (AND CL-PPCRE::LEN (PLUSP CL-PPCRE::LEN) (NOT CL-PPCRE::CONTAINS-REGISTER-P))
; --> IF IF
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-PPCRE::LEN)))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; (OR (PLUSP CL-PPCRE::MIN-LEN) (EQL CL-PPCRE::MAXIMUM 1))
; --> LET
; ==>
; (PLUSP
; (SB-C::WITH-SOURCE-FORM (SLOT-VALUE #:G0 'CL-PPCRE::MIN-LEN)
; (SB-PCL::ACCESSOR-SLOT-VALUE #:G0
; 'CL-PPCRE::MIN-LEN)))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/repetition-closures-tmpBW6GBZVX.fasl
; compilation finished in 0:00:00.484
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/scanner.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFMACRO BMH-MATCHER-AUX ...)
; processing (DEFUN CREATE-BMH-MATCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/scanner.lisp
; in: DEFUN CREATE-BMH-MATCHER
; (CL-PPCRE::BMH-MATCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION IF LOOP BLOCK LET TAGBODY LOOP BLOCK LET LET TAGBODY
; --> UNLESS IF AND IF
; ==>
; (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 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
; open code
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; processing (DEFMACRO CHAR-SEARCHER-AUX ...)
; processing (DEFUN CREATE-CHAR-SEARCHER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/scanner.lisp
; in: DEFUN CREATE-CHAR-SEARCHER
; (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION AND IF LOOP BLOCK LET LET TAGBODY WHEN 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.
; processing (DECLAIM (INLINE NEWLINE-SKIPPER))
; processing (DEFUN NEWLINE-SKIPPER ...)
; processing (DEFMACRO INSERT-ADVANCE-FN ...)
; processing (DEFUN CREATE-SCANNER-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/scanner.lisp
; in: DEFUN CREATE-SCANNER-AUX
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET)
; (FUNCTION CL-PPCRE::END-STRING-TEST))
; (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET CL-PPCRE::STARTS-WITH-LEN)
; (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET CL-PPCRE::STARTS-WITH-LEN)
; (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF
; --> AND IF
; ==>
; (NOT
; (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))
;
; 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ 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.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-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
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET)
; (FUNCTION CL-PPCRE::END-STRING-TEST))
; (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: unable to open code because: The operands might not be the same type.
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET CL-PPCRE::STARTS-WITH-LEN)
; (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (LOCALLY
; (DECLARE #)
; (WHEN # #)
; (LET #
; #)))))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
; (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
; (IF (<= (THE FIXNUM CL-PPCRE::POS) (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
; (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
; (UNLESS (SETQ CL-PPCRE::*END-STRING-POS* #)
; (RETURN-FROM CL-PPCRE:SCAN NIL))
; CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (CL-PPCRE::INSERT-ADVANCE-FN
; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF
; ==>
; (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF <
; ==>
; (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF AND IF
; ==>
; (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; CL-PPCRE::*END-POS*)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; --> LAMBDA FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK
; --> TAGBODY PROGN LET COND IF IF INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE::*END-STRING-POS*)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a T, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (FUNCALL CL-PPCRE::END-STRING-TEST CL-PPCRE::TRY-POS)
;
; note: doing signed word to integer coercion (cost 20) from TRY-POS
;
; note: doing signed word to integer coercion (cost 20) from TRY-POS
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/scanner-tmpMDMI656Q.fasl
; compilation finished in 0:00:00.740
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE)
; processing (DEFVAR *LOOK-AHEAD-FOR-SUFFIX* ...)
; processing (DEFGENERIC CREATE-SCANNER ...)
; processing (DEFMETHOD CREATE-SCANNER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD CREATE-SCANNER (STRING)
; (COPY-SEQ CL-PPCRE::QUOTED-REGEX-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; processing (DEFMETHOD CREATE-SCANNER ...)
; processing (DEFMETHOD CREATE-SCANNER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD CREATE-SCANNER (T)
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (= 1 (CL-PPCRE::LEN CL-PPCRE::END-STRING))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (= 1 (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
;
; 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
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a T, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a T, not a FIXNUM.
; etc.
; processing (DEFGENERIC SCAN ...)
; processing (DEFMETHOD SCAN ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD SCAN (STRING T)
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::REGEX-STRING)
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; processing (DEFMETHOD SCAN ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD SCAN #'T
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; processing (DEFMETHOD SCAN ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD SCAN (T T)
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::PARSE-TREE)
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; processing (DEFINE-COMPILER-MACRO SCAN ...)
; processing (DEFUN SCAN-TO-STRINGS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN SCAN-TO-STRINGS
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (MAP 'VECTOR
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (IF CL-PPCRE::REG-START
; (FUNCALL CL-PPCRE::SUBSTR-FN CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START CL-PPCRE::REG-END)
; NIL))
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; processing (DEFINE-COMPILER-MACRO SCAN-TO-STRINGS ...)
; processing (DEFMACRO REGISTER-GROUPS-BIND ...)
; processing (DEFMACRO DO-SCANS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMACRO DO-SCANS
; (DEFMACRO CL-PPCRE:DO-SCANS
; (
; (CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; &OPTIONAL
; CL-PPCRE::RESULT-FORM
; &KEY
; CL-PPCRE::START
; CL-PPCRE::END)
; &BODY CL-PPCRE::BODY &ENVIRONMENT CL-PPCRE::ENV)
; #<(SIMPLE-ARRAY CHARACTER
; (495)) Iterates over TARGET-STRING and tries to match REGEX as often as
; possible evaluating BODY with MATCH-START, MATCH-END, REG-STARTS, and
; REG-ENDS bound to the four return values of each match in turn. ... {12951007}>
; (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
; (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::%START CL-PPCRE::%END
; CL-PPCRE::%REGEX CL-PPCRE::SCANNER)
; (DECLARE (IGNORABLE CL-PPCRE::%REGEX CL-PPCRE::SCANNER))
; `(BLOCK NIL
; (LET* #
; #
; #)))))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (MATCH-START MATCH-END
; REG-STARTS REG-ENDS REGEX
; TARGET-STRING &OPTIONAL
; RESULT-FORM &KEY START END)
; processing (DEFMACRO DO-MATCHES ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMACRO DO-MATCHES
; (DEFMACRO CL-PPCRE:DO-MATCHES
; (
; (CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; &OPTIONAL
; CL-PPCRE::RESULT-FORM
; &KEY
; CL-PPCRE::START
; CL-PPCRE::END)
; &BODY CL-PPCRE::BODY)
; #<(SIMPLE-ARRAY CHARACTER
; (477)) Iterates over TARGET-STRING and tries to match REGEX as often as
; possible evaluating BODY with MATCH-START and MATCH-END bound to the
; start/end positions of each match in turn. After the last match,
; ... {12BB580F}>
; (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
; `(CL-PPCRE:DO-SCANS (,CL-PPCRE::MATCH-START ,CL-PPCRE::MATCH-END
; ,CL-PPCRE::REG-STARTS ,CL-PPCRE::REG-ENDS
; ,CL-PPCRE::REGEX ,CL-PPCRE::TARGET-STRING
; ,CL-PPCRE::RESULT-FORM :START ,CL-PPCRE::START :END
; ,CL-PPCRE::END)
; ,@CL-PPCRE::BODY)))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (MATCH-START MATCH-END REGEX
; TARGET-STRING &OPTIONAL
; RESULT-FORM &KEY START END)
; processing (DEFMACRO DO-MATCHES-AS-STRINGS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMACRO DO-MATCHES-AS-STRINGS
; (DEFMACRO CL-PPCRE:DO-MATCHES-AS-STRINGS
; (
; (CL-PPCRE::MATCH-VAR
; CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; &OPTIONAL
; CL-PPCRE::RESULT-FORM
; &KEY
; CL-PPCRE::START
; CL-PPCRE::END
; CL-PPCRE::SHAREDP)
; &BODY CL-PPCRE::BODY)
; #<(SIMPLE-ARRAY CHARACTER
; (569)) Iterates over TARGET-STRING and tries to match REGEX as often as
; possible evaluating BODY with MATCH-VAR bound to the substring of
; TARGET-STRING corresponding to each match in turn. After the last
; ma... {12C8B007}>
; (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
; (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::SUBSTR-FN)
; `(LET (#)
; (CL-PPCRE:DO-MATCHES #
; #)))))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (MATCH-VAR REGEX
; TARGET-STRING &OPTIONAL
; RESULT-FORM &KEY START END
; SHAREDP)
; processing (DEFMACRO DO-REGISTER-GROUPS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMACRO DO-REGISTER-GROUPS
; (DEFMACRO CL-PPCRE:DO-REGISTER-GROUPS
; (CL-PPCRE::VAR-LIST
; (CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; &OPTIONAL
; CL-PPCRE::RESULT-FORM
; &KEY
; CL-PPCRE::START
; CL-PPCRE::END
; CL-PPCRE::SHAREDP)
; &BODY CL-PPCRE::BODY)
; #<(SIMPLE-ARRAY CHARACTER
; (820)) Iterates over TARGET-STRING and tries to match REGEX as often as
; possible evaluating BODY with the variables in VAR-LIST bound to the
; corresponding register groups for each match in turn, i.e. each
; va... {12DA5007}>
; (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
; (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::SUBSTR-FN CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END CL-PPCRE::REG-STARTS
; CL-PPCRE::REG-ENDS CL-PPCRE::START-INDEX)
; `(LET (#)
; (CL-PPCRE:DO-SCANS #
; #)))))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (REGEX TARGET-STRING
; &OPTIONAL RESULT-FORM
; &KEY START END SHAREDP)
; processing (DEFUN ALL-MATCHES ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN ALL-MATCHES
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-MATCHES (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REGEX CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST) :START CL-PPCRE::START
; :END CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::RESULT-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::RESULT-LIST))
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF
; ==>
; (LENGTH #:TARGET-STRING3)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* SETQ THE
; --> CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF THE
; ==>
; (COERCE #:=STRING=8 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK TAGBODY PROGN
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a RATIONAL.
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFINE-COMPILER-MACRO ALL-MATCHES ...)
; processing (DEFUN ALL-MATCHES-AS-STRINGS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN ALL-MATCHES-AS-STRINGS
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-MATCHES-AS-STRINGS (CL-PPCRE::MATCH CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING
; (NREVERSE CL-PPCRE::RESULT-LIST) :START
; CL-PPCRE::START :END CL-PPCRE::END :SHAREDP
; CL-PPCRE::SHAREDP)
; (PUSH CL-PPCRE::MATCH CL-PPCRE::RESULT-LIST))
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF
; ==>
; (LENGTH #:TARGET-STRING7)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* SETQ THE
; --> CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF THE
; ==>
; (COERCE #:=STRING=12 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK
; --> TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE
; --> IF
; ==>
; (= #:MATCH-START2 #:MATCH-END3)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; ==>
; (1+ #:MATCH-END3)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a RATIONAL.
; ==>
; (= #:MATCH-START2 #:MATCH-END3)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; ==>
; (1+ #:MATCH-END3)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFINE-COMPILER-MACRO ALL-MATCHES-AS-STRINGS ...)
; processing (DEFUN SPLIT ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN SPLIT
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-SCANS (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING NIL :START CL-PPCRE::START :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN
; (AND CL-PPCRE::LIMIT (PLUSP CL-PPCRE::LIMIT) (>= # CL-PPCRE::LIMIT))
; (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR CL-PPCRE::REG-START CL-PPCRE::ACROSS CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR CL-PPCRE::REG-END CL-PPCRE::ACROSS CL-PPCRE::REG-ENDS
; IF CL-PPCRE::REG-START
; DO ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* OR LET IF
; ==>
; (LENGTH #:TARGET-STRING1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> LET BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND
; --> IF THE
; ==>
; (COERCE #:=STRING=6 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), 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 (OR REAL COMPLEX), 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 (OR REAL COMPLEX), 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 (OR REAL COMPLEX), 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 (OR REAL COMPLEX), 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 (OR REAL COMPLEX), not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (PLUSP CL-PPCRE::LIMIT)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (LOOP CL-PPCRE::FOR CL-PPCRE::REG-START CL-PPCRE::ACROSS CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR CL-PPCRE::REG-END CL-PPCRE::ACROSS CL-PPCRE::REG-ENDS
; IF CL-PPCRE::REG-START
; DO ...)
; --> BLOCK LET LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE
; ==>
; (AREF #:LOOP-ACROSS-VECTOR-9 #:LOOP-ACROSS-INDEX-10)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; ==>
; (AREF #:LOOP-ACROSS-VECTOR-12 #:LOOP-ACROSS-INDEX-13)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (CL-PPCRE:DO-SCANS (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING NIL :START CL-PPCRE::START :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN
; (AND CL-PPCRE::LIMIT (PLUSP CL-PPCRE::LIMIT) (>= # CL-PPCRE::LIMIT))
; (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR CL-PPCRE::REG-START CL-PPCRE::ACROSS CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR CL-PPCRE::REG-END CL-PPCRE::ACROSS CL-PPCRE::REG-ENDS
; IF CL-PPCRE::REG-START
; DO ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a RATIONAL.
; (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (>= (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
;
; note: unable to open code because: The operands might not be the same type.
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR REAL COMPLEX), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR REAL COMPLEX), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; (PLUSP CL-PPCRE::LIMIT)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a (NOT NULL), not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (NOT NULL), not a FIXNUM.
; etc.
; (INCF CL-PPCRE::COUNTER)
; --> SETQ THE
; ==>
; (+ 1 CL-PPCRE::COUNTER)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; (>= (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (INTEGER 1), not a FIXNUM.
; The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0))
; (RATIONAL (0))), not a FIXNUM.
; (CL-PPCRE:DO-SCANS (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING NIL :START CL-PPCRE::START :END
; CL-PPCRE::END)
; (UNLESS
; (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
; (WHEN
; (AND CL-PPCRE::LIMIT (PLUSP CL-PPCRE::LIMIT) (>= # CL-PPCRE::LIMIT))
; (RETURN))
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (WHEN CL-PPCRE::WITH-REGISTERS-P
; (LOOP CL-PPCRE::FOR CL-PPCRE::REG-START CL-PPCRE::ACROSS CL-PPCRE::REG-STARTS
; CL-PPCRE::FOR CL-PPCRE::REG-END CL-PPCRE::ACROSS CL-PPCRE::REG-ENDS
; IF CL-PPCRE::REG-START
; DO ...))
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; etc.
; processing (DEFINE-COMPILER-MACRO SPLIT ...)
; processing (DEFUN STRING-CASE-MODIFIER ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN STRING-CASE-MODIFIER
; (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM))
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-PPCRE::STR CL-PPCRE::FROM)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-PPCRE::STR CL-PPCRE::TO)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO))
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-PPCRE::STR CL-PPCRE::INDEX)
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; processing (DEFGENERIC BUILD-REPLACEMENT-TEMPLATE ...)
; processing (LET* (# #) ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFMETHOD BUILD-REPLACEMENT-TEMPLATE (STRING)
; (POSITION-IF #'CL-PPCRE::DIGIT-CHAR-P CL-PPCRE::REPLACEMENT-STRING :START
; CL-PPCRE::MATCH-START :END CL-PPCRE::MATCH-END)
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; (CHAR CL-PPCRE::REPLACEMENT-STRING (1+ CL-PPCRE::MATCH-START))
;
; note: unable to
; optimize
; because:
; Upgraded element type of array is not known at compile time.
; (< CL-PPCRE::FROM CL-PPCRE::MATCH-START)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a REAL, not a FIXNUM.
; (1-
; (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING :START CL-PPCRE::PARSE-START
; :JUNK-ALLOWED T))
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR INTEGER NULL), 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 (OR INTEGER NULL), not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (< CL-PPCRE::TOKEN 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; processing (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; processing (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; processing (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; processing (DEFUN BUILD-REPLACEMENT ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN BUILD-REPLACEMENT
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (ARRAY-DIMENSION CL-PPCRE::REG-STARTS 0)
;
; note: unable to
; optimize
; because:
; The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> SB-C::INLINED BLOCK
; ==>
; (MAKE-ARRAY (- CL-PPCRE::END CL-PPCRE::START) :ELEMENT-TYPE
; (ARRAY-ELEMENT-TYPE SEQUENCE) :DISPLACED-TO SEQUENCE
; :DISPLACED-INDEX-OFFSET CL-PPCRE::START)
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.
; (MAP 'LIST
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (AND CL-PPCRE::REG-START
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)))
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
;
; note: unable to open code because: can't determine sequence argument type
; (APPLY CL-PPCRE::TOKEN
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; (MAP 'LIST
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (AND CL-PPCRE::REG-START
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
; CL-PPCRE::REG-START
; CL-PPCRE::REG-END)))
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS))
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; (MAP 'LIST
; (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
; (AND CL-PPCRE::REG-START
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)))
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
;
; note: unable to open code because: can't determine sequence argument type
; (FUNCALL CL-PPCRE::TOKEN CL-PPCRE::TARGET-STRING CL-PPCRE::START
; CL-PPCRE::END CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> SB-C::INLINED BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX 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).
; --> BLOCK
; ==>
; (MAKE-ARRAY (- CL-PPCRE::END CL-PPCRE::START) :ELEMENT-TYPE
; (ARRAY-ELEMENT-TYPE SEQUENCE) :DISPLACED-TO SEQUENCE
; :DISPLACED-INDEX-OFFSET CL-PPCRE::START)
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK
; ==>
; (MAKE-ARRAY (- CL-PPCRE::END CL-PPCRE::START) :ELEMENT-TYPE
; (ARRAY-ELEMENT-TYPE SEQUENCE) :DISPLACED-TO SEQUENCE
; :DISPLACED-INDEX-OFFSET CL-PPCRE::START)
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.
; (WITH-OUTPUT-TO-STRING (CL-PPCRE::S NIL :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
; (LOOP CL-PPCRE::FOR CL-PPCRE::TOKEN CL-PPCRE::IN CL-PPCRE::REPLACEMENT-TEMPLATE
; DO (TYPECASE CL-PPCRE::TOKEN
; (STRING (WRITE-STRING CL-PPCRE::TOKEN CL-PPCRE::S))
; (INTEGER (WHEN # #) (WHEN # #))
; (FUNCTION (WRITE-STRING # CL-PPCRE::S))
; (SYMBOL (CASE CL-PPCRE::TOKEN # # # # #)))))
; --> SB-INT:DX-LET LET
; ==>
; (MAKE-STRING 31 :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
;
; note: could not stack allocate:
; (WITH-OUTPUT-TO-STRING (S NIL :ELEMENT-TYPE ELEMENT-TYPE)
; (LOOP FOR TOKEN IN REPLACEMENT-TEMPLATE
; DO (TYPECASE TOKEN
; (STRING (WRITE-STRING TOKEN S))
; (INTEGER
; (WHEN (>= TOKEN REG-BOUND)
; (SIGNAL-INVOCATION-ERROR
; "Reference to non-existent register ~A in replacement string."
; (1+ TOKEN)))
; (WHEN (SVREF REG-STARTS TOKEN)
; (WRITE-STRING TARGET-STRING S :START
; (SVREF REG-STARTS TOKEN) :END
; (SVREF REG-ENDS TOKEN))))
; (FUNCTION
; (WRITE-STRING
; (COND
; (SIMPLE-CALLS
; (APPLY TOKEN
; (NSUBSEQ TARGET-STRING MATCH-START MATCH-END)
; (MAP 'LIST
; (LAMBDA (REG-START REG-END)
; (AND REG-START
; (NSUBSEQ TARGET-STRING REG-START
; REG-END)))
; REG-STARTS REG-ENDS)))
; (T
; (FUNCALL TOKEN TARGET-STRING START END MATCH-START
; MATCH-END REG-STARTS REG-ENDS)))
; S))
; (SYMBOL
; (CASE TOKEN
; ((:BACKSLASH) (WRITE-CHAR #\\ S))
; ((:MATCH)
; (WRITE-STRING TARGET-STRING S :START MATCH-START :END
; MATCH-END))
; ((:BEFORE-MATCH)
; (WRITE-STRING TARGET-STRING S :START START :END
; MATCH-START))
; ((:AFTER-MATCH)
; (WRITE-STRING TARGET-STRING S :START MATCH-END :END
; END))
; (OTHERWISE
; (WRITE-STRING
; (COND
; (SIMPLE-CALLS
; (APPLY TOKEN
; (NSUBSEQ TARGET-STRING MATCH-START MATCH-END)
; (MAP 'LIST
; (LAMBDA (REG-START REG-END)
; (AND REG-START
; (NSUBSEQ TARGET-STRING REG-START
; REG-END)))
; REG-STARTS REG-ENDS)))
; (T
; (FUNCALL TOKEN TARGET-STRING START END MATCH-START
; MATCH-END REG-STARTS REG-ENDS)))
; S)))))))
; (>= CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; (1+ CL-PPCRE::TOKEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
; CL-PPCRE::MATCH-END)
; --> SB-C::INLINED BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
; CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY
; ==>
; (- CL-PPCRE::END CL-PPCRE::START)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a DOUBLE-FLOAT.
; The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
; &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a T, not a SINGLE-FLOAT.
; The second argument is a (NOT NULL), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
; &REST T).
; etc.
; processing (DEFUN REPLACE-AUX ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN REPLACE-AUX
; (FUNCALL
; (CL-PPCRE::STRING-CASE-MODIFIER CL-PPCRE::TARGET-STRING CL-PPCRE::FROM
; CL-PPCRE::TO CL-PPCRE::START CL-PPCRE::END)
; CL-PPCRE::CURR-REPLACEMENT)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; because:
; callable expression is not known to be a function
; (WITH-OUTPUT-TO-STRING (CL-PPCRE::S NIL :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
; (LOOP CL-PPCRE::FOR (CL-PPCRE::FROM CL-PPCRE::TO) CL-PPCRE::ON (APPEND
; (LIST
; CL-PPCRE::START)
; CL-PPCRE::POS-LIST
; (LIST
; CL-PPCRE::END))
; CL-PPCRE::FOR REPLACE = NIL CL-PPCRE::THEN (AND (NOT REPLACE)
; CL-PPCRE::TO)
; CL-PPCRE::FOR ...))
; --> SB-INT:DX-LET LET
; ==>
; (MAKE-STRING 31 :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
;
; note: could not stack allocate:
; (WITH-OUTPUT-TO-STRING (S NIL :ELEMENT-TYPE ELEMENT-TYPE)
; (LOOP FOR (FROM TO) ON (APPEND (LIST START) POS-LIST (LIST END))
; FOR REPLACE = NIL THEN (AND (NOT REPLACE) TO)
; FOR REG-STARTS = (IF REPLACE
; (POP REG-LIST)
; NIL)
; FOR REG-ENDS = (IF REPLACE
; (POP REG-LIST)
; NIL)
; FOR CURR-REPLACEMENT = (IF REPLACE
; (BUILD-REPLACEMENT
; REPLACEMENT-TEMPLATE TARGET-STRING
; START END FROM TO REG-STARTS
; REG-ENDS SIMPLE-CALLS ELEMENT-TYPE)
; NIL)
; WHILE TO
; IF REPLACE
; DO (WRITE-STRING
; (IF PRESERVE-CASE
; (FUNCALL
; (STRING-CASE-MODIFIER TARGET-STRING FROM TO START END)
; CURR-REPLACEMENT)
; CURR-REPLACEMENT)
; S) ELSE
; DO (WRITE-STRING TARGET-STRING S :START FROM :END TO)))
; processing (DEFUN REGEX-REPLACE ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN REGEX-REPLACE
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; processing (DEFINE-COMPILER-MACRO REGEX-REPLACE ...)
; processing (DEFUN REGEX-REPLACE-ALL ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN REGEX-REPLACE-ALL
; (LENGTH CL-PPCRE::TARGET-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; (CL-PPCRE:DO-SCANS (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING NIL :START CL-PPCRE::START :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
; (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* OR LET IF
; ==>
; (LENGTH #:TARGET-STRING1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
; --> LET BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND
; --> IF THE
; ==>
; (COERCE #:=STRING=6 'SIMPLE-STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR LIST
; (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
; (NOT SIMPLE-BASE-STRING) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR LIST
; (AND (NOT SIMPLE-BASE-STRING)
; (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
; * (*)).
; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; 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
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a FLOAT.
;
; note: unable to
; open-code float conversion in mixed numeric operation
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
; (COMPLEX DOUBLE-FLOAT)).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; associate +/(+ -) of constants
; due to type uncertainty:
; The first argument is a (OR REAL COMPLEX), not a RATIONAL.
; (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (CL-PPCRE:DO-SCANS (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
; CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS CL-PPCRE::REGEX
; CL-PPCRE::TARGET-STRING NIL :START CL-PPCRE::START :END
; CL-PPCRE::END)
; (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
; (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
; (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF
; ==>
; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
; The second argument is a T, not a DOUBLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (NOT NULL), not a SINGLE-FLOAT.
; The second argument is a T, not a SINGLE-FLOAT.
; ==>
; (1+ CL-PPCRE::MATCH-END)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR REAL COMPLEX), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; processing (DEFINE-COMPILER-MACRO REGEX-REPLACE-ALL ...)
; processing (DEFMACRO REGEX-APROPOS-AUX ...)
; processing (DEFUN REGEX-APROPOS-LIST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN REGEX-APROPOS-LIST
; (DEFUN CL-PPCRE:REGEX-APROPOS-LIST
; (CL-PPCRE::REGEX
; &OPTIONAL CL-PPCRE::PACKAGES
; &KEY (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; #<(SIMPLE-ARRAY CHARACTER
; (221)) Similar to the standard function APROPOS-LIST but returns a list of
; all symbols which match the regular expression REGEX. If
; CASE-INSENSITIVE is true and REGEX isn't already a scanner, a
; case-insensi... {14153467}>
; (LET ((CL-PPCRE::COLLECTOR 'NIL))
; (CL-PPCRE::REGEX-APROPOS-AUX (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE
; CL-PPCRE::COLLECTOR)
; (PUSH SYMBOL CL-PPCRE::COLLECTOR))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS-LIST
; (CL-PPCRE::REGEX &OPTIONAL CL-PPCRE::PACKAGES &KEY
; (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE (SB-C::TOP-LEVEL-FORM))
; #<(SIMPLE-ARRAY CHARACTER
; (221)) Similar to the standard function APROPOS-LIST but returns a list of
; all symbols which match the regular expression REGEX. If
; CASE-INSENSITIVE is true and REGEX isn't already a scanner, a
; case-insensi... {14153467}>
; (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; (BLOCK CL-PPCRE:REGEX-APROPOS-LIST
; (LET ((CL-PPCRE::COLLECTOR 'NIL))
; (CL-PPCRE::REGEX-APROPOS-AUX (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE
; CL-PPCRE::COLLECTOR)
; (PUSH SYMBOL CL-PPCRE::COLLECTOR)))))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL PACKAGES
; &KEY
; (CASE-INSENSITIVE T))
; processing (DEFUN PRINT-SYMBOL-INFO ...)
; processing (DEFUN REGEX-APROPOS ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN REGEX-APROPOS
; (DEFUN CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX
; &OPTIONAL CL-PPCRE::PACKAGES
; &KEY (CL-PPCRE::CASE-INSENSITIVE T))
; #<(SIMPLE-ARRAY CHARACTER
; (216)) Similar to the standard function APROPOS but returns a list of all
; symbols which match the regular expression REGEX. If CASE-INSENSITIVE
; is true and REGEX isn't already a scanner, a case-insensitive ... {14480007}>
; (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; (CL-PPCRE::REGEX-APROPOS-AUX (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE)
; (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
; (VALUES))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX &OPTIONAL CL-PPCRE::PACKAGES &KEY
; (CL-PPCRE::CASE-INSENSITIVE T))
; (DECLARE (SB-C::TOP-LEVEL-FORM))
; #<(SIMPLE-ARRAY CHARACTER
; (216)) Similar to the standard function APROPOS but returns a list of all
; symbols which match the regular expression REGEX. If CASE-INSENSITIVE
; is true and REGEX isn't already a scanner, a case-insensitive ... {14480007}>
; (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
; (BLOCK CL-PPCRE:REGEX-APROPOS
; (CL-PPCRE::REGEX-APROPOS-AUX (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
; CL-PPCRE::CASE-INSENSITIVE)
; (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
; (VALUES)))
;
; caught STYLE-WARNING:
; &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL PACKAGES
; &KEY
; (CASE-INSENSITIVE T))
; processing (LET* (# #) ...)
; processing (LET* (# # ...) ...)
; processing (LET* (# # ...) ...)
; processing (DEFUN PARSE-TREE-SYNONYM ...)
; processing (DEFUN (SETF PARSE-TREE-SYNONYM) ...)
; processing (DEFMACRO DEFINE-PARSE-TREE-SYNONYM ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/api-tmpQN7VP0FI.fasl
; compilation finished in 0:00:00.388
WARNING:
Lisp compilation had style-warnings while
compiling #
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/api.lisp
; in: DEFUN CL-PPCRE::QUOTE-SECTIONS
; (CL-PPCRE:QUOTE-META-CHARS CL-PPCRE::TARGET-STRING :START
; (SVREF CL-PPCRE::REG-STARTS 0) :END (SVREF CL-PPCRE::REG-ENDS 0))
;
; caught STYLE-WARNING:
; undefined function: CL-PPCRE:QUOTE-META-CHARS
;
; compilation unit finished
; Undefined function:
; CL-PPCRE:QUOTE-META-CHARS
; caught 7 STYLE-WARNING conditions
; printed 1198 notes
phase `build' succeeded after 4.3 seconds
starting phase `check'
Invoking sbcl: "/gnu/store/46wmmqdkffzzkfjpk8s3x1qmn9m2wl0h-sbcl-2.1.9/bin/sbcl" "--non-interactive" "--eval" "(require :asdf)" "--eval" "(asdf:load-asd (truename \"/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/cl-ppcre.asd\"))" "--eval" "(when (uiop:file-exists-p \"cl-ppcre-tests.asd\") (asdf:load-asd (truename \"cl-ppcre-tests.asd\")))" "--eval" "(when (uiop:file-exists-p \"cl-ppcre-test.asd\") (asdf:load-asd (truename \"cl-ppcre-test.asd\")))" "--eval" "(when (uiop:file-exists-p \"tests.asd\") (asdf:load-asd (truename \"tests.asd\")))" "--eval" "(when (uiop:file-exists-p \"test.asd\") (asdf:load-asd (truename \"test.asd\")))" "--eval" "(asdf:test-system \"cl-ppcre\")"
This is SBCL 2.1.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
WARNING:
Deprecated recursive use of (ASDF/OPERATE:OPERATE 'ASDF/LISP-ACTION:LOAD-OP
'("cl-ppcre-test")) while visiting (ASDF/LISP-ACTION:TEST-OP "cl-ppcre") -
please use proper dependencies instead
WARNING: System definition file #P"/gnu/store/v0qv7zggz2s69inbafmwialz2lh4ligp-sbcl-flexi-streams-1.0.19/share/common-lisp/sbcl/flexi-streams/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/packages.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-USER)
; processing (DEFPACKAGE :CL-PPCRE-TEST ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/test/packages-tmp7LQ0A0VI.fasl
; compilation finished in 0:00:00.032
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/tests.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE-TEST)
; processing (DEFVAR *THIS-FILE* ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/tests.lisp
; in: DEFVAR *THIS-FILE*
; (OR
; #P"/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/tests.lisp"
; *LOAD-PATHNAME*)
; --> LET IF
; ==>
; *LOAD-PATHNAME*
;
; note: deleting unreachable code
; processing (DEFMACRO DO-TESTS ...)
; processing (DEFUN SIMPLE-TESTS ...)
; processing (DEFUN RANDOM-TEST-FUNCTION ...)
; processing (DEFUN TEST-OPTIMIZED-TEST-FUNCTIONS% ...)
; processing (DEFUN TEST-OPTIMIZED-TEST-FUNCTIONS ...)
; processing (DEFUN RUN-ALL-TESTS ...)
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/test/tests-tmp74KGUNRZ.fasl
; compilation finished in 0:00:00.072
; compiling file "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/perl-tests.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-PPCRE-TEST)
; processing (DEFVAR *TESTS-TO-SKIP* ...)
; processing (DEFUN CREATE-STRING-FROM-INPUT ...)
; processing (DEFUN PERL-TEST ...)
; file: /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/share/common-lisp/sbcl/cl-ppcre/test/perl-tests.lisp
; in: DEFUN PERL-TEST
; (FIND CL-PPCRE-TEST::COUNTER CL-PPCRE-TEST::*TESTS-TO-SKIP* :TEST #'=)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a SEQUENCE, not a (OR LIST VECTOR).
; (SUBSEQ CL-PPCRE-TEST::TARGET CL-PPCRE-TEST::START CL-PPCRE-TEST::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (STRING= CL-PPCRE-TEST::RESULT CL-PPCRE-TEST::EXPECTED-RESULT)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR SIMPLE-STRING NULL), not a STRING.
; The second argument is a (OR STRING SYMBOL CHARACTER), not a STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR SIMPLE-STRING NULL), not a SIMPLE-STRING.
; The second argument is a (OR STRING SYMBOL CHARACTER), not a SIMPLE-STRING.
; (SUBSEQ CL-PPCRE-TEST::TARGET CL-PPCRE-TEST::REG-START CL-PPCRE-TEST::REG-END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a VECTOR.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a LIST.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; (STRING= CL-PPCRE-TEST::EXPECTED-REGISTER CL-PPCRE-TEST::REGISTER)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR STRING SYMBOL CHARACTER), not a STRING.
; The second argument is a (OR SIMPLE-STRING NULL), not a STRING.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR STRING SYMBOL CHARACTER), not a SIMPLE-STRING.
; The second argument is a (OR SIMPLE-STRING NULL), not a SIMPLE-STRING.
; (CL-PPCRE-TEST::DO-TESTS ((FORMAT NIL "Running tests in file ~S"
; (FILE-NAMESTRING CL-PPCRE-TEST::FILE-NAME))
; (NOT CL-PPCRE-TEST::VERBOSE))
; (LET ((CL-PPCRE-TEST::INPUT-LINE (OR # #)) CL-PPCRE-TEST::ERRORS)
; (DESTRUCTURING-BIND
; (CL-PPCRE-TEST::COUNTER CL-PPCRE-TEST::INFO-STRING%
; CL-PPCRE-TEST::REGEX% CL-PPCRE-TEST::CASE-INSENSITIVE-MODE
; CL-PPCRE-TEST::MULTI-LINE-MODE CL-PPCRE-TEST::SINGLE-LINE-MODE
; CL-PPCRE-TEST::EXTENDED-MODE CL-PPCRE-TEST::TARGET%
; CL-PPCRE-TEST::PERL-ERROR CL-PPCRE-TEST::EXPECTED-RESULT%
; CL-PPCRE-TEST::EXPECTED-REGISTERS)
; CL-PPCRE-TEST::INPUT-LINE
; (DESTRUCTURING-BIND
; (CL-PPCRE-TEST::INFO-STRING CL-PPCRE-TEST::REGEX
; CL-PPCRE-TEST::TARGET CL-PPCRE-TEST::EXPECTED-RESULT)
; (MAPCAR 'CL-PPCRE-TEST::CREATE-STRING-FROM-INPUT #)
; (SETQ #)
; (UNLESS # # #)))))
; --> LET BLOCK FLET LOOP BLOCK TAGBODY PROGN WHEN IF AND IF
; ==>
; (ZEROP (MOD CL-PPCRE-TEST::TESTCOUNT 10))
;
; note: unable to
; convert integer division to multiplication
; due to type uncertainty:
; The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 32).
; --> LET BLOCK FLET LOOP BLOCK TAGBODY PROGN WHEN IF PROGN WHEN IF
; ==>
; (ZEROP (MOD CL-PPCRE-TEST::TESTCOUNT 100))
;
; note: unable to
; convert integer division to multiplication
; due to type uncertainty:
; The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 32).
; --> LET BLOCK FLET LOOP BLOCK TAGBODY PROGN LET INCF SETQ THE
; ==>
; (+ 1 CL-PPCRE-TEST::TESTCOUNT)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (INTEGER 1), not a FIXNUM.
; The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (INTEGER 1), not a FIXNUM.
; The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; (1+ CL-PPCRE-TEST::I)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; (LOOP CL-PPCRE-TEST::FOR CL-PPCRE-TEST::I CL-PPCRE-TEST::FROM 0
; CL-PPCRE-TEST::FOR CL-PPCRE-TEST::EXPECTED-REGISTER CL-PPCRE-TEST::IN CL-PPCRE-TEST::EXPECTED-REGISTERS
; CL-PPCRE-TEST::FOR CL-PPCRE-TEST::REG-START = ...)
; --> BLOCK LET LET LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE
; ==>
; (1+ CL-PPCRE-TEST::I)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a UNSIGNED-BYTE, not a FIXNUM.
; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
; &REST T).
; etc.
; wrote /gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib/common-lisp/sbcl/cl-ppcre/test/perl-tests-tmpCEL1YIM2.fasl
; compilation finished in 0:00:00.084
Test: Running tests in file "perltestdata"
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
...
Test: Optimized test functions - this might take some time...
Test: Simple tests from file "simple"
.......
;
; compilation unit finished
; printed 17 notes
All tests passed.phase `check' succeeded after 7.7 seconds
starting phase `create-asdf-configuration'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/.cl-union/etc/common-lisp/source-registry.conf.d/50-trivial-gray-streams.conf' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/etc/common-lisp/source-registry.conf.d/50-trivial-gray-streams.conf'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/.cl-union/etc/common-lisp/source-registry.conf.d/50-flexi-streams.conf' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/etc/common-lisp/source-registry.conf.d/50-flexi-streams.conf'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/.cl-union/etc/common-lisp/asdf-output-translations.conf.d/50-trivial-gray-streams.conf' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/etc/common-lisp/asdf-output-translations.conf.d/50-trivial-gray-streams.conf'
`/tmp/guix-build-sbcl-cl-ppcre-2.1.1.drv-0/source/.cl-union/etc/common-lisp/asdf-output-translations.conf.d/50-flexi-streams.conf' -> `/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/etc/common-lisp/asdf-output-translations.conf.d/50-flexi-streams.conf'
phase `create-asdf-configuration' succeeded after 0.0 seconds
starting phase `cleanup'
phase `cleanup' succeeded after 0.0 seconds
starting phase `patch-shebangs'
phase `patch-shebangs' succeeded after 0.0 seconds
starting phase `strip'
phase `strip' succeeded after 0.0 seconds
starting phase `validate-runpath'
validating RUNPATH of 0 binaries in "/gnu/store/jj98qc0dqj5542knabbbk38pcjr2spsy-sbcl-cl-ppcre-2.1.1/lib"...
phase `validate-runpath' succeeded after 0.0 seconds
starting phase `validate-documentation-location'
phase `validate-documentation-location' succeeded after 0.0 seconds
starting phase `delete-info-dir-file'
phase `delete-info-dir-file' succeeded after 0.0 seconds
starting phase `patch-dot-desktop-files'
phase `patch-dot-desktop-files' succeeded after 0.0 seconds
starting phase `make-dynamic-linker-cache'
phase `make-dynamic-linker-cache' succeeded after 0.0 seconds
starting phase `install-license-files'
installing 0 license files from '.'
phase `install-license-files' succeeded after 0.0 seconds
starting phase `reset-gzip-timestamps'
phase `reset-gzip-timestamps' succeeded after 0.0 seconds
starting phase `compress-documentation'
phase `compress-documentation' succeeded after 0.0 seconds