X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=592dab1062f51e39a961d34fa0af759ff1d31b91;hb=902e93736a0888aa6b04dc328b1eb328423bf426;hp=fb22c960ae32f3b4e0c53ffe5dd4f11d204e3b2d;hpb=2bdf5a3484eda55b0d4b9313aa6b3505b6d7cbd8;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index fb22c96..592dab1 100644
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -45,7 +45,7 @@
 
 ;;; 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
+	  (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 
 ;;;; from the "Predicates" chapter:
@@ -56,7 +56,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) t
+(defknown typep (t type-specifier &optional lexenv-designator) t
    ;; 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
@@ -75,7 +75,8 @@
    ;; (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)
+(defknown subtypep (type-specifier type-specifier &optional lexenv-designator)
+  (values boolean boolean)
   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
@@ -95,10 +96,10 @@
 ;;;; classes
 
 (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) ())
-(defknown class-of (t) sb!xc:class (flushable))
+(defknown classoid-name (classoid) name-for-class (flushable))
+(defknown find-classoid (name-for-class &optional t lexenv-designator)
+  (or classoid null) ())
+(defknown classoid-of (t) classoid (flushable))
 (defknown layout-of (t) layout (flushable))
 (defknown copy-structure (structure-object) structure-object
   (flushable unsafe))
@@ -107,7 +108,14 @@
 
 ;;; This is not FLUSHABLE, since it's required to signal an error if
 ;;; unbound.
-(defknown (symbol-value symbol-function) (symbol) t ())
+(defknown (symbol-value) (symbol) t ())
+;;; From CLHS, "If the symbol is globally defined as a macro or a
+;;; special operator, an object of implementation-dependent nature and
+;;; identity is returned. If the symbol is not globally defined as
+;;; either a macro or a special operator, and if the symbol is fbound,
+;;; a function object is returned".  Our objects of
+;;; implementation-dependent nature happen to be functions.
+(defknown (symbol-function) (symbol) function ())
 
 (defknown boundp (symbol) boolean (flushable))
 (defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
@@ -123,13 +131,18 @@
 (defknown fmakunbound ((or symbol cons)) (or symbol cons)
   (unsafe explicit-check))
 (defknown (get-setf-method get-setf-method-multiple-value)
-  ((or list symbol) &optional lexenv)
+  ((or list symbol) &optional lexenv-designator)
   (values list list list form form)
   (flushable))
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 
-(defknown (mapcar maplist mapcan mapcon) (callable list &rest list) list
+(defknown (mapcar maplist) (callable list &rest list) list
+  (call))
+
+;;; According to CLHS the result must be a LIST, but we do not check
+;;; it.
+(defknown (mapcan mapcon) (callable list &rest list) t
   (call))
 
 (defknown (mapc mapl) (callable list &rest list) list (foldable call))
@@ -142,13 +155,13 @@
 
 ;;;; from the "Macros" chapter:
 
-(defknown macro-function (symbol &optional lexenv)
+(defknown macro-function (symbol &optional lexenv-designator)
   (or function null)
   (flushable))
-(defknown (macroexpand macroexpand-1) (t &optional lexenv)
+(defknown (macroexpand macroexpand-1) (t &optional lexenv-designator)
   (values form &optional boolean))
 
-(defknown compiler-macro-function (t &optional lexenv)
+(defknown compiler-macro-function (t &optional lexenv-designator)
   (or function null)
   (flushable))
 
@@ -442,11 +455,11 @@
 					(:initial-element t))
   consed-sequence
   (movable unsafe)
-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   ()
-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence
@@ -461,6 +474,11 @@
 (defknown %map-to-nil-on-vector (callable vector) null (flushable call))
 (defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))
 
+(defknown map-into (sequence callable &rest sequence)
+  sequence
+  (call)
+  :derive-type #'result-type-first-arg)
+
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t
   (foldable unsafely-flushable call))
@@ -616,14 +634,15 @@
 (defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
   (call)
   :derive-type (sequence-result-nth-arg 1))
-(defknown sb!impl::sort-vector (vector index index function (or function null)) vector
+(defknown sb!impl::sort-vector (vector index index function (or function null))
+  * ; SORT-VECTOR works through side-effect
   (call))
 
 (defknown merge (type-specifier sequence sequence callable
 				&key (:key callable))
   sequence
   (call)
-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
@@ -647,6 +666,9 @@
   t
   (foldable flushable))
 
+;; Correct argument type restrictions for these functions are
+;; complicated, so we just declare them to accept LISTs and suppress
+;; flushing is safe code.
 (defknown (caar cadr cdar cddr
                 caaar caadr cadar caddr cdaar cdadr cddar cdddr
                 caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
@@ -660,11 +682,11 @@
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))
-(defknown endp (t) boolean (foldable unsafely-flushable movable))
+(defknown endp (list) boolean (foldable 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 last (list &optional index) t (foldable flushable))
 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list
@@ -684,7 +706,7 @@
 ;;; not check it now :-).
 (defknown nconc (&rest t) t ())
 
-(defknown nreconc (list t) list ())
+(defknown nreconc (list t) t ())
 (defknown butlast (list &optional index) list (flushable))
 (defknown nbutlast (list &optional index) list ())
 (defknown ldiff (list t) list (flushable))
@@ -692,15 +714,15 @@
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
 			    (:test-not callable))
-  list (flushable unsafe call))
+  t (flushable unsafe call))
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
-	  (t t t &key (:key callable))
-  list (flushable unsafe call))
+	  (t callable t &key (:key callable))
+  t (flushable unsafe call))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
 				 (:test-not callable))
-  list (flushable unsafe call))
+  t (flushable unsafe call))
 
 (defknown member (t list &key (:key callable) (:test callable)
 		    (:test-not callable))
@@ -782,8 +804,8 @@
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
 
-(defknown aref (array &rest index) t (foldable flushable))
-(defknown row-major-aref (array index) t (foldable flushable))
+(defknown aref (array &rest index) t (foldable))
+(defknown row-major-aref (array index) t (foldable))
 
 (defknown array-element-type (array)
   type-specifier
@@ -791,7 +813,7 @@
 (defknown array-rank (array) array-rank (foldable flushable))
 (defknown array-dimension (array array-rank) index (foldable flushable))
 (defknown array-dimensions (array) list (foldable flushable))
-(defknown array-in-bounds-p (array &rest index) boolean (foldable flushable))
+(defknown array-in-bounds-p (array &rest integer) boolean (foldable flushable))
 (defknown array-row-major-index (array &rest index) array-total-size
   (foldable flushable))
 (defknown array-total-size (array) array-total-size (foldable flushable))
@@ -803,16 +825,19 @@
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
 		   bit-orc1 bit-orc2)
-  ((array bit) (array bit) &optional (or (array bit) (member t)))
+  ((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)))
+(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
+  (movable foldable flushable))
+
 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
 (defknown fill-pointer (vector) index (foldable unsafely-flushable))
@@ -882,7 +907,7 @@
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))
-(defknown constantp (t &optional lexenv) boolean
+(defknown constantp (t &optional lexenv-designator) boolean
   (foldable flushable))
 
 ;;;; from the "Streams" chapter:
@@ -937,7 +962,7 @@
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
   (&optional streamlike t t t) t (explicit-check))
 
-(defknown read-delimited-list (character &optional streamlike t) t
+(defknown read-delimited-list (character &optional streamlike t) list
   (explicit-check))
 (defknown read-line (&optional streamlike t t t) (values t boolean)
   (explicit-check))
@@ -1041,9 +1066,10 @@
 			   (member nil :host :device
 				   :directory :name
 				   :type :version))
-  boolean
+  generalized-boolean
   ())
-(defknown pathname-match-p (pathname-designator pathname-designator) boolean
+(defknown pathname-match-p (pathname-designator pathname-designator)
+  generalized-boolean
   ())
 (defknown translate-pathname (pathname-designator
 			      pathname-designator
@@ -1107,7 +1133,7 @@
   pathname-version (flushable))
 
 (defknown (namestring file-namestring directory-namestring host-namestring)
-  (pathname-designator) simple-string
+  (pathname-designator) (or simple-string null)
   (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
@@ -1186,9 +1212,10 @@
    (:block-compile t))
   (values (or pathname null) boolean boolean))
 
-(defknown disassemble (callable &key
-				(:stream stream)
-				(:use-labels t))
+;; FIXME: consider making (OR CALLABLE CONS) something like
+;; EXTENDED-FUNCTION-DESIGNATOR
+(defknown disassemble ((or callable cons) &key
+		       (:stream stream) (:use-labels t))
   null)
 
 (defknown fdocumentation (t symbol)
@@ -1291,6 +1318,11 @@
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) 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.
+(defknown %compile-time-type-error (t t t) *)
+
 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
@@ -1300,10 +1332,10 @@
 (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))
+  (foldable 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))
+  (foldable explicit-check))
 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
 (defknown %caller-frame-and-pc () (values t t) (flushable))
 (defknown %with-array-data (array index (or index null))
@@ -1328,6 +1360,17 @@
   function
   (flushable foldable))
 
+(defknown %check-vector-sequence-bounds (vector index sequence-end)
+  index
+  (unwind))
+;;; FIXME: including this information here is probably necessary to
+;;; get efficient compilation of the inline expansion of
+;;; %FIND-POSITION-IF, so it should maybe be in a more
+;;; compiler-friendly package (SB-INT?)
+(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))
 
@@ -1340,8 +1383,8 @@
 (defknown %put (symbol t t) t (unsafe))
 (defknown %setelt (sequence index t) t (unsafe))
 (defknown %svset (simple-vector index t) t (unsafe))
-(defknown %bitset (bit-vector &rest index) bit (unsafe))
-(defknown %sbitset (simple-bit-vector &rest index) bit (unsafe))
+(defknown %bitset ((array bit) &rest index) bit (unsafe))
+(defknown %sbitset ((simple-array bit) &rest index) bit (unsafe))
 (defknown %charset (string index character) character (unsafe))
 (defknown %scharset (simple-string index character) character (unsafe))
 (defknown %set-symbol-value (symbol t) t (unsafe))