(defknown coerce (t type-specifier) t
;; Note:
- ;; (1) This is not FLUSHABLE because it's defined to signal errors.
- ;; (2) It's not worth trying to make this FOLDABLE in the
- ;; cross-compiler,because
- ;; (a) it would probably be really hard to make all the
- ;; tricky issues (e.g. which specialized array types are
- ;; supported) match between cross-compiler and target
- ;; compiler, and besides
- ;; (b) leaving it not FOLDABLE lets us use the idiom
- ;; (COERCE FOO 'SOME-SPECIALIZED-ARRAY-TYPE-OR-ANOTHER)
- ;; as a way of delaying the generation of specialized
- ;; array types until runtime, which helps us keep the
- ;; cross-compiler's dumper relatively simple and which
- ;; 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)
+ ;; This is not FLUSHABLE because it's defined to signal errors.
+ (movable)
;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
;; returns REAL/INTEGER, not COMPLEX.
)
(defknown type-of (t) t (foldable flushable))
;;; These can be affected by type definitions, so they're not FOLDABLE.
-(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)
+(defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
(type-specifier &optional lexenv-designator) type-specifier
(unsafely-flushable))
\f
\f
;;;; from the "Packages" chapter:
-(sb!xc:deftype package-designator () '(or stringable sb!xc:package))
-(sb!xc:deftype symbols () '(or list symbol))
-
(defknown gentemp (&optional string package-designator) symbol)
-(defknown make-package (stringable &key
- (:use list)
- (:nicknames list)
- ;; ### extensions...
- (:internal-symbols index)
- (:external-symbols index))
+(defknown make-package (string-designator &key
+ (:use list)
+ (:nicknames list)
+ ;; ### extensions...
+ (:internal-symbols index)
+ (:external-symbols index))
sb!xc:package)
(defknown find-package (package-designator) (or sb!xc:package null)
(flushable))
(defknown find-symbol (string &optional package-designator)
(values symbol (member :internal :external :inherited nil))
(flushable))
-(defknown (export import) (symbols &optional package-designator) (eql t))
+(defknown (export import) (symbols-designator &optional package-designator)
+ (eql t))
(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 unexport (symbols-designator &optional package-designator) (eql t))
+(defknown shadowing-import (symbols-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))
+(defknown find-all-symbols (string-designator) list (flushable))
\f
;;;; from the "Numbers" chapter:
(movable foldable flushable explicit-check))
(defknown (ffloor fceiling fround ftruncate)
- (real &optional real) (values float float)
+ (real &optional real) (values float real)
(movable foldable flushable explicit-check))
(defknown decode-float (float) (values float float-exponent float)
(movable foldable flushable explicit-check))
-(defknown scale-float (float float-exponent) float
- (movable foldable flushable explicit-check))
+(defknown scale-float (float integer) float
+ (movable foldable unsafely-flushable explicit-check))
(defknown float-radix (float) float-radix
- (movable foldable flushable explicit-check))
+ (movable foldable flushable))
(defknown float-sign (float &optional float) float
(movable foldable flushable explicit-check))
(defknown (float-digits float-precision) (float) float-digits
(movable foldable flushable explicit-check))
(defknown integer-decode-float (float)
- (values integer float-exponent (member -1 1))
+ (values integer float-int-exponent (member -1 1))
(movable foldable flushable explicit-check))
(defknown complex (real &optional real) number
(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 logbitp (unsigned-byte integer) boolean (movable foldable flushable))
(defknown ash (integer integer) integer
(movable foldable flushable explicit-check))
(defknown (logcount integer-length) (integer) bit-index
(movable foldable flushable))
(defknown deposit-field (integer byte-specifier integer) integer
(movable foldable flushable))
-(defknown random ((real (0)) &optional random-state) (real 0) ())
+(defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
+ (or (float 0.0) (integer 0)) ())
(defknown make-random-state (&optional (or (member nil t) random-state))
random-state (flushable))
(defknown random-state-p (t) boolean (movable foldable flushable))
(defknown char-int (character) char-code (movable foldable flushable))
(defknown char-name (character) (or simple-string null)
(movable foldable flushable))
-(defknown name-char (stringable) (or character null)
+(defknown name-char (string-designator) (or character null)
(movable foldable flushable))
-(defknown code-char (char-code) base-char
+(defknown code-char (char-code) character
;; By suppressing constant folding on CODE-CHAR when the
;; cross-compiler is running in the cross-compilation host vanilla
;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until
(:initial-element t))
consed-sequence
(movable unsafe)
- :derive-type (result-type-specifier-nth-arg 1))
+ :derive-type (creation-result-type-specifier-nth-arg 1))
(defknown concatenate (type-specifier &rest sequence) consed-sequence
()
- :derive-type (result-type-specifier-nth-arg 1))
+ :derive-type (creation-result-type-specifier-nth-arg 1))
(defknown (map %map) (type-specifier callable sequence &rest sequence)
consed-sequence
&key (:key callable))
sequence
(call)
- :derive-type (result-type-specifier-nth-arg 1))
+ :derive-type (creation-result-type-specifier-nth-arg 1))
;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
(defknown read-sequence (sequence stream
(foldable flushable call))
(defknown endp (list) boolean (foldable 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) t (foldable flushable))
+(defknown nth (unsigned-byte list) t (foldable flushable))
+(defknown nthcdr (unsigned-byte list) t (foldable unsafely-flushable))
+(defknown last (list &optional unsigned-byte) t (foldable flushable))
(defknown list (&rest t) list (movable flushable unsafe))
(defknown list* (t &rest t) t (movable flushable unsafe))
(defknown make-list (index &key (:initial-element t)) list
(defknown nconc (&rest t) t ())
(defknown nreconc (list t) t ())
-(defknown butlast (list &optional index) list (flushable))
-(defknown nbutlast (list &optional index) list ())
+(defknown butlast (list &optional unsigned-byte) list (flushable))
+(defknown nbutlast (list &optional unsigned-byte) list ())
(defknown ldiff (list t) list (flushable))
(defknown (rplaca rplacd) (cons t) list (unsafe))
(defknown hash-table-size (hash-table) index (flushable))
(defknown hash-table-test (hash-table) symbol (foldable flushable))
(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
- (foldable flushable))
+ (#-sb-xc-host foldable flushable))
\f
;;;; from the "Arrays" chapter
bit-orc1 bit-orc2)
((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 nil)))
(array bit)
- (foldable)
+ ()
#|:derive-type #'result-type-last-arg|#)
(defknown bit-vector-= (bit-vector bit-vector) boolean
(defknown char (string index) character (foldable flushable))
(defknown schar (simple-string index) character (foldable flushable))
-(sb!xc:deftype stringable () '(or character string symbol))
-
(defknown (string= string-equal)
- (stringable stringable &key (:start1 index) (:end1 sequence-end)
+ (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
(:start2 index) (:end2 sequence-end))
boolean
(foldable flushable))
(defknown (string< string> string<= string>= string/= string-lessp
string-greaterp string-not-lessp string-not-greaterp
string-not-equal)
- (stringable stringable &key (:start1 index) (:end1 sequence-end)
+ (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
(:start2 index) (:end2 sequence-end))
(or index null)
(foldable flushable))
simple-string (flushable))
(defknown (string-trim string-left-trim string-right-trim)
- (sequence stringable) simple-string (flushable))
+ (sequence string-designator) simple-string (flushable))
(defknown (string-upcase string-downcase string-capitalize)
- (stringable &key (:start index) (:end sequence-end))
+ (string-designator &key (:start index) (:end sequence-end))
simple-string (flushable))
(defknown (nstring-upcase nstring-downcase nstring-capitalize)
(string &key (:start index) (:end sequence-end))
string ())
-(defknown string (stringable) string
+(defknown string (string-designator) string
(flushable explicit-check))
\f
;;;; internal non-keyword versions of string predicates:
(defknown (string<* string>* string<=* string>=* string/=*)
- (stringable stringable index sequence-end index sequence-end)
+ (string-designator string-designator index sequence-end index sequence-end)
(or index null)
(foldable flushable))
(defknown string=*
- (stringable stringable index sequence-end index sequence-end)
+ (string-designator string-designator index sequence-end index sequence-end)
boolean
(foldable flushable))
\f
(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
+(defknown make-string-input-stream (string &optional index sequence-end)
+ stream
(flushable unsafe))
-(defknown make-string-output-stream () stream (flushable))
+(defknown make-string-output-stream
+ (&key (:element-type type-specifier))
+ stream
+ (flushable))
(defknown get-output-stream-string (stream) simple-string ())
(defknown streamp (t) boolean (movable foldable flushable))
(defknown stream-element-type (stream) type-specifier
(character character &optional (or readtable null)) (or callable null)
())
+(defknown copy-pprint-dispatch
+ (&optional (or sb!pretty:pprint-dispatch-table null))
+ sb!pretty:pprint-dispatch-table
+ ())
+(defknown pprint-dispatch
+ (t &optional (or sb!pretty:pprint-dispatch-table null))
+ (values callable boolean)
+ ())
+(defknown (pprint-fill pprint-linear)
+ (stream-designator t &optional t t)
+ null
+ ())
+(defknown pprint-tabular
+ (stream-designator t &optional t t unsigned-byte)
+ null
+ ())
+(defknown pprint-indent
+ ((member :block :current) real &optional stream-designator)
+ null
+ ())
+(defknown pprint-newline
+ ((member :linear :fill :miser :mandatory) &optional stream-designator)
+ null
+ ())
+(defknown pprint-tab
+ ((member :line :section :line-relative :section-relative)
+ unsigned-byte unsigned-byte &optional stream-designator)
+ null
+ ())
+(defknown set-pprint-dispatch
+ (type-specifier (or null callable)
+ &optional real sb!pretty:pprint-dispatch-table)
+ null
+ ())
+
;;; 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 stream-designator t t t) t (explicit-check))
-(defknown read-delimited-list (character &optional streamlike t) list
+(defknown read-delimited-list (character &optional stream-designator t) list
(explicit-check))
-(defknown read-line (&optional streamlike t t t) (values t boolean)
+(defknown read-line (&optional stream-designator t t t) (values t boolean)
(explicit-check))
-(defknown unread-char (character &optional streamlike) t
+(defknown unread-char (character &optional stream-designator) t
(explicit-check))
-(defknown peek-char (&optional (or character (member nil t)) streamlike t t t)
+(defknown peek-char (&optional (or character (member nil t))
+ stream-designator t t t)
t
(explicit-check))
-(defknown listen (&optional streamlike) boolean (flushable explicit-check))
+(defknown listen (&optional stream-designator) boolean (flushable explicit-check))
-(defknown clear-input (&optional stream) null (explicit-check))
+(defknown clear-input (&optional stream-designator) null (explicit-check))
(defknown read-from-string
(string &optional t t
(defknown write
(t &key
- (:stream streamlike)
+ (:stream stream-designator)
(:escape t)
(:radix t)
(:base (integer 2 36))
(any explicit-check)
:derive-type #'result-type-first-arg)
-(defknown (prin1 print princ) (t &optional streamlike) t (any explicit-check)
+(defknown (prin1 print princ) (t &optional stream-designator)
+ t
+ (any explicit-check)
:derive-type #'result-type-first-arg)
;;; xxx-TO-STRING functions are not foldable because they depend on
-;;; the dynamic environment.
+;;; the dynamic environment, the state of the pretty printer dispatch
+;;; table, and probably other run-time factors.
(defknown write-to-string
(t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
(:circle t) (:pretty t) (:level (or unsigned-byte null))
(:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
(:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
simple-string
- (foldable flushable explicit-check))
+ (flushable explicit-check))
(defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
-(defknown write-char (character &optional streamlike) character
+(defknown write-char (character &optional stream-designator) character
(explicit-check))
(defknown (write-string write-line)
- (string &optional streamlike &key (:start index) (:end sequence-end))
+ (string &optional stream-designator &key (:start index) (:end sequence-end))
string
(explicit-check))
(defknown (terpri finish-output force-output clear-output)
- (&optional streamlike) null
+ (&optional stream-designator) null
(explicit-check))
-(defknown fresh-line (&optional streamlike) boolean
+(defknown fresh-line (&optional stream-designator) boolean
(explicit-check))
(defknown write-byte (integer stream) integer
(explicit-check))
-(defknown format ((or streamlike string) (or string function) &rest t)
+(defknown format ((or (member nil t) stream string)
+ (or string function) &rest t)
(or string null)
(explicit-check))
:rename-and-delete :overwrite
:append :supersede nil))
(:if-does-not-exist (member :error :create nil))
- (:external-format (member :default)))
+ (:external-format keyword))
(or stream null))
(defknown rename-file (pathname-designator filename)
(:verbose t)
(:print t)
(:if-does-not-exist (member :error :create nil))
- (:external-format (member :default)))
+ (:external-format keyword))
t)
(defknown directory (pathname-designator &key)
list ())
\f
-;;;; from the "Errors" chapter:
-
-(defknown error (t &rest t) nil) ; never returns
-(defknown cerror (string t &rest t) null)
+;;;; from the "Conditions" chapter:
+
+(defknown cell-error-name (cell-error) t)
+(defknown error (t &rest t) nil)
+(defknown cerror (format-control t &rest t) null)
+(defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
+(defknown method-combination-error (format-control &rest t) *)
+(defknown signal (t &rest t) null)
+(defknown simple-condition-format-control (condition)
+ format-control)
+(defknown simple-condition-format-arguments (condition)
+ list)
(defknown warn (t &rest t) null)
-(defknown break (&optional t &rest t) null)
+(defknown invoke-debugger (condition) nil)
+(defknown break (&optional format-control &rest t) null)
+(defknown make-condition (type-specifier &rest t) condition)
+(defknown compute-restarts (&optional (or condition null)) list)
+(defknown find-restart (restart-designator &optional (or condition null))
+ (or restart null))
+(defknown invoke-restart (restart-designator &rest t) *)
+(defknown invoke-restart-interactively (restart-designator) *)
+(defknown restart-name (restart) symbol)
+(defknown (abort muffle-warning) (&optional (or condition null)) nil)
+(defknown continue (&optional (or condition null)) null)
+(defknown (store-value use-value) (t &optional (or condition null))
+ null)
;;; and analogous SBCL extension:
(defknown bug (t &rest t) nil) ; never returns
(values (or function symbol cons) boolean boolean))
(defknown compile-file
- (filename
+ (pathname-designator
&key
;; ANSI options
- (:output-file (or filename
+ (:output-file (or pathname-designator
null
;; FIXME: This last case is a non-ANSI hack.
(member t)))
(:verbose t)
(:print t)
- (:external-format t)
+ (:external-format keyword)
;; extensions
(:trace-file t)
(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))
+(defknown ed (&optional (or symbol cons filename))
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 apropos (string-designator &optional package-designator t) (values))
+(defknown apropos-list (string-designator &optional package-designator t) list
(flushable))
(defknown get-decoded-time ()
;;;; miscellaneous extensions
(defknown get-bytes-consed () unsigned-byte (flushable))
+(defknown mask-signed-field ((integer 0 *) integer) integer
+ (movable flushable foldable))
;;; PCOUNTERs
(defknown incf-pcounter (pcounter unsigned-byte) pcounter)
(defknown %nlx-entry (t) *)
(defknown %%primitive (t t &rest t) *)
(defknown %pop-values (t) t)
+(defknown %nip-values (t t &rest t) (values))
+(defknown %allocate-closures (t) *)
(defknown %type-check-error (t t) nil)
;; FIXME: This function does not return, but due to the implementation
-;; of FILTER-CONTINUATION we cannot write it here.
+;; of FILTER-LVAR we cannot write it here.
(defknown %compile-time-type-error (t t t) *)
(defknown %odd-key-args-error () nil)
(defknown (setf fdocumentation) ((or string null) t symbol)
(or string null)
())
-(defknown %setnth (index list t) t (unsafe))
+(defknown %setnth (unsigned-byte list t) t (unsafe))
(defknown %set-fill-pointer (vector index) index (unsafe))
\f
+;;;; ALIEN and call-out-to-C stuff
+
+;;; 'unsafe' attribute because we store the arg on the stack, which is in
+;;; some sense 'passing it upwards'
+(defknown sb!vm::push-word-on-c-stack (system-area-pointer) (values) (unsafe))
+(defknown sb!vm::pop-words-from-c-stack (index) (values) ())
+
+#!+linkage-table
+(defknown foreign-symbol-dataref-address (simple-string)
+ system-area-pointer
+ (movable flushable))
+
+(defknown foreign-symbol-address (simple-string &optional boolean)
+ system-area-pointer
+ (movable flushable))
+
+(defknown foreign-symbol-address-as-integer (simple-string &optional boolean)
+ (values integer boolean)
+ (movable flushable))
+
;;;; miscellaneous internal utilities
(defknown %fun-name (function) t (flushable))
(defknown policy-quality (policy symbol) policy-quality
(flushable))
+
+(defknown (compiler-abort compiler-error) (string &rest t) nil ())
+(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
+ (values)
+ ())
+(defknown style-warn (string &rest t) null ())
+
projects / sbcl.git / blobdiff