0.9.2.47:
[sbcl.git] / src / compiler / fndb.lisp
index 7297776..704e7f0 100644 (file)
 
 (defknown coerce (t type-specifier) t
   ;; Note:
 
 (defknown coerce (t type-specifier) t
   ;; Note:
-  ;; (1) This is not FLUSHABLE because it's defined to signal errors.
-  ;; (2) It's not worth trying to make this FOLDABLE in the
-  ;;     cross-compiler,because
-  ;;       (a) it would probably be really hard to make all the 
-  ;;           tricky issues (e.g. which specialized array types are
-  ;;           supported) match between cross-compiler and target
-  ;;           compiler, and besides
-  ;;       (b) leaving it not FOLDABLE lets us use the idiom
-  ;;              (COERCE FOO 'SOME-SPECIALIZED-ARRAY-TYPE-OR-ANOTHER)
-  ;;          as a way of delaying the generation of specialized
-  ;;          array types until runtime, which helps us keep the
-  ;;          cross-compiler's dumper relatively simple and which
-  ;;          lets us preserve distinctions which might not even exist
-  ;;           on the cross-compilation host (because ANSI doesn't
-  ;;          guarantee that specialized array types exist there).
-  ;; FIXME: It's actually not clear that COERCE on non-NUMBER types
-  ;; is FOLDABLE at all. Check this.
-  (movable #-sb-xc-host foldable)
+  ;; This is not FLUSHABLE because it's defined to signal errors.
+  (movable)
   ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
   ;; returns REAL/INTEGER, not COMPLEX.
   )
   ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
   ;; returns REAL/INTEGER, not COMPLEX.
   )
@@ -45,7 +29,7 @@
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
-         (type-specifier &optional lexenv-designator) type-specifier
+          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 \f
 ;;;; from the "Predicates" chapter:
   (unsafely-flushable))
 \f
 ;;;; from the "Predicates" chapter:
@@ -85,9 +69,9 @@
   (unsafely-flushable))
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
   (unsafely-flushable))
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
-               complexp characterp stringp bit-vector-p vectorp
-               simple-vector-p simple-string-p simple-bit-vector-p arrayp
-               sb!xc:packagep functionp compiled-function-p not)
+                complexp characterp stringp bit-vector-p vectorp
+                simple-vector-p simple-string-p simple-bit-vector-p arrayp
+                sb!xc:packagep functionp compiled-function-p not)
   (t) boolean (movable foldable flushable))
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))
   (t) boolean (movable foldable flushable))
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))
 (defknown copy-symbol (symbol &optional t) symbol (flushable))
 (defknown gensym (&optional (or string unsigned-byte)) symbol ())
 (defknown symbol-package (symbol) (or sb!xc:package null) (flushable))
 (defknown copy-symbol (symbol &optional t) symbol (flushable))
 (defknown gensym (&optional (or string unsigned-byte)) symbol ())
 (defknown symbol-package (symbol) (or sb!xc:package null) (flushable))
-(defknown keywordp (t) boolean (flushable))      ; If someone uninterns it...
+(defknown keywordp (t) boolean (flushable))       ; If someone uninterns it...
 \f
 ;;;; from the "Packages" chapter:
 
 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown make-package (string-designator &key
 \f
 ;;;; from the "Packages" chapter:
 
 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown make-package (string-designator &key
-                                         (:use list)
-                                         (:nicknames list)
-                                         ;; ### extensions...
-                                         (:internal-symbols index)
-                                         (:external-symbols index))
+                                          (:use list)
+                                          (:nicknames list)
+                                          ;; ### extensions...
+                                          (:internal-symbols index)
+                                          (:external-symbols index))
   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))
