(defknown (eq eql) (t t) boolean (movable foldable flushable))
(defknown (equal equalp) (t t) boolean (foldable flushable recursive))
+
+#!+(or x86 x86-64)
+(defknown fixnum-mod-p (t fixnum) boolean
+ (movable foldable flushable always-translatable))
+
\f
;;;; classes
(defknown expt (number number) number
(movable foldable flushable explicit-check recursive))
(defknown log (number &optional real) irrational
- (movable foldable flushable explicit-check))
+ (movable foldable flushable explicit-check recursive))
(defknown sqrt (number) irrational
(movable foldable flushable explicit-check))
(defknown isqrt (unsigned-byte) unsigned-byte
(defknown (numerator denominator) (rational) integer
(movable foldable flushable))
-(defknown (floor ceiling truncate round)
+(defknown (floor ceiling round)
(real &optional real) (values integer real)
(movable foldable flushable explicit-check))
+(defknown truncate
+ (real &optional real) (values integer real)
+ (movable foldable flushable explicit-check recursive))
+
(defknown %multiply-high (word word) word
(movable foldable flushable))
(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
(defknown ash (integer integer) integer
(movable foldable flushable explicit-check))
+#!+ash-right-vops
+(defknown %ash/right ((or word sb!vm:signed-word) (mod #.sb!vm:n-word-bits))
+ (or word sb!vm:signed-word)
+ (movable foldable flushable always-translatable))
(defknown (logcount integer-length) (integer) bit-index
(movable foldable flushable explicit-check))
;;; FIXME: According to the ANSI spec, it's legal to use any
char-lessp char-greaterp char-not-greaterp char-not-lessp)
(character &rest character) boolean (movable foldable flushable))
+(defknown (two-arg-char-equal
+ two-arg-char-not-equal
+ two-arg-char-lessp
+ two-arg-char-not-lessp
+ two-arg-char-greaterp
+ two-arg-char-not-greaterp)
+ (character character) boolean (movable foldable flushable))
+
(defknown character (t) character (movable foldable unsafely-flushable))
(defknown char-code (character) char-code (movable foldable flushable))
(defknown (char-upcase char-downcase) (character) character
(defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
(defknown %map-to-simple-vector-arity-1 (callable sequence) simple-vector
(flushable call))
-(defknown %map-to-nil-on-simple-vector (callable simple-vector) null
- (flushable call))
-(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
(defknown make-list (index &key (:initial-element t)) list
(movable flushable))
+(defknown sb!impl::backq-list (&rest t) list (movable flushable))
+(defknown sb!impl::backq-list* (t &rest t) t (movable flushable))
+(defknown sb!impl::backq-append (&rest t) t (flushable))
+(defknown sb!impl::backq-nconc (&rest t) t ()
+ :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
+(defknown sb!impl::backq-cons (t t) cons (foldable movable flushable))
+(defknown sb!impl::backq-vector (list) simple-vector
+ (foldable movable flushable))
+
;;; All but last must be of type LIST, but there seems to be no way to
;;; express that in this syntax.
(defknown append (&rest t) t (flushable))
+(defknown sb!impl::append2 (list t) t (flushable))
(defknown copy-list (list) list (flushable))
(defknown copy-alist (list) list (flushable))
(defknown hash-table-test (hash-table) symbol (foldable flushable))
(defknown sxhash (t) hash (#-sb-xc-host foldable flushable))
(defknown psxhash (t &optional t) hash (#-sb-xc-host foldable flushable))
+(defknown hash-table-equalp (hash-table hash-table) boolean (foldable flushable))
\f
;;;; from the "Arrays" chapter
(:lines (or unsigned-byte null))
(:right-margin (or unsigned-byte null))
(:miser-width (or unsigned-byte null))
- (:pprint-dispatch t))
+ (:pprint-dispatch t)
+ (:suppress-errors t))
t
(any explicit-check)
:derive-type #'result-type-first-arg)
:directory :name
:type :version))
generalized-boolean
- ())
+ (recursive))
+
(defknown pathname-match-p (pathname-designator pathname-designator)
generalized-boolean
())
+
(defknown translate-pathname (pathname-designator
pathname-designator
pathname-designator &key)
(:end sequence-end)
(:junk-allowed t))
(values (or pathname null) sequence-end)
- ())
+ (recursive))
(defknown merge-pathnames
(pathname-designator &optional pathname-designator pathname-version)
(defknown pathname-version (pathname-designator)
pathname-version (flushable))
+(defknown pathname= (pathname pathname) boolean (movable foldable flushable))
+
(defknown (namestring file-namestring directory-namestring host-namestring)
(pathname-designator) (or simple-string null)
(unsafely-flushable))
(defknown apropos (string-designator &optional package-designator t) (values))
(defknown apropos-list (string-designator &optional package-designator t) list
- (flushable))
+ (flushable recursive))
(defknown get-decoded-time ()
(values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
(defknown (get-internal-run-time get-internal-real-time)
() internal-time (flushable))
-(defknown sleep ((or (rational 0) (float 0.0))) null)
+(defknown sleep ((real 0)) null (explicit-check))
;;; Even though ANSI defines LISP-IMPLEMENTATION-TYPE and
;;; LISP-IMPLEMENTATION-VERSION to possibly punt and return NIL, we
\f
;;;; magical compiler frobs
-(defknown %values-list-or-context (t t t) * (always-translatable))
+(defknown %rest-values (t t t) * (always-translatable))
+(defknown %rest-ref (t t t t) * (always-translatable))
+(defknown %rest-length (t t t) * (always-translatable))
+(defknown %rest-null (t t t t) * (always-translatable))
+(defknown %rest-true (t t t) * (always-translatable))
(defknown %unary-truncate/single-float (single-float) integer (movable foldable flushable))
(defknown %unary-truncate/double-float (double-float) integer (movable foldable flushable))
(defknown %check-bound (array index fixnum) index
(movable foldable flushable dx-safe))
(defknown data-vector-ref (simple-array index) t
- (foldable explicit-check always-translatable))
-(defknown data-vector-ref-with-offset (simple-array index fixnum) t
- (foldable explicit-check always-translatable))
+ (foldable unsafely-flushable explicit-check always-translatable))
+(defknown data-vector-ref-with-offset (simple-array fixnum fixnum) t
+ (foldable unsafely-flushable explicit-check always-translatable))
(defknown data-vector-set (array index t) t
(explicit-check always-translatable))
-(defknown data-vector-set-with-offset (array index fixnum t) t
+(defknown data-vector-set-with-offset (array fixnum fixnum t) t
(explicit-check always-translatable))
(defknown hairy-data-vector-ref (array index) t
(foldable explicit-check))
())
(defknown style-warn (t &rest t) null ())
+(defknown coerce-to-condition ((or condition symbol string function)
+ list type-specifier symbol)
+ condition
+ (explicit-check))
+
(defknown sc-number-or-lose (symbol) sc-number
(foldable))
(defknown sb!vm:%write-barrier () (values) ())
(defknown sb!vm:%data-dependency-barrier () (values) ())
+#!+sb-safepoint
+;;; Note: This known function does not have an out-of-line definition;
+;;; and if such a definition were needed, it would not need to "call"
+;;; itself inline, but could be a no-op, because the compiler inserts a
+;;; use of the VOP in the function prologue anyway.
+(defknown sb!kernel::gc-safepoint () (values) ())
;;;; atomic ops
(defknown %compare-and-swap-svref (simple-vector index t t) t
projects / sbcl.git / blobdiff