X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=5d060478a174b2ae07efa1cf7f846e7ebc3e318c;hb=627c66211b93537e90c08b34b387edbd7e301011;hp=72bab464fec14786d572bc6058baf41432893665;hpb=80304981972c91c1b3f3fca75f36dacf1fecf307;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 72bab46..5d06047 100644
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -36,19 +36,15 @@
   ;; 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)
-(defknown list-to-bit-vector* (list) bit-vector)
-(defknown list-to-vector* (list type) vector)
-(defknown list-to-simple-vector* (list) simple-vector)
-(defknown vector-to-vector* (vector type) vector)
-(defknown vector-to-simple-string* (vector) vector)
+(defknown list-to-vector* (list type-specifier) vector)
+(defknown vector-to-vector* (vector type-specifier) vector)
 
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown (upgraded-complex-part-type upgraded-array-element-type)
 	  (type-specifier) type-specifier
-  (flushable))
+  (unsafely-flushable))
 
 ;;;; from the "Predicates" chapter:
 
@@ -59,7 +55,6 @@
 ;;; 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) t
-  (flushable
    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
    ;; definitions, but unlike SUBTYPEP, there should be no way to make
@@ -77,14 +72,14 @@
    ;;
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
-   foldable))
-(defknown subtypep (type-specifier type-specifier) (values boolean boolean) 
+   (foldable))
+(defknown subtypep (type-specifier type-specifier) (values boolean boolean)
   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
   ;; FIXME: Is it OK to fold this when the types have already been
   ;; defined? Does the code inherited from CMU CL already do this?
-  (flushable)) 
+  (unsafely-flushable))
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
 		complexp characterp stringp bit-vector-p vectorp
@@ -113,10 +108,10 @@
 (defknown (symbol-value symbol-function) (symbol) t ())
 
 (defknown boundp (symbol) boolean (flushable))
