REPL Output
;;; ASDF-INSTALL: Downloading 26219 bytes from http://files.b9.com/cl-base64/cl-base64-latest.tar.gz to /Users/gwking/temporary/asdf-test/CL-BASE64.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/CL-BASE64.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-base64-3.3.1/
cl-base64-3.3.1/package.lisp
cl-base64-3.3.1/cl-base64.asd
cl-base64-3.3.1/encode.lisp
cl-base64-3.3.1/COPYING
cl-base64-3.3.1/tests.lisp
cl-base64-3.3.1/decode.lisp
cl-base64-3.3.1/package.fasla16
cl-base64-3.3.1/encode.fasla16
cl-base64-3.3.1/decode.fasla16
cl-base64-3.3.1/tests.fasla16
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/" ;;; ASDF-INSTALL: Downloading package KMRCL, required by cl-base64
;;; ASDF-INSTALL: Downloading 43672 bytes from http://files.b9.com/kmrcl/kmrcl-latest.tar.gz to /Users/gwking/temporary/asdf-test/kmrcl.asdf-install-tmp ...
;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/kmrcl.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
kmrcl-1.85/
kmrcl-1.85/seqs.lisp
kmrcl-1.85/sockets.lisp
kmrcl-1.85/buff-input.lisp
kmrcl-1.85/color.lisp
kmrcl-1.85/listener.lisp
kmrcl-1.85/random.lisp
kmrcl-1.85/docbook.lisp
kmrcl-1.85/os.lisp
kmrcl-1.85/macros.lisp
kmrcl-1.85/attrib-class.lisp
kmrcl-1.85/strmatch.lisp
kmrcl-1.85/symbols.lisp
kmrcl-1.85/ifstar.lisp
kmrcl-1.85/strings.lisp
kmrcl-1.85/math.lisp
kmrcl-1.85/datetime.lisp
kmrcl-1.85/byte-stream.lisp
kmrcl-1.85/xml-utils.lisp
kmrcl-1.85/impl.lisp
kmrcl-1.85/repl.lisp
kmrcl-1.85/console.lisp
kmrcl-1.85/processes.lisp
kmrcl-1.85/Makefile
kmrcl-1.85/equal.lisp
kmrcl-1.85/functions.lisp
kmrcl-1.85/kmrcl.asd
kmrcl-1.85/web-utils.lisp
kmrcl-1.85/README
kmrcl-1.85/package.lisp
kmrcl-1.85/mop.lisp
kmrcl-1.85/run-tests.lisp
kmrcl-1.85/lists.lisp
kmrcl-1.85/tests.lisp
kmrcl-1.85/io.lisp
kmrcl-1.85/kmrcl-tests.asd
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/"
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/"
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/package.lisp" (written 26 APR 2005 09:40:35 PM):
; compiling (IN-PACKAGE #:CL-USER)
; compiling (DEFPACKAGE #:KMRCL ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/package.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/ifstar.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFVAR IF*-KEYWORD-LIST ...)
; compiling (DEFMACRO IF* ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/ifstar.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/byte-stream.lisp" (written 06 APR 2005 01:40:45 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (WHEN (SB-EXT:WITHOUT-PACKAGE-LOCKS #) ...)
; compiling (DEFSTRUCT (BYTE-ARRAY-OUTPUT-STREAM # ...) ...)
; compiling (DEFUN %PRINT-BYTE-ARRAY-OUTPUT-STREAM ...)
; compiling (SETF (DOCUMENTATION # ...) ...)
; compiling (DEFUN BYTE-ARRAY-BOUT ...)
; compiling (DEFUN BYTE-ARRAY-OUT-MISC ...)
; compiling (DEFUN GET-OUTPUT-STREAM-DATA ...)
; compiling (DEFUN DUMP-OUTPUT-STREAM-DATA ...)
; compiling (SB-EXT:WITHOUT-PACKAGE-LOCKS (DEFVAR *SYSTEM-COPY-FN* ...) ...)
; compiling (DEFSTRUCT (BYTE-ARRAY-INPUT-STREAM # ...) ...)
; compiling (DEFUN %PRINT-BYTE-ARRAY-INPUT-STREAM ...)
; compiling (DEFUN BYTE-ARRAY-INCH ...)
; compiling (DEFUN BYTE-ARRAY-BINCH ...)
; compiling (DEFUN BYTE-ARRAY-STREAM-READ-N-BYTES ...)
; compiling (DEFUN BYTE-ARRAY-IN-MISC ...)
; compiling (DEFUN MAKE-BYTE-ARRAY-INPUT-STREAM ...)
; compiling (SETQ *FEATURES* ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/byte-stream.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/macros.lisp" (written 01 OCT 2004 02:41:31 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFMACRO LET-WHEN ...)
; compiling (DEFMACRO LET-IF ...)
; compiling (DEFMACRO AIF ...)
; compiling (DEFMACRO AWHEN ...)
; compiling (DEFMACRO AWHILE ...)
; compiling (DEFMACRO AAND ...)
; compiling (DEFMACRO ACOND ...)
; compiling (DEFMACRO ALAMBDA ...)
; compiling (DEFMACRO AIF2 ...)
; compiling (DEFMACRO AWHEN2 ...)
; compiling (DEFMACRO AWHILE2 ...)
; compiling (DEFMACRO ACOND2 ...)
; compiling (DEFMACRO MAC ...)
; compiling (DEFMACRO PRINT-FORM-AND-RESULTS ...)
; compiling (DEFMACRO UNTIL ...)
; compiling (DEFMACRO WHILE ...)
; compiling (DEFMACRO FOR ...)
; compiling (DEFMACRO WITH-EACH-STREAM-LINE ...)
; compiling (DEFMACRO WITH-EACH-FILE-LINE ...)
; compiling (DEFMACRO IN ...)
; compiling (DEFMACRO MEAN ...)
; compiling (DEFMACRO WITH-GENSYMS ...)
; compiling (DEFMACRO TIME-SECONDS ...)
; compiling (DEFMACRO TIME-ITERATIONS ...)
; compiling (DEFMACRO MV-BIND ...)
; compiling (DEFMACRO DEFLEX ...)
; compiling (DEFMACRO DEF-CACHED-VECTOR ...)
; compiling (DEFMACRO DEF-CACHED-INSTANCE ...)
; compiling (DEFMACRO WITH-IGNORE-ERRORS ...)
; compiling (DEFMACRO PPMX ...)
; compiling (DEFMACRO DEFCONSTANT* ...)
; compiling (DEFMACRO DEFVAR-UNBOUND ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/macros.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/functions.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE :KMRCL)
; compiling (DEFUN MEMO-PROC ...)
; compiling (DEFUN MEMOIZE ...)
; compiling (DEFMACRO DEFUN-MEMO ...)
; compiling (DEFMACRO _F ...)
; compiling (DEFUN COMPOSE ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/functions.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/lists.lisp" (written 11 NOV 2004 04:58:24 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN MKLIST ...)
; compiling (DEFUN MAP-AND-REMOVE-NILS ...)
; compiling (DEFUN FILTER ...)
; compiling (DEFUN APPENDNEW ...)
; compiling (DEFUN REMOVE-FROM-TREE-IF ...)
; compiling (DEFUN FIND-TREE ...)
; compiling (DEFUN FLATTEN ...)
; compiling (DEFUN REMOVE-KEYWORD ...)
; compiling (DEFUN REMOVE-KEYWORDS ...)
; compiling (DEFUN MAPAPPEND ...)
; compiling (DEFUN MAPCAR-APPEND-STRING-NONTAILREC ...)
; compiling (DEFUN MAPCAR-APPEND-STRING ...)
; compiling (DEFUN MAPCAR2-APPEND-STRING-NONTAILREC ...)
; compiling (DEFUN MAPCAR2-APPEND-STRING ...)
; compiling (DEFUN APPEND-SUBLISTS ...)
; compiling (DEFUN ALIST-ELEM-P ...)
; compiling (DEFUN ALISTP ...)
; compiling (DEFMACRO UPDATE-ALIST ...)
; compiling (DEFUN GET-ALIST ...)
; compiling (DEFUN (SETF GET-ALIST) ...)
; compiling (DEFUN ALIST-PLIST ...)
; compiling (DEFUN PLIST-ALIST ...)
; compiling (DEFMACRO UPDATE-PLIST ...)
; compiling (DEFUN UNIQUE-SLOT-VALUES ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/lists.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/seqs.lisp" (written 15 SEP 2004 12:45:06 PM):
; compiling (IN-PACKAGE :KMRCL)
; compiling (DEFUN NSUBSEQ ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/seqs.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/impl.lisp" (written 01 OCT 2004 02:41:31 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN CANONICALIZE-DIRECTORY-NAME ...)
; compiling (DEFUN PROBE-DIRECTORY ...)
; compiling (DEFUN CWD ...)
; compiling (DEFUN QUIT ...)
; compiling (DEFUN COMMAND-LINE-ARGUMENTS ...)
; compiling (DEFUN COPY-FILE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/impl.lisp
; in: DEFUN COPY-FILE
; (DEFUN KMRCL:COPY-FILE
; (KMRCL::FROM KMRCL::TO
; &KEY KMRCL::LINK KMRCL::OVERWRITE KMRCL::PRESERVE-SYMBOLIC-LINKS
; (KMRCL::PRESERVE-TIME T) KMRCL::REMOVE-DESTINATION KMRCL::FORCE
; KMRCL::VERBOSE)
; (COND
; ((AND (TYPEP KMRCL::FROM 'STREAM) (TYPEP KMRCL::TO 'STREAM))
; (KMRCL:COPY-BINARY-STREAM KMRCL::FROM KMRCL::TO))
; ((NOT (PROBE-FILE KMRCL::FROM))
; (ERROR "File ~A does not exist." KMRCL::FROM))
; ((EQ KMRCL::LINK :HARD)
; (KMRCL:RUN-SHELL-COMMAND "ln -f ~A ~A"
; (NAMESTRING KMRCL::FROM)
; (NAMESTRING KMRCL::TO)))
; (KMRCL::LINK
; (MULTIPLE-VALUE-BIND
; (KMRCL::STDOUT KMRCL::STDERR KMRCL::STATUS)
; (KMRCL:COMMAND-OUTPUT "ln -f ~A ~A" # #)
; (DECLARE #)
; (UNLESS # #)))
; (T (WHEN (AND # #) (DELETE-FILE KMRCL::TO))
; (LET* (# #)
; (KMRCL:RUN-SHELL-COMMAND KMRCL::CMD)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL:COPY-FILE
; (KMRCL::FROM KMRCL::TO
; &KEY
; KMRCL::LINK
; KMRCL::OVERWRITE
; KMRCL::PRESERVE-SYMBOLIC-LINKS
; (KMRCL::PRESERVE-TIME T)
; KMRCL::REMOVE-DESTINATION
; KMRCL::FORCE
; KMRCL::VERBOSE)
; (BLOCK KMRCL:COPY-FILE
; (COND
; ((AND # #)
; (KMRCL:COPY-BINARY-STREAM KMRCL::FROM KMRCL::TO))
; ((NOT #)
; (ERROR "File ~A does not exist." KMRCL::FROM))
; ((EQ KMRCL::LINK :HARD)
; (KMRCL:RUN-SHELL-COMMAND "ln -f ~A ~A" # #))
; (KMRCL::LINK (MULTIPLE-VALUE-BIND # # # #))
; (T (WHEN # #)
; (LET* #
; #)))))
;
; caught STYLE-WARNING:
; The variable OVERWRITE is defined but never used.
;
; caught STYLE-WARNING:
; The variable PRESERVE-SYMBOLIC-LINKS is defined but never used.
;
; caught STYLE-WARNING:
; The variable VERBOSE is defined but never used.
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/impl.fasl written
; compilation finished in 0:00:00
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {10007EB9}> on
#<CL-SOURCE-FILE "impl" {10007EC9}>.
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/io.lisp" (written 11 NOV 2004 04:58:24 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN PRINT-FILE-CONTENTS ...)
; compiling (DEFUN READ-STREAM-TO-STRING ...)
; compiling (DEFUN READ-FILE-TO-STRING ...)
; compiling (DEFUN READ-FILE-TO-USB8-ARRAY ...)
; compiling (DEFUN READ-STREAM-TO-STRINGS ...)
; compiling (DEFUN READ-FILE-TO-STRINGS ...)
; compiling (DEFUN FILE-SUBST ...)
; compiling (DEFUN PRINT-N-CHARS ...)
; compiling (DEFUN PRINT-N-STRINGS ...)
; compiling (DEFUN INDENT-SPACES ...)
; compiling (DEFUN INDENT-HTML-SPACES ...)
; compiling (DEFUN PRINT-LIST ...)
; compiling (DEFUN PRINT-ROWS ...)
; compiling (DEFSTRUCT BUF ...)
; compiling (DEFUN BREF ...)
; compiling (DEFUN (SETF BREF) ...)
; compiling (DEFUN NEW-BUF ...)
; compiling (DEFUN BUF-INSERT ...)
; compiling (DEFUN BUF-POP ...)
; compiling (DEFUN BUF-NEXT ...)
; compiling (DEFUN BUF-RESET ...)
; compiling (DEFUN BUF-CLEAR ...)
; compiling (DEFUN BUF-FLUSH ...)
; compiling (DEFUN STREAM-SUBST ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/io.lisp
; in: DEFUN STREAM-SUBST
; (KMRCL::BUF-FLUSH KMRCL::BUF KMRCL::OUT)
; ==>
; KMRCL::BUF
;
; note: deleting unreachable code
; compiling (DECLAIM (INLINE WRITE-FIXNUM))
; compiling (DEFUN WRITE-FIXNUM ...)
; compiling (DEFUN NULL-OUTPUT-STREAM ...)
; compiling (DEFUN DIRECTORY-TREE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/io.lisp
; in: DEFUN DIRECTORY-TREE
; (ERROR "~A" KMRCL::ROOT)
; ==>
; "~A"
;
; note: deleting unreachable code
;
; note: deleting unreachable code
; compiling (DEFMACRO WITH-UTIME-DECODING ...)
; compiling (DEFVAR +DATETIME-NUMBER-STRINGS+ ...)
; compiling (DEFUN IS-DST ...)
; compiling (DEFMACRO WITH-UTIME-DECODING-UTC-OFFSET ...)
; compiling (DEFUN WRITE-UTIME-HMS ...)
; compiling (DEFUN WRITE-UTIME-HMS-STREAM ...)
; compiling (DEFUN WRITE-UTIME-HM ...)
; compiling (DEFUN WRITE-UTIME-HM-STREAM ...)
; compiling (DEFUN WRITE-UTIME-YMDHMS ...)
; compiling (DEFUN WRITE-UTIME-YMDHMS-STREAM ...)
; compiling (DEFUN WRITE-UTIME-YMDHM ...)
; compiling (DEFUN WRITE-UTIME-YMDHM-STREAM ...)
; compiling (DEFUN COPY-BINARY-STREAM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/io.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/console.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFVAR *CONSOLE-MSGS* ...)
; compiling (DEFVAR *CONSOLE-MSGS-TYPES* ...)
; compiling (DEFUN CMSG ...)
; compiling (DEFUN CMSG-C ...)
; compiling (DEFUN CMSG-ADD ...)
; compiling (DEFUN CMSG-REMOVE ...)
; compiling (DEFUN FIXME ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/console.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp" (written 01 OCT 2004 02:41:31 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFMACRO STRING-APPEND ...)
; compiling (DEFUN LIST-TO-STRING ...)
; compiling (DEFUN COUNT-STRING-WORDS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN COUNT-STRING-WORDS
; (ALPHANUMERICP (SCHAR KMRCL::STR KMRCL::I))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; compiling (DEFUN POSITION-CHAR ...)
; compiling (DEFUN POSITION-NOT-CHAR ...)
; compiling (DEFUN DELIMITED-STRING-TO-LIST ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN DELIMITED-STRING-TO-LIST
; (SUBSEQ STRING KMRCL::POS KMRCL::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (SUBSEQ STRING KMRCL::POS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; compiling (DEFUN LIST-TO-DELIMITED-STRING ...)
; compiling (DEFUN STRING-INVERT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN STRING-INVERT
; (UPPER-CASE-P CHAR)
; --> BLOCK = IF
; ==>
; (= (SB-IMPL::UCD-VALUE-0 CHAR) 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (LOWER-CASE-P CHAR)
; --> BLOCK = IF
; ==>
; (= (SB-IMPL::UCD-VALUE-0 CHAR) 1)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; compiling (DEFUN ADD-SQL-QUOTES ...)
; compiling (DEFUN ESCAPE-BACKSLASHES ...)
; compiling (DEFUN SUBSTITUTE-STRING-FOR-CHAR ...)
; compiling (DEFUN STRING-SUBSTITUTE ...)
; compiling (DEFUN STRING-TRIM-LAST-CHARACTER ...)
; compiling (DEFUN NSTRING-TRIM-LAST-CHARACTER ...)
; compiling (DEFUN STRING-HASH ...)
; compiling (DEFUN IS-STRING-EMPTY ...)
; compiling (DEFVAR *WHITESPACE-CHARS* ...)
; compiling (DEFUN IS-CHAR-WHITESPACE ...)
; compiling (DEFUN IS-STRING-WHITESPACE ...)
; compiling (DEFUN STRING-RIGHT-TRIM-WHITESPACE ...)
; compiling (DEFUN STRING-LEFT-TRIM-WHITESPACE ...)
; compiling (DEFUN STRING-TRIM-WHITESPACE ...)
; compiling (DEFUN REPLACED-STRING-LENGTH ...)
; compiling (DEFUN SUBSTITUTE-CHARS-STRINGS ...)
; compiling (DEFUN ESCAPE-XML-STRING ...)
; compiling (DEFUN MAKE-USB8-ARRAY ...)
; compiling (DEFUN USB8-ARRAY-TO-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN USB8-ARRAY-TO-STRING
; (- KMRCL::END KMRCL::START)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; etc.
; compiling (DEFUN STRING-TO-USB8-ARRAY ...)
; compiling (DEFUN CONCAT-SEPARATED-STRINGS ...)
; compiling (DEFUN ONLY-NULL-LIST-ELEMENTS-P ...)
; compiling (DEFUN PRINT-SEPARATED-STRINGS ...)
; compiling (DEFUN PREFIXED-FIXNUM-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN PREFIXED-FIXNUM-STRING
; (MOD KMRCL::VAL 10)
; --> BLOCK LET REM BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES (INTEGER -53687091 53687091)
; (INTEGER -9 9)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (FLOOR KMRCL::VAL 10)
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES (INTEGER -53687091 53687091)
; (INTEGER -9 9)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (MOD KMRCL::VAL 10)
; --> BLOCK LET REM BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER -53687092
; 53687091), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES (INTEGER -5368709 5368709)
; (INTEGER -9 9)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; compiling (DEFUN INTEGER-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN INTEGER-STRING
; (MINUSP KMRCL::NUM)
; --> < IF
; ==>
; (< KMRCL::NUM 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; (- 0 KMRCL::NUM)
; ==>
; (SB-KERNEL:%NEGATE SB-C::Y)
;
; note: forced to do static-fun %Negate (cost 52)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; (MOD KMRCL::VAL 10)
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; (FLOOR KMRCL::VAL 10)
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF AND IF
; --> MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
; ==>
; (- SB-KERNEL::TRU 1)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (MOD KMRCL::VAL 10)
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a INTEGER, not a FIXNUM.
; etc.
; compiling (DEFUN FAST-STRING-SEARCH ...)
; compiling (DEFUN STRING-DELIMITED-STRING-TO-LIST ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN STRING-DELIMITED-STRING-TO-LIST
; (SUBSEQ KMRCL::STR KMRCL::POS KMRCL::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (SUBSEQ KMRCL::STR KMRCL::POS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; compiling (DEFUN STRING-TO-LIST-SKIP-DELIMITER ...)
; compiling (DEFUN STRING-STARTS-WITH ...)
; compiling (DEFUN COUNT-STRING-CHAR ...)
; compiling (DEFUN COUNT-STRING-CHAR-IF ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN COUNT-STRING-CHAR-IF
; (FUNCALL KMRCL::PRED (SCHAR KMRCL::S KMRCL::I))
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
;
; note: unable to
; optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
; The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.
; compiling (DEFUN NON-ALPHANUMERICP ...)
; compiling (DEFVAR +HEX-CHARS+ ...)
; compiling (DECLAIM (TYPE SIMPLE-STRING ...))
; compiling (DEFUN HEXCHAR ...)
; compiling (DEFCONSTANT* +CHAR-CODE-LOWER-A+ ...)
; compiling (DEFCONSTANT* +CHAR-CODE-UPPER-A+ ...)
; compiling (DEFCONSTANT* +CHAR-CODE-0+ ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFUN CHARHEX ...)
; compiling (DEFUN ENCODE-URI-STRING ...)
; compiling (DEFUN DECODE-URI-STRING ...)
; compiling (DEFVAR +UNAMBIGUOUS-CHARSET+ ...)
; compiling (DEFCONSTANT* +UNAMBIGUOUS-LENGTH+ ...)
; compiling (DEFUN RANDOM-CHAR ...)
; compiling (DEFUN RANDOM-STRING ...)
; compiling (DEFUN FIRST-CHAR ...)
; compiling (DEFUN LAST-CHAR ...)
; compiling (DEFUN ENSURE-STRING ...)
; compiling (DEFUN STRING-RIGHT-TRIM-ONE-CHAR ...)
; compiling (DEFUN STRING-STRIP-ENDING ...)
; compiling (DEFUN STRING-MAYBE-SHORTEN ...)
; compiling (DEFUN STRING-ELIDE ...)
; compiling (DEFUN SHRINK-VECTOR ...)
; compiling (DEFUN LEX-STRING ...)
; compiling (DEFUN SPLIT-ALPHANUMERIC-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN SPLIT-ALPHANUMERIC-STRING
; (POSITION-IF-NOT #'KMRCL::IS-SEP STRING)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%FIND-POSITION-IF-NOT
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
; SEQUENCE
; SB-C::FROM-END
; SB-C::START
; SB-C::END
; (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; (POSITION-IF #'KMRCL::IS-SEP STRING :START KMRCL::TOKEN-START)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%FIND-POSITION-IF
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
; SEQUENCE
; SB-C::FROM-END
; SB-C::START
; SB-C::END
; (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; (SUBSEQ STRING KMRCL::TOKEN-START KMRCL::TOKEN-END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (POSITION-IF-NOT #'KMRCL::IS-SEP STRING :START (1+ KMRCL::TOKEN-END))
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%FIND-POSITION-IF-NOT
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
; SEQUENCE
; SB-C::FROM-END
; SB-C::START
; SB-C::END
; (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; (POSITION-IF #'KMRCL::IS-SEP STRING :START KMRCL::TOKEN-START)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%FIND-POSITION-IF
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
; SEQUENCE
; SB-C::FROM-END
; SB-C::START
; SB-C::END
; (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
;
; note: unable to
; expand inline
; because:
; upgraded array element type not known at compile time
; compiling (DEFUN TRIM-NON-ALPHANUMERIC ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.lisp
; in: DEFUN TRIM-NON-ALPHANUMERIC
; (ALPHANUMERICP (SCHAR KMRCL::WORD (1- KMRCL::END)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (SUBSEQ KMRCL::WORD KMRCL::START KMRCL::END)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (ALPHANUMERICP (SCHAR KMRCL::WORD KMRCL::START))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET OR LET IF OR = IF
; ==>
; (= GC 12)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; (ALPHANUMERICP (SCHAR KMRCL::WORD (1- KMRCL::END)))
; --> BLOCK LET OR LET < IF
; ==>
; (< GC 5)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; compiling (DEFUN COLLAPSE-WHITESPACE ...)
; compiling (DEFUN STRING->LIST ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strings.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strmatch.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN SCORE-MULTIWORD-MATCH ...)
; compiling (DEFUN MULTIWORD-MATCH ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/strmatch.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp" (written 19 JAN 2006 01:11:42 PM):
; compiling (IN-PACKAGE :KMRCL)
; compiling (DEFCONSTANT +MAX-FIELD+ ...)
; compiling (DEFCONSTANT +MAX-FIELDS-PER-LINE+ ...)
; compiling (DEFCONSTANT +FIELD-DELIM+ ...)
; compiling (DEFCONSTANT +EOF-CHAR+ ...)
; compiling (DEFCONSTANT +NEWLINE+ ...)
; compiling (DECLAIM (TYPE CHARACTER ...) ...)
; compiling (DEFUN MAKE-FIELDS-BUFFER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN MAKE-FIELDS-BUFFER
; (MAKE-ARRAY KMRCL::MAX-FIELDS
; :ELEMENT-TYPE
; 'VECTOR
; :FILL-POINTER
; 0
; :ADJUSTABLE
; NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (MAKE-ARRAY KMRCL::MAX-FIELD-LEN
; :ELEMENT-TYPE
; 'CHARACTER
; :FILL-POINTER
; 0
; :ADJUSTABLE
; NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (SETF (AREF KMRCL::BUFS KMRCL::I)
; (MAKE-ARRAY KMRCL::MAX-FIELD-LEN
; :ELEMENT-TYPE
; 'CHARACTER
; :FILL-POINTER
; 0
; :ADJUSTABLE
; NIL))
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR T), not a SIMPLE-ARRAY.
; compiling (DEFUN READ-BUFFERED-FIELDS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN READ-BUFFERED-FIELDS
; (AREF KMRCL::FIELDS KMRCL::IFIELD)
; --> LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (SETF (CHAR KMRCL::FIELD KMRCL::IPOS) KMRCL::RC)
; --> SB-KERNEL:%CHARSET SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a BASE-STRING, not a SIMPLE-ARRAY.
; compiling (DEFSTRUCT FIELD-BUFFERS ...)
; compiling (DEFUN MAKE-FIELDS-BUFFER2 ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN MAKE-FIELDS-BUFFER2
; (MAKE-ARRAY KMRCL::MAX-FIELDS
; :ELEMENT-TYPE
; 'VECTOR
; :FILL-POINTER
; NIL
; :ADJUSTABLE
; NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; (MAKE-ARRAY KMRCL::MAX-FIELD-LEN
; :ELEMENT-TYPE
; 'CHARACTER
; :FILL-POINTER
; NIL
; :ADJUSTABLE
; NIL)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a INTEGER.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST.
; compiling (DEFUN READ-BUFFERED-FIELDS2 ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN READ-BUFFERED-FIELDS2
; (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::IFIELD)
; --> LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (SETF (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::IFIELD)
; KMRCL::IPOS)
; --> SB-KERNEL:%ASET LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; 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
; 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
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEFUN BFIELD ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN BFIELD
; (>= KMRCL::I (KMRCL::FIELD-BUFFERS-NFIELDS KMRCL::FIELDS))
; --> IF
; ==>
; (< KMRCL::I (KMRCL::FIELD-BUFFERS-NFIELDS KMRCL::FIELDS))
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::I)
; --> LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::I)
; --> LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a VECTOR, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (SUBSEQ (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::I)
; 0
; (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::I))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY SINGLE-FLOAT (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 16)
; (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
; &REST
; T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY (SIGNED-BYTE 32)
; (*))
; &REST
; T).
; (>= KMRCL::I (KMRCL::FIELD-BUFFERS-NFIELDS KMRCL::FIELDS))
; --> IF
; ==>
; (< KMRCL::I (KMRCL::FIELD-BUFFERS-NFIELDS KMRCL::FIELDS))
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; compiling (DEFCONSTANT +MAX-LINE+ ...)
; compiling (LET (#) ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.lisp
; in: DEFUN READ-BUFFERED-LINE
; (SETF (CHAR KMRCL::LINEBUFFER KMRCL::POS) KMRCL::C)
; --> SB-KERNEL:%CHARSET SB-KERNEL:%ASET THE
; ==>
; KMRCL::LINEBUFFER
;
; note: deleting unreachable code
; (INCF KMRCL::POS)
; --> LET* +
; ==>
; KMRCL::POS
;
; note: deleting unreachable code
; (SETF (FILL-POINTER KMRCL::LINEBUFFER) (1- KMRCL::POS))
; --> SB-KERNEL:%SET-FILL-POINTER
; ==>
; KMRCL::LINEBUFFER
;
; note: deleting unreachable code
; (WARN "Line overflow")
; ==>
; "Line overflow"
;
; note: deleting unreachable code
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/buff-input.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/random.lisp" (written 15 SEP 2004 12:45:06 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN SEED-RANDOM-GENERATOR ...)
; compiling (DEFMACRO RANDOM-CHOICE ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/random.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/symbols.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN CL-SYMBOLS ...)
; compiling (DEFUN CL-VARIABLES ...)
; compiling (DEFUN CL-FUNCTIONS ...)
; compiling (WHEN (CHAR= #\a ...) ...); in: LAMBDA NIL
; (PUSHNEW :KMRCL-LOWERCASE-READER *FEATURES*)
; --> LET* ADJOIN
; ==>
; *FEATURES*
;
; note: deleting unreachable code
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/symbols.lisp
; in: EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
; (PUSHNEW :KMRCL-LOWERCASE-READER *FEATURES*)
; --> LET* ADJOIN
; ==>
; *FEATURES*
;
; note: deleting unreachable code
; compiling (WHEN (NOT #) ...); in: LAMBDA NIL
; (PUSHNEW :KMRCL-CASE-SENSITIVE *FEATURES*)
; --> LET* ADJOIN
; ==>
; *FEATURES*
;
; note: deleting unreachable code
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/symbols.lisp
; in: EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
; (PUSHNEW :KMRCL-CASE-SENSITIVE *FEATURES*)
; --> LET* ADJOIN
; ==>
; *FEATURES*
;
; note: deleting unreachable code
; compiling (DEFUN STRING-DEFAULT-CASE ...)
; compiling (SETQ *FEATURES* ...)
; compiling (SETQ *FEATURES* ...)
; compiling (DEFUN CONCAT-SYMBOL-PKG ...)
; compiling (DEFUN CONCAT-SYMBOL ...)
; compiling (DEFUN ENSURE-KEYWORD ...)
; compiling (DEFUN ENSURE-KEYWORD-UPCASE ...)
; compiling (DEFUN ENSURE-KEYWORD-DEFAULT-CASE ...)
; compiling (DEFUN SHOW ...)
; compiling (DEFUN SHOW-VARIABLES ...)
; compiling (DEFUN SHOW-FUNCTIONS ...)
; compiling (DEFUN FIND-TEST-GENERIC-FUNCTIONS ...)
; compiling (DEFUN RUN-TESTS-FOR-INSTANCE ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/symbols.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/datetime.lisp" (written 04 OCT 2004 01:42:33 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN PRETTY-DATE ...)
; compiling (DEFUN DATE-STRING ...)
; compiling (DEFUN PRINT-SECONDS ...)
; compiling (DEFUN PRINT-FLOAT-UNITS ...)
; compiling (DEFCONSTANT +POSIX-EPOCH+ ...)
; compiling (DEFUN POSIX-TIME-TO-UTIME ...)
; compiling (DEFUN UTIME-TO-POSIX-TIME ...)
; compiling (DEFVAR *MONTHNAMES* ...)
; compiling (DEFUN MONTHNAME ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/datetime.lisp
; in: DEFUN MONTHNAME
; (DEFUN KMRCL::MONTHNAME
; (STREAM KMRCL::ARG KMRCL::COLON-P KMRCL::AT-P
; &OPTIONAL KMRCL::WIDTH (KMRCL::MINCOL 0) (KMRCL::COLINC 1)
; (KMRCL::MINPAD 0) (KMRCL::PADCHAR #\ ))
; "Print the name of the month (1=January) corresponding to ARG on STREAM. This is intended for embedding in a FORMAT directive: WIDTH governs the number of characters of text printed, MINCOL, COLINC, MINPAD, PADCHAR work as for ~A"
; (LET ((KMRCL::MONTHSTRING (CDR #)))
; (IF (NOT KMRCL::MONTHSTRING) (RETURN-FROM KMRCL::MONTHNAME NIL))
; (LET ((TRUNCATE #))
; (FORMAT STREAM
; (IF KMRCL::AT-P "~V,V,V,V@A" "~V,V,V,VA")
; KMRCL::MINCOL
; KMRCL::COLINC
; KMRCL::MINPAD
; KMRCL::PADCHAR
; (SUBSEQ KMRCL::MONTHSTRING 0 TRUNCATE)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::MONTHNAME
; (STREAM KMRCL::ARG
; KMRCL::COLON-P
; KMRCL::AT-P
; &OPTIONAL
; KMRCL::WIDTH
; (KMRCL::MINCOL 0)
; (KMRCL::COLINC 1)
; (KMRCL::MINPAD 0)
; (KMRCL::PADCHAR #\ ))
; (BLOCK KMRCL::MONTHNAME
; (LET ((KMRCL::MONTHSTRING #))
; (IF (NOT KMRCL::MONTHSTRING)
; (RETURN-FROM KMRCL::MONTHNAME NIL))
; (LET (#)
; (FORMAT STREAM
; #
; KMRCL::MINCOL
; KMRCL::COLINC
; KMRCL::MINPAD
; KMRCL::PADCHAR
; #)))))
;
; caught STYLE-WARNING:
; The variable COLON-P is defined but never used.
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/datetime.fasl written
; compilation finished in 0:00:00
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {40008241}> on
#<CL-SOURCE-FILE "datetime" {40008251}>.
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/math.lisp" (written 26 APR 2005 09:40:35 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN DERIV ...)
; compiling (DEFUN SIN^ ...)
; compiling (DEFMACRO ENSURE-INTEGER ...)
; compiling (DEFUN HISTOGRAM ...)
; compiling (DEFUN FIXNUM-WIDTH ...)
; compiling (DEFUN SCALED-EPSILON ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/math.lisp
; in: DEFUN SCALED-EPSILON
; (TYPECASE FLOAT
; (SHORT-FLOAT SHORT-FLOAT-NEGATIVE-EPSILON)
; (SINGLE-FLOAT SINGLE-FLOAT-NEGATIVE-EPSILON)
; (DOUBLE-FLOAT DOUBLE-FLOAT-NEGATIVE-EPSILON)
; (LONG-FLOAT LONG-FLOAT-NEGATIVE-EPSILON))
; --> LET COND IF COND IF PROGN
; ==>
; SINGLE-FLOAT-NEGATIVE-EPSILON
;
; note: deleting unreachable code
; --> LET COND IF COND IF COND IF COND IF PROGN
; ==>
; LONG-FLOAT-NEGATIVE-EPSILON
;
; note: deleting unreachable code
; (TYPECASE FLOAT
; (SHORT-FLOAT SHORT-FLOAT-EPSILON)
; (SINGLE-FLOAT SINGLE-FLOAT-EPSILON)
; (DOUBLE-FLOAT DOUBLE-FLOAT-EPSILON)
; (LONG-FLOAT LONG-FLOAT-EPSILON))
; --> LET COND IF COND IF PROGN
; ==>
; SINGLE-FLOAT-EPSILON
;
; note: deleting unreachable code
; --> LET COND IF COND IF COND IF COND IF PROGN
; ==>
; LONG-FLOAT-EPSILON
;
; note: deleting unreachable code
; compiling (DEFUN SINC ...)
; compiling (DEFUN NUMBERS-WITHIN-PERCENTAGE ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/math.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp" (written 15 SEP 2004 12:45:06 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN HSV->RGB ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN HSV->RGB
; (ZEROP KMRCL::S)
; ==>
; (= KMRCL::S 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (MINUSP KMRCL::H)
; ==>
; (< KMRCL::H 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (INCF KMRCL::H 360)
; --> LET*
; ==>
; (+ KMRCL::H #:G9)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (>= KMRCL::H 360)
; --> IF
; ==>
; (< KMRCL::H 360)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (DECF KMRCL::H 360)
; --> LET*
; ==>
; (- KMRCL::H #:G13)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (/ KMRCL::H 60)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (- 1 KMRCL::S)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (* KMRCL::V (- 1 KMRCL::S))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (* KMRCL::S KMRCL::H-FRAC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a INTEGER.
; (- 1 (* KMRCL::S KMRCL::H-FRAC))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (* KMRCL::V (- 1 (* KMRCL::S KMRCL::H-FRAC)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (- 1 KMRCL::H-FRAC)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a FLOAT.
; (* KMRCL::S (- 1 KMRCL::H-FRAC))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a INTEGER.
; (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (* KMRCL::V (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC))))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a NUMBER, not a INTEGER.
; The second argument is a NUMBER, not a INTEGER.
; (MINUSP KMRCL::H)
; ==>
; (< KMRCL::H 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; (INCF KMRCL::H 360)
; --> LET*
; ==>
; (+ KMRCL::H #:G9)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (>= KMRCL::H 360)
; --> IF
; ==>
; (< KMRCL::H 360)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET
; ==>
; (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
;
; note: forced to do full call
; unable to do inline float truncate (cost 5) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; unable to do inline float truncate (cost 5) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; --> TRUNCATE LET VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- 1 KMRCL::S)
;
; 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 &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::V (- 1 KMRCL::S))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline float arithmetic (cost 4) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (* KMRCL::S KMRCL::H-FRAC)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline float arithmetic (cost 4) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0)
; (1.0))), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (- 1 (* KMRCL::S KMRCL::H-FRAC))
;
; 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 &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::V (- 1 (* KMRCL::S KMRCL::H-FRAC)))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline float arithmetic (cost 4) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (- 1 KMRCL::H-FRAC)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (OR (RATIONAL (-1) (1))
; (DOUBLE-FLOAT (-1.0d0) (1.0d0))
; (SINGLE-FLOAT (-1.0) (1.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::S (- 1 KMRCL::H-FRAC))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline float arithmetic (cost 4) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (0.0) (2.0))
; (DOUBLE-FLOAT (0.0d0) (2.0d0))
; (RATIONAL (0) (2))), not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC)))
;
; 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 &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::V (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC))))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The second argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline float arithmetic (cost 4) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (DECF KMRCL::H 360)
; --> LET*
; ==>
; (- KMRCL::H #:G13)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFUN HSV255->RGB255 ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN HSV255->RGB255
; (ZEROP KMRCL::S)
; ==>
; (= KMRCL::S 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to open code because: The operands might not be the same type.
; (* 255 KMRCL::FV (- 1 KMRCL::FS))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a INTEGER.
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a (UNSIGNED-BYTE 32).
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; ==>
; (* (* 255 KMRCL::FV) (- 1 KMRCL::FS))
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912 536870911), not a INTEGER.
; The second argument is a (RATIONAL -536870656/255
; 536871167/255), not a INTEGER.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a INTEGER.
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a (UNSIGNED-BYTE 32).
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (* KMRCL::FS KMRCL::H-FRAC)
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a INTEGER.
; The second argument is a (RATIONAL -134217803/15 536871239/60), not a INTEGER.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; ==>
; (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912 536870911), not a INTEGER.
; The second argument is a (RATIONAL -288230551171613429/15300
; 72057637927128817/3825), not a INTEGER.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a INTEGER.
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a (UNSIGNED-BYTE 32).
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (* KMRCL::FS (- 1 KMRCL::H-FRAC))
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a INTEGER.
; The second argument is a (RATIONAL -536871179/60 134217818/15), not a INTEGER.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; ==>
; (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a (RATIONAL -536870912 536870911), not a INTEGER.
; The second argument is a (RATIONAL -72057642222088373/3825
; 72057642356313841/3825), not a INTEGER.
; (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET VALUES
; ==>
; (- SB-C::X SB-C::RES)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -134217728/15 359/60), not a FIXNUM.
; The result is a (VALUES (RATIONAL -134217803/15 536871239/60)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a (RATIONAL -134217728/15 359/60), not a FIXNUM.
; The result is a (VALUES (RATIONAL -134217803/15 536871239/60)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 KMRCL::FS))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- 1 KMRCL::FS)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870656/255 536871167/255)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870656/255 536871167/255)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 KMRCL::FS))
; ==>
; (* (* 255 KMRCL::FV) (- 1 KMRCL::FS))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912 536870911), not a FIXNUM.
; The second argument is a (RATIONAL -536870656/255
; 536871167/255), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -288230513053794304/255
; 288230512516923137/255)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The first argument is a (RATIONAL -536870912
; 536870911), not a (SIGNED-BYTE 32).
; The second argument is a (RATIONAL -536870656/255
; 536871167/255), not a (SIGNED-BYTE 32).
; The result is a (VALUES
; (RATIONAL -288230513053794304/255
; 288230512516923137/255)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::FS KMRCL::H-FRAC)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The second argument is a (RATIONAL -134217803/15
; 536871239/60), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -72057637927124992/3825
; 288230551171628729/15300)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a (SIGNED-BYTE 32).
; The second argument is a (RATIONAL -134217803/15
; 536871239/60), not a (SIGNED-BYTE 32).
; The result is a (VALUES
; (RATIONAL -72057637927124992/3825
; 288230551171628729/15300)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T).
; etc.
; (- 1 (* KMRCL::FS KMRCL::H-FRAC))
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (RATIONAL -72057637927124992/3825
; 288230551171628729/15300), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -288230551171613429/15300
; 72057637927128817/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (RATIONAL -72057637927124992/3825
; 288230551171628729/15300), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -288230551171613429/15300
; 72057637927128817/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; ==>
; (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912 536870911), not a FIXNUM.
; The second argument is a (RATIONAL -288230551171613429/15300
; 72057637927128817/3825), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -38685649790503437524271104/3825
; 38685649718445799597142287/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The first argument is a (RATIONAL -536870912
; 536870911), not a (SIGNED-BYTE 32).
; The second argument is a (RATIONAL -288230551171613429/15300
; 72057637927128817/3825), not a (SIGNED-BYTE
; 32).
; The result is a (VALUES
; (RATIONAL -38685649790503437524271104/3825
; 38685649718445799597142287/3825)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; --> * *
; ==>
; (* SB-C::Y 255)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536870912 536870911)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- 1 KMRCL::H-FRAC)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (RATIONAL -134217803/15
; 536871239/60), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536871179/60 134217818/15)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (RATIONAL -134217803/15
; 536871239/60), not a FIXNUM.
; The result is a (VALUES (RATIONAL -536871179/60 134217818/15)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* KMRCL::FS (- 1 KMRCL::H-FRAC))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a FIXNUM.
; The second argument is a (RATIONAL -536871179/60
; 134217818/15), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -72057642356310016/3825
; 72057642222092198/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The first argument is a (RATIONAL -536870912/255
; 536870911/255), not a (SIGNED-BYTE 32).
; The second argument is a (RATIONAL -536871179/60
; 134217818/15), not a (SIGNED-BYTE 32).
; The result is a (VALUES
; (RATIONAL -72057642356310016/3825
; 72057642222092198/3825)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T).
; etc.
; (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC)))
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (RATIONAL -72057642356310016/3825
; 72057642222092198/3825), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -72057642222088373/3825
; 72057642356313841/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (RATIONAL -72057642356310016/3825
; 72057642222092198/3825), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -72057642222088373/3825
; 72057642356313841/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; ==>
; (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (RATIONAL -536870912 536870911), not a FIXNUM.
; The second argument is a (RATIONAL -72057642222088373/3825
; 72057642356313841/3825), not a FIXNUM.
; The result is a (VALUES
; (RATIONAL -38685652168404040775892992/3825
; 38685652096346398419579151/3825)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The first argument is a (RATIONAL -536870912
; 536870911), not a (SIGNED-BYTE 32).
; The second argument is a (RATIONAL -72057642222088373/3825
; 72057642356313841/3825), not a (SIGNED-BYTE
; 32).
; The result is a (VALUES
; (RATIONAL -38685652168404040775892992/3825
; 38685652096346398419579151/3825)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T).
; etc.
; compiling (DEFUN RGB->HSV ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN RGB->HSV
; (MIN KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MIN LET LET IF <= IF
; ==>
; (> #:ONCE-ONLY-49 SB-C::MINREST)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; --> LET LET IF <= IF
; ==>
; (> #:ONCE-ONLY-48 SB-C::MINREST)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (MAX KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MAX LET LET IF >= IF
; ==>
; (< #:ONCE-ONLY-45 SB-C::MAXREST)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; --> LET LET IF >= IF
; ==>
; (< #:ONCE-ONLY-44 SB-C::MAXREST)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (- MAX MIN)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (PLUSP MAX)
; ==>
; (> MAX 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (/ KMRCL::DELTA MAX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; The second argument is a REAL, not a INTEGER.
; (PLUSP KMRCL::DELTA)
; ==>
; (> KMRCL::DELTA 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (= MAX KMRCL::R)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
; (- KMRCL::G KMRCL::B)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; The second argument is a REAL, not a INTEGER.
; (= MAX KMRCL::G)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to open code because: The operands might not be the same type.
; (- KMRCL::B KMRCL::R)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; The second argument is a REAL, not a INTEGER.
; (+ 2 (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA))
; ==>
; (+ SB-C::Y 2)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (- KMRCL::R KMRCL::G)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a REAL, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; The second argument is a REAL, not a INTEGER.
; (+ 4 (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA))
; ==>
; (+ SB-C::Y 4)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (* 60 KMRCL::H)
; ==>
; (* SB-C::Y 60)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert x*2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a REAL, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES FIXNUM
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (MIN KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MIN LET LET IF <= IF
; ==>
; (> #:ONCE-ONLY-49 SB-C::MINREST)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; etc.
; --> LET LET IF <= IF
; ==>
; (> #:ONCE-ONLY-48 SB-C::MINREST)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; etc.
; (MAX KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MAX LET LET IF >= IF
; ==>
; (< #:ONCE-ONLY-45 SB-C::MAXREST)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; etc.
; --> LET LET IF >= IF
; ==>
; (< #:ONCE-ONLY-44 SB-C::MAXREST)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; etc.
; (- MAX MIN)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (PLUSP MAX)
; ==>
; (> MAX 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; (/ KMRCL::DELTA MAX)
;
; note: forced to do static-fun Two-arg-/ (cost 53)
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 19) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (PLUSP KMRCL::DELTA)
; ==>
; (> KMRCL::DELTA 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; (= MAX KMRCL::R)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; (- KMRCL::G KMRCL::B)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA)
;
; note: forced to do static-fun Two-arg-/ (cost 53)
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 19) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (= MAX KMRCL::G)
;
; note: forced to do GENERIC-= (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; (- KMRCL::B KMRCL::R)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA)
;
; note: forced to do static-fun Two-arg-/ (cost 53)
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 19) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (+ 2 (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA))
; ==>
; (+ SB-C::Y 2)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- KMRCL::R KMRCL::G)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA)
;
; note: forced to do static-fun Two-arg-/ (cost 53)
; unable to do inline float arithmetic (cost 12) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 19) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (+ 4 (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA))
; ==>
; (+ SB-C::Y 4)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (* 60 KMRCL::H)
; ==>
; (* SB-C::Y 60)
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; compiling (DEFUN RGB255->HSV255 ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN RGB255->HSV255
; (* 255 KMRCL::DELTA)
; ==>
; (* SB-C::Y 255)
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES FIXNUM
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (* 60 (THE FIXNUM (- KMRCL::G KMRCL::B)))
; ==>
; (* SB-C::Y 60)
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES FIXNUM
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (* 60 (THE FIXNUM (- KMRCL::B KMRCL::R)))
; ==>
; (* SB-C::Y 60)
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES FIXNUM
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (* 60 (THE FIXNUM (- KMRCL::R KMRCL::G)))
; ==>
; (* SB-C::Y 60)
;
; note: unable to
; recode as shifts and adds
; due to type uncertainty:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES FIXNUM
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).
; (TRUNCATE (THE FIXNUM (* 255 KMRCL::DELTA)) MAX)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (TRUNCATE (THE FIXNUM (* 60 (THE FIXNUM (- KMRCL::R KMRCL::G)))) KMRCL::DELTA)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (TRUNCATE (THE FIXNUM (* 60 (THE FIXNUM (- KMRCL::B KMRCL::R)))) KMRCL::DELTA)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (TRUNCATE (THE FIXNUM (* 60 (THE FIXNUM (- KMRCL::G KMRCL::B)))) KMRCL::DELTA)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; compiling (DEFUN HSV-EQUAL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN HSV-EQUAL
; (- KMRCL::A KMRCL::B)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; The second argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
; The second argument is a NUMBER, not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The second argument is a NUMBER, not a REAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a REAL.
; The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (ABS (- KMRCL::A KMRCL::B))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (< (ABS (- KMRCL::A KMRCL::B)) KMRCL::LIMIT)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a SINGLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a DOUBLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a FLOAT.
; The second argument is a REAL, not a RATIONAL.
; (- KMRCL::A KMRCL::B)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The second argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The second argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES NUMBER
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (ABS (- KMRCL::A KMRCL::B))
;
; note: forced to do full call
; unable to do inline float arithmetic (cost 1) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 1) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (< (ABS (- KMRCL::A KMRCL::B)) KMRCL::LIMIT)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a SINGLE-FLOAT.
; The second argument is a REAL, not a SINGLE-FLOAT.
; unable to do inline float comparison (cost 3) because:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a DOUBLE-FLOAT.
; The second argument is a REAL, not a DOUBLE-FLOAT.
; etc.
; compiling (DEFUN HSV255-EQUAL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN HSV255-EQUAL
; (NULL KMRCL::B)
; --> IF
; ==>
; KMRCL::B
;
; note: deleting unreachable code
; compiling (DEFUN HSV-SIMILAR ...)
; compiling (DEFUN HSV255-SIMILAR ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.lisp
; in: DEFUN HSV255-SIMILAR
; (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a RATIONAL.
; (<= (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
; --> IF
; ==>
; (> (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a FLOAT.
; (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2))
;
; note: forced to do full call
; unable to do inline float arithmetic (cost 1) because:
; The first argument is a NUMBER, not a SINGLE-FLOAT.
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 1) because:
; The first argument is a NUMBER, not a DOUBLE-FLOAT.
; The result is a (VALUES (REAL 0)
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; (<= (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
; --> IF
; ==>
; (> (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a (OR (SINGLE-FLOAT 0.0)
; (DOUBLE-FLOAT 0.0d0)
; (RATIONAL 0)), not a FIXNUM.
; compiling (DEFUN HUE-DIFFERENCE ...)
; compiling (DEFUN HUE-DIFFERENCE-FIXNUM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/color.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/mop.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:CL-USER)
; compiling (IF (FIND-PACKAGE #) ...)
; compiling (DEFPACKAGE #:KMR-MOP ...)
; compiling (IN-PACKAGE #:KMR-MOP)
; compiling (DEFMACRO PROCESS-CLASS-OPTION ...)
; compiling (DEFMACRO PROCESS-SLOT-OPTION ...)
; compiling (SHADOWING-IMPORT (QUOTE #))
; compiling (EXPORT (QUOTE #))
; compiling (IF (FIND-PACKAGE #) ...)
; compiling (WHEN (>= # ...) ...)
; compiling (WHEN (>= # ...) ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/mop.fasl written
; compilation finished in 0:00:00
WARNING: KMR-MOP also shadows the following symbols:
(SB-MOP:COMPUTE-SLOTS SB-MOP:GENERIC-FUNCTION-LAMBDA-LIST
SB-MOP:MAKE-METHOD-LAMBDA
SB-MOP:INTERN-EQL-SPECIALIZER
SB-MOP:GENERIC-FUNCTION-METHOD-CLASS
SB-MOP:CLASS-PROTOTYPE
SB-MOP:SLOT-VALUE-USING-CLASS
SB-PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
SB-MOP:CLASS-DIRECT-SLOTS
SB-MOP:COMPUTE-EFFECTIVE-SLOT-DEFINITION
SB-MOP:EFFECTIVE-SLOT-DEFINITION-CLASS
SB-MOP:DIRECT-SLOT-DEFINITION-CLASS
SB-MOP:VALIDATE-SUPERCLASS
SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION
SB-MOP:STANDARD-DIRECT-SLOT-DEFINITION
SB-MOP:FINALIZE-INHERITANCE
SB-MOP:SLOT-DEFINITION-NAME
STANDARD-CLASS
FIND-CLASS
SB-MOP:CLASS-SLOTS
CLASS-NAME
CLASS-OF)
See also:
The ANSI Standard, Macro DEFPACKAGE
WARNING: KMR-MOP also exports the following symbols:
(SB-MOP:CLASS-DIRECT-SLOTS CLASS-OF
SB-MOP:DIRECT-SLOT-DEFINITION-CLASS
SB-MOP:SLOT-VALUE-USING-CLASS
SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION
KMR-MOP:PROCESS-SLOT-OPTION
KMR-MOP:PROCESS-CLASS-OPTION
SB-MOP:CLASS-PROTOTYPE
SB-MOP:COMPUTE-SLOTS
STANDARD-CLASS
SB-MOP:CLASS-SLOTS
SB-MOP:COMPUTE-EFFECTIVE-SLOT-DEFINITION
FIND-CLASS
CLASS-NAME
SB-MOP:FINALIZE-INHERITANCE
SB-PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
SB-MOP:MAKE-METHOD-LAMBDA
SB-MOP:STANDARD-DIRECT-SLOT-DEFINITION
SB-MOP:GENERIC-FUNCTION-METHOD-CLASS
SB-MOP:GENERIC-FUNCTION-LAMBDA-LIST
SB-MOP:INTERN-EQL-SPECIALIZER
SB-MOP:SLOT-DEFINITION-NAME
SB-MOP:VALIDATE-SUPERCLASS
SB-MOP:EFFECTIVE-SLOT-DEFINITION-CLASS)
See also:
The ANSI Standard, Macro DEFPACKAGE
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/equal.lisp" (written 30 APR 2005 06:14:18 AM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN GENERALIZED-EQUAL ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/equal.lisp
; in: DEFUN GENERALIZED-EQUAL
; (KMRCL::GENERALIZED-EQUAL-HASH-TABLE KMRCL::OBJ1 KMRCL::OBJ2)
; ==>
; KMRCL::OBJ2
;
; note: deleting unreachable code
; compiling (DEFUN GENERALIZED-EQUAL-FUNCTION ...)
; compiling (DEFUN GENERALIZED-EQUAL-ARRAY ...)
; compiling (DEFUN GENERALIZED-EQUAL-HASH-TABLE ...)
; compiling (DEFUN GENERALIZED-EQUAL-FIELDED-OBJECT ...)
; compiling (DEFUN CLASS-SLOT-NAMES ...)
; compiling (DEFUN STRUCTURE-SLOT-NAMES ...)
; compiling (DEFUN FUNCTION-TO-STRING ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/equal.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/web-utils.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFVAR *STANDARD-XML-HEADER* ...)
; compiling (DEFVAR *STANDARD-HTML-HEADER* ...)
; compiling (DEFVAR *STANDARD-XHTML-HEADER* ...)
; compiling (DEFUN USER-AGENT-IE-P ...)
; compiling (DEFVAR *BASE-URL* ...)
; compiling (DEFUN BASE-URL! ...)
; compiling (DEFUN MAKE-URL ...)
; compiling (DEFUN DECODE-URI-QUERY-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/web-utils.lisp
; in: DEFUN DECODE-URI-QUERY-STRING
; (SUBSEQ KMRCL::S (1+ KMRCL::P-OLD) (+ KMRCL::P-OLD 3))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; compiling (DEFUN SPLIT-URI-QUERY-STRING ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/web-utils.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/xml-utils.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN FIND-START-TAG ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/xml-utils.lisp
; in: DEFUN FIND-START-TAG
; (+ KMRCL::BRACKETPOS 1 KMRCL::TAGLEN)
; --> +
; ==>
; (+ KMRCL::BRACKETPOS 1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; ==>
; (+ (+ KMRCL::BRACKETPOS 1) KMRCL::TAGLEN)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (1+ KMRCL::ENDBRACK)
; ==>
; (+ KMRCL::ENDBRACK 1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; (SUBSEQ KMRCL::XMLSTR KMRCL::ENDTAG KMRCL::ENDBRACK)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a SIMPLE-BASE-STRING.
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a SIMPLE-STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
; The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
; &OPTIONAL), not a (VALUES
; (SIMPLE-ARRAY CHARACTER (*))
; &REST
; T).
; (+ KMRCL::BRACKETPOS 1 KMRCL::TAGLEN)
; --> +
; ==>
; (+ KMRCL::BRACKETPOS 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 &REST T).
; 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 &REST T).
; etc.
; ==>
; (+ (+ KMRCL::BRACKETPOS 1) KMRCL::TAGLEN)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (1+ KMRCL::ENDBRACK)
; ==>
; (+ KMRCL::ENDBRACK 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 &REST T).
; 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 &REST T).
; etc.
; (1+ KMRCL::TAGLEN)
; ==>
; (+ KMRCL::TAGLEN 1)
;
; note: doing signed word to integer coercion (cost 20), for:
; the first result of inline (signed-byte 32) arithmetic
; compiling (DEFUN FIND-END-TAG ...)
; compiling (DEFUN POSITIONS-XML-TAG-CONTENTS ...)
; compiling (DEFUN XML-TAG-CONTENTS ...)
; compiling (DEFUN CDATA-STRING ...)
; compiling (DEFUN WRITE-CDATA ...)
; compiling (DEFUN XML-DECLARATION-STREAM ...)
; compiling (DEFUN DOCTYPE-STREAM ...)
; compiling (DEFUN DOCTYPE-FORMAT ...)
; compiling (DEFUN SGML-HEADER-STREAM ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/xml-utils.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/sockets.lisp" (written 21 DEC 2004 02:44:04 AM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (REQUIRE :SB-BSD-SOCKETS)
; compiling (DEFUN LISTEN-TO-INET-PORT ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/sockets.lisp
; in: DEFUN LISTEN-TO-INET-PORT
; (DEFUN KMRCL::LISTEN-TO-INET-PORT
; (&KEY (KMRCL::PORT 0) (KMRCL::KIND :STREAM) (KMRCL::REUSE ()))
; "Create, bind and listen to an inet socket on *:PORT.
; setsockopt SO_REUSEADDR if :reuse is not nil"
; (LET ((KMRCL::SOCKET
; (MAKE-INSTANCE 'SB-BSD-SOCKETS:INET-SOCKET
; :TYPE
; :STREAM
; :PROTOCOL
; :TCP)))
; (IF KMRCL::REUSE
; (SETF (SB-BSD-SOCKETS:SOCKOPT-REUSE-ADDRESS KMRCL::SOCKET) T))
; (SB-BSD-SOCKETS:SOCKET-BIND KMRCL::SOCKET
; (SB-BSD-SOCKETS:MAKE-INET-ADDRESS "0.0.0.0")
; KMRCL::PORT)
; (SB-BSD-SOCKETS:SOCKET-LISTEN KMRCL::SOCKET 15)
; KMRCL::SOCKET))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::LISTEN-TO-INET-PORT
; (&KEY (KMRCL::PORT 0)
; (KMRCL::KIND :STREAM)
; (KMRCL::REUSE NIL))
; (BLOCK KMRCL::LISTEN-TO-INET-PORT
; (LET ((KMRCL::SOCKET #))
; (IF KMRCL::REUSE (SETF # T))
; (SB-BSD-SOCKETS:SOCKET-BIND KMRCL::SOCKET
; (SB-BSD-SOCKETS:MAKE-INET-ADDRESS
; "0.0.0.0")
; KMRCL::PORT)
; (SB-BSD-SOCKETS:SOCKET-LISTEN KMRCL::SOCKET 15)
; KMRCL::SOCKET)))
;
; caught STYLE-WARNING:
; The variable KIND is defined but never used.
; compiling (DEFUN CREATE-INET-LISTENER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/sockets.lisp
; in: DEFUN CREATE-INET-LISTENER
; (DEFUN KMRCL::CREATE-INET-LISTENER
; (KMRCL::PORT &KEY (FORMAT :TEXT) (KMRCL::REUSE-ADDRESS T))
; (KMRCL::LISTEN-TO-INET-PORT :PORT KMRCL::PORT :REUSE KMRCL::REUSE-ADDRESS))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::CREATE-INET-LISTENER
; (KMRCL::PORT &KEY
; (FORMAT :TEXT)
; (KMRCL::REUSE-ADDRESS T))
; (BLOCK KMRCL::CREATE-INET-LISTENER
; (KMRCL::LISTEN-TO-INET-PORT :PORT
; KMRCL::PORT
; :REUSE
; KMRCL::REUSE-ADDRESS)))
;
; caught STYLE-WARNING:
; The variable FORMAT is defined but never used.
; compiling (DEFUN MAKE-FD-STREAM ...)
; compiling (DEFUN ACCEPT-TCP-CONNECTION ...)
; compiling (DEFMACRO ERRORSET ...)
; compiling (DEFUN CLOSE-PASSIVE-SOCKET ...)
; compiling (DEFUN CLOSE-ACTIVE-SOCKET ...)
; compiling (DEFUN IPADDR-TO-DOTTED ...)
; compiling (DEFUN DOTTED-TO-IPADDR ...)
; compiling (DEFUN IPADDR-TO-HOSTNAME ...)
; compiling (DEFUN LOOKUP-HOSTNAME ...)
; compiling (DEFUN MAKE-ACTIVE-SOCKET ...)
; compiling (DEFUN IPADDR-ARRAY-TO-DOTTED ...)
; compiling (DEFUN REMOTE-HOST ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/sockets.fasl written
; compilation finished in 0:00:00
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {40007E29}> on
#<CL-SOURCE-FILE "sockets" {400E9831}>.
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp" (written 19 MAR 2005 04:40:22 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN MAKE-PROCESS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp
; in: DEFUN MAKE-PROCESS
; (DEFUN KMRCL::MAKE-PROCESS (KMRCL::NAME KMRCL::FUNC) (FUNCALL KMRCL::FUNC))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::MAKE-PROCESS
; (KMRCL::NAME KMRCL::FUNC)
; (BLOCK KMRCL::MAKE-PROCESS (FUNCALL KMRCL::FUNC)))
;
; caught STYLE-WARNING:
; The variable NAME is defined but never used.
; compiling (DEFUN DESTROY-PROCESS ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp
; in: DEFUN DESTROY-PROCESS
; (DEFUN KMRCL::DESTROY-PROCESS (KMRCL::PROCESS))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::DESTROY-PROCESS
; (KMRCL::PROCESS)
; (BLOCK KMRCL::DESTROY-PROCESS))
;
; caught STYLE-WARNING:
; The variable PROCESS is defined but never used.
; compiling (DEFUN MAKE-LOCK ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp
; in: DEFUN MAKE-LOCK
; (DEFUN KMRCL::MAKE-LOCK (KMRCL::NAME))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA KMRCL::MAKE-LOCK
; (KMRCL::NAME)
; (BLOCK KMRCL::MAKE-LOCK))
;
; caught STYLE-WARNING:
; The variable NAME is defined but never used.
; compiling (DEFMACRO WITH-LOCK-HELD ...); in: LAMBDA NIL
; (LET* ((KMRCL::LOCK (CAR #:SUBLIST-19)) (KMRCL::BODY (CDR (CDR #:WHOLE17))))
; (BLOCK KMRCL::WITH-LOCK-HELD `(PROGN ,@KMRCL::BODY)))
;
; caught STYLE-WARNING:
; The variable LOCK is defined but never used.
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp
; in: DEFMACRO WITH-LOCK-HELD
; (DEFMACRO KMRCL::WITH-LOCK-HELD ((KMRCL::LOCK) &BODY KMRCL::BODY)
; `(PROGN ,@KMRCL::BODY))
; --> EVAL-WHEN SB-C::%DEFMACRO SB-C::%DEFMACRO FUNCTION LET*
; ==>
; (LET* ((KMRCL::LOCK (CAR #:SUBLIST-19)) (KMRCL::BODY (CDR (CDR #:WHOLE17))))
; (BLOCK KMRCL::WITH-LOCK-HELD `(PROGN ,@KMRCL::BODY)))
;
; caught STYLE-WARNING:
; The variable LOCK is defined but never used.
; compiling (DEFMACRO WITH-TIMEOUT ...); in: LAMBDA NIL
; (LET* ((KMRCL::SECONDS (CAR #:SUBLIST-26))
; (KMRCL::BODY (CDR (CDR #:WHOLE24))))
; (BLOCK KMRCL::WITH-TIMEOUT `(PROGN ,@KMRCL::BODY)))
;
; caught STYLE-WARNING:
; The variable SECONDS is defined but never used.
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.lisp
; in: DEFMACRO WITH-TIMEOUT
; (DEFMACRO KMRCL::WITH-TIMEOUT ((KMRCL::SECONDS) &BODY KMRCL::BODY)
; `(PROGN ,@KMRCL::BODY))
; --> EVAL-WHEN SB-C::%DEFMACRO SB-C::%DEFMACRO FUNCTION LET*
; ==>
; (LET* ((KMRCL::SECONDS (CAR #:SUBLIST-26))
; (KMRCL::BODY (CDR (CDR #:WHOLE24))))
; (BLOCK KMRCL::WITH-TIMEOUT `(PROGN ,@KMRCL::BODY)))
;
; caught STYLE-WARNING:
; The variable SECONDS is defined but never used.
; compiling (DEFUN PROCESS-SLEEP ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/processes.fasl written
; compilation finished in 0:00:01
WARNING:
COMPILE-FILE warned while performing #<COMPILE-OP NIL {40007E29}> on
#<CL-SOURCE-FILE "processes" {400E9841}>.
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/listener.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFVAR *LISTENER-COUNT* ...)
; compiling (DEFVAR *WORKER-COUNT* ...)
; compiling (DEFVAR *ACTIVE-LISTENERS* ...)
; compiling (DEFCLASS LISTENER ...)
; compiling (DEFCLASS FIXED-WORKER ...)
; compiling (DEFCLASS WORKER ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFUN INIT/LISTENER ...)
; compiling (DEFUN STOP-ALL/LISTENER ...)
; compiling (DEFUN LISTENER-STARTUP ...)
; compiling (DEFUN LISTENER-SHUTDOWN ...)
; compiling (DEFUN NEXT-SERVER-NAME ...)
; compiling (DEFUN NEXT-WORKER-NAME ...)
; compiling (DEFUN MAKE-SOCKET-SERVER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFUN ACCEPT-AND-CHECK-TCP-CONNECTION ...)
; compiling (DEFUN START-SOCKET-SERVER ...)
; compiling (DEFUN START-FIXED-NUMBER-OF-WORKERS ...)
; compiling (DEFUN FIXED-WORKER ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/listener.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/repl.lisp" (written 15 SEP 2004 12:45:07 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFCONSTANT +DEFAULT-REPL-SERVER-PORT+ ...)
; compiling (DEFCLASS REPL ...)
; compiling (DEFUN MAKE-REPL ...)
; compiling (DEFUN INIT/REPL ...)
; compiling (DEFUN REPL-WORKER ...)
; compiling (DEFUN READ-SOCKET-LINE ...)
; compiling (DEFUN PRINT-PROMPT ...)
; compiling (DEFUN REPL-ON-STREAM ...)
; compiling (DEFUN %REPL ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/repl.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/os.lisp" (written 26 AUG 2005 04:02:06 PM):
; compiling (IN-PACKAGE #:KMRCL)
; compiling (DEFUN COMMAND-OUTPUT ...)
; compiling (DEFUN RUN-SHELL-COMMAND ...)
; compiling (DEFUN DELETE-DIRECTORY-AND-FILES ...)
; compiling (DEFUN FILE-SIZE ...)
; compiling (DEFUN GETPID ...)
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/kmrcl-1.85/os.fasl written
; compilation finished in 0:00:00
;
; compilation unit finished
; caught 13 STYLE-WARNING conditions
; printed 352 notes
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/package.lisp" (written 07 SEP 2003 02:34:45 AM):
; compiling (DEFPACKAGE #:CL-BASE64 ...)
; compiling (IN-PACKAGE #:CL-BASE64)
; compiling (DEFVAR *ENCODE-TABLE* ...)
; compiling (DECLAIM (TYPE SIMPLE-STRING ...))
; compiling (DEFVAR *URI-ENCODE-TABLE* ...)
; compiling (DECLAIM (TYPE SIMPLE-STRING ...))
; compiling (DEFTYPE DECODE-TABLE ...)
; compiling (DEFUN MAKE-DECODE-TABLE ...)
; compiling (DEFVAR *DECODE-TABLE* ...)
; compiling (DEFVAR *URI-DECODE-TABLE* ...)
; compiling (DEFVAR *PAD-CHAR* ...)
; compiling (DEFVAR *URI-PAD-CHAR* ...)
; compiling (DECLAIM (TYPE CHARACTER ...))
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp" (written 07 SEP 2003 02:34:45 AM):
; compiling (IN-PACKAGE #:CL-BASE64)
; compiling (DEFUN ROUND-NEXT-MULTIPLE ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFUN ROUND-NEXT-MULTIPLE
; (+ CL-BASE64::X (THE FIXNUM (- CL-BASE64::N CL-BASE64::REMAINDER)))
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; (MOD CL-BASE64::X CL-BASE64::N)
; --> BLOCK LET IF AND IF NOT IF ZEROP
; ==>
; (= REM 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-536870912) (536870912))
; (DOUBLE-FLOAT (-5.36870912d8) (5.36870912d8))
; (SINGLE-FLOAT (-5.368709e8)
; (5.368709e8))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET IF AND IF AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-536870912) (536870912))
; (DOUBLE-FLOAT (-5.36870912d8) (5.36870912d8))
; (SINGLE-FLOAT (-5.368709e8)
; (5.368709e8))), not a FLOAT.
; --> BLOCK LET REM BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; --> BLOCK LET IF AND IF AND IF PLUSP
; ==>
; (> NUMBER 0)
;
; note: forced to do GENERIC-> (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR (RATIONAL (-536870912) (536870912))
; (DOUBLE-FLOAT (-5.36870912d8) (5.36870912d8))
; (SINGLE-FLOAT (-5.368709e8)
; (5.368709e8))), not a FIXNUM.
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a (OR (RATIONAL (-536870912) (536870912))
; (DOUBLE-FLOAT (-5.36870912d8) (5.36870912d8))
; (SINGLE-FLOAT (-5.368709e8)
; (5.368709e8))), not a FIXNUM.
; etc.
; (+ CL-BASE64::X (THE FIXNUM (- CL-BASE64::N CL-BASE64::REMAINDER)))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; compiling (DEFMACRO DEF-*-TO-BASE64-* ...)
; compiling (DEF-*-TO-BASE64-* :STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFMACRO DEF-*-TO-BASE64-*
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (+ 2 CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (TRUNCATE (+ CL-BASE64::STRING-LENGTH 2) 3)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER 2 536870912), not a (UNSIGNED-BYTE 29).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (INTEGER 2 536870912), not a FIXNUM.
; (TRUNCATE (+ CL-BASE64::PADDED-LENGTH (1- CL-BASE64::COLUMNS))
; CL-BASE64::COLUMNS)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (MOD 1073741822), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES (MOD 1073741822)
; (MOD 536870911)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (MOD 1073741822), not a FIXNUM.
; The result is a (VALUES (MOD 1073741822)
; (MOD 536870911)
; &OPTIONAL), not a (VALUES FIXNUM FIXNUM &REST T).
; compiling (DEF-*-TO-BASE64-* :STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFMACRO DEF-*-TO-BASE64-*
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (+ 2 CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (TRUNCATE (+ CL-BASE64::STRING-LENGTH 2) 3)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER 2 536870912), not a (UNSIGNED-BYTE 29).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (INTEGER 2 536870912), not a FIXNUM.
; compiling (DEF-*-TO-BASE64-* :USB8-ARRAY ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFMACRO DEF-*-TO-BASE64-*
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (1+ CL-BASE64::ISOURCE))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (+ 2 CL-BASE64::ISOURCE))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (TRUNCATE (+ CL-BASE64::STRING-LENGTH 2) 3)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER 2 536870912), not a (UNSIGNED-BYTE 29).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (INTEGER 2 536870912), not a FIXNUM.
; (TRUNCATE (+ CL-BASE64::PADDED-LENGTH (1- CL-BASE64::COLUMNS))
; CL-BASE64::COLUMNS)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (MOD 1073741822), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES (MOD 1073741822)
; (MOD 536870911)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (MOD 1073741822), not a FIXNUM.
; The result is a (VALUES (MOD 1073741822)
; (MOD 536870911)
; &OPTIONAL), not a (VALUES FIXNUM FIXNUM &REST T).
; compiling (DEF-*-TO-BASE64-* :USB8-ARRAY ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFMACRO DEF-*-TO-BASE64-*
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (1+ CL-BASE64::ISOURCE))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (+ 2 CL-BASE64::ISOURCE))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL
; ==>
; (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; (TRUNCATE (+ CL-BASE64::STRING-LENGTH 2) 3)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER 2 536870912), not a (UNSIGNED-BYTE 29).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (INTEGER 2 536870912), not a FIXNUM.
; compiling (DEFUN INTEGER-TO-BASE64-STRING ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFUN INTEGER-TO-BASE64-STRING
; (MOD CL-BASE64::PADDED-BITS 24)
; --> BLOCK LET REM BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; --> BLOCK LET IF AND IF NOT IF ZEROP
; ==>
; (= REM 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FLOAT.
; (ZEROP CL-BASE64::REMAINDER-PADDING)
; ==>
; (= CL-BASE64::REMAINDER-PADDING 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (- 24 CL-BASE64::REMAINDER-PADDING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FLOAT.
; (/ CL-BASE64::PADDING-BITS 6)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a INTEGER.
; (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a SINGLE-FLOAT.
; (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; (/ CL-BASE64::PADDING-BITS 3)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a INTEGER.
; (INTEGER-LENGTH CL-BASE64::INPUT)
;
; note: forced to do full call
; unable to do inline (unsigned-byte 32) integer-length (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; unable to do inline (signed-byte 32) integer-length (cost 6) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; (MOD CL-BASE64::PADDED-BITS 24)
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (48.0))
; (DOUBLE-FLOAT (0.0d0) (48.0d0))
; (RATIONAL (0) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (48.0))
; (DOUBLE-FLOAT (0.0d0) (48.0d0))
; (RATIONAL (0) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- 24 CL-BASE64::REMAINDER-PADDING)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS)
;
; note: forced to do fixnum truncate (cost 50)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a FIXNUM, not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; (* CL-BASE64::COLUMNS (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS))
;
; note: forced to do GENERIC-* (cost 50)
; unable to do inline fixnum arithmetic (cost 2) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230375077969921)
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline (signed-byte 32) arithmetic (cost 4) because:
; The result is a (VALUES (INTEGER -288230375614840832 288230375077969921)
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (- CL-BASE64::PADDED-LENGTH
; (* CL-BASE64::COLUMNS
; (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS)))
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (INTEGER -288230375614840832
; 288230375077969921), not a FIXNUM.
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (INTEGER -288230375614840832
; 288230375077969921), not a FIXNUM.
; etc.
; (TRUNCATE (+ CL-BASE64::PADDED-LENGTH (1- CL-BASE64::COLUMNS))
; CL-BASE64::COLUMNS)
;
; note: forced to do (signed-byte 32) truncate (cost 60)
; unable to do unsigned fixnum truncate (cost 45) because:
; The first argument is a (INTEGER -536870912
; 1073741821), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES FIXNUM
; (INTEGER -536870910 536870910)
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 29)
; (UNSIGNED-BYTE 29)
; &REST
; T).
; unable to do fixnum truncate (cost 50) because:
; The first argument is a (INTEGER -536870912 1073741821), not a FIXNUM.
; (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a (INTEGER -7 15), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (LOGAND CL-BASE64::INT 63)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; (ASH CL-BASE64::INT -6)
;
; note: forced to do full call
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; unable to do inline constant ASH (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; compiling (DEFUN INTEGER-TO-BASE64-STREAM ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.lisp
; in: DEFUN INTEGER-TO-BASE64-STREAM
; (MOD CL-BASE64::PADDED-BITS 24)
; --> BLOCK LET REM BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
; ==>
; (TRUNCATE NUMBER SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert division by 2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; --> BLOCK LET IF AND IF NOT IF ZEROP
; ==>
; (= REM 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FLOAT.
; (ZEROP CL-BASE64::REMAINDER-PADDING)
; ==>
; (= CL-BASE64::REMAINDER-PADDING 0)
;
; note: unable to
; open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
; The first argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FLOAT.
;
; note: unable to open code because: The operands might not be the same type.
; (- 24 CL-BASE64::REMAINDER-PADDING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FLOAT.
; (/ CL-BASE64::PADDING-BITS 6)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a INTEGER.
; (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a RATIONAL.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a RATIONAL.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a DOUBLE-FLOAT.
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a SINGLE-FLOAT.
; (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a REAL, not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a REAL, not a INTEGER.
; (- CL-BASE64::STRLEN CL-BASE64::PADDING-CHARS)
;
; note: unable to
; optimize
; due to type uncertainty:
; The second argument is a (OR (RATIONAL (-4) (8))
; (DOUBLE-FLOAT (-4.0d0) (8.0d0))
; (SINGLE-FLOAT (-4.0) (8.0))), not a FLOAT.
; (1- CL-BASE64::NONPAD-CHARS)
; ==>
; (- CL-BASE64::NONPAD-CHARS 1)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920) (536870915))), not a FLOAT.
; (/ CL-BASE64::PADDING-BITS 3)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a FLOAT.
;
; note: unable to
; convert x/2^k to shift
; due to type uncertainty:
; The first argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a INTEGER.
; (= CL-BASE64::STRPOS CL-BASE64::NONPAD-CHARS)
;
; note: unable to open code because: The operands might not be the same type.
; (INTEGER-LENGTH CL-BASE64::INPUT)
;
; note: forced to do full call
; unable to do inline (unsigned-byte 32) integer-length (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; unable to do inline (signed-byte 32) integer-length (cost 6) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; (MOD CL-BASE64::PADDED-BITS 24)
; --> BLOCK LET IF AND IF AND IF MINUSP
; ==>
; (< NUMBER 0)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 3) because:
; The first argument is a REAL, not a FIXNUM.
; unable to do inline fixnum comparison (cost 4) because:
; The first argument is a REAL, not a FIXNUM.
; etc.
; --> BLOCK LET IF
; ==>
; (+ REM SB-KERNEL::DIVISOR)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (48.0))
; (DOUBLE-FLOAT (0.0d0) (48.0d0))
; (RATIONAL (0) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR (RATIONAL (-24) (24))
; (DOUBLE-FLOAT (-24.0d0) (24.0d0))
; (SINGLE-FLOAT (-24.0) (24.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (0.0) (48.0))
; (DOUBLE-FLOAT (0.0d0) (48.0d0))
; (RATIONAL (0) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (- 24 CL-BASE64::REMAINDER-PADDING)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (OR (RATIONAL (-24) (48))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (SINGLE-FLOAT (-24.0) (48.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a DOUBLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a DOUBLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; unable to do inline float arithmetic (cost 2) because:
; The first argument is a REAL, not a SINGLE-FLOAT.
; The second argument is a (OR (SINGLE-FLOAT (-24.0) (48.0))
; (DOUBLE-FLOAT (-24.0d0) (48.0d0))
; (RATIONAL (-24) (48))), not a SINGLE-FLOAT.
; The result is a (VALUES REAL
; &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; etc.
; (- CL-BASE64::STRLEN CL-BASE64::PADDING-CHARS)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a (OR (RATIONAL (-4) (8))
; (DOUBLE-FLOAT (-4.0d0) (8.0d0))
; (SINGLE-FLOAT (-4.0) (8.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920) (536870915)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a (OR (RATIONAL (-4) (8))
; (DOUBLE-FLOAT (-4.0d0) (8.0d0))
; (SINGLE-FLOAT (-4.0) (8.0))), not a FIXNUM.
; The result is a (VALUES
; (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920) (536870915)))
; &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; (1- CL-BASE64::NONPAD-CHARS)
; ==>
; (- CL-BASE64::NONPAD-CHARS 1)
;
; note: forced to do GENERIC-- (cost 10)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920)
; (536870915))), not a FIXNUM.
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920)
; (536870915))), not a FIXNUM.
; etc.
; (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The second argument is a (INTEGER -7 15), not a (UNSIGNED-BYTE 29).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (LOGAND CL-BASE64::INT 63)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; (DOTIMES (CL-BASE64::I CL-BASE64::NONPAD-CHARS)
; (DECLARE (FIXNUM CL-BASE64::I))
; (WRITE-CHAR (SCHAR CL-BASE64::STR CL-BASE64::I) STREAM)
; (WHEN (PLUSP CL-BASE64::COLUMNS)
; (INCF CL-BASE64::COL)
; (WHEN (= CL-BASE64::COL CL-BASE64::COLUMNS)
; (WRITE-CHAR #\Newline STREAM)
; (SETQ CL-BASE64::COL 0))))
; --> DO BLOCK LET TAGBODY UNLESS COND IF NOT IF >= IF
; ==>
; (< CL-BASE64::I #:G385)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a (OR (SINGLE-FLOAT (-5.368709e8) (5.368709e8))
; (DOUBLE-FLOAT (-5.3687092d8) (5.36870915d8))
; (RATIONAL (-536870920)
; (536870915))), not a FIXNUM.
; (DOTIMES (CL-BASE64::IPAD CL-BASE64::PADDING-CHARS)
; (DECLARE (FIXNUM CL-BASE64::IPAD))
; (WRITE-CHAR CL-BASE64::PAD STREAM)
; (WHEN (PLUSP CL-BASE64::COLUMNS)
; (INCF CL-BASE64::COL)
; (WHEN (= CL-BASE64::COL CL-BASE64::COLUMNS)
; (WRITE-CHAR #\Newline STREAM)
; (SETQ CL-BASE64::COL 0))))
; --> DO BLOCK LET TAGBODY UNLESS COND IF NOT IF >= IF
; ==>
; (< CL-BASE64::IPAD #:G391)
;
; note: forced to do GENERIC-< (cost 10)
; unable to do inline fixnum comparison (cost 4) because:
; The second argument is a (OR (RATIONAL (-4) (8))
; (DOUBLE-FLOAT (-4.0d0) (8.0d0))
; (SINGLE-FLOAT (-4.0) (8.0))), not a FIXNUM.
; (ASH CL-BASE64::INT -6)
;
; note: forced to do full call
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; unable to do inline constant ASH (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; (LOGAND CL-BASE64::INT 63)
;
; note: forced to do static-fun Two-arg-and (cost 53)
; unable to do inline fixnum logical op (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; unable to do inline (unsigned-byte 32) logical op (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; etc.
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/encode.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp" (written 07 SEP 2003 02:34:45 AM):
; compiling (IN-PACKAGE #:CL-BASE64)
; compiling (DECLAIM (INLINE WHITESPACE-P))
; compiling (DEFUN WHITESPACE-P ...)
; compiling (DEFMACRO DEF-BASE64-STRING-TO-* ...)
; compiling (DEF-BASE64-STRING-TO-* :STRING)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp
; in: DEF-BASE64-STRING-TO-* :STRING
; (CL-BASE64::DEF-BASE64-STRING-TO-* :STRING)
; --> DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; --> FUNCTION BLOCK LET LET LOOP BLOCK LET LET LET LET SB-LOOP::LOOP-BODY
; --> TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEF-BASE64-STRING-TO-* :STREAM)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp
; in: DEF-BASE64-STRING-TO-* :STREAM
; (CL-BASE64::DEF-BASE64-STRING-TO-* :STREAM)
; --> DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; --> FUNCTION BLOCK LET LET LOOP BLOCK LET LET LET LET SB-LOOP::LOOP-BODY
; --> TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEF-BASE64-STRING-TO-* :USB8-ARRAY)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp
; in: DEF-BASE64-STRING-TO-* :USB8-ARRAY
; (CL-BASE64::DEF-BASE64-STRING-TO-* :USB8-ARRAY)
; --> DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA
; --> FUNCTION BLOCK LET LET LOOP BLOCK LET LET LET LET SB-LOOP::LOOP-BODY
; --> TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; compiling (DEFUN BASE64-STRING-TO-INTEGER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp
; in: DEFUN BASE64-STRING-TO-INTEGER
; (LOOP CL-BASE64::FOR
; CHAR
; CL-BASE64::OF-TYPE
; CHARACTER
; CL-BASE64::ACROSS
; STRING
; CL-BASE64::FOR
; CL-BASE64::SVALUE
; CL-BASE64::OF-TYPE
; FIXNUM
; =
; ...)
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ
; --> THE AREF LET*
; ==>
; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a STRING, not a SIMPLE-STRING.
;
; note: unable to
; avoid runtime dispatch on array element type
; because:
; Upgraded element type of array is not known at compile time.
; (ASH CL-BASE64::VALUE -2)
;
; note: forced to do full call
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; unable to do inline constant ASH (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; (ASH CL-BASE64::VALUE 6)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (+ CL-BASE64::SVALUE (ASH CL-BASE64::VALUE 6))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; compiling (DEFUN BASE64-STREAM-TO-INTEGER ...)
; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.lisp
; in: DEFUN BASE64-STREAM-TO-INTEGER
; (ASH CL-BASE64::VALUE -2)
;
; note: forced to do full call
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; unable to do inline constant ASH (cost 4) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
; &REST
; T).
; etc.
; (ASH CL-BASE64::VALUE 6)
;
; note: forced to do full call
; unable to do inline ASH (cost 2) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do inline ASH (cost 3) because:
; The first argument is a INTEGER, not a (SIGNED-BYTE 32).
; The result is a (VALUES INTEGER
; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
; &REST
; T).
; etc.
; (+ CL-BASE64::SVALUE (ASH CL-BASE64::VALUE 6))
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; unable to do safe inline fixnum arithmetic (cost 4) because:
; The second argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
; etc.
; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-base64-3.3.1/decode.fasl written
; compilation finished in 0:00:01
;
; compilation unit finished
; printed 134 notes