-(defknown (export import) (symbols-designator &optional package-designator) 
+(defknown (export import) (symbols-designator &optional package-designator)
   (eql t))
 (defknown unintern (symbol &optional package-designator) boolean)
 (defknown unexport (symbols-designator &optional package-designator) (eql t))
   (eql t))
 (defknown unintern (symbol &optional package-designator) boolean)
 (defknown unexport (symbols-designator &optional package-designator) (eql t))
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)
-         (values integer float-int-exponent (member -1 1))
-         (movable foldable flushable explicit-check))
+          (values integer float-int-exponent (member -1 1))
+          (movable foldable flushable explicit-check))
 
 (defknown complex (real &optional real) number
   (movable foldable flushable explicit-check))
 
 (defknown complex (real &optional real) number
   (movable foldable flushable explicit-check))
   (movable foldable flushable explicit-check))
 
 (defknown (lognand lognor logandc1 logandc2 logorc1 logorc2)
   (movable foldable flushable explicit-check))
 
 (defknown (lognand lognor logandc1 logandc2 logorc1 logorc2)
-         (integer integer) integer
+          (integer integer) integer
   (movable foldable flushable explicit-check))
 
 (defknown boole (boole-code integer integer) integer
   (movable foldable flushable explicit-check))
 
 (defknown boole (boole-code integer integer) integer
 \f
 ;;;; from the "Characters" chapter:
 (defknown (standard-char-p graphic-char-p alpha-char-p
 \f
 ;;;; from the "Characters" chapter:
 (defknown (standard-char-p graphic-char-p alpha-char-p
-                          upper-case-p lower-case-p both-case-p alphanumericp)
+                           upper-case-p lower-case-p both-case-p alphanumericp)
   (character) boolean (movable foldable flushable))
 
 (defknown digit-char-p (character &optional (integer 2 36))
   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
   (character) boolean (movable foldable flushable))
 
 (defknown digit-char-p (character &optional (integer 2 36))
   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
-                char-lessp char-greaterp char-not-greaterp char-not-lessp)
+                 char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 
 (defknown character (t) character (movable foldable unsafely-flushable))
   (character &rest character) boolean (movable foldable flushable))
 
 (defknown character (t) character (movable foldable unsafely-flushable))
   :derive-type #'result-type-first-arg)
 
 (defknown make-sequence (type-specifier index
   :derive-type #'result-type-first-arg)
 
 (defknown make-sequence (type-specifier index
-                                       &key
-                                       (:initial-element t))
+                                        &key
+                                        (:initial-element t))
   consed-sequence
   (movable unsafe)
   :derive-type (creation-result-type-specifier-nth-arg 1))
   consed-sequence
   (movable unsafe)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable
-                 sequence
-                 &key
-                 (:from-end t)
-                 (:start index)
-                 (:end sequence-end)
-                 (:initial-value t)
-                 (:key callable))
+                  sequence
+                  &key
+                  (:from-end t)
+                  (:start index)
+                  (:end sequence-end)
+                  (:initial-value t)
+                  (:key callable))
   t
   (foldable flushable call unsafe))
 
   t
   (foldable flushable call unsafe))
 
   :derive-type #'result-type-first-arg)
 
 (defknown replace (sequence
   :derive-type #'result-type-first-arg)
 
 (defknown replace (sequence
-                  sequence
-                  &key
-                  (:start1 index)
-                  (:end1 sequence-end)
-                  (:start2 index)
-                  (:end2 sequence-end))
+                   sequence
+                   &key
+                   (:start1 index)
+                   (:end1 sequence-end)
+                   (:start2 index)
+                   (:end2 sequence-end))
   sequence ()
   :derive-type #'result-type-first-arg)
 
   sequence ()
   :derive-type #'result-type-first-arg)
 
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:count sequence-count) (:key callable))
+            (:count sequence-count) (:key callable))
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:count sequence-count) (:key callable))
+            (:count sequence-count) (:key callable))
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown remove-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
 
 (defknown remove-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
-           (:from-end t) (:end sequence-end) (:key callable))
+            (:from-end t) (:end sequence-end) (:key callable))
   consed-sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
   consed-sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
-           (:from-end t) (:end sequence-end) (:key callable))
+            (:from-end t) (:end sequence-end) (:key callable))
   sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)
   sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)