-(defknown fboundp ((or symbol cons)) boolean (flushable explicit-check))
+(defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.
-  (movable foldable flushable)) 
+  (movable foldable flushable))
 (defknown set (symbol t) t (unsafe)
   :derive-type #'result-type-last-arg)
 (defknown fdefinition ((or symbol cons)) function (unsafe explicit-check))
@@ -141,7 +136,7 @@
 ;;; it into VALUES. VALUES is not foldable, since MV constants are
 ;;; represented by a call to VALUES.
 (defknown values (&rest t) * (movable flushable unsafe))
-(defknown values-list (list) * (movable foldable flushable))
+(defknown values-list (list) * (movable foldable unsafely-flushable))
 
 ;;;; from the "Macros" chapter:
 
@@ -178,7 +173,6 @@
 (sb!xc:deftype package-designator () '(or stringable sb!xc:package))
 (sb!xc:deftype symbols () '(or list symbol))
 
-;;; Should allow a package name, I think, tho CLtL II doesn't say so...
 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown make-package (stringable &key
@@ -191,13 +185,13 @@
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
 (defknown package-name (package-designator) (or simple-string null)
-  (flushable))
-(defknown package-nicknames (package-designator) list (flushable))
+  (unsafely-flushable))
+(defknown package-nicknames (package-designator) list (unsafely-flushable))
 (defknown rename-package (package-designator package-designator &optional list)
   sb!xc:package)
-(defknown package-use-list (package-designator) list (flushable))
-(defknown package-used-by-list (package-designator) list (flushable))
-(defknown package-shadowing-symbols (package-designator) list (flushable))
+(defknown package-use-list (package-designator) list (unsafely-flushable))
+(defknown package-used-by-list (package-designator) list (unsafely-flushable))
+(defknown package-shadowing-symbols (package-designator) list (unsafely-flushable))
 (defknown list-all-packages () list (flushable))
 (defknown intern (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
@@ -281,7 +275,7 @@
 
 (defknown atan
   (number &optional real) irrational
-  (movable foldable flushable explicit-check recursive)
+  (movable foldable unsafely-flushable explicit-check recursive)
   :derive-type #'result-type-float-contagion)
 
 (defknown (tan sinh cosh tanh asinh)
@@ -297,7 +291,7 @@
 
 (defknown atan
   (number &optional real) irrational
-  (movable foldable flushable explicit-check recursive))
+  (movable foldable unsafely-flushable explicit-check recursive))
 
 (defknown (tan sinh cosh tanh asinh)
   (number) irrational (movable foldable flushable explicit-check recursive))
@@ -401,7 +395,7 @@
 		 char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 
-(defknown character (t) character (movable foldable flushable))
+(defknown character (t) character (movable foldable unsafely-flushable))
 (defknown char-code (character) char-code (movable foldable flushable))
 (defknown (char-upcase char-downcase) (character) character
   (movable foldable flushable))
@@ -424,7 +418,7 @@
 
 ;;;; from the "Sequences" chapter:
 
-(defknown elt (sequence index) t (foldable flushable))
+(defknown elt (sequence index) t (foldable unsafely-flushable))
 
 (defknown subseq (sequence index &optional sequence-end) consed-sequence
   (flushable)
@@ -445,16 +439,16 @@
 					&key
 					(:initial-element t))
   consed-sequence
-  (movable flushable unsafe)
+  (movable unsafe)
   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
-  (flushable)
+  ()
   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence
-  (flushable call)
+  (call)
 ; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
   )
 (defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
@@ -467,10 +461,10 @@
 
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t
-  (foldable flushable call))
+  (foldable unsafely-flushable call))
 
 (defknown (every notany notevery) (callable sequence &rest sequence) boolean
-  (foldable flushable call))
+  (foldable unsafely-flushable call))
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable
@@ -562,14 +556,14 @@
   (sequence &key (:test callable) (:test-not callable) (:start index)
 	    (:from-end t) (:end sequence-end) (:key callable))
   consed-sequence
-  (flushable call)
+  (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))
   sequence
-  (flushable call)
+  (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)
@@ -624,7 +618,7 @@
 (defknown merge (type-specifier sequence sequence callable
 				&key (:key callable))
   sequence
-  (flushable call)
+  (call)
   :derive-type (result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
@@ -644,23 +638,28 @@
   :derive-type (sequence-result-nth-arg 1))
 
 ;;;; from the "Manipulating List Structure" chapter:
-(defknown (car cdr caar cadr cdar cddr
-	       caaar caadr cadar caddr cdaar cdadr cddar cdddr
-	       caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
-	       cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
-	       first second third fourth fifth sixth seventh eighth ninth tenth
-	       rest)
+(defknown (car cdr first rest)
   (list)
   t
   (foldable flushable))
 
+(defknown (caar cadr cdar cddr
+                caaar caadr cadar caddr cdaar cdadr cddar cdddr
+                caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
+                cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+                second third fourth fifth sixth seventh eighth ninth tenth)
+  (list)
+  t
+  (foldable unsafely-flushable))
+
 (defknown cons (t t) cons (movable flushable unsafe))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))
-(defknown endp (t) boolean (foldable flushable movable))
-(defknown list-length (list) (or index null) (foldable flushable))
-(defknown (nth nthcdr) (index list) t (foldable flushable))
+(defknown endp (t) boolean (foldable unsafely-flushable movable))
+(defknown list-length (list) (or index null) (foldable unsafely-flushable))
+(defknown nth (index list) t (foldable flushable))
+(defknown nthcdr (index list) t (foldable unsafely-flushable))
 (defknown last (list &optional index) list (foldable flushable))
 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
@@ -756,7 +755,7 @@
   (foldable flushable))
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
-(defknown sxhash (t) (integer 0 #.sb!vm:*target-most-positive-fixnum*)
+(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
   (foldable flushable))
 
 ;;;; from the "Arrays" chapter
@@ -807,7 +806,7 @@
 
 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
-(defknown fill-pointer (vector) index (foldable flushable))
+(defknown fill-pointer (vector) index (foldable unsafely-flushable))
 (defknown vector-push (t vector) (or index null) ())
 (defknown vector-push-extend (t vector &optional index) index ())
 (defknown vector-pop (vector) t ())
@@ -880,9 +879,9 @@
 ;;;; from the "Streams" chapter:
 
 (defknown make-synonym-stream (symbol) stream (flushable))
-(defknown make-broadcast-stream (&rest stream) stream (flushable))
-(defknown make-concatenated-stream (&rest stream) stream (flushable))
-(defknown make-two-way-stream (stream stream) stream (flushable))
+(defknown make-broadcast-stream (&rest stream) stream (unsafely-flushable))
+(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
   (flushable unsafe))
@@ -922,8 +921,8 @@
   (character character callable &optional readtable) function
   (unsafe))
 (defknown get-dispatch-macro-character
-  (character character &optional (or readtable null)) callable
-  (flushable))
+  (character character &optional (or readtable null)) (or callable null)
+  ())
 
 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
@@ -1025,7 +1024,8 @@
 
 ;;; (No pathname functions are FOLDABLE because they all potentially
 ;;; depend on *DEFAULT-PATHNAME-DEFAULTS*, e.g. to provide a default
-;;; host when parsing a namestring.)
+;;; host when parsing a namestring. They are not FLUSHABLE because
+;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
 
 (defknown wild-pathname-p (pathname-designator
 			   &optional
@@ -1033,21 +1033,21 @@
 				   :directory :name
 				   :type :version))
   boolean
-  (flushable))
+  ())
 (defknown pathname-match-p (pathname-designator pathname-designator) boolean
-  (flushable))
+  ())
 (defknown translate-pathname (pathname-designator
 			      pathname-designator
 			      pathname-designator &key)
   pathname
-  (flushable))
+  ())
 
 (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 pathname (pathname-designator) pathname (unsafely-flushable))
 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
