;;; 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))
\f
;;;; from the "Predicates" chapter:
;;; 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
;; (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.
;;
;;;; 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))
;;; 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))
(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))
\f
;;;; 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))
\f
(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))
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
(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 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
(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))
;;;; from the "Eval" chapter:
(defknown eval (t) * (recursive))
-(defknown constantp (t &optional lexenv) boolean
+(defknown constantp (t &optional lexenv-designator) boolean
(foldable flushable))
\f
;;;; from the "Streams" chapter:
(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))
: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)
(: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)
(: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)
(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))
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))
\f
(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))
projects / sbcl.git / blobdiff