;; FIXME: It's actually not clear that COERCE on non-NUMBER types
;; is FOLDABLE at all. Check this.
(movable #-sb-xc-host foldable)
- :derive-type (result-type-specifier-nth-arg 2))
-(defknown list-to-simple-string* (list) simple-string)
-(defknown list-to-bit-vector* (list) bit-vector)
-(defknown list-to-vector* (list type) vector)
-(defknown list-to-simple-vector* (list) simple-vector)
-(defknown vector-to-vector* (vector type) vector)
-(defknown vector-to-simple-string* (vector) vector)
+ ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
+ ;; returns REAL/INTEGER, not COMPLEX.
+ )
+(defknown list-to-vector* (list type-specifier) vector)
+(defknown vector-to-vector* (vector type-specifier) vector)
(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)
- (type-specifier) type-specifier
- (flushable))
+ (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
- (flushable
+(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)
+ (foldable))
+(defknown subtypep (type-specifier type-specifier &optional lexenv-designator)
+ (values boolean boolean)
;; This is not FOLDABLE because its value is affected by type
;; definitions.
;;
;; FIXME: Is it OK to fold this when the types have already been
;; defined? Does the code inherited from CMU CL already do this?
- (flushable))
+ (unsafely-flushable))
(defknown (null symbolp atom consp listp numberp integerp rationalp floatp
complexp characterp stringp bit-vector-p vectorp
\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)
+(defknown find-class (name-for-class &optional t lexenv-designator)
(or sb!xc:class null) ())
(defknown class-of (t) sb!xc:class (flushable))
(defknown layout-of (t) layout (flushable))
(defknown (symbol-value symbol-function) (symbol) t ())
(defknown boundp (symbol) boolean (flushable))
-(defknown fboundp ((or symbol cons)) boolean (flushable explicit-check))
+(defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
(defknown special-operator-p (symbol) t
;; The set of special operators never changes.
- (movable foldable flushable))
+ (movable foldable flushable))
(defknown set (symbol t) t (unsafe)
:derive-type #'result-type-last-arg)
(defknown fdefinition ((or symbol cons)) function (unsafe 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))
;;; it into VALUES. VALUES is not foldable, since MV constants are
;;; represented by a call to VALUES.
(defknown values (&rest t) * (movable flushable unsafe))
-(defknown values-list (list) * (movable foldable flushable))
+(defknown values-list (list) * (movable foldable unsafely-flushable))
\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
(sb!xc:deftype package-designator () '(or stringable sb!xc:package))
(sb!xc:deftype symbols () '(or list symbol))
-;;; Should allow a package name, I think, tho CLtL II doesn't say so...
(defknown gentemp (&optional string package-designator) symbol)
(defknown make-package (stringable &key
(defknown find-package (package-designator) (or sb!xc:package null)
(flushable))
(defknown package-name (package-designator) (or simple-string null)
- (flushable))
-(defknown package-nicknames (package-designator) list (flushable))
+ (unsafely-flushable))
+(defknown package-nicknames (package-designator) list (unsafely-flushable))
(defknown rename-package (package-designator package-designator &optional list)
sb!xc:package)
-(defknown package-use-list (package-designator) list (flushable))
-(defknown package-used-by-list (package-designator) list (flushable))
-(defknown package-shadowing-symbols (package-designator) list (flushable))
+(defknown package-use-list (package-designator) list (unsafely-flushable))
+(defknown package-used-by-list (package-designator) list (unsafely-flushable))
+(defknown package-shadowing-symbols (package-designator) list (unsafely-flushable))
(defknown list-all-packages () list (flushable))
(defknown intern (string &optional package-designator)
(values symbol (member :internal :external :inherited nil))
(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))
(defknown atan
(number &optional real) irrational
- (movable foldable flushable explicit-check recursive)
+ (movable foldable unsafely-flushable explicit-check recursive)
:derive-type #'result-type-float-contagion)
(defknown (tan sinh cosh tanh asinh)
: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 atan
(number &optional real) irrational
- (movable foldable flushable explicit-check recursive))
+ (movable foldable unsafely-flushable explicit-check recursive))
(defknown (tan sinh cosh tanh asinh)
(number) irrational (movable foldable flushable explicit-check recursive))
upper-case-p lower-case-p both-case-p alphanumericp)
(character) boolean (movable foldable flushable))
-(defknown digit-char-p (character &optional unsigned-byte)
+(defknown digit-char-p (character &optional (integer 2 36))
(or (integer 0 35) null) (movable foldable flushable))
(defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
char-lessp char-greaterp char-not-greaterp char-not-lessp)
(character &rest character) boolean (movable foldable flushable))
-(defknown character (t) character (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
(movable foldable flushable))
-(defknown digit-char (integer &optional integer)
+(defknown digit-char (unsigned-byte &optional (integer 2 36))
(or character null) (movable foldable flushable))
(defknown char-int (character) char-code (movable foldable flushable))
(defknown char-name (character) (or simple-string null)
\f
;;;; from the "Sequences" chapter:
-(defknown elt (sequence index) t (foldable flushable))
+(defknown elt (sequence index) t (foldable unsafely-flushable))
(defknown subseq (sequence index &optional sequence-end) consed-sequence
(flushable)
:derive-type (sequence-result-nth-arg 1))
(defknown copy-seq (sequence) consed-sequence (flushable)
- :derive-type #'result-type-first-arg)
+ :derive-type (sequence-result-nth-arg 1))
(defknown length (sequence) index (foldable flushable))
(defknown reverse (sequence) consed-sequence (flushable)
- :derive-type #'result-type-first-arg)
+ :derive-type (sequence-result-nth-arg 1))
(defknown nreverse (sequence) sequence ()
:derive-type #'result-type-first-arg)
&key
(:initial-element t))
consed-sequence
- (movable flushable unsafe)
+ (movable unsafe)
:derive-type (result-type-specifier-nth-arg 1))
(defknown concatenate (type-specifier &rest sequence) consed-sequence
- (flushable)
+ ()
:derive-type (result-type-specifier-nth-arg 1))
(defknown (map %map) (type-specifier callable sequence &rest sequence)
consed-sequence
- (flushable call)
+ (call)
; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
)
(defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
;;; returns the result from the predicate...
(defknown some (callable sequence &rest sequence) t
- (foldable flushable call))
+ (foldable unsafely-flushable call))
(defknown (every notany notevery) (callable sequence &rest sequence) boolean
- (foldable flushable call))
+ (foldable unsafely-flushable call))
;;; unsafe for :INITIAL-VALUE...
(defknown reduce (callable
(defknown remove
(t sequence &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 2))
(defknown substitute
(t t sequence &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 3))
(defknown (remove-if remove-if-not)
(callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 2))
(defknown (substitute-if substitute-if-not)
(t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 3))
(defknown delete
(t sequence &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
sequence
(flushable call)
:derive-type (sequence-result-nth-arg 2))
(defknown nsubstitute
(t t sequence &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
sequence
(flushable call)
:derive-type (sequence-result-nth-arg 3))
(defknown (delete-if delete-if-not)
(callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
sequence
(flushable call)
:derive-type (sequence-result-nth-arg 2))
(defknown (nsubstitute-if nsubstitute-if-not)
(t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-end) (:key callable))
+ (:count sequence-count) (:key callable))
sequence
(flushable call)
:derive-type (sequence-result-nth-arg 3))
(sequence &key (:test callable) (:test-not callable) (:start index)
(:from-end t) (:end sequence-end) (:key callable))
consed-sequence
- (flushable call)
+ (unsafely-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
- (flushable call)
+ (unsafely-flushable call)
:derive-type (sequence-result-nth-arg 1))
(defknown find (t sequence &key (:test callable) (:test-not callable)
(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
+ (call))
(defknown merge (type-specifier sequence sequence callable
&key (:key callable))
sequence
- (flushable call)
+ (call)
:derive-type (result-type-specifier-nth-arg 1))
;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
:derive-type (sequence-result-nth-arg 1))
\f
;;;; from the "Manipulating List Structure" chapter:
-(defknown (car cdr caar cadr cdar cddr
- caaar caadr cadar caddr cdaar cdadr cddar cdddr
- caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
- cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
- first second third fourth fifth sixth seventh eighth ninth tenth
- rest)
+(defknown (car cdr first rest)
(list)
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
+ cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+ second third fourth fifth sixth seventh eighth ninth tenth)
+ (list)
+ t
+ (foldable unsafely-flushable))
+
(defknown cons (t t) cons (movable flushable unsafe))
(defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
(foldable flushable call))
-(defknown endp (t) boolean (foldable flushable movable))
-(defknown list-length (list) (or index null) (foldable flushable))
-(defknown (nth nthcdr) (index list) t (foldable flushable))
+(defknown endp (t) boolean (foldable unsafely-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 list (&rest t) list (movable flushable unsafe))
(defknown list* (t &rest t) t (movable flushable unsafe))
(movable flushable unsafe))
;;; All but last must be of type LIST, but there seems to be no way to
-;;; express that in this syntax..
+;;; express that in this syntax.
(defknown append (&rest t) t (flushable))
(defknown copy-list (list) list (flushable))
(defknown copy-alist (list) list (flushable))
(defknown copy-tree (t) t (flushable recursive))
(defknown revappend (list t) t (flushable))
-(defknown nconc (&rest list) list ())
+
+;;; All but last must be of type LIST, but there seems to be no way to
+;;; express that in this syntax. The result must be LIST, but we do
+;;; 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 ())
(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!vm:*target-most-positive-fixnum*)
+(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
(foldable flushable))
\f
;;;; from the "Arrays" chapter
(defknown array-rank (array) array-rank (foldable flushable))
(defknown array-dimension (array array-rank) index (foldable flushable))
(defknown array-dimensions (array) list (foldable flushable))
-(defknown array-in-bounds-p (array &rest index) boolean (foldable flushable))
+(defknown array-in-bounds-p (array &rest integer) boolean (foldable flushable))
(defknown array-row-major-index (array &rest index) array-total-size
(foldable flushable))
(defknown array-total-size (array) array-total-size (foldable flushable))
(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 array-has-fill-pointer-p (array) boolean
(movable foldable flushable))
-(defknown fill-pointer (vector) index (foldable flushable))
+(defknown fill-pointer (vector) index (foldable unsafely-flushable))
(defknown vector-push (t vector) (or index null) ())
(defknown vector-push-extend (t vector &optional index) index ())
(defknown vector-pop (vector) t ())
(defknown adjust-array
(array (or index list) &key (:element-type type-specifier)
- (:initial-element t) (:initial-contents list)
+ (:initial-element t) (:initial-contents t)
(:fill-pointer t) (:displaced-to (or array null))
(:displaced-index-offset index))
array (unsafe))
;;;; 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 make-synonym-stream (symbol) stream (flushable))
-(defknown make-broadcast-stream (&rest stream) stream (flushable))
-(defknown make-concatenated-stream (&rest stream) stream (flushable))
-(defknown make-two-way-stream (stream stream) stream (flushable))
+(defknown make-broadcast-stream (&rest stream) stream (unsafely-flushable))
+(defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
+(defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
(defknown make-echo-stream (stream stream) stream (flushable))
(defknown make-string-input-stream (string &optional index index) stream
(flushable unsafe))
(movable foldable flushable))
(defknown (output-stream-p input-stream-p) (stream) boolean
(movable foldable flushable))
-(defknown close (stream &key (:abort t)) stream ())
+(defknown close (stream &key (:abort t)) (eql t) ())
\f
;;;; from the "Input/Output" chapter:
(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 (or readtable null)) callable
- (flushable))
+ (character character &optional (or readtable null)) (or callable null)
+ ())
;;; may return any type due to eof-value...
(defknown (read read-preserving-whitespace read-char-no-hang read-char)
;;; (No pathname functions are FOLDABLE because they all potentially
;;; depend on *DEFAULT-PATHNAME-DEFAULTS*, e.g. to provide a default
-;;; host when parsing a namestring.)
+;;; host when parsing a namestring. They are not FLUSHABLE because
+;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
(defknown wild-pathname-p (pathname-designator
&optional
:directory :name
:type :version))
boolean
- (flushable))
+ ())
(defknown pathname-match-p (pathname-designator pathname-designator) boolean
- (flushable))
+ ())
(defknown translate-pathname (pathname-designator
pathname-designator
pathname-designator &key)
pathname
- (flushable))
+ ())
(defknown logical-pathname (pathname-designator) logical-pathname ())
-(defknown translate-logical-pathname (pathname-designator &key) pathname ())
+(defknown translate-logical-pathname (pathname-designator &key) pathname
+ (recursive))
(defknown load-logical-pathname-translations (string) t ())
(defknown logical-pathname-translations (logical-host-designator) list ())
-(defknown pathname (pathname-designator) pathname (flushable))
+(defknown pathname (pathname-designator) pathname (unsafely-flushable))
(defknown truename (pathname-designator) pathname ())
(defknown parse-namestring
(:start index)
(:end sequence-end)
(:junk-allowed t))
- (values (or pathname null) index)
+ (values (or pathname null) sequence-end)
())
(defknown merge-pathnames
(pathname-designator &optional pathname-designator pathname-version)
pathname
- (flushable))
+ (unsafely-flushable))
(defknown make-pathname
(&key (:defaults pathname-designator)
(:name (or pathname-name string (member :wild)))
(:type (or pathname-type string (member :wild)))
(:version pathname-version) (:case (member :local :common)))
- pathname (flushable))
+ pathname (unsafely-flushable))
(defknown pathnamep (t) boolean (movable flushable))
(defknown (namestring file-namestring directory-namestring host-namestring)
(pathname-designator) simple-string
- (flushable))
+ (unsafely-flushable))
(defknown enough-namestring (pathname-designator &optional pathname-designator)
simple-string
- (flushable))
+ (unsafely-flushable))
(defknown user-homedir-pathname (&optional t) pathname (flushable))
(defknown rename-file (pathname-designator filename)
(values pathname pathname pathname))
(defknown delete-file (pathname-designator) t)
-(defknown probe-file (pathname-designator) (or pathname null) (flushable))
+(defknown probe-file (pathname-designator) (or pathname null) ())
(defknown file-write-date (pathname-designator) (or unsigned-byte null)
- (flushable))
+ ())
(defknown file-author (pathname-designator) (or simple-string null)
- (flushable))
+ ())
(defknown file-position (stream &optional
(or unsigned-byte (member :start :end)))
(or unsigned-byte (member t nil)))
-(defknown file-length (stream) (or unsigned-byte null) (flushable))
+(defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
(defknown load
((or filename stream)
(: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))
- list (flushable))
+(defknown directory (pathname-designator &key)
+ list ())
\f
;;;; from the "Errors" chapter:
-(defknown error (t &rest t) nil) ; never returns...
+(defknown error (t &rest t) nil) ; never returns
(defknown cerror (string t &rest t) null)
(defknown warn (t &rest t) null)
(defknown break (&optional t &rest t) null)
+
+;;; and analogous SBCL extension:
+(defknown bug (t &rest t) nil) ; never returns
\f
;;;; from the "Miscellaneous" 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)
- (:block-compile t)
- (:entry-points list)
- (:byte-compile (member t nil :maybe)))
+
+ ;; extensions
+ (:trace-file t)
+ (:block-compile t))
(values (or pathname null) boolean boolean))
(defknown disassemble (callable &key
(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 %more-arg-context (t t) (values t index) (flushable))
(defknown %more-arg (t index) t)
(defknown %more-arg-values (t index index) * (flushable))
-(defknown %verify-argument-count (index index) (values))
-(defknown %argument-count-error (t) nil)
+(defknown %verify-arg-count (index index) (values))
+(defknown %arg-count-error (t) nil)
(defknown %unknown-values () *)
(defknown %catch (t t) t)
(defknown %unwind-protect (t t) t)
(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-args-error () nil)
+(defknown %unknown-key-arg-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
(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 %caller-frame-and-pc () (values t t) (flushable))
+(defknown %with-array-data (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-function ((or symbol cons)) function (flushable))
-(defknown %coerce-callable-to-function (callable) function (flushable))
-
-;;; Structure slot accessors or setters are magically "known" to be
-;;; these functions, although the var remains the Slot-Accessor
-;;; describing the actual function called.
-;;;
-;;; FIXME: It would be nice to make structure slot accessors be
-;;; ordinary functions.
-(defknown %slot-accessor (t) t (flushable))
-(defknown %slot-setter (t 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 %find-position
+ (t sequence t index sequence-end function function)
+ (values t (or index null))
+ (flushable call))
+(defknown (%find-position-if %find-position-if-not)
+ (function sequence t index sequence-end function)
+ (values t (or index null))
+ (call))
+(defknown effective-find-position-test (callable callable)
+ function
+ (flushable foldable))
+(defknown effective-find-position-key (callable)
+ 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 index)
+ nil) ; never returns
+
+
+(defknown arg-count-error (t t t t t t) nil (unsafe))
\f
;;;; SETF inverses
(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))
-(defknown fset (symbol function) function (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 %setnth (index list t) t (unsafe))
(defknown %set-fill-pointer (vector index) index (unsafe))
\f
-;;;; internal type predicates
+;;;; miscellaneous internal utilities
-;;; 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 %fun-name (function) t (flushable))
+(defknown (setf %fun-name) (t function) t (unsafe))
-(defknown %sp-string-compare
- (simple-string index index simple-string index index)
- (or index null)
- (foldable flushable))
+(defknown policy-quality (policy symbol) policy-quality
+ (flushable))