-                 (:start index) (:from-end t) (:end sequence-end)
-                 (:key callable))
+                  (:start index) (:from-end t) (:end sequence-end)
+                  (:key callable))
   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+            (:key callable))
   t
   (foldable flushable call))
 
 (defknown position (t sequence &key (:test callable) (:test-not callable)
   t
   (foldable flushable call))
 
 (defknown position (t sequence &key (:test callable) (:test-not callable)
-                     (:start index) (:from-end t) (:end sequence-end)
-                     (:key callable))
+                      (:start index) (:from-end t) (:end sequence-end)
+                      (:key callable))
   (or index null)
   (foldable flushable call))
 
 (defknown (position-if position-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   (or index null)
   (foldable flushable call))
 
 (defknown (position-if position-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+            (:key callable))
   (or index null)
   (foldable flushable call))
 
 (defknown count (t sequence &key (:test callable) (:test-not callable)
   (or index null)
   (foldable flushable call))
 
 (defknown count (t sequence &key (:test callable) (:test-not callable)
-                     (:start index) (:from-end t) (:end sequence-end)
-                     (:key callable))
+                      (:start index) (:from-end t) (:end sequence-end)
+                      (:key callable))
   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+            (:key callable))
   index
   (foldable flushable call))
 
 (defknown (mismatch search)
   (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
   index
   (foldable flushable call))
 
 (defknown (mismatch search)
   (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
-           (:start1 index) (:end1 sequence-end)
-           (:start2 index) (:end2 sequence-end)
-           (:key callable))
+            (:start1 index) (:end1 sequence-end)
+            (:start2 index) (:end2 sequence-end)
+            (:key callable))
   (or index null)
   (foldable flushable call))
 
   (or index null)
   (foldable flushable call))
 
   (call))
 
 (defknown merge (type-specifier sequence sequence callable
   (call))
 
 (defknown merge (type-specifier sequence sequence callable
-                               &key (:key callable))
+                                &key (:key callable))
   sequence
   (call)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
   sequence
   (call)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
-                                 &key
-                                 (:start index)
-                                 (:end sequence-end))
+                                  &key
+                                  (:start index)
+                                  (:end sequence-end))
   (index)
   ())
 
 (defknown write-sequence (sequence stream
   (index)
   ())
 
 (defknown write-sequence (sequence stream
-                                  &key
-                                  (:start index)
-                                  (:end sequence-end))
+                                   &key
+                                   (:start index)
+                                   (:end sequence-end))
   sequence
   ()
   :derive-type (sequence-result-nth-arg 1))
   sequence
   ()
   :derive-type (sequence-result-nth-arg 1))
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
-                           (:test-not callable))
+                            (:test-not callable))
   t (flushable unsafe call))
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
   t (flushable unsafe call))
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
-         (t callable t &key (:key callable))
+          (t callable t &key (:key callable))
   t (flushable unsafe call))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
   t (flushable unsafe call))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
-                                (:test-not callable))
+                                 (:test-not callable))
   t (flushable unsafe call))
 
 (defknown member (t list &key (:key callable) (:test callable)
   t (flushable unsafe call))
 
 (defknown member (t list &key (:key callable) (:test callable)
-                   (:test-not callable))
+                    (:test-not callable))
   list (foldable flushable call))
 (defknown (member-if member-if-not) (callable list &key (:key callable))
   list (foldable flushable call))
   list (foldable flushable call))
 (defknown (member-if member-if-not) (callable list &key (:key callable))
   list (foldable flushable call))
 (defknown tailp (t list) boolean (foldable flushable))
 
 (defknown adjoin (t list &key (:key callable) (:test callable)
 (defknown tailp (t list) boolean (foldable flushable))
 
 (defknown adjoin (t list &key (:key callable) (:test callable)
-                   (:test-not callable))
+                    (:test-not callable))
   list (foldable flushable unsafe call))
 
 (defknown (union intersection set-difference set-exclusive-or)
   list (foldable flushable unsafe call))
 
 (defknown (union intersection set-difference set-exclusive-or)
 (defknown pairlis (t t &optional t) list (flushable unsafe))
 
 (defknown (rassoc assoc)
 (defknown pairlis (t t &optional t) list (flushable unsafe))
 
 (defknown (rassoc assoc)
-         (t list &key (:key callable) (:test callable) (:test-not callable))
+          (t list &key (:key callable) (:test callable) (:test-not callable))
   list (foldable flushable call))
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
   list (foldable flushable call))
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
-         (callable list &key (:key callable)) list (foldable flushable call))
+          (callable list &key (:key callable)) list (foldable flushable call))
 
 (defknown (memq assq) (t list) list (foldable flushable unsafe))
 (defknown delq (t list) list (flushable unsafe))
 
 (defknown (memq assq) (t list) list (foldable flushable unsafe))
 (defknown delq (t list) list (flushable unsafe))
 ;;;; from the "Arrays" chapter
 
 (defknown make-array ((or index list)
 ;;;; from the "Arrays" chapter
 
 (defknown make-array ((or index list)
-                     &key
-                     (:element-type type-specifier)
-                     (:initial-element t)
-                     (:initial-contents t)
-                     (:adjustable t)
-                     (:fill-pointer t)
-                     (:displaced-to (or array null))
-                     (:displaced-index-offset index))
+                      &key
+                      (:element-type type-specifier)
+                      (:initial-element t)
+                      (:initial-contents t)
+                      (:adjustable t)
+                      (:fill-pointer t)
+                      (:displaced-to (or array null))
+                      (:displaced-index-offset index))
   array (flushable unsafe))
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
   array (flushable unsafe))
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
-                  bit-orc1 bit-orc2)
+                   bit-orc1 bit-orc2)
   ((array bit) (array bit) &optional (or (array bit) (member t nil)))
   (array bit)
   ((array bit) (array bit) &optional (or (array bit) (member t nil)))
   (array bit)
