X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=113cb1da2dacf22615f597c7b2012692e7a954b5;hb=6a756846fe0fe89835ec5eb68327b612c93f82c4;hp=6f9eaa712e0b0f067898ca5812d4bed39fd6d708;hpb=c03cebe05df9c538f85d30aa5f22c5ca1f3a8283;p=sbcl.git diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp index 6f9eaa7..113cb1d 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)) @@ -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)) @@ -647,6 +665,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,7 +681,7 @@ (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)) @@ -782,8 +803,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 @@ -803,16 +824,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 +906,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 +961,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)) @@ -1124,7 +1148,12 @@ :rename-and-delete :overwrite :append :supersede nil)) (:if-does-not-exist (member :error :create nil)) - (:external-format (member :default))) + (:external-format + ;; FIXME: This is logically (MEMBER :DEFAULT), + ;; but as a workaround for bug 244, we don't + ;; declare it (to keep the compiler from trusting + ;; the declaration unchecked). + t)) (or stream null)) (defknown rename-file (pathname-designator filename) @@ -1147,7 +1176,11 @@ (:verbose t) (:print t) (:if-does-not-exist (member :error :create nil)) - (:external-format (member :default))) + (:external-format + ;; FIXME: This is logically (MEMBER :DEFAULT), but as a workaround + ;; for bug 244, we don't declare it (to keep the compiler from + ;; trusting the declaration unchecked). + t)) t) (defknown directory (pathname-designator &key) @@ -1186,9 +1219,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) @@ -1300,10 +1334,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 +1362,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 +1385,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))