;; 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
(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 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 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 ())
\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)
(character character callable &optional readtable) (eql t)
(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))
pathname
(flushable))
-;;; FIXME: What about logical pathname stuff?
-;;; LOGICAL-PATHNAME
-;;; TRANSLATE-LOGICAL-PATHNAME
-;;; LOAD-LOGICAL-PATHNAME-TRANSLATIONS
-;;; LOGICAL-PATHNAME-TRANSLATIONS
+(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
- ;; ANSI also allows LIST here, but leaves its
- ;; interpretation implementation-defined. Our
- ;; interpretation is that it's unsupported.:-|
- (or pathname-host string (member :unspecific))
+ (or list host string (member :unspecific))
pathname-designator
&key
(:start index)
(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
(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))
;;; 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