X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=969c5d8a9c239254339bd1b7db42dea2222539b0;hb=1bbb76fcfb9baddf0dc96412c87575d8aeb69c6d;hp=2b6ba93a138d902f9b4fd7aeb4a4ce1ba3b6b518;hpb=1aefe68236aaf048ce602e7725ad26d130be1fd5;p=sbcl.git diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp index 2b6ba93..969c5d8 100644 --- a/src/compiler/fndb.lisp +++ b/src/compiler/fndb.lisp @@ -35,7 +35,9 @@ ;; 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)) + ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX) + ;; returns REAL/INTEGER, not COMPLEX. + ) (defknown list-to-vector* (list type-specifier) vector) (defknown vector-to-vector* (vector type-specifier) vector) @@ -43,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: @@ -54,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 @@ -73,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. ;; @@ -94,7 +97,7 @@ (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) +(defknown find-class (name-for-class &optional t lexenv-designator) (or sb!xc:class null) ()) (defknown class-of (t) sb!xc:class (flushable)) (defknown layout-of (t) layout (flushable)) @@ -121,13 +124,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)) @@ -140,13 +148,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)) @@ -388,7 +396,7 @@ upper-case-p lower-case-p both-case-p alphanumericp) (character) boolean (movable foldable flushable)) -(defknown digit-char-p (character &optional unsigned-byte) +(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 @@ -399,7 +407,7 @@ (defknown char-code (character) char-code (movable foldable flushable)) (defknown (char-upcase char-downcase) (character) character (movable foldable flushable)) -(defknown digit-char (integer &optional integer) +(defknown digit-char (unsigned-byte &optional (integer 2 36)) (or character null) (movable foldable flushable)) (defknown char-int (character) char-code (movable foldable flushable)) (defknown char-name (character) (or simple-string null) @@ -425,12 +433,12 @@ :derive-type (sequence-result-nth-arg 1)) (defknown copy-seq (sequence) consed-sequence (flushable) - :derive-type #'result-type-first-arg) + :derive-type (sequence-result-nth-arg 1)) (defknown length (sequence) index (foldable flushable)) (defknown reverse (sequence) consed-sequence (flushable) - :derive-type #'result-type-first-arg) + :derive-type (sequence-result-nth-arg 1)) (defknown nreverse (sequence) sequence () :derive-type #'result-type-first-arg) @@ -614,6 +622,8 @@ (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 + (call)) (defknown merge (type-specifier sequence sequence callable &key (:key callable)) @@ -643,6 +653,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 @@ -787,7 +800,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)) @@ -799,12 +812,12 @@ (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|#) @@ -818,7 +831,7 @@ (defknown adjust-array (array (or index list) &key (:element-type type-specifier) - (:initial-element t) (:initial-contents list) + (:initial-element t) (:initial-contents t) (:fill-pointer t) (:displaced-to (or array null)) (:displaced-index-offset index)) array (unsafe)) @@ -878,7 +891,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: @@ -1048,7 +1061,8 @@ ()) (defknown logical-pathname (pathname-designator) logical-pathname ()) -(defknown translate-logical-pathname (pathname-designator &key) pathname ()) +(defknown translate-logical-pathname (pathname-designator &key) pathname + (recursive)) (defknown load-logical-pathname-translations (string) t ()) (defknown logical-pathname-translations (logical-host-designator) list ()) @@ -1300,8 +1314,8 @@ (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)) +(defknown %caller-frame-and-pc () (values t t) (flushable)) +(defknown %with-array-data (array index (or index null)) (values (simple-array * (*)) index index index) (foldable flushable)) (defknown %set-symbol-package (symbol t) t (unsafe)) @@ -1316,8 +1330,25 @@ (function sequence t index sequence-end function) (values t (or index null)) (call)) - -(defknown sb!kernel::arg-count-error (t t t t t t) nil (unsafe)) +(defknown effective-find-position-test (callable callable) + function + (flushable foldable)) +(defknown effective-find-position-key (callable) + 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 index) + nil) ; never returns + + +(defknown arg-count-error (t t t t t t) nil (unsafe)) ;;;; SETF inverses @@ -1328,8 +1359,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)) @@ -1345,3 +1376,6 @@ (defknown %fun-name (function) t (flushable)) (defknown (setf %fun-name) (t function) t (unsafe)) + +(defknown policy-quality (policy symbol) policy-quality + (flushable))