-  (foldable)
+  ()
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))
   (array bit)
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))
   (array bit)
-  (foldable)
+  ()
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-vector-= (bit-vector bit-vector) boolean
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-vector-= (bit-vector bit-vector) boolean
 
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
 
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
-        (:initial-element t) (:initial-contents t)
-        (:fill-pointer t) (:displaced-to (or array null))
-        (:displaced-index-offset index))
+         (:initial-element t) (:initial-contents t)
+         (:fill-pointer t) (:displaced-to (or array null))
+         (:displaced-index-offset index))
   array (unsafe))
 ;  :derive-type 'result-type-arg1) Not even close...
 \f
   array (unsafe))
 ;  :derive-type 'result-type-arg1) Not even close...
 \f
 
 (defknown (string= string-equal)
   (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
 
 (defknown (string= string-equal)
   (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
-             (:start2 index) (:end2 sequence-end))
+              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))
 
 (defknown (string< string> string<= string>= string/= string-lessp
   boolean
   (foldable flushable))
 
 (defknown (string< string> string<= string>= string/= string-lessp
-                  string-greaterp string-not-lessp string-not-greaterp
-                  string-not-equal)
+                   string-greaterp string-not-lessp string-not-greaterp
+                   string-not-equal)
   (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
   (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
-             (:start2 index) (:end2 sequence-end))
+              (:start2 index) (:end2 sequence-end))
   (or index null)
   (foldable flushable))
 
 (defknown make-string (index &key (:element-type type-specifier)
   (or index null)
   (foldable flushable))
 
 (defknown make-string (index &key (:element-type type-specifier)
-                      (:initial-element character))
+                       (:initial-element character))
   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)
   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)
 (defknown make-string-input-stream (string &optional index sequence-end)
   stream
   (flushable unsafe))
 (defknown make-string-input-stream (string &optional index sequence-end)
   stream
   (flushable unsafe))
-(defknown make-string-output-stream 
-    (&key (:element-type type-specifier)) 
-    stream 
+(defknown make-string-output-stream
+    (&key (:element-type type-specifier))
+    stream
   (flushable))
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
   (flushable))
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
   (explicit-check))
 (defknown unread-char (character &optional stream-designator) t
   (explicit-check))
   (explicit-check))
 (defknown unread-char (character &optional stream-designator) t
   (explicit-check))
