(defun result-type-open-class (call)
(declare (type sb-c::combination call))
(let* ((not-set '#:not-set)
- (not-constant '#:not-constant)
- (direction not-set)
- (if-exists not-set)
- (if-does-not-exist not-set)
- (class not-set))
+ (not-constant '#:not-constant)
+ (direction not-set)
+ (if-exists not-set)
+ (if-does-not-exist not-set)
+ (class not-set))
;; find (the first occurence of) each interesting keyword argument
(do ((args (cdr (combination-args call)) (cddr args)))
- ((null args))
+ ((null args))
(macrolet ((maybe-set (var)
- `(when (and (eq ,var not-set) (cadr args))
- (if (constant-continuation-p (cadr args))
- (setq ,var (continuation-value (cadr args)))
- (setq ,var not-constant)))))
- (case (continuation-value (car args))
- (:direction (maybe-set direction))
- (:if-exists (maybe-set if-exists))
- (:if-does-not-exist (maybe-set if-does-not-exist))
- (:class (maybe-set class)))))
+ `(when (and (eq ,var not-set) (cadr args))
+ (if (constant-continuation-p (cadr args))
+ (setq ,var (continuation-value (cadr args)))
+ (setq ,var not-constant)))))
+ (case (continuation-value (car args))
+ (:direction (maybe-set direction))
+ (:if-exists (maybe-set if-exists))
+ (:if-does-not-exist (maybe-set if-does-not-exist))
+ (:class (maybe-set class)))))
;; and set default values for any that weren't set above
(when (eq direction not-set) (setq direction :input))
(when (eq if-exists not-constant) (setq if-exists nil))
;; direction is :output or :io or not-constant and :if-exists is nil
;; :if-does-not-exist is nil
(if (or (and (or (eq direction :probe) (eq direction not-constant))
- (not (eq if-does-not-exist :error)))
- (and (or (eq direction :output) (eq direction :io)
- (eq direction not-constant))
- (eq if-exists nil))
- (eq if-does-not-exist nil))
+ (not (eq if-does-not-exist :error)))
+ (and (or (eq direction :output) (eq direction :io)
+ (eq direction not-constant))
+ (eq if-exists nil))
+ (eq if-does-not-exist nil))
(specifier-type `(or null ,class))
(specifier-type class))))
||#
-(handler-bind ((error #'(lambda (condition) (declare (ignore condition))
- (continue))))
+(handler-bind ((error #'continue))
(sb-c:defknown open (t &rest t
&key (:direction (member :input :output :io :probe))
(:element-type sb-kernel:type-specifier)
:rename-and-delete :overwrite
:append :supersede nil))
(:if-does-not-exist (member :error :create nil))
- (:external-format (member :default))
+ (:external-format keyword)
(:class (or symbol class))
(:mapped (member t nil))
(:input-handle (or null fixnum stream))
;; :derive-type #'result-type-open-class
)
- (sb-c:defknown listen (&optional sb-kernel:streamlike
- (or null (integer 1 10) (member 'character)))
+ (sb-c:defknown listen (&optional sb-kernel:stream-designator
+ (or null (integer 1 10) (member character)))
boolean (sb-c::unsafely-flushable sb-c::explicit-check))
(sb-c:defknown read-sequence (sequence stream &key (:start sb-int:index)