(defknown type-of (t) t (foldable flushable))
;;; These can be affected by type definitions, so they're not FOLDABLE.
-(defknown (upgraded-complex-part-type upgraded-array-element-type)
+(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)
(type-specifier &optional lexenv-designator) type-specifier
(unsafely-flushable))
\f
(movable foldable flushable explicit-check))
(defknown (ffloor fceiling fround ftruncate)
- (real &optional real) (values float float)
+ (real &optional real) (values float real)
(movable foldable flushable explicit-check))
(defknown decode-float (float) (values float float-exponent float)
(movable foldable flushable explicit-check))
(defknown scale-float (float float-exponent) float
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown float-radix (float) float-radix
- (movable foldable flushable explicit-check))
+ (movable foldable flushable))
(defknown float-sign (float &optional float) float
(movable foldable flushable explicit-check))
(defknown (float-digits float-precision) (float) float-digits
(movable foldable flushable explicit-check))
(defknown integer-decode-float (float)
- (values integer float-exponent (member -1 1))
+ (values integer float-int-exponent (member -1 1))
(movable foldable flushable explicit-check))
(defknown complex (real &optional real) number
(defknown lognot (integer) integer (movable foldable flushable explicit-check))
(defknown logtest (integer integer) boolean (movable foldable flushable))
-(defknown logbitp (bit-index integer) boolean (movable foldable flushable))
+(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
(defknown ash (integer integer) integer
(movable foldable flushable explicit-check))
(defknown (logcount integer-length) (integer) bit-index
(movable foldable flushable))
(defknown deposit-field (integer byte-specifier integer) integer
(movable foldable flushable))
-(defknown random ((real (0)) &optional random-state) (real 0) ())
+(defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
+ (or (float 0.0) (integer 0)) ())
(defknown make-random-state (&optional (or (member nil t) random-state))
random-state (flushable))
(defknown random-state-p (t) boolean (movable foldable flushable))
(: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
(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
(foldable flushable call))
(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 nth (unsigned-byte list) t (foldable flushable))
+(defknown nthcdr (unsigned-byte list) t (foldable unsafely-flushable))
+(defknown last (list &optional unsigned-byte) 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
;;; not check it now :-).
(defknown nconc (&rest t) t ())
-(defknown nreconc (list t) list ())
-(defknown butlast (list &optional index) list (flushable))
-(defknown nbutlast (list &optional index) list ())
+(defknown nreconc (list t) t ())
+(defknown butlast (list &optional unsigned-byte) list (flushable))
+(defknown nbutlast (list &optional unsigned-byte) list ())
(defknown ldiff (list t) list (flushable))
(defknown (rplaca rplacd) (cons t) list (unsafe))
(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))
(defknown make-echo-stream (stream stream) stream (flushable))
(defknown make-string-input-stream (string &optional index index) stream
(flushable unsafe))
-(defknown make-string-output-stream () stream (flushable))
+(defknown make-string-output-stream
+ (&key (:element-type type-specifier))
+ stream
+ (flushable))
(defknown get-output-stream-string (stream) simple-string ())
(defknown streamp (t) boolean (movable foldable flushable))
(defknown stream-element-type (stream) type-specifier
(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
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)
:rename-and-delete :overwrite
:append :supersede nil))
(:if-does-not-exist (member :error :create nil))
- (: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))
+ (:external-format (member :default)))
(or stream null))
(defknown rename-file (pathname-designator filename)
(:verbose t)
(:print t)
(:if-does-not-exist (member :error :create nil))
- (: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))
+ (:external-format (member :default)))
t)
(defknown directory (pathname-designator &key)
list ())
\f
-;;;; from the "Errors" chapter:
-
-(defknown error (t &rest t) nil) ; never returns
-(defknown cerror (string t &rest t) null)
+;;;; from the "Conditions" chapter:
+
+(defknown cell-error-name (cell-error) t)
+(defknown error (t &rest t) nil)
+(defknown cerror (format-control t &rest t) null)
+(defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
+(defknown method-combination-error (format-control &rest t) *)
+(defknown signal (t &rest t) null)
+(defknown simple-condition-format-control (condition)
+ format-control)
+(defknown simple-condition-format-arguments (condition)
+ list)
(defknown warn (t &rest t) null)
-(defknown break (&optional t &rest t) null)
+(defknown invoke-debugger (condition) nil)
+(defknown break (&optional format-control &rest t) null)
+(defknown make-condition (type-specifier &rest t) condition)
+(defknown compute-restarts (&optional (or condition null)) list)
+(defknown find-restart (restart-designator &optional (or condition null))
+ (or restart null))
+(defknown invoke-restart (restart-designator &rest t) *)
+(defknown invoke-restart-interactively (restart-designator) *)
+(defknown restart-name (restart) symbol)
+(defknown (abort muffle-warning) (&optional (or condition null)) nil)
+(defknown continue (&optional (or condition null)) null)
+(defknown (store-value use-value) (t &optional (or condition null))
+ null)
;;; and analogous SBCL extension:
(defknown bug (t &rest t) nil) ; never returns
(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-LVAR 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
(defknown (setf fdocumentation) ((or string null) t symbol)
(or string null)
())
-(defknown %setnth (index list t) t (unsafe))
+(defknown %setnth (unsigned-byte list t) t (unsafe))
(defknown %set-fill-pointer (vector index) index (unsafe))
\f
+;;;; ALIEN and call-out-to-C stuff
+
+;;; 'call' attribute because we store the arg on the stack, which is in
+;;; some sense 'passing it upwards'
+(defknown sb!vm::push-word-on-c-stack (system-area-pointer) (values) (call))
+(defknown sb!vm::pop-words-from-c-stack (index) (values) (call))
+
;;;; miscellaneous internal utilities
(defknown %fun-name (function) t (flushable))
(defknown policy-quality (policy symbol) policy-quality
(flushable))
+
+(defknown (compiler-abort compiler-error) (string &rest t) nil ())
+(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
+ (values)
+ ())
+(defknown style-warn (string &rest t) null ())