=>> Building devel/cl-flexi-streams-sbcl build started at Wed Mar 11 15:33:31 EDT 2026 port directory: /usr/ports/devel/cl-flexi-streams-sbcl package name: cl-flexi-streams-sbcl-1.0.20_3 building for: FreeBSD pkg.DaveG.ca 14.4-RELEASE FreeBSD 14.4-RELEASE 1404000 amd64 maintained by: jrm@FreeBSD.org Makefile datestamp: -rw-r--r-- 1 root wheel 741 Mar 6 20:23 /usr/ports/devel/cl-flexi-streams-sbcl/Makefile Ports top last git commit: 26b198eb3ee3 Ports top unclean checkout: no Port dir last git commit: f7832f9e6def Port dir unclean checkout: no Poudriere version: poudriere-git-3.4.2 Host OSVERSION: 1500068 Jail OSVERSION: 1404000 Job Id: 05 ---Begin Environment--- SHELL=/bin/sh OSVERSION=1404000 UNAME_v=FreeBSD 14.4-RELEASE 1404000 UNAME_r=14.4-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/freebsd_14_4_x64-HEAD-ALL/ref LC_COLLATE=C POUDRIERE_BUILD_TYPE=bulk PACKAGE_BUILDING=yes SAVED_TERM=tmux-256color OUTPUT_REDIRECTED_STDERR=4 OUTPUT_REDIRECTED=1 PWD=/usr/local/poudriere/data/.m/freebsd_14_4_x64-HEAD-ALL/05/.p OUTPUT_REDIRECTED_STDOUT=3 P_PORTS_FEATURES=FLAVORS SUBPACKAGES SELECTED_OPTIONS MASTERNAME=freebsd_14_4_x64-HEAD-ALL SCRIPTPREFIX=/usr/local/share/poudriere SCRIPTNAME=bulk.sh OLDPWD=/usr/local/poudriere/data/.m/freebsd_14_4_x64-HEAD-ALL/ref/.p/pool POUDRIERE_PKGNAME=poudriere-git-3.4.2 SCRIPTPATH=/usr/local/share/poudriere/bulk.sh POUDRIEREPATH=/usr/local/bin/poudriere ---End Environment--- ---Begin Poudriere Port Flags/Env--- PORT_FLAGS= PKGENV= FLAVOR= MAKE_ARGS= ---End Poudriere Port Flags/Env--- ---Begin OPTIONS List--- ---End OPTIONS List--- --MAINTAINER-- 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=" " 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.4 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--- DEFAULT_VERSIONS+=pgsql=15 DEFAULT_VERSIONS+=php=82 DISABLE_LICENSES=yes SELECTED_OPTIONS+=OPENBLAS ARCHDEF=AMD64K10h64SSE3 USE_PACKAGE_DEPENDS=yes BATCH=yes WRKDIRPREFIX=/wrkdirs PORTSDIR=/usr/ports PACKAGES=/packages DISTDIR=/distfiles FORCE_PACKAGE=yes PACKAGE_BUILDING=yes PACKAGE_BUILDING_FLAVORS=yes #### #### DEFAULT_VERSIONS+=pgsql=15 DEFAULT_VERSIONS+=php=82 DISABLE_LICENSES=yes SELECTED_OPTIONS+=OPENBLAS ARCHDEF=AMD64K10h64SSE3 WITH_CCACHE_BUILD=yes CCACHE_DIR=/root/.ccache #### Misc Poudriere #### .include "/etc/make.conf.ports_env" GID=0 UID=0 ---End make.conf--- --Resource limits-- cpu time (seconds, -t) unlimited file size (512-blocks, -f) unlimited data seg size (kbytes, -d) 33554432 stack size (kbytes, -s) 524288 core file size (512-blocks, -c) unlimited max memory size (kbytes, -m) unlimited locked memory (kbytes, -l) unlimited max user processes (-u) 89999 open files (-n) 8192 virtual mem size (kbytes, -v) unlimited swap limit (kbytes, -w) unlimited socket buffer size (bytes, -b) unlimited pseudo-terminals (-p) unlimited kqueues (-k) unlimited umtx shared locks (-o) unlimited pipebuf (-y) unlimited --End resource limits-- =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/sbin/pkg - not found ===> Installing existing package /packages/All/pkg-2.6.2.pkg [pkg.DaveG.ca] Installing pkg-2.6.2... [pkg.DaveG.ca] Extracting pkg-2.6.2: .......... done ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/sbin/pkg - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_3 =========================================================================== =================================================== ===== 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_3 for building =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Fetching all distfiles required by cl-flexi-streams-sbcl-1.0.20_3 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_3 for building ===> Extracting for cl-flexi-streams-sbcl-1.0.20_3 =========================================================================== =================================================== ===== 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_3 =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-flexi-streams-sbcl-1.0.20_3 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.DaveG.ca] Installing cl-flexi-streams-1.0.20... [pkg.DaveG.ca] `-- Installing cl-trivial-gray-streams-20240217... [pkg.DaveG.ca] `-- Extracting cl-trivial-gray-streams-20240217: ......... done [pkg.DaveG.ca] Extracting cl-flexi-streams-1.0.20: .......... done ===> cl-flexi-streams-sbcl-1.0.20_3 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_3 ===> cl-flexi-streams-sbcl-1.0.20_3 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_10.pkg [pkg.DaveG.ca] Installing cl-trivial-gray-streams-sbcl-20240217_10... [pkg.DaveG.ca] `-- Installing sbcl-2.6.2,1... [pkg.DaveG.ca] | `-- Installing cl-freebsd-asdf-init-20250101... [pkg.DaveG.ca] | `-- Extracting cl-freebsd-asdf-init-20250101: .. done [pkg.DaveG.ca] | `-- Installing gmp-6.3.0... [pkg.DaveG.ca] | | `-- Installing indexinfo-0.3.1_1... [pkg.DaveG.ca] | | `-- Extracting indexinfo-0.3.1_1: . done [pkg.DaveG.ca] | `-- Extracting gmp-6.3.0: .......... done [pkg.DaveG.ca] | `-- Installing mpfr-4.2.2,1... [pkg.DaveG.ca] | `-- Extracting mpfr-4.2.2,1: .......... done [pkg.DaveG.ca] | `-- Installing zstd-1.5.7_1... [pkg.DaveG.ca] | `-- Extracting zstd-1.5.7_1: .......... done [pkg.DaveG.ca] `-- Extracting sbcl-2.6.2,1: .......... done [pkg.DaveG.ca] Extracting cl-trivial-gray-streams-sbcl-20240217_10: .. done ===> cl-flexi-streams-sbcl-1.0.20_3 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_3 ===> cl-flexi-streams-sbcl-1.0.20_3 depends on executable: sbcl - found ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/bin/ccache - not found ===> Installing existing package /packages/All/ccache-3.7.12_8.pkg [pkg.DaveG.ca] Installing ccache-3.7.12_8... [pkg.DaveG.ca] Extracting ccache-3.7.12_8: ......... done Create compiler links... create symlink for cc create symlink for cc (world) create symlink for c++ create symlink for c++ (world) create symlink for CC create symlink for CC (world) create symlink for clang create symlink for clang (world) create symlink for clang++ create symlink for clang++ (world) ===== Message from ccache-3.7.12_8: -- NOTE: Please read /usr/local/share/doc/ccache/ccache-howto-freebsd.txt for information on using ccache with FreeBSD ports and src. ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/bin/ccache - found ===> Returning to build of cl-flexi-streams-sbcl-1.0.20_3 =========================================================================== =================================================== ===== 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_3 =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Building for cl-flexi-streams-sbcl-1.0.20_3 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/packages.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/packages-tmpGHU3ALSV.fasl ; compilation finished in 0:00:00.004 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/mapping.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/mapping-tmpAAURSO1.fasl ; compilation finished in 0:00:00.013 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/ascii.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/ascii-tmp5GEXGEG5.fasl ; compilation finished in 0:00:00.002 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/koi8-r.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.002 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/mac.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/mac-tmpJAIDFZTC.fasl ; compilation finished in 0:00:00.002 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/iso-8859.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.017 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/enc-cn-tbl.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.174 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/code-pages.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.027 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/specials.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/specials-tmp1CXFJSK9.fasl ; compilation finished in 0:00:00.017 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/util.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; 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.068 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/conditions.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/conditions-tmpQ371UGST.fasl ; compilation finished in 0:00:00.013 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/external-format.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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 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. ; unable to do inline float comparison (cost 4) because: ; The first argument is a T, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-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.204 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/length.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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 (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-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. ; (DECF LENGTH) ; --> 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. ; (DECF LENGTH) ; --> 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 (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.338 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/encode.lisp" (written 10 MAR 2026 10:37:58 PM): ; file: /usr/local/lib/common-lisp/flexi-streams/encode.lisp ; 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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* 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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* 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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::LOGAND* 65280 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 65280 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a (NOT NULL), not a FIXNUM. ; etc. ; (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD) ; ==> ; (LOGAND 255 FLEXI-STREAMS::WORD) ; ; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (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* 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; (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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR INTEGER ; (CONS INTEGER ; NULL)). ; --> 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 ; --> SB-C::WITH-SOURCE-FORM AREF 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 ; optimize ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))), 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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 (OR STRING NULL). ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a (OR LIST VECTOR), not a (OR NULL 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 (unsigned-byte 64) arithmetic (cost 4) because: ; The first argument is a T, not a (UNSIGNED-BYTE 64). ; The second argument is a (INTEGER -9223372036854775807 ; 9223372036854775807), not a (UNSIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES ; (UNSIGNED-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 SB-C::WITH-SOURCE-FORM ; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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:02.451 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/decode.lisp" (written 10 MAR 2026 10:37:58 PM): ; file: /usr/local/lib/common-lisp/flexi-streams/decode.lisp ; 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-C::WITH-SOURCE-FORM SCHAR 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-C::WITH-SOURCE-FORM SCHAR 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 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 LET* LOOP BLOCK LET TAGBODY SETF ; --> SB-C::WITH-SOURCE-FORM SCHAR 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. ; 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-C::WITH-SOURCE-FORM SCHAR 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-C::WITH-SOURCE-FORM SCHAR 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 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 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-C::WITH-SOURCE-FORM SCHAR 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. ; 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-C::WITH-SOURCE-FORM SCHAR 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-C::WITH-SOURCE-FORM SCHAR 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 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::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-C::WITH-SOURCE-FORM SCHAR 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. ; 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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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-C::WITH-SOURCE-FORM SCHAR 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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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-C::WITH-SOURCE-FORM SCHAR 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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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 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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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-C::WITH-SOURCE-FORM SCHAR 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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-8 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; in: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT ; FLEXI-CRLF-UTF-16-LE-FORMAT) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; in: ; DEFINE-CHAR-DECODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT ; FLEXI-CRLF-UTF-16-BE-FORMAT) ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.") ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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::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. ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-16 sequence.")) ; ; note: deleting unreachable code ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL) ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; ; note: deleting unreachable code ; 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-C::WITH-SOURCE-FORM SCHAR 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-C::WITH-SOURCE-FORM SCHAR 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 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 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-C::WITH-SOURCE-FORM SCHAR 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. ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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 ; ==> ; (+ #:SUM436 (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. ; ==> ; (+ #:SUM453 (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. ; ==> ; (+ #:SUM416 (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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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 ; ==> ; (+ #:SUM741 (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. ; ==> ; (+ #:SUM704 (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. ; ==> ; (+ #:SUM724 (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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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 ; ==> ; (+ #:SUM436 (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. ; ==> ; (+ #:SUM453 (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. ; ==> ; (+ #:SUM416 (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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; --> 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 ; ==> ; (+ #:SUM704 (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. ; ==> ; (+ #:SUM741 (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. ; ==> ; (+ #:SUM724 (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. ; (OR FLEXI-STREAMS::OCTET-GETTER ; (COND ; (FLEXI-STREAMS::FIRST-OCTET-SEEN ; (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER ; (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT ; "End of data while in UTF-32 sequence."))) ; (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)))) ; ; 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. ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/decode-tmpZX2WN8N4.fasl ; compilation finished in 0:00:07.806 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/in-memory.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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 ; (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. ; 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 ; (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. ; 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. ; in: DEFMETHOD GET-OUTPUT-STREAM-SEQUENCE (IN-MEMORY-OUTPUT-STREAM) ; (COERCE VECTOR 'LIST) ; ; note: unable to ; optimize ; because: ; upgraded array element type not known at compile time ; 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.333 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/stream.lisp" (written 10 MAR 2026 10:37:58 PM): ; wrote /wrkdirs/usr/ports/devel/cl-flexi-streams-sbcl/work/flexi-streams-1.0.20/stream-tmpY2ML9CFA.fasl ; compilation finished in 0:00:00.069 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/output.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.035 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/input.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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 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 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))) ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))) ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))) ; 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 (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))) ; SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-ARRAY. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR LIST ; (AND (NOT (ARRAY CHARACTER)) VECTOR ; (NOT (ARRAY BASE-CHAR))) ; 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.241 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/io.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.130 ; compiling file "/usr/local/lib/common-lisp/flexi-streams/strings.lisp" (written 10 MAR 2026 10:37:58 PM): ; 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.034 ; ; compilation unit finished ; printed 1142 notes =========================================================================== =================================================== ===== env: USE_PACKAGE_DEPENDS_ONLY=1 USER=root UID=0 GID=0 ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/lib/common-lisp/flexi-streams/flexi-streams.asd - found ===> cl-flexi-streams-sbcl-1.0.20_3 depends on file: /usr/local/lib/common-lisp/trivial-gray-streams/sbclfasl/package.fasl - found ===> cl-flexi-streams-sbcl-1.0.20_3 depends on executable: sbcl - found =========================================================================== =================================================== ===== env: NO_DEPENDS=yes USER=root UID=0 GID=0 ===> Staging for cl-flexi-streams-sbcl-1.0.20_3 ===> 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=2026-03-11T19:33:32+0000' 'PKG_NOTE_ports_top_git_hash=26b198eb3ee3' 'PKG_NOTE_ports_top_checkout_unclean=no' 'PKG_NOTE_port_git_hash=f7832f9e6def' '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_3 ===> Building cl-flexi-streams-sbcl-1.0.20_3 =========================================================================== =>> Cleaning up wrkdir ===> Cleaning for cl-flexi-streams-sbcl-1.0.20_3 build of devel/cl-flexi-streams-sbcl | cl-flexi-streams-sbcl-1.0.20_3 ended at Wed Mar 11 15:34:20 EDT 2026 build time: 00:00:51