=>> Building textproc/cl-ppcre-sbcl build started at Sun Nov 9 18:36:22 EST 2025 port directory: /usr/ports/textproc/cl-ppcre-sbcl package name: cl-ppcre-sbcl-2.1.2_17 building for: FreeBSD pkg.DaveG.ca 15.0-ALPHA3 FreeBSD 15.0-ALPHA3 1500064 amd64 maintained by: olgeni@FreeBSD.org Makefile datestamp: -rw-r--r-- 1 root wheel 479 Aug 6 08:11 /usr/ports/textproc/cl-ppcre-sbcl/Makefile Ports top last git commit: ec159283c191 Ports top unclean checkout: no Port dir last git commit: b6ad8fb49880 Port dir unclean checkout: no Poudriere version: poudriere-git-3.4.2 Host OSVERSION: 1500068 Jail OSVERSION: 1500064 Job Id: 16 ---Begin Environment--- SHELL=/bin/sh OSVERSION=1500064 UNAME_v=FreeBSD 15.0-ALPHA3 1500064 UNAME_r=15.0-ALPHA3 BLOCKSIZE=K MAIL=/var/mail/root MM_CHARSET=UTF-8 LANG=C.UTF-8 STATUS=1 HOME=/root PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin MAKE_OBJDIR_CHECK_WRITABLE=0 LOCALBASE=/usr/local USER=root POUDRIERE_NAME=poudriere-git LIBEXECPREFIX=/usr/local/libexec/poudriere POUDRIERE_VERSION=3.4.2 MASTERMNT=/usr/local/poudriere/data/.m/freebsd_15_c_x64-HEAD-ALL/ref LC_COLLATE=C POUDRIERE_BUILD_TYPE=bulk PACKAGE_BUILDING=yes SAVED_TERM=tmux-256color OUTPUT_REDIRECTED_STDERR=4 OUTPUT_REDIRECTED=1 PWD=/usr/local/poudriere/data/.m/freebsd_15_c_x64-HEAD-ALL/16/.p OUTPUT_REDIRECTED_STDOUT=3 P_PORTS_FEATURES=FLAVORS SUBPACKAGES SELECTED_OPTIONS MASTERNAME=freebsd_15_c_x64-HEAD-ALL SCRIPTPREFIX=/usr/local/share/poudriere SCRIPTNAME=bulk.sh OLDPWD=/usr/local/poudriere/data/.m/freebsd_15_c_x64-HEAD-ALL/ref/.p/pool POUDRIERE_PKGNAME=poudriere-git-3.4.2 SCRIPTPATH=/usr/local/share/poudriere/bulk.sh POUDRIEREPATH=/usr/local/bin/poudriere ---End Environment--- ---Begin Poudriere Port Flags/Env--- PORT_FLAGS= PKGENV= FLAVOR= MAKE_ARGS= ---End Poudriere Port Flags/Env--- ---Begin OPTIONS List--- ---End OPTIONS List--- --MAINTAINER-- olgeni@FreeBSD.org --End MAINTAINER-- --CONFIGURE_ARGS-- --End CONFIGURE_ARGS-- --CONFIGURE_ENV-- XDG_DATA_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work XDG_CONFIG_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work XDG_CACHE_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.cache HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin PKG_CONFIG_LIBDIR=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.pkgconfig:/usr/local/libdata/pkgconfig:/usr/local/share/pkgconfig:/usr/libdata/pkgconfig SHELL=/bin/sh CONFIG_SHELL=/bin/sh --End CONFIGURE_ENV-- --MAKE_ENV-- XDG_DATA_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work XDG_CONFIG_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work XDG_CACHE_HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.cache HOME=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin PKG_CONFIG_LIBDIR=/wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/.pkgconfig:/usr/local/libdata/pkgconfig:/usr/local/share/pkgconfig:/usr/libdata/pkgconfig MK_DEBUG_FILES=no MK_KERNEL_SYMBOLS=no SHELL=/bin/sh NO_LINT=YES PREFIX=/usr/local LOCALBASE=/usr/local CC="cc" CFLAGS="-O2 -pipe -fstack-protector-strong -fno-strict-aliasing " CPP="cpp" CPPFLAGS="" LDFLAGS=" " LIBS="" CXX="c++" CXXFLAGS="-O2 -pipe -fstack-protector-strong -fno-strict-aliasing " BSD_INSTALL_PROGRAM="install -s -m 555" BSD_INSTALL_LIB="install -s -m 0644" BSD_INSTALL_SCRIPT="install -m 555" BSD_INSTALL_DATA="install -m 0644" BSD_INSTALL_MAN="install -m 444" --End MAKE_ENV-- --PLIST_SUB-- OSREL=15.0 PREFIX=%D LOCALBASE=/usr/local RESETPREFIX=/usr/local LIB32DIR=lib DOCSDIR="share/doc/cl-ppcre-sbcl" EXAMPLESDIR="share/examples/cl-ppcre-sbcl" DATADIR="share/cl-ppcre" WWWDIR="www/cl-ppcre" ETCDIR="etc/cl-ppcre" --End PLIST_SUB-- --SUB_LIST-- PREFIX=/usr/local LOCALBASE=/usr/local DATADIR=/usr/local/share/cl-ppcre DOCSDIR=/usr/local/share/doc/cl-ppcre-sbcl EXAMPLESDIR=/usr/local/share/examples/cl-ppcre-sbcl WWWDIR=/usr/local/www/cl-ppcre ETCDIR=/usr/local/etc/cl-ppcre --End SUB_LIST-- ---Begin make.conf--- DEFAULT_VERSIONS+=pgsql=15 DEFAULT_VERSIONS+=php=82 DISABLE_LICENSES=yes SELECTED_OPTIONS+=OPENBLAS ARCHDEF=AMD64K10h64SSE3 USE_PACKAGE_DEPENDS=yes BATCH=yes WRKDIRPREFIX=/wrkdirs PORTSDIR=/usr/ports PACKAGES=/packages DISTDIR=/distfiles FORCE_PACKAGE=yes PACKAGE_BUILDING=yes PACKAGE_BUILDING_FLAVORS=yes #### #### DEFAULT_VERSIONS+=pgsql=15 DEFAULT_VERSIONS+=php=82 DISABLE_LICENSES=yes SELECTED_OPTIONS+=OPENBLAS ARCHDEF=AMD64K10h64SSE3 WITH_CCACHE_BUILD=yes CCACHE_DIR=/root/.ccache #### Misc Poudriere #### .include "/etc/make.conf.ports_env" GID=0 UID=0 ---End make.conf--- --Resource limits-- cpu time (seconds, -t) unlimited file size (512-blocks, -f) unlimited data seg size (kbytes, -d) 33554432 stack size (kbytes, -s) 524288 core file size (512-blocks, -c) unlimited max memory size (kbytes, -m) unlimited locked memory (kbytes, -l) unlimited max user processes (-u) 89999 open files (-n) 8192 virtual mem size (kbytes, -v) unlimited swap limit (kbytes, -w) unlimited socket buffer size (bytes, -b) unlimited pseudo-terminals (-p) unlimited kqueues (-k) unlimited umtx shared locks (-o) unlimited pipebuf (-y) unlimited --End resource limits-- =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/sbin/pkg - not found ===> Installing existing package /packages/All/pkg-2.4.2_1.pkg [pkg.DaveG.ca] Installing pkg-2.4.2_1... [pkg.DaveG.ca] Extracting pkg-2.4.2_1: .......... done ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/sbin/pkg - found ===> Returning to build of cl-ppcre-sbcl-2.1.2_17 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Fetching all distfiles required by cl-ppcre-sbcl-2.1.2_17 for building =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Fetching all distfiles required by cl-ppcre-sbcl-2.1.2_17 for building =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Fetching all distfiles required by cl-ppcre-sbcl-2.1.2_17 for building ===> Extracting for cl-ppcre-sbcl-2.1.2_17 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Patching for cl-ppcre-sbcl-2.1.2_17 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/lib/common-lisp/cl-ppcre/cl-ppcre.asd - not found ===> Installing existing package /packages/All/cl-ppcre-2.1.2_1.pkg [pkg.DaveG.ca] Installing cl-ppcre-2.1.2_1... [pkg.DaveG.ca] Extracting cl-ppcre-2.1.2_1: .......... done ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/lib/common-lisp/cl-ppcre/cl-ppcre.asd - found ===> Returning to build of cl-ppcre-sbcl-2.1.2_17 ===> cl-ppcre-sbcl-2.1.2_17 depends on executable: sbcl - not found ===> Installing existing package /packages/All/sbcl-2.5.7,1.pkg [pkg.DaveG.ca] Installing sbcl-2.5.7,1... [pkg.DaveG.ca] `-- Installing cl-freebsd-asdf-init-20250101... [pkg.DaveG.ca] `-- Extracting cl-freebsd-asdf-init-20250101: .. done [pkg.DaveG.ca] `-- Installing gmp-6.3.0... [pkg.DaveG.ca] | `-- Installing indexinfo-0.3.1_1... [pkg.DaveG.ca] | `-- Extracting indexinfo-0.3.1_1: . done [pkg.DaveG.ca] `-- Extracting gmp-6.3.0: .......... done [pkg.DaveG.ca] `-- Installing mpfr-4.2.2,1... [pkg.DaveG.ca] `-- Extracting mpfr-4.2.2,1: .......... done [pkg.DaveG.ca] `-- Installing zstd-1.5.7... [pkg.DaveG.ca] | `-- Installing liblz4-1.10.0_2,1... [pkg.DaveG.ca] | `-- Extracting liblz4-1.10.0_2,1: .......... done [pkg.DaveG.ca] `-- Extracting zstd-1.5.7: .......... done [pkg.DaveG.ca] Extracting sbcl-2.5.7,1: .......... done ===> cl-ppcre-sbcl-2.1.2_17 depends on executable: sbcl - found ===> Returning to build of cl-ppcre-sbcl-2.1.2_17 ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/bin/ccache - not found ===> Installing existing package /packages/All/ccache-3.7.12_8.pkg [pkg.DaveG.ca] Installing ccache-3.7.12_8... [pkg.DaveG.ca] Extracting ccache-3.7.12_8: ......... done Create compiler links... create symlink for cc create symlink for cc (world) create symlink for c++ create symlink for c++ (world) create symlink for CC create symlink for CC (world) create symlink for clang create symlink for clang (world) create symlink for clang++ create symlink for clang++ (world) ===== Message from ccache-3.7.12_8: -- NOTE: Please read /usr/local/share/doc/ccache/ccache-howto-freebsd.txt for information on using ccache with FreeBSD ports and src. ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/bin/ccache - found ===> Returning to build of cl-ppcre-sbcl-2.1.2_17 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Configuring for cl-ppcre-sbcl-2.1.2_17 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Building for cl-ppcre-sbcl-2.1.2_17 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/packages.lisp" (written 27 SEP 2025 07:33:09 PM): ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/packages-tmpGHU3ALSV.fasl ; compilation finished in 0:00:00.007 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/specials.lisp" (written 27 SEP 2025 07:33:09 PM): ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/specials-tmpAAURSO1.fasl ; compilation finished in 0:00:00.020 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/util.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a STRING, not a (OR SIMPLE-BASE-STRING NULL). ; 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 /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/util-tmp5GEXGEG5.fasl ; compilation finished in 0:00:00.077 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/errors.lisp" (written 27 SEP 2025 07:33:09 PM): ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/errors-tmpAR3FSGEY.fasl ; compilation finished in 0:00:00.030 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/charset.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/cl-ppcre/charset.lisp ; in: DEFUN MIX ; (+ CL-PPCRE::CODE CL-PPCRE::HASH) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; 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. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (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 (-17592186044414) (17592186044414))), not a FIXNUM. ; The result is a (VALUES ; (OR FLOAT (RATIONAL (-17592186044413) (17592186044415))) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (OR FLOAT ; (RATIONAL (-17592186044414) (17592186044414))), not a FIXNUM. ; The result is a (VALUES ; (OR FLOAT (RATIONAL (-17592186044413) (17592186044415))) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; in: DEFUN %ADD-TO-CHARSET/EXPAND ; (>= CL-PPCRE::NEW-SIZE 371370) ; ; note: forced to do <-INTEGER-FIXNUM (cost 8) ; unable to do inline fixnum comparison (cost 3) because: ; The first argument is a INTEGER, not a FIXNUM. ; (* 2 CL-PPCRE::NEW-SIZE) ; ; note: forced to do full call ; unable to do inline ASH (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline ASH (cost 3) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; 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 * 4611686018427387903), not a FIXNUM. ; The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER * 4611686018427387903), not a FIXNUM. ; The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; etc. ; in: DEFUN CREATE-CHARSET-FROM-TEST-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 ...) ; --> LET LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 ; (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 ...) ; --> LET LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: forced to do full call ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-FLOAT. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/charset-tmpJAIDFZTC.fasl ; compilation finished in 0:00:00.096 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/charmap.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 ; in: DEFUN CREATE-CHARMAP-FROM-TEST-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 ...) ; --> LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; (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 ...) ; --> LET LET TAGBODY WHEN IF ; ==> ; (< CL-PPCRE::CODE #:LIM31) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 ...) ; --> LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: forced to do full call ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-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 &OPTIONAL). ; 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 &OPTIONAL). ; 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 ...) ; --> LET LET TAGBODY WHEN IF ; ==> ; (< CL-PPCRE::CODE #:LIM31) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a REAL, not a DOUBLE-FLOAT. ; etc. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/charmap-tmp8V3J6PE9.fasl ; compilation finished in 0:00:00.114 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/chartest.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/cl-ppcre/chartest.lisp ; in: DEFUN CREATE-HASH-TABLE-FROM-TEST-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 ...) ; --> LET LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 ; (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 ...) ; --> LET LET LET TAGBODY WHEN IF ; ==> ; (>= CL-PPCRE::CODE #:LIM0) ; ; note: forced to do full call ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-FLOAT. ; in: DEFUN CREATE-OPTIMIZED-TEST-FUNCTION ; (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 ; optimize ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a REAL, not a (UNSIGNED-BYTE 62). ; ; 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 ; 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 ; optimize ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a REAL, not a (UNSIGNED-BYTE 62). ; ; note: unable to ; convert division by 2^k to shift ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (- CL-PPCRE::END CL-PPCRE::START) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/chartest-tmp9V47YWQF.fasl ; compilation finished in 0:00:00.046 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/lexer.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/cl-ppcre/lexer.lisp ; in: DEFUN NEXT-CHAR ; (- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER) 2) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFUN GET-NUMBER ; (+ (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER) (THE FIXNUM CL-PPCRE::MAX-LENGTH)) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFUN MAKE-CHAR-FROM-CODE ; (CL-PPCRE::SIGNAL-SYNTAX-ERROR* CL-PPCRE::ERROR-POS ; "No character for hex-code ~X." NUMBER) ; ; note: deleting unreachable code ; in: DEFUN UNESCAPE-CHAR ; (CHAR-UPCASE CL-PPCRE::NEXT-CHAR) ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/lexer-tmp9BN22RMA.fasl ; compilation finished in 0:00:00.383 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/parser.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/cl-ppcre/parser.lisp ; in: DEFUN GROUP ; (+ CL-PPCRE::OPEN-PAREN-POS 2) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFUN SEQ ; (VECTOR-PUSH-EXTEND CL-PPCRE::QUANT (CAR CL-PPCRE::LAST-CDR)) ; ; note: unable to ; optimize ; because: ; Upgraded element type of array is not known at compile time. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/parser-tmp1CXFJSK9.fasl ; compilation finished in 0:00:00.077 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/regex-class.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; (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 /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/regex-class-tmpX4BRKI0R.fasl ; compilation finished in 0:00:00.044 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/regex-class-util.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; 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. ; in: DEFMETHOD EVERYTHINGP (ALTERNATION) ; (LENGTH CL-PPCRE::CHOICES) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; in: DEFMETHOD EVERYTHINGP (REPETITION) ; (= 1 CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first 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 DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a (OR (REAL 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX ; (DOUBLE-FLOAT 1.0d0 1.0d0))), not a SINGLE-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 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX ; (DOUBLE-FLOAT 1.0d0 1.0d0))), not a DOUBLE-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 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX ; (DOUBLE-FLOAT 1.0d0 1.0d0))), not a (COMPLEX ; SINGLE-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 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX ; (DOUBLE-FLOAT 1.0d0 1.0d0))), not a (COMPLEX ; DOUBLE-FLOAT). ; The second argument is a NUMBER, 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 (OR (REAL 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))), not a SINGLE-FLOAT. ; The second argument is a NUMBER, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a (OR (REAL 1 1) (COMPLEX (INTEGER 1 1)) ; (COMPLEX (SINGLE-FLOAT 1.0 1.0)) ; (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))), not a SINGLE-FLOAT. ; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; etc. ; 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 ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM6 CL-PPCRE::LEN) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The second argument is a (NOT NULL), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD REGEX-LENGTH (ALTERNATION) ; (/= CL-PPCRE::LEN CL-PPCRE::OLD-LEN) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, 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 (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a (NOT NULL), not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; in: DEFMETHOD REGEX-LENGTH (BRANCH) ; (EQL CL-PPCRE::THEN-LENGTH ; (CL-PPCRE::REGEX-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH))) ; ; note: forced to do IF-EQL (cost 15) ; 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; etc. ; in: DEFMETHOD REGEX-LENGTH (REPETITION) ; (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) ; ; note: forced to do IF-EQL (cost 15) ; 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; etc. ; (* CL-PPCRE::MINIMUM CL-PPCRE::LEN) ; ; note: forced to do GENERIC-* (cost 30) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a T, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; 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) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM6 CL-PPCRE::LEN) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; 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) ; --> LET LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY ; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF ; ==> ; (< #:MINMAXTMP10 #:MINMAX9) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 SINGLE-FLOAT. ; The second argument is a REAL, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a REAL, not a DOUBLE-FLOAT. ; etc. ; 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a T, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-FLOAT. ; etc. ; in: DEFMETHOD REGEX-MIN-LENGTH (REPETITION) ; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION) ; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)) ; ; note: forced to do GENERIC-* (cost 30) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a T, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (ALTERNATION T) ; (/= CL-PPCRE::CURR-OFFSET CL-PPCRE::OLD-OFFSET) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, 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 (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a (NOT NULL), not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; 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: forced to do IF-EQL (cost 15) ; 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (REPETITION T) ; (* CL-PPCRE::MINIMUM CL-PPCRE::LEN) ; ; note: forced to do GENERIC-* (cost 30) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a T, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; (+ CL-PPCRE::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)) ; ; 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 NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (CHAR-CLASS T) ; (1+ CL-PPCRE::START-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 &OPTIONAL). ; 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 &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (EVERYTHING T) ; (1+ CL-PPCRE::START-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 &OPTIONAL). ; 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 &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (STR T) ; (+ CL-PPCRE::START-POS (CL-PPCRE::LEN CL-PPCRE::STR)) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-OFFSETS (FILTER T) ; (+ CL-PPCRE::START-POS CL-PPCRE::LEN) ; ; 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 (NOT NULL), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/regex-class-util-tmpQ371UGST.fasl ; compilation finished in 0:00:00.315 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/convert.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 ; in: DEFUN MAYBE-SPLIT-REPETITION ; (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM) ; ; note: doing signed word to integer coercion (cost 20) ; in: DEFUN MAYBE-ACCUMULATE ; (SETF (SUBSEQ (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR) ; (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) ; (CL-PPCRE::LEN CL-PPCRE::STR))) ; (CL-PPCRE::STR CL-PPCRE::STR) ; (CL-PPCRE::SKIP CL-PPCRE::STR) T) ; --> SETF LET* ; ==> ; (REPLACE #:SEQUENCE #:NEW2 :START1 #:START :END1 NIL) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))). ; The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL). ; The second argument is a SEQUENCE, not a (OR NULL ; (SIMPLE-ARRAY CHARACTER (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (OR NULL ; (SIMPLE-ARRAY CHARACTER (*))). ; The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL). ; (MAKE-ARRAY (CL-PPCRE::LEN CL-PPCRE::STR) :INITIAL-CONTENTS ; (CL-PPCRE::STR CL-PPCRE::STR) :ELEMENT-TYPE 'CHARACTER ; :FILL-POINTER T :ADJUSTABLE T) ; ; 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 second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a LIST. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL). ; (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR)) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR)) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; 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. ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; 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. ; 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 SIMPLE-BASE-STRING. ; The second argument is a (OR STRING (AND SYMBOL (NOT NULL)) ; CHARACTER), not a SIMPLE-BASE-STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR STRING SYMBOL CHARACTER), not a (SIMPLE-ARRAY ; CHARACTER (*)). ; The second argument is a (OR STRING (AND SYMBOL (NOT NULL)) ; CHARACTER), not a (SIMPLE-ARRAY CHARACTER (*)). ; (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 &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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 ...) ; --> LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY ; --> SB-LOOP::LOOP-DESETQ SETQ THE 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; 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-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/convert-tmp2OWI3Q7U.fasl ; compilation finished in 0:00:00.468 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/optimize.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a VECTOR, not a (OR SIMPLE-BASE-STRING NULL). ; (INCF CL-PPCRE::COLLECTOR-LENGTH (CL-PPCRE::LEN CL-PPCRE::ELEMENT)) ; --> 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 &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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. ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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 SEQUENCE, not a VECTOR. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a LIST. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL). ; (CHAR CL-PPCRE::STR CL-PPCRE::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; 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)) ; --> LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY ; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF ; ==> ; (< #:MINMAXTMP11 #:MINMAX10) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 SINGLE-FLOAT. ; The second argument is a REAL, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a REAL, not a DOUBLE-FLOAT. ; etc. ; 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a T, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-FLOAT. ; etc. ; in: DEFMETHOD COMPUTE-MIN-REST (STR T) ; (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::STR)) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-MIN-REST (FILTER T) ; (+ CL-PPCRE::CURRENT-MIN-REST (OR (CL-PPCRE::LEN CL-PPCRE::FILTER) 0)) ; ; 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 (NOT NULL), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-MIN-REST (REPETITION T) ; (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION) ; (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)) ; ; note: forced to do GENERIC-* (cost 30) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a T, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-MIN-REST (LOOKBEHIND T) ; (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::LOOKBEHIND)) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-MIN-REST (REGEX T) ; (1+ CL-PPCRE::CURRENT-MIN-REST) ; ; 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 &OPTIONAL). ; 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 &OPTIONAL). ; etc. ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/optimize-tmp9KKTJMYV.fasl ; compilation finished in 0:00:00.237 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/closures.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; in: DEFMETHOD CREATE-MATCHER-AUX (LOOKBEHIND T) ; (- CL-PPCRE::START-POS CL-PPCRE::LEN) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; 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 LAMBDA FUNCTION AND IF IF FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize away possible call to FDEFINITION at runtime ; because: ; callable expression is not known to be a function ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; 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) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; 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) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; (+ CL-PPCRE::START-POS CL-PPCRE::LEN) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; 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) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; 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 ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/closures-tmpJU0JWO19.fasl ; compilation finished in 0:00:00.310 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/repetition-closures.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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 CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET BLOCK ; --> TAGBODY WHEN IF FUNCALL ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; 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) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (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)) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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)) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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 CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T) ; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0) ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; 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) ; --> SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; 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 CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET ; --> LOOP BLOCK LET LET TAGBODY UNLESS IF FUNCALL ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; 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) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; (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)) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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)) ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; (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 CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET ; --> MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET ; --> 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM. ; The second argument is a (INTEGER -13835058055282163709 ; 13835058055282163712), not a FIXNUM. ; --> LAMBDA FUNCTION LET 1+ ; ==> ; 1 ; ; note: forced to do -/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163710 13835058055282163711) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -13835058055282163710 ; 13835058055282163711), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -13835058055282163709 13835058055282163712) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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 CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET ; --> MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (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)) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE ; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))) ; --> LAMBDA FUNCTION LET MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T) ; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0) ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; 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) ; --> SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; 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 CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE LAMBDA FUNCTION ; --> LET AND IF IF LOOP BLOCK LET TAGBODY UNLESS IF AND IF FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize away possible call to FDEFINITION at runtime ; because: ; callable expression is not known to be a function ; (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS CL-PPCRE::NEXT-POS ; 0 CL-PPCRE::LEN) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)) ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; The second argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T) ; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0) ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0 ; (AREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM) NIL) ; --> SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (ZEROP (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first 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 DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> + AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)) ; --> SB-IMPL::XSUBTRACT AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; --> FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY. ; in: DEFMETHOD CREATE-MATCHER-AUX (REPETITION T) ; (ZEROP CL-PPCRE::MAXIMUM) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first 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 DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; 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 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 DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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::MIN-LEN) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first 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 DOUBLE-FLOAT. ; (PLUSP CL-PPCRE::LEN) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first 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 DOUBLE-FLOAT. ; (PLUSP 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (= CL-PPCRE::MINIMUM 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 T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 T, not a (COMPLEX SINGLE-FLOAT). ; etc. ; (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM) ; ; note: forced to do IF-EQL (cost 15) ; 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; etc. ; ; note: forced to do IF-EQL (cost 15) ; 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; etc. ; (PLUSP 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. ; (PLUSP 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. ; (PLUSP 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 /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/repetition-closures-tmpZX2WN8N4.fasl ; compilation finished in 0:00:00.533 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/scanner.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/cl-ppcre/scanner.lisp ; in: DEFUN CREATE-BMH-MATCHER ; (CL-PPCRE::BMH-MATCHER-AUX :CASE-INSENSITIVE-P T) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; 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. ; in: DEFUN CREATE-CHAR-SEARCHER ; (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T) ; --> 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The first argument is a CHARACTER, not a BASE-CHAR. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; in: DEFUN CREATE-SCANNER-AUX ; (CL-PPCRE::INSERT-ADVANCE-FN ; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS)) ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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 # ; #))))) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (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 # ; #))))) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; (CL-PPCRE::INSERT-ADVANCE-FN ; (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS)) ; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF ; --> NOT ; ==> ; 1 ; ; 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. ; ; note: unable to ; open code ; due to type uncertainty: ; The second argument is a CHARACTER, not a BASE-CHAR. ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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)) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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)) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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)) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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)) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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)) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; etc. ; (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 # ; #))))) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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 # ; #))))) ; --> 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 fixnum arithmetic (cost 2) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; --> 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. ; --> 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 &OPTIONAL). ; 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 &OPTIONAL). ; 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 /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/scanner-tmpOU81XRV0.fasl ; compilation finished in 0:00:01.450 ; compiling file "/usr/local/lib/common-lisp/cl-ppcre/api.lisp" (written 27 SEP 2025 07:33:09 PM): ; file: /usr/local/lib/common-lisp/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. ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a DOUBLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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. ; 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-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; 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-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; 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-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; 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. ; --> LET PROGN UNLESS IF TYPEP ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE). ; (FUNCALL CL-PPCRE::SUBSTR-FN CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START ; CL-PPCRE::MATCH-END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE). ; 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. ... {110287F32F}> ; (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) ; 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, ; ... {1102C7000F}> ; (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) ; 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... {1102DC24AF}> ; (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) ; 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... {1102F6BEAF}> ; (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) ; in: DEFUN COUNT-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::S CL-PPCRE::E CL-PPCRE::REGEX ; CL-PPCRE::TARGET-STRING COUNT :START CL-PPCRE::START ; :END CL-PPCRE::END) ; (INCF COUNT)) ; --> 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. ; --> LET BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND ; --> IF THE COERCE ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT SIMPLE-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF ; ==> ; (= CL-PPCRE::S CL-PPCRE::E) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; note: unable to open code because: The operands might not be the same type. ; (INCF COUNT) ; --> THE ; ==> ; (+ 1 COUNT) ; ; 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 ; &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; (CL-PPCRE:DO-MATCHES (CL-PPCRE::S CL-PPCRE::E CL-PPCRE::REGEX ; CL-PPCRE::TARGET-STRING COUNT :START CL-PPCRE::START ; :END CL-PPCRE::END) ; (INCF COUNT)) ; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF ; ==> ; (= CL-PPCRE::S CL-PPCRE::E) ; ; 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 SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; 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)) ; --> 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. ; --> LET BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND ; --> IF THE COERCE ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT SIMPLE-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; --> 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, 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 (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; 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 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 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 ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT SIMPLE-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; --> 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, 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 (NOT NULL), not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; --> 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 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; 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))) ; --> 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. ; --> BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF ; --> THE COERCE ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT SIMPLE-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; 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 SINGLE-FLOAT. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-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 ...) ; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET LET ; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET TAGBODY ; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF ; ==> ; 1 ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (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))) ; --> 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; note: unable to open code because: The operands might not be the same type. ; (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a SINGLE-FLOAT. ; The second argument is a REAL, not a RATIONAL. ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a DOUBLE-FLOAT. ; The second argument is a REAL, 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 SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)) ; ; note: forced to do GENERIC-= (cost 10) ; unable to do inline float comparison (cost 3) because: ; The first argument is a NUMBER, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 T, not a (COMPLEX SINGLE-FLOAT). ; etc. ; (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) ; --> 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 ; &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; (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))) ; --> 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 SINGLE-FLOAT. ; The second argument is a NUMBER, not a SINGLE-FLOAT. ; unable to do inline float comparison (cost 3) because: ; The first argument is a NUMBER, not a SINGLE-FLOAT. ; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT). ; etc. ; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 SINGLE-FLOAT. ; The second argument is a (NOT NULL), not a SINGLE-FLOAT. ; 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. ; etc. ; in: DEFUN STRING-CASE-MODIFIER ; (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR CL-PPCRE::STR CL-PPCRE::FROM) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR CL-PPCRE::STR CL-PPCRE::TO) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR CL-PPCRE::STR CL-PPCRE::INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; 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 ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (< 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 (NOT NULL), 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 NULL INTEGER), not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (OR NULL INTEGER), not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; etc. ; (< CL-PPCRE::TOKEN 0) ; ; note: forced to do <-INTEGER-FIXNUM (cost 8) ; unable to do inline fixnum comparison (cost 3) because: ; The first argument is a INTEGER, not a FIXNUM. ; in: DEFUN BUILD-REPLACEMENT ; (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::REG-START ; CL-PPCRE::REG-END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-ARRAY. ; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START ; CL-PPCRE::MATCH-END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-ARRAY. ; (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 ; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START ; CL-PPCRE::MATCH-END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-ARRAY. ; (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: ; TOKEN is not known to be a function ; (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: ; TOKEN is not known to be a function ; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START ; CL-PPCRE::REG-END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-ARRAY. ; ; 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 (NOT NULL), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; ; 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 (NOT NULL), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; (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 ; &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START ; CL-PPCRE::MATCH-END) ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; ; 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 T, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; &OPTIONAL). ; etc. ; 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. ; 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)) ; --> 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. ; --> BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF ; --> THE COERCE ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT SIMPLE-BASE-STRING) ; (NOT (SIMPLE-ARRAY CHARACTER (*))) 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 (OR NULL ; (SIMPLE-ARRAY ; * (*))). ; ; 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 LIST. ; ; 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 (OR ; SIMPLE-BASE-STRING ; NULL). ; --> 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 to RATIONAL comparison ; due to type uncertainty: ; The first argument is a NUMBER, not a SINGLE-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 DOUBLE-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 (COMPLEX SINGLE-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 (COMPLEX DOUBLE-FLOAT). ; The second argument is a NUMBER, not a RATIONAL. ; ; note: unable to open code because: The operands might not be the same type. ; (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)) ; --> 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 SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-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 (COMPLEX SINGLE-FLOAT). ; etc. ; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ ; ==> ; 1 ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a NUMBER, not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; 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... {1101DC041F}> ; (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)))) ; --> 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... {1101DC041F}> ; (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)) ; 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 ... {1102251B5F}> ; (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)) ; --> 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 ... {1102251B5F}> ; (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)) ; wrote /wrkdirs/usr/ports/textproc/cl-ppcre-sbcl/work/cl-ppcre-2.1.2/api-tmpY2ML9CFA.fasl ; compilation finished in 0:00:00.643 WARNING: Lisp compilation had style-warnings while compiling # ; file: /usr/local/lib/common-lisp/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 641 notes =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-ppcre-sbcl-2.1.2_17 depends on file: /usr/local/lib/common-lisp/cl-ppcre/cl-ppcre.asd - found ===> cl-ppcre-sbcl-2.1.2_17 depends on executable: sbcl - found =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Staging for cl-ppcre-sbcl-2.1.2_17 ===> Generating temporary packing list ====> Compressing man pages (compress-man) =========================================================================== =================================================== ===== env: 'PKG_NOTES=build_timestamp ports_top_git_hash ports_top_checkout_unclean port_git_hash port_checkout_unclean built_by' 'PKG_NOTE_build_timestamp=2025-11-09T23:36:22+0000' 'PKG_NOTE_ports_top_git_hash=ec159283c191' 'PKG_NOTE_ports_top_checkout_unclean=no' 'PKG_NOTE_port_git_hash=b6ad8fb49880' 'PKG_NOTE_port_checkout_unclean=no' 'PKG_NOTE_built_by=poudriere-git-3.4.2' NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Building packages for cl-ppcre-sbcl-2.1.2_17 ===> Building cl-ppcre-sbcl-2.1.2_17 =========================================================================== =>> Cleaning up wrkdir ===> Cleaning for cl-ppcre-sbcl-2.1.2_17 build of textproc/cl-ppcre-sbcl | cl-ppcre-sbcl-2.1.2_17 ended at Sun Nov 9 18:36:40 EST 2025 build time: 00:00:19