;;;; from the "Symbols" chapter:
(defknown get (symbol t &optional t) t (flushable))
-(defknown sb!impl::get2 (symbol t) t (flushable))
(defknown sb!impl::get3 (symbol t t) t (flushable))
(defknown remprop (symbol t) t)
(defknown symbol-plist (symbol) list (flushable))
()
:derive-type (creation-result-type-specifier-nth-arg 1))
+(defknown %concatenate-to-string (&rest sequence) simple-string
+ (explicit-check flushable))
+(defknown %concatenate-to-base-string (&rest sequence) simple-base-string
+ (explicit-check flushable))
+
(defknown (map %map) (type-specifier callable sequence &rest sequence)
consed-sequence
(call)
(defknown adjoin (t list &key (:key callable) (:test callable)
(:test-not callable))
- cons (foldable flushable call))
+ cons (flushable call))
(defknown (union intersection set-difference set-exclusive-or)
(list list &key (:key callable) (:test callable) (:test-not callable))
(defknown hash-table-p (t) boolean (movable foldable flushable))
(defknown gethash (t hash-table &optional t) (values t boolean)
(flushable)) ; not FOLDABLE, since hash table contents can change
-(defknown sb!impl::gethash2 (t hash-table) (values t boolean)
- (flushable)) ; not FOLDABLE, since hash table contents can change
(defknown sb!impl::gethash3 (t hash-table t) (values t boolean)
(flushable)) ; not FOLDABLE, since hash table contents can change
(defknown %puthash (t hash-table t) t ()
(defknown streamp (t) boolean (movable foldable flushable))
(defknown stream-element-type (stream) type-specifier
(movable foldable flushable))
+(defknown stream-external-format (stream) t (flushable))
(defknown (output-stream-p input-stream-p) (stream) boolean
(movable foldable flushable))
+(defknown open-stream-p (stream) boolean (flushable))
(defknown close (stream &key (:abort t)) (eql t) ())
+(defknown file-string-length (ansi-stream (or string character))
+ (or unsigned-byte null)
+ (flushable))
\f
;;;; from the "Input/Output" chapter:
(any explicit-check)
:derive-type #'result-type-first-arg)
+(defknown (pprint) (t &optional stream-designator) (values)
+ (explicit-check))
+
;;; xxx-TO-STRING functions are not foldable because they depend on
;;; the dynamic environment, the state of the pretty printer dispatch
;;; table, and probably other run-time factors.
(:emit-cfasl t))
(values (or pathname null) boolean boolean))
+(defknown (compile-file-pathname)
+ (pathname-designator &key (:output-file (or pathname-designator
+ null
+ (member t)))
+ &allow-other-keys)
+ pathname)
+
;; FIXME: consider making (OR CALLABLE CONS) something like
;; EXTENDED-FUNCTION-DESIGNATOR
(defknown disassemble ((or callable cons) &key
null)
(defknown describe (t &optional (or stream (member t nil))) (values))
+(defknown function-lambda-expression (function) (values t boolean t))
(defknown inspect (t) (values))
(defknown room (&optional (member t nil :default)) (values))
(defknown ed (&optional (or symbol cons filename))
(defknown sleep ((real 0)) null (explicit-check))
+(defknown call-with-timing (callable callable &rest t) *
+ (call))
+
;;; Even though ANSI defines LISP-IMPLEMENTATION-TYPE and
;;; LISP-IMPLEMENTATION-VERSION to possibly punt and return NIL, we
;;; know that there's no valid reason for our implementations to ever
(movable flushable explicit-check))
(defknown %instance-typep (t (or type-specifier ctype)) boolean
(movable flushable explicit-check always-translatable))
+;;; We should never emit a call to %typep-wrapper
+(defknown %typep-wrapper (t t (or type-specifier ctype)) t
+ (movable flushable always-translatable))
(defknown %cleanup-point () t)
(defknown %special-bind (t t) t)
function
(flushable foldable))
-(defknown (%adjoin %adjoin-eq %member %member-eq
+(defknown (%adjoin %adjoin-eq)
+ (t list)
+ list
+ (explicit-check flushable))
+
+(defknown (%member %member-eq
%assoc %assoc-eq %rassoc %rassoc-eq)
(t list)
list
(explicit-check foldable flushable))
-(defknown (%adjoin-key %adjoin-key-eq %member-key %member-key-eq
+(defknown (%adjoin-key %adjoin-key-eq)
+ (t list function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-key %member-key-eq
%assoc-key %assoc-key-eq %rassoc-key %rassoc-key-eq)
(t list function)
list
list
(explicit-check foldable flushable call))
-(defknown (%adjoin-test %adjoin-test-not
- %member-test %member-test-not
+(defknown (%adjoin-test %adjoin-test-not)
+ (t list function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-test %member-test-not
%assoc-test %assoc-test-not
%rassoc-test %rassoc-test-not)
(t list function)
list
(explicit-check foldable flushable call))
-(defknown (%adjoin-key-test %adjoin-key-test-not
- %member-key-test %member-key-test-not
+(defknown (%adjoin-key-test %adjoin-key-test-not)
+ (t list function function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-key-test %member-key-test-not
%assoc-key-test %assoc-key-test-not
%rassoc-key-test %rassoc-key-test-not)
(t list function function)
\f
;;;; SETF inverses
-(defknown %aset (array &rest t) t ()
- :destroyed-constant-args (nth-constant-args 1))
+(defknown (setf aref) (t array &rest index) t ()
+ :destroyed-constant-args (nth-constant-args 2)
+ :derive-type #'result-type-first-arg)
(defknown %set-row-major-aref (array index t) t ()
:destroyed-constant-args (nth-constant-args 1))
(defknown (%rplaca %rplacd) (cons t) t ()
:derive-type #'result-type-last-arg)
(defknown %svset (simple-vector index t) t ()
:destroyed-constant-args (nth-constant-args 1))
-(defknown %bitset ((array bit) &rest index) bit ()
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %sbitset ((simple-array bit) &rest index) bit ()
- :destroyed-constant-args (nth-constant-args 1))
+(defknown (setf bit) (bit (array bit) &rest index) bit ()
+ :destroyed-constant-args (nth-constant-args 2))
+(defknown (setf sbit) (bit (simple-array bit) &rest index) bit ()
+ :destroyed-constant-args (nth-constant-args 2))
(defknown %charset (string index character) character ()
:destroyed-constant-args (nth-constant-args 1))
(defknown %scharset (simple-string index character) character ()
projects / sbcl.git / blobdiff