X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcompiler%2Ffndb.lisp;h=704e7f0ba402ec0ef8c7e3aa3f36d8cc099f81f8;hb=d604a358d8e5eb5587989e0a4f1d31dbe6ac5ffe;hp=ca85fa77afce7ae4bdd30ac47dcc1dbc9d202de3;hpb=b953c186cfe68e48801cb54715da0120c9580888;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index ca85fa7..704e7f0 100644
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -17,24 +17,8 @@
 
 (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.
   )
@@ -44,8 +28,8 @@
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
-(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)
-	  (type-specifier &optional lexenv-designator) type-specifier
+(defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
+          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 
 ;;;; from the "Predicates" chapter:
@@ -85,9 +69,9 @@
   (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))
@@ -181,21 +165,18 @@
 (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...
 
 ;;;; from the "Packages" chapter:
 
-(sb!xc:deftype package-designator () '(or stringable sb!xc:package))
-(sb!xc:deftype symbols () '(or list symbol))
-
 (defknown gentemp (&optional string package-designator) symbol)
 
-(defknown make-package (stringable &key
-				   (:use list)
-				   (:nicknames list)
-				   ;; ### extensions...
-				   (:internal-symbols index)
-				   (:external-symbols index))
+(defknown make-package (string-designator &key
+                                          (: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))
@@ -214,15 +195,17 @@
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))
-(defknown (export import) (symbols &optional package-designator) (eql t))
+(defknown (export import) (symbols-designator &optional package-designator)
+  (eql t))
 (defknown unintern (symbol &optional package-designator) boolean)
-(defknown unexport (symbols &optional package-designator) (eql t))
-(defknown shadowing-import (symbols &optional package-designator) (eql t))
+(defknown unexport (symbols-designator &optional package-designator) (eql t))
+(defknown shadowing-import (symbols-designator &optional package-designator)
+  (eql t))
 (defknown shadow ((or symbol string list) &optional package-designator)
   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))
-(defknown find-all-symbols (stringable) list (flushable))
+(defknown find-all-symbols (string-designator) list (flushable))
 
 ;;;; from the "Numbers" chapter:
 
@@ -336,22 +319,22 @@
   (movable foldable flushable explicit-check))
 
 (defknown (ffloor fceiling fround ftruncate)
-  (real &optional real) (values float float)
+  (real &optional real) (values float real)
   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)
   (movable foldable flushable explicit-check))
-(defknown scale-float (float float-exponent) float
+(defknown scale-float (float integer) float
   (movable foldable unsafely-flushable explicit-check))
 (defknown float-radix (float) float-radix
-  (movable foldable flushable explicit-check))
+  (movable foldable flushable))
 (defknown float-sign (float &optional float) float
   (movable foldable flushable explicit-check))
 (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))
@@ -362,7 +345,7 @@
   (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
@@ -370,7 +353,7 @@
 
 (defknown lognot (integer) integer (movable foldable flushable explicit-check))
 (defknown logtest (integer integer) boolean (movable foldable flushable))
-(defknown logbitp (bit-index integer) boolean (movable foldable flushable))
+(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (defknown (logcount integer-length) (integer) bit-index
@@ -393,21 +376,22 @@
   (movable foldable flushable))
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))
-(defknown random ((real (0)) &optional random-state) (real 0) ())
+(defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
+  (or (float 0.0) (integer 0)) ())
 (defknown make-random-state (&optional (or (member nil t) random-state))
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))
 
 ;;;; 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
-		 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))
@@ -419,9 +403,9 @@
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)
   (movable foldable flushable))
-(defknown name-char (stringable) (or character null)
+(defknown name-char (string-designator) (or character null)
   (movable foldable flushable))
-(defknown code-char (char-code) base-char
+(defknown code-char (char-code) character
   ;; By suppressing constant folding on CODE-CHAR when the
   ;; cross-compiler is running in the cross-compilation host vanilla
   ;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until
@@ -451,8 +435,8 @@
   :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))
@@ -488,13 +472,13 @@
 
 ;;; 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))
 
@@ -503,12 +487,12 @@
   :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)
 
@@ -530,7 +514,7 @@
 
 (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))
@@ -560,7 +544,7 @@
 
 (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))
@@ -574,59 +558,59 @@
 
 (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)
-	    (: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)
-		  (: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)
-	    (:key callable))
+            (:key 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)
-	    (:key callable))
+            (:key 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)
-	    (:key callable))
+            (:key 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))
 
@@ -639,23 +623,23 @@
   (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
-				  &key
-				  (:start index)
-				  (:end sequence-end))
+                                  &key
+                                  (:start index)
+                                  (:end sequence-end))
   (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))
@@ -713,19 +697,19 @@
 (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 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)
-				 (:test-not callable))
+                                 (:test-not 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))
@@ -733,7 +717,7 @@
 (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)