-(defknown peek-char (&optional (or character (member nil t)) 
-                              stream-designator t t t)
+(defknown peek-char (&optional (or character (member nil t))
+                               stream-designator t t t)
   t
   (explicit-check))
 (defknown listen (&optional stream-designator) boolean (flushable explicit-check))
   t
   (explicit-check))
 (defknown listen (&optional stream-designator) boolean (flushable explicit-check))
 
 (defknown read-from-string
   (string &optional t t
 
 (defknown read-from-string
   (string &optional t t
-         &key
-         (:start index)
-         (:end sequence-end)
-         (:preserve-whitespace t))
+          &key
+          (:start index)
+          (:end sequence-end)
+          (:preserve-whitespace t))
   (values t index))
 (defknown parse-integer
   (string &key
   (values t index))
 (defknown parse-integer
   (string &key
-         (:start index)
-         (:end sequence-end)
-         (:radix (integer 2 36))
-         (:junk-allowed t))
+          (:start index)
+          (:end sequence-end)
+          (:radix (integer 2 36))
+          (:junk-allowed t))
   (values (or integer null ()) index))
 
 (defknown read-byte (stream &optional t t) t (explicit-check))
   (values (or integer null ()) index))
 
 (defknown read-byte (stream &optional t t) t (explicit-check))
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
-(defknown (prin1 print princ) (t &optional stream-designator) 
-  t 
+(defknown (prin1 print princ) (t &optional stream-designator)
+  t
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 
-(defknown format ((or (member nil t) stream string) 
-                 (or string function) &rest t)
+(defknown format ((or (member nil t) stream string)
+                  (or string function) &rest t)
   (or string null)
   (explicit-check))
 
   (or string null)
   (explicit-check))
 
 ;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
 
 (defknown wild-pathname-p (pathname-designator
 ;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
 
 (defknown wild-pathname-p (pathname-designator
-                          &optional
-                          (member nil :host :device
-                                  :directory :name
-                                  :type :version))
+                           &optional
+                           (member nil :host :device
+                                   :directory :name
+                                   :type :version))
   generalized-boolean
   ())
 (defknown pathname-match-p (pathname-designator pathname-designator)
   generalized-boolean
   ())
 (defknown translate-pathname (pathname-designator
   generalized-boolean
   ())
 (defknown pathname-match-p (pathname-designator pathname-designator)
   generalized-boolean
   ())
 (defknown translate-pathname (pathname-designator
-                             pathname-designator
-                             pathname-designator &key)
+                              pathname-designator
+                              pathname-designator &key)
   pathname
   ())
 
   pathname
   ())
 
   (pathname-designator &optional
                        (or list host string (member :unspecific))
                        pathname-designator
   (pathname-designator &optional
                        (or list host string (member :unspecific))
                        pathname-designator
-                      &key
-                      (:start index)
-                      (:end sequence-end)
-                      (:junk-allowed t))
+                       &key
+                       (:start index)
+                       (:end sequence-end)
+                       (:junk-allowed t))
   (values (or pathname null) sequence-end)
   ())
 
   (values (or pathname null) sequence-end)
   ())
 
 (defknown pathnamep (t) boolean (movable flushable))
 
 (defknown pathname-host (pathname-designator
 (defknown pathnamep (t) boolean (movable flushable))
 
 (defknown pathname-host (pathname-designator
-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))
   pathname-host (flushable))
 (defknown pathname-device (pathname-designator
   pathname-host (flushable))
 (defknown pathname-device (pathname-designator
-                          &key (:case (member :local :common)))
+                           &key (:case (member :local :common)))
   pathname-device (flushable))
 (defknown pathname-directory (pathname-designator
   pathname-device (flushable))
 (defknown pathname-directory (pathname-designator
-                             &key (:case (member :local :common)))
+                              &key (:case (member :local :common)))
   pathname-directory (flushable))
 (defknown pathname-name (pathname-designator
   pathname-directory (flushable))
 (defknown pathname-name (pathname-designator
-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))
   pathname-name (flushable))
 (defknown pathname-type (pathname-designator
   pathname-name (flushable))
 (defknown pathname-type (pathname-designator
-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))
   pathname-type (flushable))
 (defknown pathname-version (pathname-designator)
   pathname-version (flushable))
   pathname-type (flushable))
 (defknown pathname-version (pathname-designator)
   pathname-version (flushable))
 
 (defknown open
   (pathname-designator &key
 
 (defknown open
   (pathname-designator &key
-                      (:direction (member :input :output :io :probe))
-                      (:element-type type-specifier)
-                      (:if-exists (member :error :new-version :rename
-                                          :rename-and-delete :overwrite
-                                          :append :supersede nil))
-                      (:if-does-not-exist (member :error :create nil))
-                      (:external-format keyword))
+                       (:direction (member :input :output :io :probe))
+                       (:element-type type-specifier)
+                       (:if-exists (member :error :new-version :rename
+                                           :rename-and-delete :overwrite
+                                           :append :supersede nil))
+                       (:if-does-not-exist (member :error :create nil))
+                       (:external-format keyword))
   (or stream null))
 
 (defknown rename-file (pathname-designator filename)
   (or stream null))
 
 (defknown rename-file (pathname-designator filename)
   ())
 
 (defknown file-position (stream &optional
   ())
 
 (defknown file-position (stream &optional
-                               (or unsigned-byte (member :start :end)))
+                                (or unsigned-byte (member :start :end)))
   (or unsigned-byte (member t nil)))
 (defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
 
   (or unsigned-byte (member t nil)))
 (defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
 
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))
-   (:external-format (member :default)))
+   (:external-format keyword))
   t)
 
 (defknown directory (pathname-designator &key)
   t)
 
 (defknown directory (pathname-designator &key)
   (values (or function symbol cons) boolean boolean))
 
 (defknown compile-file
   (values (or function symbol cons) boolean boolean))
 
 (defknown compile-file
-  (filename
+  (pathname-designator
    &key
 
    ;; ANSI options
    &key
 
    ;; ANSI options
-   (:output-file (or filename
-                    null
-                    ;; FIXME: This last case is a non-ANSI hack.
-                    (member t)))
+   (:output-file (or pathname-designator
+                     null
+                     ;; FIXME: This last case is a non-ANSI hack.
+                     (member t)))
    (:verbose t)
    (:print t)
    (:verbose t)
    (:print t)
-   (:external-format t)
+   (:external-format keyword)
 
    ;; extensions
    (:trace-file t)
 
    ;; extensions
    (:trace-file t)
 ;; FIXME: consider making (OR CALLABLE CONS) something like
 ;; EXTENDED-FUNCTION-DESIGNATOR
 (defknown disassemble ((or callable cons) &key
 ;; FIXME: consider making (OR CALLABLE CONS) something like
 ;; EXTENDED-FUNCTION-DESIGNATOR
 (defknown disassemble ((or callable cons) &key
-                      (:stream stream) (:use-labels t))
+                       (:stream stream) (:use-labels t))
   null)
 
 (defknown fdocumentation (t symbol)
   null)
 
 (defknown fdocumentation (t symbol)
 
 (defknown get-decoded-time ()
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
 
 (defknown get-decoded-time ()
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
-         (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
+          (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
   (flushable))
 
 (defknown get-universal-time () unsigned-byte (flushable))
 
 (defknown decode-universal-time
   (flushable))
 
 (defknown get-universal-time () unsigned-byte (flushable))
 
 (defknown decode-universal-time
-         (unsigned-byte &optional (or null (rational -24 24)))
+          (unsigned-byte &optional (or null (rational -24 24)))
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
-         (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
+          (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
   (flushable))
 
 (defknown encode-universal-time
   (flushable))
 
 (defknown encode-universal-time
 ;;; available, so -- unlike the related LISP-IMPLEMENTATION-FOO
 ;;; functions -- these really can return NIL.
 (defknown (machine-type machine-version machine-instance
 ;;; available, so -- unlike the related LISP-IMPLEMENTATION-FOO
 ;;; functions -- these really can return NIL.
 (defknown (machine-type machine-version machine-instance
-          software-type software-version
-          short-site-name long-site-name)
+           software-type software-version
+           short-site-name long-site-name)
   () (or simple-string null) (flushable))
 
 (defknown identity (t) t (movable foldable flushable unsafe)
   () (or simple-string null) (flushable))
 
 (defknown identity (t) t (movable foldable flushable unsafe)
 (defknown sb!impl::signal-bounding-indices-bad-error
     (sequence index sequence-end)
   nil) ; never returns
 (defknown sb!impl::signal-bounding-indices-bad-error
     (sequence index sequence-end)
   nil) ; never returns
-  
+
 
 (defknown arg-count-error (t t t t t t) nil (unsafe))
 \f
 
 (defknown arg-count-error (t t t t t t) nil (unsafe))
 \f
 (defknown sb!vm::pop-words-from-c-stack (index) (values) ())
 
 #!+linkage-table
 (defknown sb!vm::pop-words-from-c-stack (index) (values) ())
 
 #!+linkage-table
-(defknown foreign-symbol-dataref-address (simple-string)
+(defknown foreign-symbol-dataref-sap (simple-string)
   system-area-pointer
   (movable flushable))
 
   system-area-pointer
   (movable flushable))
 
-(defknown foreign-symbol-address (simple-string &optional boolean)
+(defknown foreign-symbol-sap (simple-string &optional boolean)
   system-area-pointer
   (movable flushable))
 
   system-area-pointer
   (movable flushable))
 
-(defknown foreign-symbol-address-as-integer (simple-string &optional boolean)
-  integer
+(defknown foreign-symbol-address (simple-string &optional boolean)
+  (values integer boolean)
   (movable flushable))
 
 ;;;; miscellaneous internal utilities
   (movable flushable))
 
 ;;;; miscellaneous internal utilities