;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; information for known functions:
;; lets us preserve distinctions which might not even exist
;; on the cross-compilation host (because ANSI doesn't
;; guarantee that specialized array types exist there).
+ ;; 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)
;;; 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-propagate-fun-type
(defknown exp (number) irrational
(movable foldable flushable explicit-check recursive)
:derive-type #'result-type-float-contagion)
-#!+propagate-fun-type
+#!+sb-propagate-fun-type
(defknown exp (number) irrational
(movable foldable flushable explicit-check recursive))
(defknown cis (real) (complex float)
(movable foldable flushable explicit-check))
-#!-propagate-fun-type
+#!-sb-propagate-fun-type
(progn
(defknown (sin cos) (number)
(or (float -1.0 1.0) (complex float))
:derive-type #'result-type-float-contagion)
) ; PROGN
-#!+propagate-fun-type
+#!+sb-propagate-fun-type
(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 (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.
)
(defknown %map-to-nil-on-vector (callable vector) null (flushable call))
(defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))
-;;; returns predicate result...
+;;; returns the result from the predicate...
(defknown some (callable sequence &rest sequence) t
(foldable flushable call))
: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))
(flushable unsafe))
(defknown hash-table-p (t) boolean (movable foldable flushable))
(defknown gethash (t hash-table &optional t) (values t boolean)
- (foldable flushable unsafe))
+ (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
(defknown %puthash (t hash-table t) t (unsafe))
(defknown remhash (t hash-table) boolean ())
-(defknown maphash (callable hash-table) null (foldable flushable call))
+(defknown maphash (callable hash-table) null (flushable call))
(defknown clrhash (hash-table) hash-table ())
-(defknown hash-table-count (hash-table) index (foldable flushable))
+(defknown hash-table-count (hash-table) index (flushable))
(defknown hash-table-rehash-size (hash-table) (or (integer 1) (float (1.0)))
(foldable flushable))
(defknown hash-table-rehash-threshold (hash-table) (real 0 1)
(foldable flushable))
-(defknown hash-table-size (hash-table) index (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*)
(foldable flushable))
(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))
\f
;;;; from the "File System Interface" chapter:
-;;; No pathname functions are foldable because they all potentially
+;;; (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.)
(defknown wild-pathname-p (pathname-designator
&optional
pathname
(flushable))
-;;; KLUDGE: There was a comment from CMU CL here, "We need to add the
-;;; logical pathname stuff here." -- WHN 19991213
+(defknown logical-pathname (pathname-designator) logical-pathname ())
+(defknown translate-logical-pathname (pathname-designator &key) pathname ())
+(defknown load-logical-pathname-translations (string) t ())
+(defknown logical-pathname-translations (logical-host-designator) list ())
(defknown pathname (pathname-designator) pathname (flushable))
(defknown truename (pathname-designator) pathname ())
(defknown parse-namestring
- (pathname-designator &optional pathname-host pathname-designator
+ (pathname-designator &optional
+ (or list host string (member :unspecific))
+ pathname-designator
&key
(:start index)
(:end sequence-end)
(:junk-allowed t))
- (values (or pathname null) index)
+ (values (or pathname null) sequence-end)
())
(defknown merge-pathnames
(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 identity (t) t (movable foldable flushable unsafe)
:derive-type #'result-type-first-arg)
-;;; &OPTIONAL is to agree with the optimization in the interpreter stub.
-(defknown constantly (t &optional t t &rest t) function (movable flushable))
+(defknown constantly (t) function (movable flushable))
(defknown complement (function) function (movable flushable))
\f
;;;; magical compiler frobs
(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))
(values (simple-array * (*)) index index index)
(foldable flushable))
(defknown %set-symbol-package (symbol t) t (unsafe))
-(defknown %coerce-name-to-function (t) function (flushable))
+(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 (proclaimed as SB-EXT:CONSTANT-FUNCTION, but
-;;; otherwise ordinary).
+;;; ordinary functions.
(defknown %slot-accessor (t) t (flushable))
(defknown %slot-setter (t t) t (unsafe))
\f
projects / sbcl.git / blobdiff