@@ -755,10 +739,10 @@
 (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)
-	  (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))
@@ -787,19 +771,19 @@
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
 (defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
-  (foldable flushable))
+  (#-sb-xc-host foldable flushable))
 
 ;;;; 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))
@@ -824,15 +808,15 @@
 (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)
-  (foldable)
+  ()
   #|: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
@@ -847,9 +831,9 @@
 
 (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...
 
@@ -858,49 +842,47 @@
 (defknown char (string index) character (foldable flushable))
 (defknown schar (simple-string index) character (foldable flushable))
 
-(sb!xc:deftype stringable () '(or character string symbol))
-
 (defknown (string= string-equal)
-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
-	      (:start2 index) (:end2 sequence-end))
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
+              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))
 
 (defknown (string< string> string<= string>= string/= string-lessp
-		   string-greaterp string-not-lessp string-not-greaterp
-		   string-not-equal)
-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
-	      (:start2 index) (:end2 sequence-end))
+                   string-greaterp string-not-lessp string-not-greaterp
+                   string-not-equal)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
+              (:start2 index) (:end2 sequence-end))
   (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)
-  (sequence stringable) simple-string (flushable))
+  (sequence string-designator) simple-string (flushable))
 
 (defknown (string-upcase string-downcase string-capitalize)
-  (stringable &key (:start index) (:end sequence-end))
+  (string-designator &key (:start index) (:end sequence-end))
   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))
   string ())
 
-(defknown string (stringable) string
+(defknown string (string-designator) string
   (flushable explicit-check))
 
 ;;;; internal non-keyword versions of string predicates:
 
 (defknown (string<* string>* string<=* string>=* string/=*)
-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)
   (or index null)
   (foldable flushable))
 
 (defknown string=*
-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)
   boolean
   (foldable flushable))
 
@@ -917,11 +899,12 @@
 (defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
 (defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))
-(defknown make-string-input-stream (string &optional index index) stream
+(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))
@@ -961,43 +944,79 @@
   (character character &optional (or readtable null)) (or callable null)
   ())
 
+(defknown copy-pprint-dispatch
+  (&optional (or sb!pretty:pprint-dispatch-table null))
+  sb!pretty:pprint-dispatch-table
+  ())
+(defknown pprint-dispatch
+  (t &optional (or sb!pretty:pprint-dispatch-table null))
+  (values callable boolean)
+  ())
+(defknown (pprint-fill pprint-linear)
+  (stream-designator t &optional t t)
+  null
+  ())
+(defknown pprint-tabular
+  (stream-designator t &optional t t unsigned-byte)
+  null
+  ())
+(defknown pprint-indent
+  ((member :block :current) real &optional stream-designator)
+  null
+  ())
+(defknown pprint-newline
+  ((member :linear :fill :miser :mandatory) &optional stream-designator)
+  null
+  ())
+(defknown pprint-tab
+  ((member :line :section :line-relative :section-relative)
+   unsigned-byte unsigned-byte &optional stream-designator)
+  null
+  ())
+(defknown set-pprint-dispatch
+  (type-specifier (or null callable)
+   &optional real sb!pretty:pprint-dispatch-table)
+  null
+  ())
+
 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
-  (&optional streamlike t t t) t (explicit-check))
+  (&optional stream-designator t t t) t (explicit-check))
 