@@ -1064,7 +1064,7 @@
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
   pathname
-  (flushable))
+  (unsafely-flushable))
 
 (defknown make-pathname
  (&key (:defaults pathname-designator)
@@ -1074,7 +1074,7 @@
        (:name (or pathname-name string (member :wild)))
        (:type (or pathname-type string (member :wild)))
        (:version pathname-version) (:case (member :local :common)))
-  pathname (flushable))
+  pathname (unsafely-flushable))
 
 (defknown pathnamep (t) boolean (movable flushable))
 
@@ -1098,11 +1098,11 @@
 
 (defknown (namestring file-namestring directory-namestring host-namestring)
   (pathname-designator) simple-string
-  (flushable))
+  (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
   simple-string
-  (flushable))
+  (unsafely-flushable))
 
 (defknown user-homedir-pathname (&optional t) pathname (flushable))
 
@@ -1120,16 +1120,16 @@
 (defknown rename-file (pathname-designator filename)
   (values pathname pathname pathname))
 (defknown delete-file (pathname-designator) t)
-(defknown probe-file (pathname-designator) (or pathname null) (flushable))
+(defknown probe-file (pathname-designator) (or pathname null) ())
 (defknown file-write-date (pathname-designator) (or unsigned-byte null)
-  (flushable))
+  ())
 (defknown file-author (pathname-designator) (or simple-string null)
-  (flushable))
+  ())
 
 (defknown file-position (stream &optional
 				(or unsigned-byte (member :start :end)))
   (or unsigned-byte (member t nil)))
-(defknown file-length (stream) (or unsigned-byte null) (flushable))
+(defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
 
 (defknown load
   ((or filename stream)
@@ -1141,14 +1141,17 @@
   t)
 
 (defknown directory (pathname-designator &key)
-  list (flushable))
+  list ())
 
 ;;;; from the "Errors" chapter:
 
-(defknown error (t &rest t) nil) ; never returns...
+(defknown error (t &rest t) nil) ; never returns
 (defknown cerror (string t &rest t) null)
 (defknown warn (t &rest t) null)
 (defknown break (&optional t &rest t) null)
+
+;;; and analogous SBCL extension:
+(defknown bug (t &rest t) nil) ; never returns
 
 ;;;; from the "Miscellaneous" Chapter:
 
@@ -1304,7 +1307,7 @@
   (t sequence t index sequence-end function function)
   (values t (or index null))
   (flushable call))
-(defknown %find-position-if 
+(defknown (%find-position-if %find-position-if-not)
   (function sequence t index sequence-end function)
   (values t (or index null))
   (call))