;;;; classes
(sb!xc:deftype name-for-class () t)
-(defknown classoid-name (classoid) name-for-class (flushable))
-(defknown find-classoid (name-for-class &optional t lexenv-designator)
+(defknown classoid-name (classoid) symbol (flushable))
+(defknown find-classoid (name-for-class &optional t)
(or classoid null) ())
(defknown classoid-of (t) classoid (flushable))
(defknown layout-of (t) layout (flushable))
(movable foldable flushable explicit-check))
(defknown decode-float (float) (values float float-exponent float)
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown scale-float (float integer) float
(movable foldable unsafely-flushable explicit-check))
(defknown float-radix (float) float-radix
- (movable foldable flushable))
+ (movable foldable unsafely-flushable))
(defknown float-sign (float &optional float) float
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown (float-digits float-precision) (float) float-digits
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown integer-decode-float (float)
- (values integer float-int-exponent (member -1 1))
- (movable foldable flushable explicit-check))
+ (values integer float-int-exponent (member -1 1))
+ (movable foldable unsafely-flushable explicit-check))
(defknown complex (real &optional real) number
(movable foldable flushable explicit-check))
(defknown deposit-field (integer byte-specifier integer) integer
(movable foldable flushable))
(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))
+ (or (float 0.0) (integer 0))
+ (explicit-check))
+(defknown make-random-state (&optional
+ (or (member nil t) random-state unsigned-byte
+ (simple-array (unsigned-byte 8) (*))
+ (simple-array (unsigned-byte 32) (*))))
random-state (flushable))
(defknown random-state-p (t) boolean (movable foldable flushable))
\f
(:start index) (:end sequence-end)) sequence
(unsafe)
:derive-type #'result-type-first-arg
- :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+ :result-arg 0)
(defknown replace (sequence sequence &rest t &key (:start1 index)
(:end1 sequence-end) (:start2 index) (:end2 sequence-end))
sequence ()
:derive-type #'result-type-first-arg
- :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+ :result-arg 0)
(defknown remove
(t sequence &rest t &key (:from-end t) (:test callable)
(defknown list-length (list) (or index null) (foldable unsafely-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 sb!impl::last1 (list) t (foldable flushable))
+(defknown %last0 (list) t (foldable flushable))
+(defknown %last1 (list) t (foldable flushable))
+(defknown %lastn/fixnum (list (and unsigned-byte fixnum)) t (foldable flushable))
+(defknown %lastn/bignum (list (and unsigned-byte bignum)) 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
(&key (:test callable) (:size unsigned-byte)
(:rehash-size (or (integer 1) (float (1.0))))
(:rehash-threshold (real 0 1))
- (:weakness (member nil :key :value :key-and-value :key-or-value)))
+ (:hash-function (or null callable))
+ (:weakness (member nil :key :value :key-and-value :key-or-value))
+ (:synchronized t))
hash-table
(flushable unsafe))
(defknown hash-table-p (t) boolean (movable foldable flushable))
(defknown clrhash (hash-table) hash-table ()
:destroyed-constant-args (nth-constant-args 2))
(defknown hash-table-count (hash-table) index (flushable))
-(defknown hash-table-rehash-size (hash-table) (or (integer 1) (float (1.0)))
+(defknown hash-table-rehash-size (hash-table) (or index (single-float (1.0)))
(foldable flushable))
-(defknown hash-table-rehash-threshold (hash-table) (real 0 1)
+(defknown hash-table-rehash-threshold (hash-table) (single-float (0.0) 1.0)
(foldable flushable))
(defknown hash-table-size (hash-table) index (flushable))
(defknown hash-table-test (hash-table) symbol (foldable flushable))
-(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
- (#-sb-xc-host foldable flushable))
-(defknown psxhash (t &optional t) (integer 0 #.sb!xc:most-positive-fixnum)
- (#-sb-xc-host foldable flushable))
+(defknown sxhash (t) hash (#-sb-xc-host foldable flushable))
+(defknown psxhash (t &optional t) hash (#-sb-xc-host foldable flushable))
\f
;;;; from the "Arrays" chapter
(defknown array-has-fill-pointer-p (array) boolean
(movable foldable flushable))
-(defknown fill-pointer (vector) index (foldable unsafely-flushable))
-(defknown vector-push (t vector) (or index null) ()
+(defknown fill-pointer (complex-vector) index
+ (unsafely-flushable explicit-check))
+(defknown vector-push (t complex-vector) (or index null)
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 2))
-(defknown vector-push-extend (t vector &optional index) index ()
+(defknown vector-push-extend (t complex-vector &optional (and index (integer 1))) index
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 2))
-(defknown vector-pop (vector) t ()
+(defknown vector-pop (complex-vector) t
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 1))
;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
simple-string (flushable))
(defknown (string-trim string-left-trim string-right-trim)
- (sequence string-designator) simple-string (flushable))
+ (sequence string-designator) string (flushable))
(defknown (string-upcase string-downcase string-capitalize)
(string-designator &key (:start index) (:end sequence-end))
(flushable unsafe))
(defknown make-string-output-stream
(&key (:element-type type-specifier))
- stream
+ string-output-stream
(flushable))
(defknown get-output-stream-string (stream) simple-string ())
(defknown streamp (t) boolean (movable foldable flushable))
(character character &optional readtable (or readtable null)) (eql t)
())
-(defknown set-macro-character (character callable &optional t readtable)
+(defknown set-macro-character (character callable &optional t (or readtable null))
(eql t)
(unsafe))
(defknown get-macro-character (character &optional (or readtable null))
(defknown make-dispatch-macro-character (character &optional t readtable)
(eql t) ())
(defknown set-dispatch-macro-character
- (character character callable &optional readtable) function
+ (character character callable &optional (or readtable null)) (eql t)
(unsafe))
(defknown get-dispatch-macro-character
(character character &optional (or readtable null)) (or callable null)
:rename-and-delete :overwrite
:append :supersede nil))
(:if-does-not-exist (member :error :create nil))
- (:external-format keyword))
+ (:external-format external-format-designator))
(or stream null))
(defknown rename-file (pathname-designator filename)
&key
(:verbose t)
(:print t)
- (:if-does-not-exist (member :error :create nil))
- (:external-format keyword))
+ (:if-does-not-exist t)
+ (:external-format external-format-designator))
t)
-(defknown directory (pathname-designator &key)
+(defknown directory (pathname-designator &key (:resolve-symlinks t))
list ())
\f
;;;; 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 invoke-debugger (condition) nil)
(defknown break (&optional format-control &rest t) null)
null)
;;; and analogous SBCL extension:
+(defknown sb!impl::%failed-aver (t) nil)
(defknown bug (t &rest t) nil) ; never returns
+
\f
;;;; from the "Miscellaneous" Chapter:
(member t)))
(:verbose t)
(:print t)
- (:external-format keyword)
+ (:external-format external-format-designator)
;; extensions
(:trace-file t)
- (:block-compile t))
+ (:block-compile t)
+ (:emit-cfasl t))
(values (or pathname null) boolean boolean))
;; FIXME: consider making (OR CALLABLE CONS) something like
(:stream stream) (:use-labels t))
null)
-(defknown fdocumentation (t symbol)
- (or string null)
- (flushable))
-
(defknown describe (t &optional (or stream (member t nil))) (values))
(defknown inspect (t) (values))
(defknown room (&optional (member t nil :default)) (values))
\f
;;;; miscellaneous extensions
+(defknown symbol-global-value (symbol) t ())
+(defknown set-symbol-global-value (symbol t) t ())
+
(defknown get-bytes-consed () unsigned-byte (flushable))
(defknown mask-signed-field ((integer 0 *) integer) integer
(movable flushable foldable))
-;;; PCOUNTERs
-(defknown incf-pcounter (pcounter unsigned-byte) pcounter)
-(defknown pcounter->integer (pcounter) unsigned-byte)
-(defknown %incf-pcounter-or-fixnum ((or pcounter fixnum) unsigned-byte)
- (or pcounter fixnum))
-(defknown pcounter-or-fixnum->integer ((or pcounter fixnum)) unsigned-byte)
+(defknown array-storage-vector (array) (simple-array * (*))
+ (any))
\f
;;;; magical compiler frobs
+(defknown %unary-truncate/single-float (single-float) integer (movable foldable flushable))
+(defknown %unary-truncate/double-float (double-float) integer (movable foldable flushable))
+
;;; We can't fold this in general because of SATISFIES. There is a
;;; special optimizer anyway.
(defknown %typep (t (or type-specifier ctype)) boolean
(movable flushable explicit-check))
(defknown %instance-typep (t (or type-specifier ctype)) boolean
- (movable flushable explicit-check))
+ (movable flushable explicit-check always-translatable))
(defknown %cleanup-point () t)
(defknown %special-bind (t t) t)
(defknown %more-arg-context (t t) (values t index) (flushable))
(defknown %more-arg (t index) t)
#!+stack-grows-downward-not-upward
-(defknown %more-kw-arg (t index) (values t t))
+;;; FIXME: The second argument here should really be NEGATIVE-INDEX, but doing that
+;;; breaks the build, and I cannot seem to figure out why. --NS 2006-06-29
+(defknown %more-kw-arg (t fixnum) (values t t))
(defknown %more-arg-values (t index index) * (flushable))
(defknown %verify-arg-count (index index) (values))
(defknown %arg-count-error (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 %compile-time-type-error (t t t t) *)
+(defknown sb!kernel::case-failure (t t t) nil)
(defknown %odd-key-args-error () nil)
(defknown %unknown-key-arg-error (t) nil)
(defknown %check-bound (array index fixnum) index (movable foldable flushable))
(defknown data-vector-ref (simple-array index) t
(foldable explicit-check always-translatable))
-#!+(or x86 x86-64)
(defknown data-vector-ref-with-offset (simple-array index fixnum) t
(foldable explicit-check always-translatable))
(defknown data-vector-set (array index t) t
(unsafe explicit-check always-translatable))
-#!+(or x86 x86-64)
(defknown data-vector-set-with-offset (array index fixnum t) t
(unsafe explicit-check always-translatable))
(defknown hairy-data-vector-ref (array index) t
(defknown hairy-data-vector-set/check-bounds (array index t)
t
(unsafe explicit-check))
-(defknown %caller-frame-and-pc () (values t t) (flushable))
+(defknown %caller-frame () t (flushable))
+(defknown %caller-pc () system-area-pointer (flushable))
(defknown %with-array-data (array index (or index null))
(values (simple-array * (*)) index index index)
(foldable flushable))
+(defknown %with-array-data/fp (array index (or index null))
+ (values (simple-array * (*)) index index index)
+ (foldable flushable))
(defknown %set-symbol-package (symbol t) t (unsafe))
(defknown %coerce-name-to-fun ((or symbol cons)) function (flushable))
(defknown %coerce-callable-to-fun (callable) function (flushable))
-(defknown failed-%with-array-data (t t t) nil)
+(defknown array-bounding-indices-bad-error (t t t) nil)
+(defknown sequence-bounding-indices-bad-error (t t t) nil)
(defknown %find-position
(t sequence t index sequence-end function function)
(values t (or index null))
function
(flushable foldable))
+(defknown %adjoin (t list) list (explicit-check foldable flushable))
+(defknown %adjoin-key (t list function) list (explicit-check foldable flushable call))
+(defknown %assoc (t list) list (explicit-check foldable flushable))
+(defknown %assoc-key (t list function) list (explicit-check foldable flushable call))
+(defknown %member (t list) list (explicit-check foldable flushable))
+(defknown %member-key (t list function) list (explicit-check foldable flushable call))
+(defknown %rassoc (t list) list (explicit-check foldable flushable))
+(defknown %rassoc-key (t list function) list (explicit-check foldable flushable call))
+
(defknown %check-vector-sequence-bounds (vector index sequence-end)
index
(unwind))
:destroyed-constant-args (nth-constant-args 1))
(defknown %set-symbol-value (symbol t) t (unsafe))
(defknown (setf symbol-function) (function symbol) function (unsafe))
-(defknown %set-symbol-plist (symbol t) t (unsafe))
-(defknown (setf fdocumentation) ((or string null) t symbol)
- (or string null)
- ())
+(defknown %set-symbol-plist (symbol list) list (unsafe))
(defknown %setnth (unsigned-byte list t) t (unsafe)
:destroyed-constant-args (nth-constant-args 2))
-(defknown %set-fill-pointer (vector index) index (unsafe)
+(defknown %set-fill-pointer (complex-vector index) index
+ (unsafe explicit-check)
:destroyed-constant-args (nth-constant-args 1))
\f
;;;; ALIEN and call-out-to-C stuff
-;;; 'unsafe' 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) (unsafe))
-(defknown sb!vm::pop-words-from-c-stack (index) (values) ())
+;; Used by WITH-PINNED-OBJECTS
+#!+(or x86 x86-64)
+(defknown sb!vm::touch-object (t) (values)
+ (unsafe always-translatable))
#!+linkage-table
(defknown foreign-symbol-dataref-sap (simple-string)
(flushable))
(defknown compiler-error (t &rest t) nil ())
-(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(defknown (compiler-warn compiler-style-warn) (t &rest t) (values) ())
(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
(values)
())
-(defknown style-warn (string &rest t) null ())
+(defknown style-warn (t &rest t) null ())
+
+
+;;;; memory barriers
+
+(defknown sb!vm:%compiler-barrier () (values) ())
+(defknown sb!vm:%memory-barrier () (values) ())
+(defknown sb!vm:%read-barrier () (values) ())
+(defknown sb!vm:%write-barrier () (values) ())
+(defknown sb!vm:%data-dependency-barrier () (values) ())
+
;;;; atomic ops
-#!+(or x86 x86-64)
-(progn
- (defknown %simple-vector-compare-and-swap (simple-vector index t t) t
- (unsafe))
- (defknown %instance-compare-and-swap (instance index t t) t
- (unsafe)))
+(defknown %compare-and-swap-svref (simple-vector index t t) t
+ (unsafe))
+(defknown %compare-and-swap-instance-ref (instance index t t) t
+ (unsafe))
+(defknown %compare-and-swap-symbol-value (symbol t t) t
+ (unsafe unwind))
projects / sbcl.git / blobdiff