X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=8aa12399aa4f733fe41240412c076578d088df51;hb=98f3f617894ce24a40764aa98606ce68c5482cf0;hp=604f85b273b239e399b2c405e3d5a7d7d4366e76;hpb=09d7974601df2aaaa820ca576026b9b4f03e6ab1;p=sbcl.git diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp index 604f85b..8aa1239 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)) @@ -105,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)) @@ -121,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)) @@ -140,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)) @@ -645,6 +660,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 @@ -789,7 +807,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)) @@ -801,12 +819,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|#) @@ -820,7 +838,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)) @@ -880,7 +898,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: @@ -935,7 +953,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)) @@ -1050,7 +1068,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 ()) @@ -1302,8 +1321,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)) @@ -1325,8 +1344,18 @@ function (flushable foldable)) - -(defknown sb!kernel::arg-count-error (t t t t t t) nil (unsafe)) +(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 @@ -1337,8 +1366,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)) @@ -1354,3 +1383,6 @@ (defknown %fun-name (function) t (flushable)) (defknown (setf %fun-name) (t function) t (unsafe)) + +(defknown policy-quality (policy symbol) policy-quality + (flushable))