-(defknown read-delimited-list (character &optional streamlike t) list
+(defknown read-delimited-list (character &optional stream-designator t) list
   (explicit-check))
-(defknown read-line (&optional streamlike t t t) (values t boolean)
+(defknown read-line (&optional stream-designator t t t) (values t boolean)
   (explicit-check))
-(defknown unread-char (character &optional streamlike) t
+(defknown unread-char (character &optional stream-designator) t
   (explicit-check))
-(defknown peek-char (&optional (or character (member nil t)) streamlike t t t)
+(defknown peek-char (&optional (or character (member nil t))
+                               stream-designator t t t)
   t
   (explicit-check))
-(defknown listen (&optional streamlike) boolean (flushable explicit-check))
+(defknown listen (&optional stream-designator) boolean (flushable explicit-check))
 
-(defknown clear-input (&optional stream) null (explicit-check))
+(defknown clear-input (&optional stream-designator) null (explicit-check))
 
 (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
-	  (: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))
 
 (defknown write
   (t &key
-     (:stream streamlike)
+     (:stream stream-designator)
      (:escape t)
      (:radix t)
      (:base (integer 2 36))
@@ -1017,11 +1036,14 @@
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
-(defknown (prin1 print princ) (t &optional streamlike) t (any explicit-check)
+(defknown (prin1 print princ) (t &optional stream-designator)
+  t
+  (any explicit-check)
   :derive-type #'result-type-first-arg)
 
 ;;; xxx-TO-STRING functions are not foldable because they depend on
-;;; the dynamic environment.
+;;; the dynamic environment, the state of the pretty printer dispatch
+;;; table, and probably other run-time factors.
 (defknown write-to-string
   (t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
      (:circle t) (:pretty t) (:level (or unsigned-byte null))
@@ -1029,28 +1051,29 @@
      (:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
   simple-string
-  (foldable flushable explicit-check))
+  (flushable explicit-check))
 
 (defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
 
-(defknown write-char (character &optional streamlike) character
+(defknown write-char (character &optional stream-designator) character
   (explicit-check))
 (defknown (write-string write-line)
-  (string &optional streamlike &key (:start index) (:end sequence-end))
+  (string &optional stream-designator &key (:start index) (:end sequence-end))
   string
   (explicit-check))
 
 (defknown (terpri finish-output force-output clear-output)
-  (&optional streamlike) null
+  (&optional stream-designator) null
   (explicit-check))
 
-(defknown fresh-line (&optional streamlike) boolean
+(defknown fresh-line (&optional stream-designator) boolean
   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 
-(defknown format ((or streamlike string) (or string function) &rest t)
+(defknown format ((or (member nil t) stream string)
+                  (or string function) &rest t)
   (or string null)
   (explicit-check))
 
@@ -1065,18 +1088,18 @@
 ;;; 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
-			      pathname-designator
-			      pathname-designator &key)
+                              pathname-designator
+                              pathname-designator &key)
   pathname
   ())
 
@@ -1093,10 +1116,10 @@
   (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)
   ())
 
@@ -1118,19 +1141,19 @@
 (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
-			   &key (:case (member :local :common)))
+                           &key (:case (member :local :common)))
   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
-			 &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))
   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))
@@ -1147,13 +1170,13 @@
 
 (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 (member :default)))
+                       (: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)
@@ -1166,7 +1189,7 @@
   ())
 
 (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))
 
@@ -1176,7 +1199,7 @@
    (: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)
@@ -1218,17 +1241,17 @@
   (values (or function symbol cons) boolean boolean))
 
 (defknown compile-file
-  (filename
+  (pathname-designator
    &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)
-   (:external-format t)
+   (:external-format keyword)
 
    ;; extensions
    (:trace-file t)
@@ -1238,7 +1261,7 @@
 ;; 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)
@@ -1248,25 +1271,25 @@
 (defknown describe (t &optional (or stream (member t nil))) (values))
 (defknown inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))
-(defknown ed (&optional (or symbol cons filename) &key (:init t) (:display t))
+(defknown ed (&optional (or symbol cons filename))
   t)
 (defknown dribble (&optional filename &key (:if-exists t)) (values))
 
-(defknown apropos      (stringable &optional package-designator t) (values))
-(defknown apropos-list (stringable &optional package-designator t) list
+(defknown apropos      (string-designator &optional package-designator t) (values))
+(defknown apropos-list (string-designator &optional package-designator t) list
   (flushable))
 
 (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
-	  (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)
-	  (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
@@ -1291,8 +1314,8 @@
 ;;; 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)
@@ -1304,6 +1327,8 @@
 ;;;; miscellaneous extensions
 
 (defknown get-bytes-consed () unsigned-byte (flushable))
+(defknown mask-signed-field ((integer 0 *) integer) integer
+          (movable flushable foldable))
 
 ;;; PCOUNTERs
 (defknown incf-pcounter (pcounter unsigned-byte) pcounter)
@@ -1340,10 +1365,12 @@
 (defknown %nlx-entry (t) *)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
+(defknown %nip-values (t t &rest t) (values))
+(defknown %allocate-closures (t) *)
 (defknown %type-check-error (t t) nil)
 
 ;; FIXME: This function does not return, but due to the implementation
-;; of FILTER-CONTINUATION we cannot write it here.
+;; of FILTER-LVAR we cannot write it here.
 (defknown %compile-time-type-error (t t t) *)
 
 (defknown %odd-key-args-error () nil)
@@ -1393,7 +1420,7 @@
 (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))
 
@@ -1419,6 +1446,26 @@
 (defknown %setnth (unsigned-byte list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
 
+;;;; ALIEN and call-out-to-C stuff
+
+;;; 'unsafe' attribute because we store the arg on the stack, which is in
+;;; some sense 'passing it upwards'
+(defknown sb!vm::push-word-on-c-stack (system-area-pointer) (values) (unsafe))
+(defknown sb!vm::pop-words-from-c-stack (index) (values) ())
+
+#!+linkage-table
+(defknown foreign-symbol-dataref-sap (simple-string)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-sap (simple-string &optional boolean)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-address (simple-string &optional boolean)
+  (values integer boolean)
+  (movable flushable))
+
 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
@@ -1433,3 +1480,4 @@
   (values)
   ())
 (defknown style-warn (string &rest t) null ())
+