=>> Building devel/cl-flexi-streams-sbcl build started at Sat May 3 04:27:19 BST 2025 port directory: /usr/ports/devel/cl-flexi-streams-sbcl package name: cl-flexi-streams-sbcl-1.0.20_1 building for: FreeBSD pkg-builder.dan.net.uk 14.2-RELEASE FreeBSD 14.2-RELEASE amd64 maintained by: jrm@FreeBSD.org Makefile datestamp: -rw-r--r-- 1 root wheel 741 Jan 27 13:48 /usr/ports/devel/cl-flexi-streams-sbcl/Makefile Ports top last git commit: 5529c5919b Ports top unclean checkout: yes Port dir last git commit: 5022036b0f Port dir unclean checkout: no Poudriere version: poudriere-git-3.4.2 Host OSVERSION: 1402000 Jail OSVERSION: 1402000 Job Id: 06 ---Begin Environment--- SHELL=/bin/sh OSVERSION=1402000 UNAME_v=FreeBSD 14.2-RELEASE UNAME_r=14.2-RELEASE 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/14-amd64-default-dan/ref LC_COLLATE=C POUDRIERE_BUILD_TYPE=bulk PACKAGE_BUILDING=yes SAVED_TERM=screen OUTPUT_REDIRECTED_STDERR=4 OUTPUT_REDIRECTED=1 PWD=/usr/local/poudriere/data/.m/14-amd64-default-dan/06/.p OUTPUT_REDIRECTED_STDOUT=3 P_PORTS_FEATURES=FLAVORS SUBPACKAGES SELECTED_OPTIONS MASTERNAME=14-amd64-default-dan SCRIPTPREFIX=/usr/local/share/poudriere SCRIPTNAME=bulk.sh OLDPWD=/usr/local/poudriere/data/.m/14-amd64-default-dan/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-- jrm@FreeBSD.org --End MAINTAINER-- --CONFIGURE_ARGS-- --End CONFIGURE_ARGS-- --CONFIGURE_ENV-- XDG_DATA_HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work XDG_CONFIG_HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work XDG_CACHE_HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/.cache HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin PKG_CONFIG_LIBDIR=/wrkdirs/usr/ports/devel/cl-flexi-streams-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/devel/cl-flexi-streams-sbcl/work XDG_CONFIG_HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work XDG_CACHE_HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/.cache HOME=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin PKG_CONFIG_LIBDIR=/wrkdirs/usr/ports/devel/cl-flexi-streams-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=" -fstack-protector-strong " 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=14.2 PREFIX=%D LOCALBASE=/usr/local RESETPREFIX=/usr/local LIB32DIR=lib DOCSDIR="share/doc/cl-flexi-streams-sbcl" EXAMPLESDIR="share/examples/cl-flexi-streams-sbcl" DATADIR="share/flexi-streams" WWWDIR="www/flexi-streams" ETCDIR="etc/flexi-streams" --End PLIST_SUB-- --SUB_LIST-- PREFIX=/usr/local LOCALBASE=/usr/local DATADIR=/usr/local/share/flexi-streams DOCSDIR=/usr/local/share/doc/cl-flexi-streams-sbcl EXAMPLESDIR=/usr/local/share/examples/cl-flexi-streams-sbcl WWWDIR=/usr/local/www/flexi-streams ETCDIR=/usr/local/etc/flexi-streams --End SUB_LIST-- ---Begin make.conf--- 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 #### #### CCACHE_CPP2=1 WITH_SSP_PORTS=yes WITH_SSP=yes #WITH_LTO=yes DISABLE_LICENSES=yes LICENSES_ACCEPTED=AGPLv3 APACHE10 APACHE11 APACHE20 ART10 ARTPERL10 ART20 BSD BSD2CLAUSE BSD3CLAUSE BSD4CLAUSE BSL CC0-1.0 CDDL ClArtistic EPL GFDL GMGPL GPLv1 GPLv2 GPLv3 GPLv3RLE ISCL LGPL20 LGPL21 LGPL3 LPPL10 LPPL11 LPPL12 LPPL13 LPPL13a LPPL13b LPPL13c MIT MPL OpenSSL OFL10 OFL11 OWL PostgreSQL PHP202 PHP30 PHP301 PSFL RUBY ZLIB ZPL21 SVM-Light EULA ALASIR Microsoft-exFAT SIMIAN UDEVGAME unknown MTA COMMERCIAL teamspeak NO_LICENSES_DIALOGS=yes #### #### NO_IGNORE=yes DEFAULT_VERSIONS+=ssl=openssl apache=2.4 imagemagick=7 java=21 linux=c7 mysql=8.0 php=8.3 samba=4.19 varnish=7 WITH_SETID_MODE=force PHP_ZTS=enabled OPTIONS_UNSET+=OPENJPEG OPTIONS_UNSET+=GSSAPI_BASE OPTIONS_SET+=ZTS OPTIONS_SET+=GSSAPI_NONE ALLOW_UNSUPPORTED_SYSTEM=yes WITH_CCACHE_BUILD=yes CCACHE_DIR=/root/.ccache #### Misc Poudriere #### .include "/etc/make.conf.ports_env" GID=0 UID=0 DISABLE_MAKE_JOBS=poudriere ---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-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/sbin/pkg - not found ===> Installing existing package /packages/All/pkg-2.1.2.pkg [pkg-builder.dan.net.uk] Installing pkg-2.1.2... [pkg-builder.dan.net.uk] Extracting pkg-2.1.2: .......... done ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/sbin/pkg - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_1 =========================================================================== =================================================== ===== 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-flexi-streams-sbcl-1.0.20_1 for building =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Fetching all distfiles required by cl-flexi-streams-sbcl-1.0.20_1 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-flexi-streams-sbcl-1.0.20_1 for building ===> Extracting for cl-flexi-streams-sbcl-1.0.20_1 =========================================================================== =================================================== ===== 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-flexi-streams-sbcl-1.0.20_1 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/flexi-streams/flexi-streams.asd - not found ===> Installing existing package /packages/All/cl-flexi-streams-1.0.20.pkg [pkg-builder.dan.net.uk] Installing cl-flexi-streams-1.0.20... [pkg-builder.dan.net.uk] `-- Installing cl-trivial-gray-streams-20240217... [pkg-builder.dan.net.uk] `-- Extracting cl-trivial-gray-streams-20240217: ......... done [pkg-builder.dan.net.uk] Extracting cl-flexi-streams-1.0.20: .......... done ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/flexi-streams/flexi-streams.asd - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_1 ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/trivial-gray-streams/sbclfasl/package.fasl - not found ===> Installing existing package /packages/All/cl-trivial-gray-streams-sbcl-20240217_5.pkg [pkg-builder.dan.net.uk] Installing cl-trivial-gray-streams-sbcl-20240217_5... [pkg-builder.dan.net.uk] `-- Installing sbcl-2.5.4,1... [pkg-builder.dan.net.uk] | `-- Installing cl-freebsd-asdf-init-20250101... [pkg-builder.dan.net.uk] | `-- Extracting cl-freebsd-asdf-init-20250101: .. done [pkg-builder.dan.net.uk] | `-- Installing gmp-6.3.0... [pkg-builder.dan.net.uk] | | `-- Installing indexinfo-0.3.1_1... [pkg-builder.dan.net.uk] | | `-- Extracting indexinfo-0.3.1_1: . done [pkg-builder.dan.net.uk] | `-- Extracting gmp-6.3.0: .......... done [pkg-builder.dan.net.uk] | `-- Installing mpfr-4.2.2,1... [pkg-builder.dan.net.uk] | `-- Extracting mpfr-4.2.2,1: .......... done [pkg-builder.dan.net.uk] | `-- Installing zstd-1.5.7... [pkg-builder.dan.net.uk] | | `-- Installing liblz4-1.10.0,1... [pkg-builder.dan.net.uk] | | `-- Extracting liblz4-1.10.0,1: .......... done [pkg-builder.dan.net.uk] | `-- Extracting zstd-1.5.7: .......... done [pkg-builder.dan.net.uk] `-- Extracting sbcl-2.5.4,1: .......... done [pkg-builder.dan.net.uk] Extracting cl-trivial-gray-streams-sbcl-20240217_5: .. done ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/trivial-gray-streams/sbclfasl/package.fasl - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_1 ===> cl-flexi-streams-sbcl-1.0.20_1 depends on executable: sbcl - found ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/bin/ccache - not found ===> Installing existing package /packages/All/ccache-3.7.12_8.pkg [pkg-builder.dan.net.uk] Installing ccache-3.7.12_8... [pkg-builder.dan.net.uk] 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-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/bin/ccache - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_1 =========================================================================== =================================================== ===== 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-flexi-streams-sbcl-1.0.20_1 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Building for cl-flexi-streams-sbcl-1.0.20_1 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/packages.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/packages-tmpGHU3ALSV.fasl ; compilation finished in 0:00:00.002 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/mapping.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/mapping-tmpAAURSO1.fasl ; compilation finished in 0:00:00.007 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/ascii.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/ascii-tmp5GEXGEG5.fasl ; compilation finished in 0:00:00.001 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/koi8-r.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/koi8-r-tmpAR3FSGEY.fasl ; compilation finished in 0:00:00.001 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/mac.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/mac-tmpJAIDFZTC.fasl ; compilation finished in 0:00:00.001 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/iso-8859.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/iso-8859-tmp8V3J6PE9.fasl ; compilation finished in 0:00:00.011 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/enc-cn-tbl.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/enc-cn-tbl-tmp9V47YWQF.fasl ; compilation finished in 0:00:00.101 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/code-pages.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/code-pages-tmp9BN22RMA.fasl ; compilation finished in 0:00:00.017 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/specials.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/specials-tmp1CXFJSK9.fasl ; compilation finished in 0:00:00.009 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/util.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/util.lisp ; in: DEFUN MAKE-OCTET-BUFFER ; (MAKE-ARRAY FLEXI-STREAMS::SIZE :ELEMENT-TYPE 'FLEXI-STREAMS:OCTET) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; in: DEFUN GET-MULTIBYTE-MAPPER ; (AREF FLEXI-STREAMS::TABLE FLEXI-STREAMS::M 0) ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; (AREF FLEXI-STREAMS::TABLE FLEXI-STREAMS::M 1) ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/util-tmpX4BRKI0R.fasl ; compilation finished in 0:00:00.030 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/conditions.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/conditions-tmpQ371UGST.fasl ; compilation finished in 0:00:00.009 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/external-format.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/external-format.lisp ; in: DEFUN EXTERNAL-FORMAT-EQUAL ; (EQL (FLEXI-STREAMS:EXTERNAL-FORMAT-ID FLEXI-STREAMS::EF1) ; (FLEXI-STREAMS:EXTERNAL-FORMAT-ID FLEXI-STREAMS::EF2)) ; ; 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. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/external-format-tmp2OWI3Q7U.fasl ; compilation finished in 0:00:00.133 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/length.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/length.lisp ; in: DEFMETHOD ENCODING-FACTOR (FLEXI-CRLF-MIXIN) ; (* 1.02d0 (CALL-NEXT-METHOD)) ; ; note: forced to do GENERIC-* (cost 30) ; unable to do inline float arithmetic (cost 5) because: ; The first argument is a T, not a DOUBLE-FLOAT. ; The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) ; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL). ; unable to do inline float arithmetic (cost 5) because: ; The first argument is a T, not a (COMPLEX DOUBLE-FLOAT). ; The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) ; &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) ; &OPTIONAL). ; in: DEFGENERIC CHECK-END ; (- FLEXI-STREAMS::I FLEXI-STREAMS::END) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS :AROUND (T LIST T T) ; (COERCE LIST 'VECTOR) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR NULL (SIMPLE-ARRAY * (*))). ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-8-BIT-FORMAT T T T) ; (- FLEXI-STREAMS::END FLEXI-STREAMS::START) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-MIXIN T T T) ; (SEARCH #(13 10) SEQUENCE :START2 FLEXI-STREAMS::I :END2 FLEXI-STREAMS::END ; :TEST #'=) ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to open code because: The operands might not be the same type. ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-8-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-8-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS :BEFORE (FLEXI-UTF-16-FORMAT T T T) ; (- FLEXI-STREAMS::END FLEXI-STREAMS::START) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-LE-FORMAT T T T) ; (AREF SEQUENCE (1+ FLEXI-STREAMS::I)) ; ; 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. ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-BE-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T) ; (AREF SEQUENCE (1+ FLEXI-STREAMS::I)) ; ; 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. ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; (AREF SEQUENCE (1+ FLEXI-STREAMS::I)) ; ; 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. ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-GBK-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-GBK-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::I) ; ; 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. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS :BEFORE (FLEXI-UTF-32-FORMAT T T T) ; (- FLEXI-STREAMS::END FLEXI-STREAMS::START) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-32-FORMAT T T T) ; (CEILING (- FLEXI-STREAMS::END FLEXI-STREAMS::START) 4) ; ; note: forced to do +/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-LE-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::J) ; ; 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. ; (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J)) ; ; note: unable to open code because: The operands might not be the same type. ; (CEILING (- FLEXI-STREAMS::END FLEXI-STREAMS::START) 4) ; ; note: forced to do +/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; (DECF LENGTH) ; --> THE SB-IMPL::XSUBTRACT BLOCK ; ==> ; (- SB-IMPL::B SB-IMPL::A) ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM. ; The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM. ; The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; etc. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-BE-FORMAT T T T) ; (AREF SEQUENCE FLEXI-STREAMS::J) ; ; 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. ; (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J)) ; ; note: unable to open code because: The operands might not be the same type. ; (CEILING (- FLEXI-STREAMS::END FLEXI-STREAMS::START) 4) ; ; note: forced to do +/SIGNED=>INTEGER (cost 7) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (INTEGER -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 -9223372036854775804 9223372036854775810) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; (DECF LENGTH) ; --> THE SB-IMPL::XSUBTRACT BLOCK ; ==> ; (- SB-IMPL::B SB-IMPL::A) ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM. ; The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM. ; The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES ; FIXNUM ; &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS :AROUND (T LIST T T) ; (COERCE LIST 'FLEXI-STREAMS::STRING*) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR SIMPLE-BASE-STRING NULL). ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-8-BIT-FORMAT T T T) ; (- FLEXI-STREAMS::END FLEXI-STREAMS::START) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-GBK-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-GBK-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-8-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-8-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-16-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: ; DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T) ; (CHAR STRING FLEXI-STREAMS::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-32-FORMAT T T T) ; (* 4 (- FLEXI-STREAMS::END FLEXI-STREAMS::START)) ; ; note: forced to do */SIGNED=>INTEGER (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM. ; The result is a (VALUES ; (OR (INTEGER -36893488147419103228 -4) (INTEGER 0 0) ; (INTEGER 4 36893488147419103228)) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; 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 ; (OR (INTEGER -36893488147419103228 -4) (INTEGER 0 0) ; (INTEGER 4 36893488147419103228)) ; &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; etc. ; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-MIXIN T T T) ; (+ (CALL-NEXT-METHOD) ; (* ; (CASE (FLEXI-STREAMS:EXTERNAL-FORMAT-NAME FORMAT) ; (:UTF-32 4) ; (OTHERWISE 1)) ; (COUNT #\Newline STRING :START FLEXI-STREAMS::START :END ; FLEXI-STREAMS::END :TEST #'CHAR=))) ; ; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; in: ; DEFMETHOD CHARACTER-LENGTH :AROUND (FLEXI-CRLF-MIXIN (EQL #\Newline)) ; (+ (CALL-NEXT-METHOD FORMAT FLEXI-STREAMS::+CR+) ; (CALL-NEXT-METHOD FORMAT FLEXI-STREAMS::+LF+)) ; ; 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/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/length-tmp9KKTJMYV.fasl ; compilation finished in 0:00:00.126 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/encode.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/encode.lisp ; in: DEFMETHOD STRING-TO-OCTETS* :AROUND (T LIST T T) ; (COERCE LIST 'FLEXI-STREAMS::STRING*) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR NULL (SIMPLE-ARRAY * (*))). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR SIMPLE-BASE-STRING NULL). ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT ; FLEXI-CRLF-LATIN-1-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 255) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 255) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 255) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not a LATIN-1 character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT ; FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (WHEN (> FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not an ASCII character." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET WHEN IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT ; FLEXI-CRLF-8-BIT-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::ENCODING-HASH ; FLEXI-STREAMS::EXTERNAL-FORMAT-ENCODING-HASH)) ; FORMAT ; (LET ((FLEXI-STREAMS:OCTET #)) ; (UNLESS FLEXI-STREAMS:OCTET ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::ENCODING-HASH ; FLEXI-STREAMS::EXTERNAL-FORMAT-ENCODING-HASH)) ; FORMAT ; (LET ((FLEXI-STREAMS:OCTET #)) ; (UNLESS FLEXI-STREAMS:OCTET ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; ; 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::ENCODING-HASH ; FLEXI-STREAMS::EXTERNAL-FORMAT-ENCODING-HASH)) ; FORMAT ; (LET ((FLEXI-STREAMS:OCTET #)) ; (UNLESS FLEXI-STREAMS:OCTET ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET)) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET ; --> GETHASH ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET ; --> UNLESS IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET ; --> SYMBOL-MACROLET LET GETHASH ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET ; --> SYMBOL-MACROLET LET UNLESS IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET ; --> SYMBOL-MACROLET LET GETHASH ; ==> ; 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET ; --> SYMBOL-MACROLET LET UNLESS IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT ; FLEXI-CRLF-UTF-8-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (TAGBODY ; (COND (# # #) (# # #) (# # #) (T #)) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::TWO ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ONE ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ZERO))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (TAGBODY ; (COND (# # #) (# # #) (# # #) (T #)) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::TWO ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ONE ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ZERO))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (TAGBODY ; (COND (# # #) (# # #) (# # #) (T #)) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::TWO ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ONE ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #)) ; FLEXI-STREAMS::ZERO))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD) ; (FLEXI-STREAMS::OCTET-WRITER #) ; (FLEXI-STREAMS::OCTET-WRITER #))) ; (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD)) ; (LET ((CHAR-CODE #)) ; (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE)) ; (COND (# #) (T # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-GBK-FORMAT FLEXI-CR-GBK-FORMAT ; FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (IF (<= FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET) ; (FLET (#) ; (DECLARE #) ; (DECLARE #) ; (COND # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (IF (<= FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET) ; (FLET (#) ; (DECLARE #) ; (DECLARE #) ; (COND # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT ; "~S (code ~A) is not in this encoding." ; FLEXI-STREAMS::CHAR-GETTER ; FLEXI-STREAMS:OCTET) ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (IF (<= FLEXI-STREAMS:OCTET 127) ; (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET) ; (FLET (#) ; (DECLARE #) ; (DECLARE #) ; (COND # # #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET IF FLET COND IF IF THE LET IF ; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET IF FLET COND IF IF ; --> THE LET IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET IF FLET COND IF IF ; --> THE LET IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-CRLF-UTF-32-LE-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; in: ; DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-CRLF-UTF-32-BE-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER) ; --> CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT) ; (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16))) ; (FLEXI-STREAMS::OCTET-WRITER ; (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8))) ; (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET MAKE-ARRAY ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET ; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* FUNCALL ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 ; fold division by 1 ; due to type uncertainty: ; The first argument is a REAL, not a INTEGER. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER CHAR ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a STRING, not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE LOOP ; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET ; --> FLEXI-STREAMS::CHAR-GETTER 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 (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET POSITION ; ==> ; 1 ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a LIST. ; ; note: unable to ; expand inline ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a STRING. ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a BIT-VECTOR. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; 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 (INTEGER -9223372036854775807 ; 9223372036854775807), not a FIXNUM. ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL). ; unable to do inline (signed-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF ; ==> ; (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::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 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 (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE ; 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* MIN ; ==> ; 1 ; ; note: doing signed word to integer coercion (cost 20), for: ; the second argument of GENERIC-* ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/encode-tmpJU0JWO19.fasl ; compilation finished in 0:00:01.010 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/decode.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/decode.lisp ; in: DEFMETHOD OCTETS-TO-STRING* :AROUND (T LIST T T) ; (COERCE LIST 'VECTOR) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a LIST, not a (OR NULL (SIMPLE-ARRAY * (*))). ; in: ; DEFINE-CHAR-DECODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT ; FLEXI-CRLF-LATIN-1-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT) ; FLEXI-STREAMS::OCTET-GETTER) ; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER ; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* ; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET ; --> IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 ; --> LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 ; --> LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 ; --> LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 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: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT ; FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER ; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* ; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET ; --> IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET)) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; FLEXI-STREAMS:OCTET))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT ; FLEXI-CRLF-8-BIT-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER ; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* ; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET ; --> IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET ((CHAR-CODE (AREF # #))) ; (IF (OR (NULL CHAR-CODE) (= # 65533)) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET) ; CHAR-CODE))) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT) ; (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE ; FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE)) ; FORMAT ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (LET (#) ; (IF # ; # ; CHAR-CODE))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT ; FLEXI-CRLF-UTF-8-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER ; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* ; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET ; --> IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (DECLARE #) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), 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. ; ; 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. ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (FLET (#) ; (DECLARE #) ; (LET # ; # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-GBK-FORMAT FLEXI-CR-GBK-FORMAT ; FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER ; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* ; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET ; --> IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN ; --> IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; ; 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. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET ; --> PROGN LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET PROGN ; --> LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; ; 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. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; --> BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK ; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* ; --> FLET MACROLET ETYPECASE COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP ; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY FLET ; --> #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF ; ==> ; (> #:CHAR-CODE0 1114111) ; ; 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. ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ; ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127) ; FLEXI-STREAMS:OCTET) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364) ; ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733) ; (T ; (LET (#) ; (IF # ; # ; #))))) ; ; 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. ; (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER) ; ; 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. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT) ; (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER) ; (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733) ; (T ; (LET # ; #))))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; 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. ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-CRLF-UTF-32-LE-FORMAT) ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM21 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM146 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM163 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM126 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM461 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM478 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM441 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM774 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM754 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM791 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-CRLF-UTF-32-BE-FORMAT) ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM21 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM146 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM163 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM126 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM461 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM478 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM441 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; --> LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF ; ==> ; 1 ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE ; ==> ; (+ #:SUM774 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM754 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; ==> ; (+ #:SUM791 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::READ-NEXT-BYTE) ; ; 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. ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE ; 64) ; &OPTIONAL). ; etc. ; (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT ; FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT) ; (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN) ; (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN)) ; (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE # ; '#)) ; (LOOP FLEXI-STREAMS::FOR ; COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8 ; FLEXI-STREAMS::FOR ...)))) ; --> FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN EVAL-WHEN ; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD ; --> LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET ; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* ; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-KERNEL:%SCHARSET ; ==> ; 1 ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 FIXNUM, 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. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/decode-tmpZX2WN8N4.fasl ; compilation finished in 0:00:02.695 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/in-memory.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/in-memory.lisp ; in: DEFMETHOD PEEK-BYTE (VECTOR-INPUT-STREAM) ; (= BYTE FLEXI-STREAMS::PEEK-TYPE) ; ; note: unable to open code because: The operands might not be the same type. ; (PLUSP BYTE) ; ; 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. ; (LOOP :FOR BYTE = (READ-BYTE STREAM FLEXI-STREAMS::EOF-ERROR-P :EOF) ; :FOR FLEXI-STREAMS::NEW-INDEX :FROM FLEXI-STREAMS::INDEX ; :UNTIL (COND ((EQ BYTE :EOF) (RETURN FLEXI-STREAMS::EOF-VALUE)) ; ((NULL FLEXI-STREAMS::PEEK-TYPE)) ; ((EQ FLEXI-STREAMS::PEEK-TYPE 'T) (PLUSP BYTE)) ; ((= BYTE FLEXI-STREAMS::PEEK-TYPE))) ; :FINALLY ...) ; --> 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 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: DEFMETHOD PEEK-BYTE (LIST-INPUT-STREAM) ; (= BYTE FLEXI-STREAMS::PEEK-TYPE) ; ; note: unable to open code because: The operands might not be the same type. ; (PLUSP BYTE) ; ; 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: DEFMETHOD TRANSFORM-OCTET (IN-MEMORY-STREAM T) ; (FUNCALL (OR (FLEXI-STREAMS::IN-MEMORY-STREAM-TRANSFORMER STREAM) #'IDENTITY) ; FLEXI-STREAMS:OCTET) ; ; note: unable to ; optimize away possible call to FDEFINITION at runtime ; because: ; callable expression is not known to be a function ; in: DEFMETHOD STREAM-READ-SEQUENCE (LIST-INPUT-STREAM T T T) ; (FUNCALL FLEXI-STREAMS::TRANSFORMER ELT) ; ; note: unable to ; optimize away possible call to FDEFINITION at runtime ; because: ; TRANSFORMER is not known to be a function ; (SETF (ELT SEQUENCE FLEXI-STREAMS::INDEX) ; (IF FLEXI-STREAMS::TRANSFORMER ; (FUNCALL FLEXI-STREAMS::TRANSFORMER ELT) ; ELT)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a LIST. ; in: DEFMETHOD STREAM-READ-BYTE (VECTOR-INPUT-STREAM) ; (AREF VECTOR FLEXI-STREAMS::CURRENT-INDEX) ; ; 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. ; in: DEFMETHOD STREAM-READ-SEQUENCE (VECTOR-INPUT-STREAM T T T) ; (AREF VECTOR FLEXI-STREAMS::VECTOR-INDEX) ; ; 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. ; (FUNCALL FLEXI-STREAMS::TRANSFORMER ELT) ; ; note: unable to ; optimize away possible call to FDEFINITION at runtime ; because: ; TRANSFORMER is not known to be a function ; (SETF (ELT SEQUENCE FLEXI-STREAMS::INDEX) ; (IF FLEXI-STREAMS::TRANSFORMER ; (FUNCALL FLEXI-STREAMS::TRANSFORMER ELT) ; ELT)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a LIST. ; in: DEFMETHOD STREAM-WRITE-BYTE (VECTOR-OUTPUT-STREAM T) ; (VECTOR-PUSH-EXTEND (FLEXI-STREAMS::TRANSFORM-OCTET STREAM BYTE) VECTOR) ; ; note: unable to ; optimize ; because: ; Upgraded element type of array is not known at compile time. ; in: DEFMETHOD STREAM-WRITE-SEQUENCE (VECTOR-OUTPUT-STREAM T T T) ; (ELT SEQUENCE FLEXI-STREAMS::INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a LIST. ; (VECTOR-PUSH-EXTEND ; (FLEXI-STREAMS::TRANSFORM-OCTET STREAM (ELT SEQUENCE FLEXI-STREAMS::INDEX)) ; VECTOR) ; ; note: unable to ; optimize ; because: ; Upgraded element type of array is not known at compile time. ; in: DEFMETHOD (SETF STREAM-FILE-POSITION) (T VECTOR-INPUT-STREAM) ; (<= 0 FLEXI-STREAMS::POSITION-SPEC FLEXI-STREAMS::END) ; ; 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 MAKE-OUTPUT-VECTOR ; (MAKE-ARRAY 0 :ADJUSTABLE T :FILL-POINTER 0 :ELEMENT-TYPE ; FLEXI-STREAMS::ELEMENT-TYPE) ; ; note: unable to optimize because: ELEMENT-TYPE is not constant. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/in-memory-tmpOU81XRV0.fasl ; compilation finished in 0:00:00.065 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/stream.lisp" (written 01 JAN 2025 03:04:15 AM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/stream-tmpY2ML9CFA.fasl ; compilation finished in 0:00:00.025 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/output.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/output.lisp ; in: DEFMETHOD STREAM-WRITE-CHAR :AFTER (FLEXI-OUTPUT-STREAM T) ; (INCF (THE INTEGER FLEXI-STREAMS::COLUMN)) ; ==> ; (+ 1 (THE INTEGER (FLEXI-STREAMS:FLEXI-STREAM-COLUMN #:G913))) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; etc. ; in: DEFMETHOD STREAM-WRITE-STRING (FLEXI-OUTPUT-STREAM T) ; (LENGTH 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 VECTOR. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/output-tmpX2JYJDQE.fasl ; compilation finished in 0:00:00.055 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/input.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/input.lisp ; in: DEFMETHOD READ-BYTE* (FLEXI-INPUT-STREAM) ; (>= POSITION FLEXI-STREAMS::BOUND) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a INTEGER, not a FIXNUM. ; The second argument is a (OR NULL INTEGER), not a FIXNUM. ; (INCF POSITION) ; ==> ; (+ 1 (THE INTEGER (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G1214))) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; etc. ; (DECF POSITION) ; --> SB-IMPL::XSUBTRACT BLOCK ; ==> ; (- SB-IMPL::B SB-IMPL::A) ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; etc. ; in: DEFMETHOD STREAM-LISTEN (FLEXI-INPUT-STREAM) ; (>= POSITION FLEXI-STREAMS::BOUND) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a INTEGER, not a FIXNUM. ; The second argument is a (OR NULL INTEGER), not a FIXNUM. ; in: DEFUN UNREAD-CHAR% ; (DECF POSITION FLEXI-STREAMS::COUNTER) ; --> SB-IMPL::XSUBTRACT BLOCK ; ==> ; (- SB-IMPL::B SB-IMPL::A) ; ; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; in: DEFMETHOD STREAM-READ-CHAR (FLEXI-INPUT-STREAM) ; (OR (CODE-CHAR CHAR-CODE) CHAR-CODE) ; --> IF ; ==> ; CHAR-CODE ; ; note: deleting unreachable code ; in: DEFMETHOD STREAM-READ-SEQUENCE (FLEXI-INPUT-STREAM T T T) ; (MIN FLEXI-STREAMS::END ; (+ FLEXI-STREAMS::START (- FLEXI-STREAMS::BOUND POSITION))) ; ; 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. ; (REPLACE SEQUENCE FLEXI-STREAMS::OCTET-STACK :START1 FLEXI-STREAMS::START ; :END1 FLEXI-STREAMS::END) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)) ; SB-KERNEL:EXTENDED-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 (OR LIST ; (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)) ; SB-KERNEL:EXTENDED-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 (OR LIST ; (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)) ; SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL ; (SIMPLE-ARRAY ; CHARACTER ; (*))). ; The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL). ; (LENGTH FLEXI-STREAMS::OCTET-STACK) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (ELT SEQUENCE (1- FLEXI-STREAMS::INDEX)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)) ; SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND VECTOR (NOT (VECTOR CHARACTER)) ; (NOT BASE-STRING)) ; SB-KERNEL:EXTENDED-SEQUENCE), not a LIST. ; (- FLEXI-STREAMS::BOUND POSITION) ; ; 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. ; (+ FLEXI-STREAMS::START (- FLEXI-STREAMS::BOUND POSITION)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a (INTEGER -4611686018427387904 4611686018427387902), not a (UNSIGNED-BYTE ; 64). ; The second argument is a NUMBER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &OPTIONAL). ; etc. ; (MIN FLEXI-STREAMS::END ; (+ FLEXI-STREAMS::START (- FLEXI-STREAMS::BOUND POSITION))) ; ; 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. ; (INCF POSITION (- FLEXI-STREAMS::INDEX FLEXI-STREAMS::START)) ; ==> ; (+ (- FLEXI-STREAMS::INDEX FLEXI-STREAMS::START) ; (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G2852)) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (INTEGER -4611686018427387902 4611703610613432319), 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 (INTEGER -4611686018427387902 4611703610613432319), 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. ; ; note: doing signed word to integer coercion (cost 20), for: ; the first argument of GENERIC-+ ; in: DEFMETHOD STREAM-UNREAD-CHAR (FLEXI-INPUT-STREAM T) ; (= (CHAR-CODE CHAR) FLEXI-STREAMS::LAST-CHAR-CODE) ; ; note: unable to open code because: The operands might not be the same type. ; in: DEFMETHOD UNREAD-BYTE (T FLEXI-INPUT-STREAM) ; (= BYTE FLEXI-STREAMS::LAST-OCTET) ; ; 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 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. ; (DECF (THE INTEGER POSITION)) ; --> SB-IMPL::XSUBTRACT BLOCK ; ==> ; (- SB-IMPL::B SB-IMPL::A) ; ; note: forced to do GENERIC-- (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM ; &OPTIONAL). ; etc. ; in: DEFMETHOD PEEK-BYTE (FLEXI-INPUT-STREAM) ; (= FLEXI-STREAMS:OCTET FLEXI-STREAMS::PEEK-TYPE) ; ; note: unable to open code because: The operands might not be the same type. ; (PLUSP FLEXI-STREAMS:OCTET) ; ; 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. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/input-tmpOPCILR65.fasl ; compilation finished in 0:00:00.035 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/io.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/io.lisp ; in: DEFMETHOD RESET-INPUT-STATE (FLEXI-IO-STREAM) ; (LENGTH FLEXI-STREAMS::OCTET-STACK) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; in: DEFMETHOD WRITE-BYTE* :AFTER (T FLEXI-IO-STREAM) ; (INCF POSITION) ; ==> ; (+ 1 (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G79)) ; ; 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/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/io-tmpRV9F8A9A.fasl ; compilation finished in 0:00:00.015 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/strings.lisp" (written 01 JAN 2025 03:04:15 AM): ; file: /usr/local/lib/common-lisp/flexi-streams/strings.lisp ; in: DEFUN STRING-TO-OCTETS ; (LENGTH STRING) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; in: DEFUN OCTETS-TO-STRING ; (LENGTH SEQUENCE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; in: DEFUN OCTET-LENGTH ; (LENGTH STRING) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; in: DEFUN CHAR-LENGTH ; (LENGTH SEQUENCE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/strings-tmpK2ZAJT4I.fasl ; compilation finished in 0:00:00.018 ; ; compilation unit finished ; printed 1039 notes =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/flexi-streams/flexi-streams.asd - found ===> cl-flexi-streams-sbcl-1.0.20_1 depends on file: /usr/local/lib/common-lisp/trivial-gray-streams/sbclfasl/package.fasl - found ===> cl-flexi-streams-sbcl-1.0.20_1 depends on executable: sbcl - found =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Staging for cl-flexi-streams-sbcl-1.0.20_1 ===> 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-05-03T03:27:20+0000' 'PKG_NOTE_ports_top_git_hash=5529c5919b' 'PKG_NOTE_ports_top_checkout_unclean=yes' 'PKG_NOTE_port_git_hash=5022036b0f' '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-flexi-streams-sbcl-1.0.20_1 ===> Building cl-flexi-streams-sbcl-1.0.20_1 =========================================================================== =>> Cleaning up wrkdir ===> Cleaning for cl-flexi-streams-sbcl-1.0.20_1 build of devel/cl-flexi-streams-sbcl | cl-flexi-streams-sbcl-1.0.20_1 ended at Sat May 3 04:28:10 BST 2025 build time: 00:00:51