(typecase expanded-type
(atom (cond
((eq expanded-type 'string) '(vector character))
- ((eq expanded-type 'simple-string) '(simple-array character (*)))
+ ((eq expanded-type 'simple-string)
+ '(simple-array character (*)))
(t type)))
(cons (cond
- ((eq (car expanded-type) 'string) `(vector character ,@(cdr expanded-type)))
+ ((eq (car expanded-type) 'string)
+ `(vector character ,@(cdr expanded-type)))
((eq (car expanded-type) 'simple-string)
`(simple-array character ,(if (cdr expanded-type)
(cdr expanded-type)
'(*))))
- (t type)))
- (t type)))
+ (t type)))))
(type (specifier-type adjusted-type)))
(cond ((csubtypep type (specifier-type 'list))
(cond
(let ((,sequence ,s))
(seq-dispatch ,sequence
(dolist (,e ,sequence ,return) ,@body)
- (dovector (,e ,sequence ,return) ,@body)
+ (do-vector-data (,e ,sequence ,return) ,@body)
(multiple-value-bind (state limit from-end step endp elt)
(sb!sequence:make-sequence-iterator ,sequence)
(do ((state state (funcall step ,sequence state from-end)))
(type list sequences))
(let ((index start))
(declare (type index index))
- (if (and sequences (null (rest sequences)))
- ;; do it manually when there is 1 input sequence
- (with-array-data ((src (first sequences)) (src-start) (src-end)
- :check-fill-pointer t)
- (let ((src-index src-start))
- (declare (type index src-index))
- (loop until (or (eql src-index src-end)
- (eql index end))
- do (setf (aref data index) (funcall fun (aref src src-index)))
- (incf index)
- (incf src-index))))
- (block mapping
- (map-into-lambda sequences (&rest args)
- (declare (truly-dynamic-extent args))
- (when (eql index end)
- (return-from mapping))
- (setf (aref data index) (apply fun args))
- (incf index))))
+ (block mapping
+ (map-into-lambda sequences (&rest args)
+ (declare (truly-dynamic-extent args))
+ (when (eql index end)
+ (return-from mapping))
+ (setf (aref data index) (apply fun args))
+ (incf index)))
index))
;;; Uses the machinery of (MAP NIL ...). For non-vectors we avoid
;; from the old seq.lisp into target-seq.lisp.
(define-compiler-macro ,name (pred first-seq &rest more-seqs)
(let ((elements (make-gensym-list (1+ (length more-seqs))))
- (blockname (gensym "BLOCK")))
+ (blockname (sb!xc:gensym "BLOCK")))
(once-only ((pred pred))
`(block ,blockname
(map nil
((simple-array base-char (*)) (frob2))
,@(when bit-frob
`((simple-bit-vector
- (if (and (eq #'identity key)
+ (if (and (typep item 'bit)
+ (eq #'identity key)
(or (eq #'eq test)
(eq #'eql test)
(eq #'equal test)))
- (let ((p (%bit-position (the bit item) sequence
+ (let ((p (%bit-position item sequence
from-end start end)))
(if p
(values item p)