Debian Codegraph @

ext/uvector/uvlib.scm.tmpl

raw
1 ///; Process this file with uvgen.scm to generate uvlib.scm
2 ///; Lines beginning with '///' are directives for ugven.scm.
3
4 ;;;
5 ;;; Copyright (c) 2000-2014 Shiro Kawai, All rights reserved.
6 ;;;
7 ;;; Redistribution and use in source and binary forms, with or without
8 ;;; modification, are permitted provided that the following conditions
9 ;;; are met:
10 ;;;
11 ;;; 1. Redistributions of source code must retain the above copyright
12 ;;; notice, this list of conditions and the following disclaimer.
13 ;;;
14 ;;; 2. Redistributions in binary form must reproduce the above copyright
15 ;;; notice, this list of conditions and the following disclaimer in the
16 ;;; documentation and/or other materials provided with the distribution.
17 ;;;
18 ;;; 3. Neither the name of the authors nor the names of its contributors
19 ;;; may be used to endorse or promote products derived from this
20 ;;; software without specific prior written permission.
21 ;;;
22 ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
28 ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29 ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 ;;;
34
35 ///;; Begin template ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
36 ///;;
37 ///(define *tmpl-body* '(
38
39 ;;--------------------------------------------------------------------
40 ;; ${t}vector basic API
41 ;;
42
43 ;; NB: Predicates referencers and modifiers are in the core.
44
45 (define-cproc ${t}vector-empty? (v::<${t}vector>) ::<boolean>
46 (return (== (SCM_${T}VECTOR_SIZE v) 0)))
47
48 (define-cproc ${t}vector (:optarray (elts nelts 10) :rest args)
49 :fast-flonum
50 (cond [(SCM_NULLP args)
51 (return (Scm_ObjArrayTo${T}Vector elts nelts SCM_CLAMP_ERROR))]
52 [else
53 (let* ([i::int (- nelts 1)] [p args])
54 (for [() (>= i 0) (post-- i)]
55 (SCM_FLONUM_ENSURE_MEM (aref elts i))
56 (set! p (Scm_Cons (aref elts i) p)))
57 (return (Scm_ListToUVector SCM_CLASS_${T}VECTOR p SCM_CLAMP_ERROR)))]))
58
59 (define-cproc ${t}vector-length (v::<${t}vector>) ::<ulong> SCM_${T}VECTOR_SIZE)
60
61 (define-cproc ${t}vector-copy
62 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
63 Scm_${T}VectorCopy)
64
65 ;; NB: this function accommodates to two APIs.
66 ;; The 'modern' API, compatible to srfi-13 and srfi-43, takes arguments:
67 ;; (dst dstart src :optional sstart send)
68 ;; The old API only takes:
69 ;; (dst src)
70 ;; We dispatch by the second argument. The old API is deprecated, but
71 ;; kept for the existing code.
72 (define-cproc ${t}vector-copy!
73 (dst::<${t}vector> dstart :optional src (sstart::<int> 0) (send::<int> -1))
74 (SCM_UVECTOR_CHECK_MUTABLE dst)
75 (cond
76 [(SCM_INTEGERP dstart) ; new API
77 (unless (SCM_${T}VECTORP src)
78 (Scm_Error "${t}vector-copy!: argument is not a matching uvector: %S"src))
79 (return (Scm_${T}VectorCopyX dst (Scm_GetInteger dstart)
80 (SCM_${T}VECTOR src) sstart send))]
81 [(SCM_${T}VECTORP dstart) ; old API
82 (return (Scm_${T}VectorCopyX dst 0 (SCM_${T}VECTOR dstart) 0 -1))]
83 [else (SCM_TYPE_ERROR dstart "integer") (return SCM_UNDEFINED)]))
84
85 (define-cproc ${t}vector-reverse-copy
86 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
87 (let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)])
88 (SCM_CHECK_START_END start end len)
89 (let* ([r::ScmUVector* (SCM_UVECTOR (Scm_Make${T}Vector (- end start)
90 (C: "${ZERO}")))]
91 [i::ScmSmallInt (- end 1)]
92 [j::ScmSmallInt 0])
93 (while (>= i start)
94 (set! (SCM_${T}VECTOR_ELEMENT r j) (SCM_${T}VECTOR_ELEMENT v i))
95 (post-- i)
96 (post++ j))
97 (return (SCM_OBJ r)))))
98
99 (define-cproc ${t}vector-reverse-copy!
100 (dst::<${t}vector> dstart::<fixnum> src::<${t}vector>
101 :optional (sstart::<fixnum> 0) (send::<fixnum> -1))
102 ::<void>
103 (let* ([dlen::ScmSmallInt (SCM_UVECTOR_SIZE dst)]
104 [slen::ScmSmallInt (SCM_UVECTOR_SIZE src)]
105 [dend::ScmSmallInt -1])
106 (SCM_UVECTOR_CHECK_MUTABLE dst)
107 (SCM_CHECK_START_END sstart send slen)
108 (SCM_CHECK_START_END dstart dend dlen)
109 (set! dend (+ dstart (- send sstart)))
110 (when (> dend dlen)
111 (Scm_Error "Copy region is out of bound, from [%d,%d]%S to [%d,%d]%S"
112 sstart send (SCM_OBJ src)
113 dstart dend (SCM_OBJ dst)))
114 (while (>= (pre-- dend) dstart)
115 (set! (SCM_${T}VECTOR_ELEMENT dst dend)
116 (SCM_${T}VECTOR_ELEMENT src sstart))
117 (post++ sstart))))
118
119 ;; multi-copy! - copy src repeatedly to different parts of dst.
120 (define-cproc ${t}vector-multi-copy!
121 (dst::<${t}vector> dstart::<fixnum> dstride::<fixnum>
122 src::<${t}vector> :optional (sstart::<fixnum> 0) (ssize::<fixnum> 0)
123 (sstride::<fixnum> -1) (count::<fixnum> -1))
124 ::<void>
125 (SCM_UVECTOR_CHECK_MUTABLE dst)
126 (when (< sstride 0)
127 (if (<= ssize 0) (set! sstride 0) (set! sstride ssize)))
128 (when (<= ssize 0)
129 (set! ssize (- (SCM_UVECTOR_SIZE src) sstart)))
130 (let* ([di::long dstart] [si::long sstart]
131 [dlen::long (SCM_UVECTOR_SIZE dst)]
132 [slen::long (SCM_UVECTOR_SIZE src)]
133 [c::long 0]
134 [cnt::long (?: (< count 0) LONG_MAX count)])
135 (if (== ssize 1)
136 ;; shortcut for optimization
137 (for [() (and (< c cnt) (< di dlen) (< si slen)) (inc! c)]
138 (set! (SCM_${T}VECTOR_ELEMENT dst di)
139 (SCM_${T}VECTOR_ELEMENT src si))
140 (+= di dstride)
141 (+= si sstride))
142 ;; general case
143 (for [() (and (< c cnt) (< di dlen) (< si slen)) (inc! c)]
144 (let* ([nitems::long ssize])
145 (when (< dlen (+ di nitems)) (set! nitems (- dlen di)))
146 (when (< slen (+ si nitems)) (set! nitems (- slen si)))
147 (memmove (+ (SCM_${T}VECTOR_ELEMENTS dst) di)
148 (+ (SCM_${T}VECTOR_ELEMENTS src) si)
149 (* nitems (sizeof (.type ${etype})))))
150 (+= di dstride)
151 (+= si sstride)))))
152
153 (define-cproc ${t}vector->list
154 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
155 Scm_${T}VectorToList)
156
157 (define-cproc reverse-${t}vector->list
158 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
159 (let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)]
160 [h SCM_NIL] [t SCM_NIL] [e::(${etype})] [z])
161 (SCM_CHECK_START_END start end len)
162 (pre-- end)
163 (while (<= start end)
164 (set! e (SCM_${T}VECTOR_ELEMENT v end))
165 (C: "${BOX z e}")
166 (SCM_APPEND1 h t z)
167 (pre-- end))
168 (return h)))
169
170 (define-cproc list->${t}vector (l::<list> :optional clamp)
171 (return (Scm_ListToUVector SCM_CLASS_${T}VECTOR l (Scm_ClampMode clamp))))
172
173 (define (reverse-list->${t}vector l :optional (clamp #f))
174 (let* ([len (length l)]
175 [v (make-${t}vector len)])
176 (do [(l l (cdr l))
177 (i (- len 1) (- i 1))]
178 [(< i 0) v]
179 (${t}vector-set! v i (car l) clamp))))
180
181 (define-cproc ${t}vector-fill!
182 (v::<${t}vector> val :optional (start::<fixnum> 0) (end::<fixnum> -1)) ::<void>
183 (let* ([filler :: (${etype})])
184 (C: "${UNBOX filler val SCM_CLAMP_ERROR}")
185 (Scm_${T}VectorFill v filler start end)))
186
187 (define-cproc ${t}vector->vector
188 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
189 Scm_${T}VectorToVector)
190
191 (define-cproc vector->${t}vector
192 (v::<vector> :optional (start::<fixnum> 0) (end::<fixnum> -1) clamp)
193 (return (Scm_VectorTo${T}Vector v start end (Scm_ClampMode clamp))))
194
195 (define-cproc ${t}vector=? ; srfi-66
196 (a::<${t}vector> b::<${t}vector>) ; we just typecheck args and call equal?
197 ::<boolean>
198 (return (Scm_EqualP (SCM_OBJ a) (SCM_OBJ b))))
199
200 (define-cproc ${t}vector-compare ; srfi-66
201 (a::<${t}vector> b::<${t}vector>) ; we just typecheck args and call compare
202 ::<int>
203 (return (Scm_Compare (SCM_OBJ a) (SCM_OBJ b))))
204
205 ;;;
206 ;;; Some srfi-160 procedures
207 ;;;
208
209 ;; Constructors
210 (define (${t}vector-unfold f len seed)
211 (let1 rvec (make-${t}vector len)
212 (let loop ([i 0] [seed seed])
213 (if (= i len)
214 rvec
215 (receive (e seed) (f i seed)
216 (${t}vector-set! rvec i e)
217 (loop (+ i 1) seed))))))
218 (define (${t}vector-unfold-right f len seed)
219 (let1 rvec (make-${t}vector len)
220 (let loop ([i (- len 1)] [seed seed])
221 (if (< i 0)
222 rvec
223 (receive (e seed) (f i seed)
224 (${t}vector-set! rvec i e)
225 (loop (- i 1) seed))))))
226
227 (define (${t}vector-concatenate vs)
228 (let* ([size (fold (^[v l] (+ (${t}vector-length v) l)) 0 vs)]
229 [dst (make-${t}vector size)])
230 (do ([vs vs (cdr vs)]
231 [k 0 (+ k (${t}vector-length (car vs)))])
232 [(null? vs) dst]
233 (${t}vector-copy! dst k (car vs)))))
234 (define (${t}vector-append . vs) (${t}vector-concatenate vs))
235
236 (define-cproc ${t}vector-append-subvectors (:rest args)
237 ;; first path - check args and lengths
238 (unless (== (% (Scm_Length args) 3) 0)
239 (Scm_Error "Argument count isn't a multiple of 3: %S" args))
240 (let* ([total::ScmSmallInt 0]
241 [lis args])
242 (while (SCM_PAIRP lis)
243 (let* ([v (SCM_CAR lis)]
244 [s (SCM_CADR lis)]
245 [e (SCM_CAR (SCM_CDDR lis))])
246 (unless (SCM_${T}VECTORP v)
247 (Scm_Error "<${t}vector> expected, but got: %S" v))
248 (unless (SCM_INTP s)
249 (Scm_Error "fixnum expected for start, but got: %S" s))
250 (unless (SCM_INTP e)
251 (Scm_Error "fixnum expected for end, but got: %S" e))
252 (let* ([start::ScmSmallInt (SCM_INT_VALUE s)]
253 [end::ScmSmallInt (SCM_INT_VALUE e)]
254 [len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)])
255 (SCM_CHECK_START_END start end len)
256 (+= total (- end start)))
257 (set! lis (SCM_CDR (SCM_CDDR lis)))))
258 ;; Second path - fill it
259 (let* ([r (Scm_Make${T}Vector total (C: "${ZERO}"))]
260 [i::ScmSmallInt 0]
261 [lis args])
262 (while (SCM_PAIRP lis)
263 (let* ([v (SCM_CAR lis)]
264 [start::ScmSmallInt (SCM_INT_VALUE (SCM_CADR lis))]
265 [end::ScmSmallInt (SCM_INT_VALUE (SCM_CAR (SCM_CDDR lis)))]
266 [len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)])
267 (SCM_CHECK_START_END start end len)
268 (let* ([j::ScmSmallInt start])
269 (while (< j end)
270 (set! (SCM_${T}VECTOR_ELEMENT r i)
271 (SCM_${T}VECTOR_ELEMENT v j))
272 (pre++ i)
273 (pre++ j))))
274 (set! lis (SCM_CDR (SCM_CDDR lis))))
275 (return r))))
276
277 ;; Iteration
278
279 (define (${t}vector-take v n) (${t}vector-copy v 0 n))
280 (define (${t}vector-take-right v n)
281 (${t}vector-copy v (- (${t}vector-length v) n)))
282 (define (${t}vector-drop v n) (${t}vector-copy v n))
283 (define (${t}vector-drop-right v n)
284 (${t}vector-copy v 0 (- (${t}vector-length v) n)))
285 (define (${t}vector-segment v n)
286 (define (rec i len vs)
287 (if (<= (- len i) n)
288 (reverse (cons (${t}vector-copy v i) vs))
289 (rec (+ i n) len
290 (cons (${t}vector-copy v i (+ i n)) vs))))
291 (unless (and (exact-integer? n)
292 (positive? n))
293 (error "positive exact integer required, but got:" n))
294 (rec 0 (${t}vector-length v) '()))
295 (define (${t}vector= a b . rest) ; can have shortcut of 3 arg case as well
296 (and (${t}vector=? a b)
297 (or (null? rest)
298 (apply ${t}vector= b rest))))
299
300 (define (%minlen vec vecs)
301 (apply min (uvector-length vec) (map uvector-length vecs)))
302 (define (%vecrefs i vec vecs)
303 (cons (uvector-ref vec i) (map (cut uvector-ref <> i) vecs)))
304
305 (define (${t}vector-fold kons knil vec . vecs)
306 (if (null? vecs)
307 (let1 len (${t}vector-length vec)
308 (do ([i 0 (+ i 1)]
309 [seed knil (kons seed (${t}vector-ref vec i))])
310 [(= i len) seed]))
311 (let1 len (%minlen vec vecs)
312 (do ([i 0 (+ i 1)]
313 [seed knil (apply kons seed (%vecrefs i vec vecs))])
314 [(= i len) seed]))))
315 (define (${t}vector-fold-right kons knil vec . vecs)
316 (if (null? vecs)
317 (let1 len (${t}vector-length vec)
318 (do ([i (- len 1) (- i 1)]
319 [seed knil (kons (${t}vector-ref vec i) seed)])
320 [(< i 0) seed]))
321 (let1 len (%minlen vec vecs)
322 (do ([i (- len 1) (- i 1)]
323 [seed knil (apply kons seed (%vecrefs i vec vecs))])
324 [(< i 0) seed]))))
325 (define (${t}vector-map proc vec . vecs)
326 (if (null? vecs)
327 ;; we need intermediate list to be restart-safe
328 (let1 len (${t}vector-length vec)
329 (do ([i 0 (+ i 1)]
330 [rs '() (cons (proc (${t}vector-ref vec i)) rs)])
331 [(= i len) (list->${t}vector (reverse rs))]))
332 (let1 len (%minlen vec vecs)
333 (do ([i 0 (+ i 1)]
334 [rs '() (cons (apply proc (%vecrefs i vec vecs)) rs)])
335 [(= i len) (list->${t}vector (reverse rs))]))))
336 (define (${t}vector-map! proc vec . vecs)
337 (if (null? vecs)
338 (let1 len (${t}vector-length vec)
339 (do ([i 0 (+ i 1)])
340 [(= i len) vec]
341 (${t}vector-set! vec i (proc (${t}vector-ref vec i)))))
342 (let1 len (%minlen vec vecs)
343 (do ([i 0 (+ i 1)])
344 [(= i len) vec]
345 (${t}vector-set! vec i (apply proc (%vecrefs i vec vecs)))))))
346 (define (${t}vector-for-each proc vec . vecs)
347 (if (null? vecs)
348 (let1 len (${t}vector-length vec)
349 (do ([i 0 (+ i 1)])
350 [(= i len) (undefined)]
351 (proc (${t}vector-ref vec i))))
352 (let1 len (%minlen vec vecs)
353 (do ([i 0 (+ i 1)])
354 [(= i len) (undefined)]
355 (apply proc (%vecrefs i vec vecs))))))
356 (define (${t}vector-count pred vec . vecs)
357 (if (null? vecs)
358 (let1 len (${t}vector-length vec)
359 (do ([i 0 (+ i 1)]
360 [c 0 (if (pred (${t}vector-ref vec i)) (+ c 1) c)])
361 [(= i len) c]))
362 (let1 len (%minlen vec vecs)
363 (do ([i 0 (+ i 1)]
364 [c 0 (if (apply pred (%vecrefs i vec vecs)) (+ c 1) c)])
365 [(= i len) c]))))
366 (define (${t}vector-cumulate proc knil vec)
367 (let* ([len (${t}vector-length vec)]
368 [rvec (make-${t}vector len)])
369 (do ([i 0 (+ i 1)]
370 [seed knil
371 (rlet1 seed (proc seed (${t}vector-ref vec i))
372 (${t}vector-set! rvec i seed))])
373 [(= i len) rvec])))
374
375 ;; Searching
376
377 (define (${t}vector-take-while pred vec)
378 (let1 len (${t}vector-length vec)
379 (let loop ([i 0] [r '()])
380 (if (= i len)
381 (list->${t}vector (reverse r))
382 (let1 e (${t}vector-ref vec i)
383 (if (pred e)
384 (loop (+ i 1) (cons e r))
385 (list->${t}vector (reverse r))))))))
386 (define (${t}vector-take-while-right pred vec)
387 (let1 len (${t}vector-length vec)
388 (let loop ([i (- len 1)] [r '()])
389 (if (< i 0)
390 (list->${t}vector r)
391 (let1 e (${t}vector-ref vec i)
392 (if (pred e)
393 (loop (- i 1) (cons e r))
394 (list->${t}vector r)))))))
395 (define (${t}vector-drop-while pred vec)
396 (let1 len (${t}vector-length vec)
397 (let loop ([i 0])
398 (if (= i len)
399 (make-${t}vector 0)
400 (let1 e (${t}vector-ref vec i)
401 (if (pred e)
402 (loop (+ i 1))
403 (${t}vector-copy vec i)))))))
404 (define (${t}vector-drop-while-right pred vec)
405 (let1 len (${t}vector-length vec)
406 (let loop ([i (- len 1)])
407 (if (< i 0)
408 (make-${t}vector 0)
409 (let1 e (${t}vector-ref vec i)
410 (if (pred e)
411 (loop (- i 1))
412 (${t}vector-copy vec 0 (+ i 1))))))))
413
414 (define (${t}vector-index pred vec . vecs)
415 (if (null? vecs)
416 (let1 len (${t}vector-length vec)
417 (let loop ([i 0])
418 (cond [(= i len) #f]
419 [(pred (${t}vector-ref vec i)) i]
420 [else (loop (+ i 1))])))
421 (let1 len (%minlen vec vecs)
422 (let loop ([i 0])
423 (cond [(= i len) #f]
424 [(apply pred (%vecrefs i vec vecs)) i]
425 [else (loop (+ i 1))])))))
426 (define (${t}vector-index-right pred vec . vecs)
427 (if (null? vecs)
428 (let1 len (${t}vector-length vec)
429 (let loop ([i (- len 1)])
430 (cond [(< i 0) #f]
431 [(pred (${t}vector-ref vec i)) i]
432 [else (loop (- i 1))])))
433 (let1 len (%minlen vec vecs)
434 (let loop ([i (- len 1)])
435 (cond [(< i 0) #f]
436 [(apply pred (%vecrefs i vec vecs)) i]
437 [else (loop (- i 1))])))))
438 (define (${t}vector-skip pred vec . vecs)
439 (if (null? vecs)
440 (let1 len (${t}vector-length vec)
441 (let loop ([i 0])
442 (cond [(= i len) #f]
443 [(pred (${t}vector-ref vec i)) (loop (+ i 1))]
444 [else i])))
445 (let1 len (%minlen vec vecs)
446 (let loop ([i 0])
447 (cond [(= i len) #f]
448 [(apply pred (%vecrefs i vec vecs)) (loop (+ i 1))]
449 [else i])))))
450 (define (${t}vector-skip-right pred vec . vecs)
451 (if (null? vecs)
452 (let1 len (${t}vector-length vec)
453 (let loop ([i (- len 1)])
454 (cond [(< i 0) #f]
455 [(pred (${t}vector-ref vec i)) (loop (- i 1))]
456 [else i])))
457 (let1 len (%minlen vec vecs)
458 (let loop ([i (- len 1)])
459 (cond [(< i 0) #f]
460 [(apply pred (%vecrefs i vec vecs)) (loop (- i 1))]
461 [else i])))))
462 (define (${t}vector-any pred vec . vecs)
463 (if (null? vecs)
464 (let1 len (${t}vector-length vec)
465 (let loop ([i 0])
466 (cond [(= i len) #f]
467 [(pred (${t}vector-ref vec i))]
468 [else (loop (+ i 1))])))
469 (let1 len (%minlen vec vecs)
470 (let loop ([i 0])
471 (cond [(= i len) #f]
472 [(apply pred (%vecrefs i vec vecs))]
473 [else (loop (+ i 1))])))))
474 (define (${t}vector-every pred vec . vecs)
475 (if (null? vecs)
476 (let1 len (${t}vector-length vec)
477 (let loop ([i 0] [last #t])
478 (cond [(= i len) last]
479 [(pred (${t}vector-ref vec i)) => (^r (loop (+ i 1) r))]
480 [else #f])))
481 (let1 len (%minlen vec vecs)
482 (let loop ([i 0] [last #t])
483 (cond [(= i len) last]
484 [(apply pred (%vecrefs i vec vecs)) => (^r (loop (+ i 1) r))]
485 [else #f])))))
486 (define (${t}vector-partition pred vec)
487 (let1 len (${t}vector-length vec)
488 (let loop ([i 0] [ins '()] [outs '()])
489 (if (= i len)
490 (do ([rvec (make-${t}vector len)]
491 [rs (reverse ins (reverse outs)) (cdr rs)]
492 [i 0 (+ i 1)])
493 [(= i len) (values rvec (length ins))]
494 (${t}vector-set! rvec i (car rs)))
495 (let1 e (${t}vector-ref vec i)
496 (if (pred e)
497 (loop (+ i 1) (cons e ins) outs)
498 (loop (+ i 1) ins (cons e outs))))))))
499
500 (define (${t}vector-filter pred vec)
501 (let1 len (${t}vector-length vec)
502 (let loop ([i 0] [rs '()])
503 (if (= i len)
504 (list->${t}vector (reverse rs))
505 (let1 e (${t}vector-ref vec i)
506 (loop (+ i 1) (if (pred e) (cons e rs) rs)))))))
507 (define (${t}vector-remove pred vec)
508 (let1 len (${t}vector-length vec)
509 (let loop ([i 0] [rs '()])
510 (if (= i len)
511 (list->${t}vector (reverse rs))
512 (let1 e (${t}vector-ref vec i)
513 (loop (+ i 1) (if (pred e) rs (cons e rs))))))))
514
515 ;; Mutators
516
517 (define-cproc ${t}vector-swap! (v::<${t}vector> i::<fixnum> j::<fixnum>) ::<void>
518 (SCM_UVECTOR_CHECK_MUTABLE v)
519 (unless (and (<= 0 i) (< i (SCM_${T}VECTOR_SIZE v)))
520 (Scm_Error "Index i out of bound: %d" i))
521 (unless (and (<= 0 j) (< j (SCM_${T}VECTOR_SIZE v)))
522 (Scm_Error "Index j out of bound: %d" j))
523 (let* ([e::(${etype}) (SCM_${T}VECTOR_ELEMENT v i)])
524 (set! (SCM_${T}VECTOR_ELEMENT v i) (SCM_${T}VECTOR_ELEMENT v j))
525 (set! (SCM_${T}VECTOR_ELEMENT v j) e)))
526
527 (define-cproc ${t}vector-reverse!
528 (v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) ::<void>
529 (SCM_UVECTOR_CHECK_MUTABLE v)
530 (let* ([len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)])
531 (SCM_CHECK_START_END start end len)
532 (let* ([i::ScmSmallInt start]
533 [j::ScmSmallInt (- end 1)]
534 [e::(${etype})])
535 (while (< i j)
536 (set! e (SCM_${T}VECTOR_ELEMENT v i))
537 (set! (SCM_${T}VECTOR_ELEMENT v i) (SCM_${T}VECTOR_ELEMENT v j))
538 (set! (SCM_${T}VECTOR_ELEMENT v j) e)
539 (pre++ i)
540 (pre-- j)))))
541
542 (define (${t}vector-unfold! f v start end seed)
543 (let loop ([i start] [seed seed])
544 (when (< i end)
545 (receive (e seed) (f i seed)
546 (${t}vector-set! v i e)
547 (loop (+ i 1) seed)))))
548
549 (define (${t}vector-unfold-right! f v start end seed)
550 (let loop ([i (- end 1)] [seed seed])
551 (when (>= i start)
552 (receive (e seed) (f i seed)
553 (${t}vector-set! v i e)
554 (loop (- i 1) seed)))))
555
556 ;; Generators
557
558 (define (make-${t}vector-generator vec)
559 (assume-type vec <${t}vector>)
560 (uvector->generator vec))
561
562 ;; Comparator
563
564 (define ${t}vector-comparator
565 (make-comparator ${t}vector? ${t}vector=
566 (^[a b] (< (compare a b) 0))
567 default-hash))
568
569 ;; Output
570
571 (define (write-${t}vector vec :optional (port (current-output-port)))
572 (assume-type vec <${t}vector>)
573 (write vec port))
574
575 ;;;
576 ;;; Sequence protocol implementation
577 ;;;
578
579 ;; call-with-iterator - in gauche.collection
580
581 (define-method call-with-builder ((v <${t}vector-meta>) proc :key (size #f))
582 (if size
583 (let ([v (make-${t}vector size)] [i 0])
584 (proc (^[item] (${t}vector-set! v i item) (inc! i))
585 (^[] v)))
586 (let1 q '()
587 (proc (^[item] (push! q item))
588 (^[] (reverse-list->${t}vector q))))
589 ))
590
591 (define-method referencer ((v <${t}vector>)) ${t}vector-ref)
592 (define-method modifier ((v <${t}vector>)) ${t}vector-set!)
593 (define-method size-of ((v <${t}vector>)) (${t}vector-length v))
594 (define-method coerce-to ((c <list-meta>) (v <${t}vector>))
595 (${t}vector->list v))
596 (define-method coerce-to ((c <${t}vector-meta>) (v <list>))
597 (list->${t}vector v))
598 (define-method coerce-to ((c <vector-meta>) (v <${t}vector>))
599 (${t}vector->vector v))
600 (define-method coerce-to ((c <${t}vector-meta>) (v <vector>))
601 (vector->${t}vector v))
602 (define-method coerce-to ((c <${t}vector-meta>) (v <${t}vector>))
603 (${t}vector-copy v))
604 (define-method subseq ((v <${t}vector>) . args)
605 (apply ${t}vector-copy v args))
606
607
608 ///)) ;; end of tmpl-body
609
610 ///(define *tmpl-numop* '(
611 (define-cproc ${t}vector-${opname} (v0::<${t}vector> v1 :optional clamp)
612 :fast-flonum
613 (return (Scm_${T}Vector${Opname} v0 v1 (Scm_ClampMode clamp))))
614
615 (define-cproc ${t}vector-${opname}! (v0::<${t}vector> v1 :optional clamp)
616 :fast-flonum
617 (return (Scm_${T}Vector${Opname}X v0 v1 (Scm_ClampMode clamp))))
618 ///)) ;; end of tmpl-numop
619
620 ///(define *tmpl-bitop* '(
621 (define-cproc ${t}vector-${opname} (v0::<${t}vector> v1)
622 (return (Scm_${T}Vector${Opname} v0 v1)))
623
624 (define-cproc ${t}vector-${opname}! (v0::<${t}vector> v1)
625 (return (Scm_${T}Vector${Opname}X v0 v1)))
626 ///)) ;; end of tmpl-bitop
627
628 ///(define *tmpl-dotop* '(
629 (define-cproc ${t}vector-dot (v0::<${t}vector> v1) Scm_VM${T}VectorDotProd)
630 ///)) ;; end of tmpl-dotop
631
632 ///(define *tmpl-rangeop* '(
633 (define-cproc ${t}vector-${opname} (v0::<${t}vector> min max)
634 Scm_${T}Vector${Opname})
635 ///)) ;; end of tmpl-rangeop
636
637 ///(define *tmpl-swapb* '(
638 (define-cproc ${t}vector-swap-bytes (v0::<${t}vector>) Scm_${T}VectorSwapBytes)
639 (define-cproc ${t}vector-swap-bytes!(v0::<${t}vector>) Scm_${T}VectorSwapBytesX)
640 ///)) ;; end of tmpl-rangeop
641
642 ///(define *extra-procedure* ;; procedurally generates code
643 /// (lambda ()
644 /// (generate-numop)
645 /// (generate-bitop)
646 /// (generate-dotop)
647 /// (generate-rangeop)
648 /// (generate-swapb)
649 ///)) ;; end of extra-procedure
650
651 ///; Local variables:
652 ///; mode: scheme
653 ///; end: