X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=a3d4f156be4cc8cf4928bfb433c832e8a4fff111;hb=dfa55a883f94470267b626dae77ce7e7dfac3df6;hp=5c8df94bfbced5619487ec02dde6396c461cbd51;hpb=a8f2656f635d81ec326303f47e0612fb1f35fd91;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 5c8df94..a3d4f15 100644
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -32,6 +32,8 @@
   ;;	       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)
   :derive-type (result-type-specifier-nth-arg 2))
 (defknown list-to-simple-string* (list) simple-string)
@@ -56,7 +58,7 @@
 ;;; FIXNUMness) might be different between host and target. Perhaps
 ;;; this property should be protected by #-SB-XC-HOST? Perhaps we need
 ;;; 3-stage bootstrapping after all? (Ugh! It's *so* slow already!)
-(defknown typep (t type-specifier) boolean
+(defknown typep (t type-specifier) t
   (flushable
    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
@@ -95,7 +97,7 @@
 
 ;;;; classes
 
-(sb!xc:deftype name-for-class () 't)
+(sb!xc:deftype name-for-class () t)
 (defknown class-name (sb!xc:class) name-for-class (flushable))
 (defknown find-class (name-for-class &optional t lexenv)
   (or sb!xc:class null) ())
@@ -182,7 +184,7 @@
 (defknown make-package (stringable &key
 				   (:use list)
 				   (:nicknames list)
-				   ;; ### Extensions...
+				   ;; ### extensions...
 				   (:internal-symbols index)
 				   (:external-symbols index))
   sb!xc:package)
@@ -207,8 +209,10 @@
 (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 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 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))
 
 ;;;; from the "Numbers" chapter:
@@ -245,12 +249,12 @@
 (defknown lcm (&rest integer) unsigned-byte
   (movable foldable flushable explicit-check))
 
-#!-propagate-fun-type
+#!-sb-propagate-fun-type
 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive)
   :derive-type #'result-type-float-contagion)
 
-#!+propagate-fun-type
+#!+sb-propagate-fun-type
 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive))
 
@@ -268,7 +272,7 @@
 (defknown cis (real) (complex float)
   (movable foldable flushable explicit-check))
 
-#!-propagate-fun-type
+#!-sb-propagate-fun-type
 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))
@@ -285,7 +289,7 @@
   :derive-type #'result-type-float-contagion)
 ) ; PROGN
 
-#!+propagate-fun-type
+#!+sb-propagate-fun-type
 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))
@@ -358,7 +362,8 @@
 (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 ash (integer integer) integer (movable foldable flushable explicit-check))
+(defknown ash (integer integer) integer
+  (movable foldable flushable explicit-check))
 (defknown (logcount integer-length) (integer) bit-index
   (movable foldable flushable explicit-check))
 ;;; FIXME: According to the ANSI spec, it's legal to use any
@@ -447,7 +452,8 @@
   (flushable)
   :derive-type (result-type-specifier-nth-arg 1))
 
-(defknown (map %map) (type-specifier callable sequence &rest sequence) consed-sequence
+(defknown (map %map) (type-specifier callable sequence &rest sequence)
+  consed-sequence
   (flushable call)
 ; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
   )
@@ -553,21 +559,22 @@
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown remove-duplicates
-  (sequence &key (:test callable) (:test-not callable) (:start index) (:from-end t)
-	    (:end sequence-end) (:key callable))
+  (sequence &key (:test callable) (:test-not callable) (:start index)
+	    (:from-end t) (:end sequence-end) (:key callable))
   consed-sequence
   (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))
+  (sequence &key (:test callable) (:test-not callable) (:start index)
+	    (:from-end t) (:end sequence-end) (:key callable))
   sequence
   (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))
 
@@ -603,7 +610,8 @@
 
 (defknown (mismatch search)
   (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
-	    (:start1 index) (:end1 sequence-end) (:start2 index) (:end2 sequence-end)
+	    (:start1 index) (:end1 sequence-end)
+	    (:start2 index) (:end2 sequence-end)
 	    (:key callable))
   (or index null)
   (foldable flushable call))
@@ -659,7 +667,8 @@
 (defknown make-list (index &key (:initial-element t)) list
   (movable flushable unsafe))
 
-;;; All but last must be list...
+;;; All but last must be of type LIST, but there seems to be no way to
+;;; express that in this syntax..
 (defknown append (&rest t) t (flushable))
 
 (defknown copy-list (list) list (flushable))
@@ -698,17 +707,17 @@
   list (foldable flushable unsafe call))
 
 (defknown (union intersection set-difference set-exclusive-or)
-	  (list list &key (:key callable) (:test callable) (:test-not callable))
+  (list list &key (:key callable) (:test callable) (:test-not callable))
   list
   (foldable flushable call))
 
 (defknown (nunion nintersection nset-difference nset-exclusive-or)
-	  (list list &key (:key callable) (:test callable) (:test-not callable))
+  (list list &key (:key callable) (:test callable) (:test-not callable))
   list
   (foldable flushable call))
 
 (defknown subsetp
-	  (list list &key (:key callable) (:test callable) (:test-not callable))
+  (list list &key (:key callable) (:test callable) (:test-not callable))
   boolean
   (foldable flushable call))
 
@@ -796,7 +805,8 @@
   (foldable)
   #|:derive-type #'result-type-last-arg|#)
 
-(defknown array-has-fill-pointer-p (array) boolean (movable foldable flushable))
+(defknown array-has-fill-pointer-p (array) boolean
+  (movable foldable flushable))
 (defknown fill-pointer (vector) index (foldable flushable))
 (defknown vector-push (t vector) (or index null) ())
 (defknown vector-push-extend (t vector &optional index) index ())
@@ -874,22 +884,25 @@
 (defknown make-concatenated-stream (&rest stream) stream (flushable))
 (defknown make-two-way-stream (stream stream) stream (flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))
-(defknown make-string-input-stream (string &optional index index) stream (flushable unsafe))
+(defknown make-string-input-stream (string &optional index index) stream
+  (flushable unsafe))
 (defknown make-string-output-stream () stream (flushable))
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
-(defknown stream-element-type (stream) type-specifier (movable foldable flushable))
-(defknown (output-stream-p input-stream-p) (stream) boolean (movable foldable
-								     flushable))
-(defknown close (stream &key (:abort t)) stream ())
+(defknown stream-element-type (stream) type-specifier
+  (movable foldable flushable))
+(defknown (output-stream-p input-stream-p) (stream) boolean
+  (movable foldable flushable))
+(defknown close (stream &key (:abort t)) (eql t) ())
 
 ;;;; from the "Input/Output" chapter:
 
-;;; The I/O functions are currently given effects ANY under the theory
-;;; that code motion over I/O operations is particularly confusing and
-;;; not very important for efficency.
+;;; (The I/O functions are given effects ANY under the theory that
+;;; code motion over I/O operations is particularly confusing and not
+;;; very important for efficiency.)
 
-(defknown copy-readtable (&optional (or readtable null) readtable) readtable
+(defknown copy-readtable (&optional (or readtable null) (or readtable null))
+  readtable
   ())
 (defknown readtablep (t) boolean (movable foldable flushable))
 
@@ -897,23 +910,24 @@
   (character character &optional (or readtable null) readtable) (eql t)
   ())
 
-(defknown set-macro-character (character callable &optional t readtable) (eql t)
+(defknown set-macro-character (character callable &optional t readtable)
+  (eql t)
   (unsafe))
-(defknown get-macro-character (character &optional readtable)
+(defknown get-macro-character (character &optional (or readtable null))
   (values callable boolean) (flushable))
 
 (defknown make-dispatch-macro-character (character &optional t readtable)
   (eql t) ())
 (defknown set-dispatch-macro-character
-  (character character callable &optional readtable) (eql t)
+  (character character callable &optional readtable) function
   (unsafe))
 (defknown get-dispatch-macro-character
-  (character character &optional readtable) callable
+  (character character &optional (or readtable null)) callable
   (flushable))
 
 ;;; 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 streamlike t t t) t (explicit-check))
 
 (defknown read-delimited-list (character &optional streamlike t) t
   (explicit-check))
@@ -1028,27 +1042,23 @@
   pathname
   (flushable))
 
-;;; FIXME: What about logical pathname stuff?
-;;;   LOGICAL-PATHNAME
-;;;   TRANSLATE-LOGICAL-PATHNAME
-;;;   LOAD-LOGICAL-PATHNAME-TRANSLATIONS
-;;;   LOGICAL-PATHNAME-TRANSLATIONS
+(defknown logical-pathname (pathname-designator) logical-pathname ())
+(defknown translate-logical-pathname (pathname-designator &key) pathname ())
+(defknown load-logical-pathname-translations (string) t ())
+(defknown logical-pathname-translations (logical-host-designator) list ())
 
 (defknown pathname (pathname-designator) pathname (flushable))
 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
   (pathname-designator &optional
-		       ;; ANSI also allows LIST here, but leaves its
-		       ;; interpretation implementation-defined. Our
-		       ;; interpretation is that it's unsupported.:-|
-                       (or pathname-host string (member :unspecific))
+                       (or list host string (member :unspecific))
                        pathname-designator
 		       &key
 		       (:start index)
 		       (:end sequence-end)
 		       (:junk-allowed t))
-  (values (or pathname null) index)
+  (values (or pathname null) sequence-end)
   ())
 
 (defknown merge-pathnames
@@ -1175,11 +1185,10 @@
 
 (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))
   t)
-(defknown dribble (&optional filename &key (:if-exists t)) 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
@@ -1227,8 +1236,7 @@
 (defknown identity (t) t (movable foldable flushable unsafe)
   :derive-type #'result-type-first-arg)
 
-;;; &OPTIONAL is to agree with the optimization in the interpreter stub.
-(defknown constantly (t &optional t t &rest t) function (movable flushable))
+(defknown constantly (t) function (movable flushable))
 (defknown complement (function) function (movable flushable))
 
 ;;;; magical compiler frobs
@@ -1260,17 +1268,19 @@
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
 (defknown %type-check-error (t t) nil)
-(defknown %odd-keyword-arguments-error () nil)
-(defknown %unknown-keyword-argument-error (t) nil)
+(defknown %odd-key-arguments-error () nil)
+(defknown %unknown-key-argument-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
   (movable foldable flushable explicit-check))
 (defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer
   (movable foldable flushable explicit-check))
 (defknown %negate (number) number (movable foldable flushable explicit-check))
 (defknown %check-bound (array index fixnum) index (movable foldable flushable))
-(defknown data-vector-ref (simple-array index) t (foldable flushable explicit-check))
+(defknown data-vector-ref (simple-array index) t
+  (foldable flushable explicit-check))
 (defknown data-vector-set (array index t) t (unsafe explicit-check))
-(defknown hairy-data-vector-ref (array index) t (foldable flushable explicit-check))
+(defknown hairy-data-vector-ref (array index) t
+  (foldable flushable explicit-check))
 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
 (defknown sb!kernel:%caller-frame-and-pc () (values t t) (flushable))
 (defknown sb!kernel:%with-array-data (array index (or index null))
@@ -1285,8 +1295,7 @@
 ;;; describing the actual function called.
 ;;;
 ;;; FIXME: It would be nice to make structure slot accessors be
-;;; ordinary functions (proclaimed as SB-EXT:CONSTANT-FUNCTION, but
-;;; otherwise ordinary).
+;;; ordinary functions.
 (defknown %slot-accessor (t) t (flushable))
 (defknown %slot-setter (t t) t (unsafe))