;;; 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) boolean
+(defknown typep (t type-specifier) t
(flushable
;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
\f
;;;; classes
-(sb!xc:deftype name-for-class () 't)
+(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 make-package (stringable &key
(:use list)
(:nicknames list)
- ;; ### Extensions...
+ ;; ### extensions...
(:internal-symbols index)
(:external-symbols index))
sb!xc:package)
(defknown unintern (symbol &optional package-designator) boolean)
(defknown unexport (symbols &optional package-designator) (eql t))
(defknown shadowing-import (symbols &optional package-designator) (eql t))
-(defknown shadow ((or symbol string list) &optional package-designator) (eql t))
-(defknown (use-package unuse-package) ((or list package-designator) &optional package-designator) (eql t))
+(defknown shadow ((or symbol string list) &optional package-designator)
+ (eql t))
+(defknown (use-package unuse-package)
+ ((or list package-designator) &optional package-designator) (eql t))
(defknown find-all-symbols (stringable) list (flushable))
\f
;;;; from the "Numbers" chapter:
(defknown lcm (&rest integer) unsigned-byte
(movable foldable flushable explicit-check))
-#!-propagate-fun-type
+#+sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
(defknown exp (number) irrational
(movable foldable flushable explicit-check recursive)
:derive-type #'result-type-float-contagion)
-#!+propagate-fun-type
+#-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
(defknown exp (number) irrational
(movable foldable flushable explicit-check recursive))
(defknown cis (real) (complex float)
(movable foldable flushable explicit-check))
-#!-propagate-fun-type
+#+sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
(progn
(defknown (sin cos) (number)
(or (float -1.0 1.0) (complex float))
:derive-type #'result-type-float-contagion)
) ; PROGN
-#!+propagate-fun-type
+#-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
(progn
(defknown (sin cos) (number)
(or (float -1.0 1.0) (complex float))
(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 ash (integer integer) integer (movable foldable flushable explicit-check))
+(defknown ash (integer integer) integer
+ (movable foldable flushable explicit-check))
(defknown (logcount integer-length) (integer) bit-index
(movable foldable flushable explicit-check))
;;; FIXME: According to the ANSI spec, it's legal to use any
(flushable)
:derive-type (result-type-specifier-nth-arg 1))
-(defknown (map %map) (type-specifier callable sequence &rest sequence) consed-sequence
+(defknown (map %map) (type-specifier callable sequence &rest sequence)
+ consed-sequence
(flushable call)
; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
)
:derive-type (sequence-result-nth-arg 3))
(defknown remove-duplicates
- (sequence &key (:test callable) (:test-not callable) (:start index) (:from-end t)
- (:end sequence-end) (:key callable))
+ (sequence &key (:test callable) (:test-not callable) (:start index)
+ (:from-end t) (:end sequence-end) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 1))
(defknown delete-duplicates
- (sequence &key (:test callable) (:test-not callable) (:start index) (:from-end t)
- (:end sequence-end) (:key callable))
+ (sequence &key (:test callable) (:test-not callable) (:start index)
+ (:from-end t) (:end sequence-end) (:key callable))
sequence
(flushable call)
:derive-type (sequence-result-nth-arg 1))
(defknown find (t sequence &key (:test callable) (:test-not callable)
- (:start index) (:from-end t) (:end sequence-end) (:key callable))
+ (:start index) (:from-end t) (:end sequence-end)
+ (:key callable))
t
(foldable flushable call))
(defknown (mismatch search)
(sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
- (:start1 index) (:end1 sequence-end) (:start2 index) (:end2 sequence-end)
+ (:start1 index) (:end1 sequence-end)
+ (:start2 index) (:end2 sequence-end)
(:key callable))
(or index null)
(foldable flushable call))
(defknown make-list (index &key (:initial-element t)) list
(movable flushable unsafe))
-;;; All but last must be list...
+;;; 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 copy-list (list) list (flushable))
list (foldable flushable unsafe call))
(defknown (union intersection set-difference set-exclusive-or)
- (list list &key (:key callable) (:test callable) (:test-not callable))
+ (list list &key (:key callable) (:test callable) (:test-not callable))
list
(foldable flushable call))
(defknown (nunion nintersection nset-difference nset-exclusive-or)
- (list list &key (:key callable) (:test callable) (:test-not callable))
+ (list list &key (:key callable) (:test callable) (:test-not callable))
list
(foldable flushable call))
(defknown subsetp
- (list list &key (:key callable) (:test callable) (:test-not callable))
+ (list list &key (:key callable) (:test callable) (:test-not callable))
boolean
(foldable flushable call))
(foldable)
#|:derive-type #'result-type-last-arg|#)
-(defknown array-has-fill-pointer-p (array) boolean (movable foldable flushable))
+(defknown array-has-fill-pointer-p (array) boolean
+ (movable foldable flushable))
(defknown fill-pointer (vector) index (foldable flushable))
(defknown vector-push (t vector) (or index null) ())
(defknown vector-push-extend (t vector &optional index) index ())
(defknown make-concatenated-stream (&rest stream) stream (flushable))
(defknown make-two-way-stream (stream stream) stream (flushable))
(defknown make-echo-stream (stream stream) stream (flushable))
-(defknown make-string-input-stream (string &optional index index) stream (flushable unsafe))
+(defknown make-string-input-stream (string &optional index index) stream
+ (flushable unsafe))
(defknown make-string-output-stream () stream (flushable))
(defknown get-output-stream-string (stream) simple-string ())
(defknown streamp (t) boolean (movable foldable flushable))
-(defknown stream-element-type (stream) type-specifier (movable foldable flushable))
-(defknown (output-stream-p input-stream-p) (stream) boolean (movable foldable
- flushable))
-(defknown close (stream &key (:abort t)) stream ())
+(defknown stream-element-type (stream) type-specifier
+ (movable foldable flushable))
+(defknown (output-stream-p input-stream-p) (stream) boolean
+ (movable foldable flushable))
+(defknown close (stream &key (:abort t)) (eql t) ())
\f
;;;; from the "Input/Output" chapter:
-;;; The I/O functions are currently given effects ANY under the theory
-;;; that code motion over I/O operations is particularly confusing and
-;;; not very important for efficency.
+;;; (The I/O functions are given effects ANY under the theory that
+;;; code motion over I/O operations is particularly confusing and not
+;;; very important for efficiency.)
-(defknown copy-readtable (&optional (or readtable null) readtable) readtable
+(defknown copy-readtable (&optional (or readtable null) (or readtable null))
+ readtable
())
(defknown readtablep (t) boolean (movable foldable flushable))
(character character &optional (or readtable null) readtable) (eql t)
())
-(defknown set-macro-character (character callable &optional t readtable) (eql t)
+(defknown set-macro-character (character callable &optional t readtable)
+ (eql t)
(unsafe))
-(defknown get-macro-character (character &optional readtable)
+(defknown get-macro-character (character &optional (or readtable null))
(values callable boolean) (flushable))
(defknown make-dispatch-macro-character (character &optional t readtable)
(eql t) ())
(defknown set-dispatch-macro-character
- (character character callable &optional readtable) (eql t)
+ (character character callable &optional readtable) function
(unsafe))
(defknown get-dispatch-macro-character
- (character character &optional readtable) callable
+ (character character &optional (or readtable null)) callable
(flushable))
;;; may return any type due to eof-value...
(defknown (read read-preserving-whitespace read-char-no-hang read-char)
- (&optional streamlike t t t) t (explicit-check))
+ (&optional streamlike t t t) t (explicit-check))
(defknown read-delimited-list (character &optional streamlike t) t
(explicit-check))
(:start index)
(:end sequence-end)
(:junk-allowed t))
- (values (or pathname null) index)
+ (values (or pathname null) sequence-end)
())
(defknown merge-pathnames
(:verbose t)
(:print t)
(:if-does-not-exist (member :error :create nil))
- ;; FIXME: ANSI specifies an :EXTERNAL-FORMAT keyword too.
- )
+ (:external-format (member :default)))
t)
-(defknown directory (pathname-designator &key
- (:check-for-subdirs t)
- (:all t)
- (:follow-links t))
+(defknown directory (pathname-designator &key)
list (flushable))
\f
;;;; from the "Errors" chapter:
(defknown compile-file
(filename
&key
+
+ ;; ANSI options
(:output-file (or filename
null
;; FIXME: This last case is a non-ANSI hack.
(:verbose t)
(:print t)
(:external-format t)
+
+ ;; extensions
+ (:trace-file t)
(:block-compile t)
- (:entry-points list)
(:byte-compile (member t nil :maybe)))
(values (or pathname null) boolean boolean))
(defknown describe (t &optional (or stream (member t nil))) (values))
(defknown inspect (t) (values))
-
(defknown room (&optional (member t nil :default)) (values))
(defknown ed (&optional (or symbol cons filename) &key (:init t) (:display t))
t)
-(defknown dribble (&optional filename &key (:if-exists t)) t)
+(defknown dribble (&optional filename &key (:if-exists t)) (values))
(defknown apropos (stringable &optional package-designator t) (values))
(defknown apropos-list (stringable &optional package-designator t) list
(defknown constantly (t) function (movable flushable))
(defknown complement (function) function (movable flushable))
\f
+;;;; miscellaneous extensions
+
+(defknown get-bytes-consed () unsigned-byte (flushable))
+
+;;; 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)
+\f
;;;; magical compiler frobs
;;; We can't fold this in general because of SATISFIES. There is a
(defknown %%primitive (t t &rest t) *)
(defknown %pop-values (t) t)
(defknown %type-check-error (t t) nil)
-(defknown %odd-keyword-arguments-error () nil)
-(defknown %unknown-keyword-argument-error (t) nil)
+(defknown %odd-key-arguments-error () nil)
+(defknown %unknown-key-argument-error (t) nil)
(defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
(movable foldable flushable explicit-check))
(defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer
(movable foldable flushable explicit-check))
(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))
+(defknown data-vector-ref (simple-array index) t
+ (foldable flushable 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))
+(defknown hairy-data-vector-ref (array index) t
+ (foldable flushable explicit-check))
(defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
(defknown sb!kernel:%caller-frame-and-pc () (values t t) (flushable))
(defknown sb!kernel:%with-array-data (array index (or index null))
(defknown %set-symbol-package (symbol t) t (unsafe))
(defknown %coerce-name-to-function ((or symbol cons)) function (flushable))
(defknown %coerce-callable-to-function (callable) function (flushable))
+(defknown failed-%with-array-data (t t t) nil)
+(defknown %find-position
+ (t sequence t index sequence-end function function)
+ (values t (or index null))
+ (flushable call))
+(defknown %find-position-if
+ (function sequence t index sequence-end function)
+ (values t (or index null))
+ (call))
;;; Structure slot accessors or setters are magically "known" to be
;;; these functions, although the var remains the Slot-Accessor
;;; ordinary functions.
(defknown %slot-accessor (t) t (flushable))
(defknown %slot-setter (t t) t (unsafe))
+
+(defknown sb!kernel::do-arg-count-error (t t t t t t) nil (unsafe))
\f
;;;; SETF inverses
())
(defknown %setnth (index list t) t (unsafe))
(defknown %set-fill-pointer (vector index) index (unsafe))
-\f
-;;;; internal type predicates
-
-;;; Simple TYPEP uses that don't have any standard predicate are
-;;; translated into non-standard unary predicates.
-(defknown (fixnump bignump ratiop short-float-p single-float-p double-float-p
- long-float-p base-char-p %standard-char-p %instancep
- array-header-p)
- (t) boolean (movable foldable flushable))
-\f
-;;;; miscellaneous "sub-primitives"
-
-(defknown %sp-string-compare
- (simple-string index index simple-string index index)
- (or index null)
- (foldable flushable))