Debian Codegraph @

src/libvec.scm

raw
1 ;;;
2 ;;; libvec.scm - builtin vector procedures
3 ;;;
4 ;;; Copyright (c) 2000-2024 Shiro Kawai <[email protected]>
5 ;;;
6 ;;; Redistribution and use in source and binary forms, with or without
7 ;;; modification, are permitted provided that the following conditions
8 ;;; are met:
9 ;;;
10 ;;; 1. Redistributions of source code must retain the above copyright
11 ;;; notice, this list of conditions and the following disclaimer.
12 ;;;
13 ;;; 2. Redistributions in binary form must reproduce the above copyright
14 ;;; notice, this list of conditions and the following disclaimer in the
15 ;;; documentation and/or other materials provided with the distribution.
16 ;;;
17 ;;; 3. Neither the name of the authors nor the names of its contributors
18 ;;; may be used to endorse or promote products derived from this
19 ;;; software without specific prior written permission.
20 ;;;
21 ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 ;;;
33
34 (select-module gauche.internal)
35
36 (inline-stub
37 (.include "gauche/priv/configP.h"
38 "gauche/vminsn.h"
39 "gauche/priv/vectorP.h"
40 "gauche/priv/bytesP.h"
41 "gauche/priv/mmapP.h"))
42
43 ;;;
44 ;;; Standard Vector
45 ;;;
46
47 ;; NB: make-vector is defined in libalpha.scm
48
49 (select-module scheme)
50
51 (define-cproc vector (:rest args) (inliner VEC)
52 (return (Scm_ListToVector args 0 -1)))
53
54 (define-cproc vector? (obj) ::<boolean> :fast-flonum :constant
55 (inliner VECTORP) SCM_VECTORP)
56
57 (define-cproc vector-length (vec::<vector>) ::<fixnum> :constant
58 (inliner VEC-LEN) SCM_VECTOR_SIZE)
59
60 (define-cproc vector-ref (vec::<vector> k::<integer> :optional fallback)
61 :constant
62 (setter vector-set!)
63 (cond [(or (SCM_BIGNUMP k)
64 (< (SCM_INT_VALUE k) 0)
65 (>= (SCM_INT_VALUE k) (SCM_VECTOR_SIZE vec)))
66 (when (SCM_UNBOUNDP fallback)
67 (Scm_Error "vector-ref index out of range: %S" k))
68 (return fallback)]
69 [else (return (SCM_VECTOR_ELEMENT vec (SCM_INT_VALUE k)))]))
70
71 (define-cproc vector-set! (vec::<vector> k::<integer> obj) ::<void>
72 (begin
73 (SCM_VECTOR_CHECK_MUTABLE vec)
74 (if (or (SCM_BIGNUMP k)
75 (< (SCM_INT_VALUE k) 0)
76 (>= (SCM_INT_VALUE k) (SCM_VECTOR_SIZE vec)))
77 (Scm_Error "vector-set! index out of range: %S" k)
78 (set! (SCM_VECTOR_ELEMENT vec (SCM_INT_VALUE k)) obj))))
79
80 (define-cproc vector->list
81 (vec::<vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
82 Scm_VectorToList)
83
84 (define-cproc list->vector
85 (list::<list> :optional (start::<fixnum> 0) (end::<fixnum> -1))
86 Scm_ListToVector)
87
88 (define-cproc vector-fill!
89 (vec::<vector> fill :optional (start::<fixnum> 0) (end::<fixnum> -1))
90 ::<void> Scm_VectorFill)
91
92 (define-cproc vector-copy
93 (v::<vector> :optional (start::<fixnum> 0) (end::<fixnum> -1) fill)
94 Scm_VectorCopy)
95
96 (define-cproc vector-copy!
97 (t::<vector> tstart::<fixnum> s::<vector>
98 :optional (sstart::<fixnum> 0) (send::<fixnum> -1)) ::<void>
99 (let* ([tsize::long (SCM_VECTOR_SIZE t)])
100 (SCM_VECTOR_CHECK_MUTABLE t)
101 (when (< send 0) (set! send (SCM_VECTOR_SIZE s)))
102 (unless (and (<= 0 tstart) (<= tstart tsize))
103 (Scm_Error "tstart out of range: %ld" tstart))
104 (unless (and (<= 0 sstart) (<= sstart (SCM_VECTOR_SIZE s)))
105 (Scm_Error "sstart out of range: %ld" sstart))
106 (unless (and (<= 0 send) (<= send (SCM_VECTOR_SIZE s)))
107 (Scm_Error "send out of range: %ld" send))
108 (unless (<= (+ tstart (- send sstart)) tsize)
109 (Scm_Error "source vector overruns the target vector: %20.0S [%ld,%ld]"
110 s sstart send))
111 (unless (<= sstart send)
112 (Scm_Error "send (%ld) must be greater than or equal to sstart (%ld)"
113 send sstart))
114 (if (<= tstart sstart)
115 (let* ([i::ScmSmallInt sstart] [j::ScmSmallInt tstart])
116 (for [() (and (< i send) (< j tsize)) (begin (post++ i) (post++ j))]
117 (set! (SCM_VECTOR_ELEMENT t j) (SCM_VECTOR_ELEMENT s i))))
118 (let* ([i::ScmSmallInt send]
119 [j::ScmSmallInt (+ tstart (- send sstart))])
120 (when (>= j tsize)
121 (set! i (- i (- j tsize)))
122 (set! j tsize))
123 (for [(begin (post-- i) (post-- j))
124 (and (>= i sstart) (>= j tstart))
125 (begin (post-- i) (post-- j))]
126 (set! (SCM_VECTOR_ELEMENT t j) (SCM_VECTOR_ELEMENT s i)))))))
127
128 (define-cproc vector-append (:rest vecs)
129 (let* ([len::long 0]
130 [_ (dolist [v vecs]
131 (unless (SCM_VECTORP v)
132 (Scm_Error "vector required, but got: %S" v))
133 (set! len (+ len (SCM_VECTOR_SIZE v))))]
134 [dst (Scm_MakeVector len SCM_UNDEFINED)]
135 [j::long 0])
136 (dolist [v vecs]
137 (let* ([k::long (SCM_VECTOR_SIZE v)])
138 (memcpy (+ (SCM_VECTOR_ELEMENTS dst) j) (SCM_VECTOR_ELEMENTS v)
139 (* k (sizeof ScmWord)))
140 (set! j (+ j k))))
141 (return dst)))
142
143 (select-module gauche)
144 (define-cproc vector-immutable? (v::<vector>) ::<boolean>
145 SCM_VECTOR_IMMUTABLE_P)
146
147 (select-module gauche)
148 ;; R7RS
149 (define-in-module scheme (vector->string v :optional (start 0)
150 (end (vector-length v)))
151 (assume-type v <vector>)
152 (assume (exact-integer? start))
153 (assume (exact-integer? end))
154 (with-output-to-string
155 (^[]
156 (do ([i start (+ i 1)])
157 ((>= i end))
158 (write-char (vector-ref v i))))))
159 (define-in-module scheme (string->vector s :optional
160 (start (string-cursor-start s))
161 (end (string-cursor-end s)))
162 (assume-type s <string>)
163 (let* ([ss (string-index->cursor s start)]
164 [ee (string-index->cursor s end)]
165 [size (string-cursor-diff s ss ee)])
166 (when (< size 0)
167 (error "End point precedes start point" (list start end)))
168 (rlet1 v (make-vector size)
169 (do ([ss ss (string-cursor-next s ss)]
170 [i 0 (+ i 1)])
171 [(string-cursor>=? ss ee)]
172 (vector-set! v i (string-ref s ss))))))
173
174 ;;;
175 ;;; Weak vectors
176 ;;;
177
178 (select-module gauche)
179
180 (define-cproc make-weak-vector (size::<fixnum>) Scm_MakeWeakVector)
181
182 (define-cproc weak-vector-length (wv::<weak-vector>) ::<int>
183 (return (-> wv size)))
184
185 (define-cproc weak-vector-ref
186 (wv::<weak-vector> index::<fixnum> :optional fallback)
187 Scm_WeakVectorRef)
188
189 (define-cproc weak-vector-set! (wv::<weak-vector> index::<fixnum> val)
190 Scm_WeakVectorSet)
191
192 ;;;
193 ;;; Uniform vectors
194 ;;;
195
196 ;; Most public uniform vector APIs are defined in gauche.uvector.
197 ;; We provide a handful basic APIs here for the performance.
198
199 (select-module gauche)
200
201 (inline-stub
202 (define-enum SCM_UVECTOR_S8)
203 (define-enum SCM_UVECTOR_U8)
204 (define-enum SCM_UVECTOR_S16)
205 (define-enum SCM_UVECTOR_U16)
206 (define-enum SCM_UVECTOR_S32)
207 (define-enum SCM_UVECTOR_U32)
208 (define-enum SCM_UVECTOR_S64)
209 (define-enum SCM_UVECTOR_U64)
210 (define-enum SCM_UVECTOR_F16)
211 (define-enum SCM_UVECTOR_F32)
212 (define-enum SCM_UVECTOR_F64)
213 (define-enum SCM_UVECTOR_GENERIC)
214 )
215
216 (define-cproc make-s8vector (length::<fixnum> :optional (fill 0))
217 (let* ([filler::int8_t (Scm_GetInteger8Clamp fill SCM_CLAMP_ERROR NULL)])
218 (return (Scm_MakeS8Vector length filler))))
219
220 (define-cproc make-u8vector (length::<fixnum> :optional (fill 0))
221 (let* ([filler::uint8_t (Scm_GetIntegerU8Clamp fill SCM_CLAMP_ERROR NULL)])
222 (return (Scm_MakeU8Vector length filler))))
223
224 (define-cproc make-s16vector (length::<fixnum> :optional (fill 0))
225 (let* ([filler::int16_t (Scm_GetInteger16Clamp fill SCM_CLAMP_ERROR NULL)])
226 (return (Scm_MakeS16Vector length filler))))
227
228 (define-cproc make-u16vector (length::<fixnum> :optional (fill 0))
229 (let* ([filler::uint16_t (Scm_GetIntegerU16Clamp fill SCM_CLAMP_ERROR NULL)])
230 (return (Scm_MakeU16Vector length filler))))
231
232 (define-cproc make-s32vector (length::<fixnum> :optional (fill 0))
233 (let* ([filler::int32_t (Scm_GetInteger32Clamp fill SCM_CLAMP_ERROR NULL)])
234 (return (Scm_MakeS32Vector length filler))))
235
236 (define-cproc make-u32vector (length::<fixnum> :optional (fill 0))
237 (let* ([filler::uint32_t (Scm_GetIntegerU32Clamp fill SCM_CLAMP_ERROR NULL)])
238 (return (Scm_MakeU32Vector length filler))))
239
240 (define-cproc make-s64vector (length::<fixnum> :optional (fill 0))
241 (let* ([filler::int64_t (Scm_GetInteger64Clamp fill SCM_CLAMP_ERROR NULL)])
242 (return (Scm_MakeS64Vector length filler))))
243
244 (define-cproc make-u64vector (length::<fixnum> :optional (fill 0))
245 (let* ([filler::uint64_t (Scm_GetIntegerU64Clamp fill SCM_CLAMP_ERROR NULL)])
246 (return (Scm_MakeU64Vector length filler))))
247
248 (define-cproc make-f16vector (length::<fixnum> :optional (fill 0))
249 (let* ([filler::ScmHalfFloat (Scm_DoubleToHalf (Scm_GetDouble fill))])
250 (return (Scm_MakeF16Vector length filler))))
251
252 (define-cproc make-f32vector (length::<fixnum> :optional (fill 0))
253 (let* ([filler::float (cast float (Scm_GetDouble fill))])
254 (return (Scm_MakeF32Vector length filler))))
255
256 (define-cproc make-f64vector (length::<fixnum> :optional (fill 0))
257 (let* ([filler::double (Scm_GetDouble fill)])
258 (return (Scm_MakeF64Vector length filler))))
259
260 (define-cproc make-c32vector (length::<fixnum> :optional (fill 0))
261 (let* ([filler::ScmHalfComplex (Scm_GetHalfComplex fill)])
262 (return (Scm_MakeC32Vector length filler))))
263
264 (define-cproc make-c64vector (length::<fixnum> :optional (fill 0))
265 (let* ([filler::ScmFloatComplex (Scm_GetFloatComplex fill)])
266 (return (Scm_MakeC64Vector length filler))))
267
268 (define-cproc make-c128vector (length::<fixnum> :optional (fill 0))
269 (let* ([filler::ScmDoubleComplex (Scm_GetDoubleComplex fill)])
270 (return (Scm_MakeC128Vector length filler))))
271
272 (define-cproc s8vector-set! (v::<s8vector> i::<fixnum> val :optional clamp)
273 (return (Scm_UVectorSet v SCM_UVECTOR_S8 i val (Scm_ClampMode clamp))))
274 (define-cproc s8vector-ref (v::<s8vector> i::<fixnum> :optional fallback)
275 :fast-flonum
276 (setter s8vector-set!)
277 (return (Scm_VMUVectorRef v SCM_UVECTOR_S8 i fallback)))
278
279 (define-cproc u8vector-set! (v::<u8vector> i::<fixnum> val :optional clamp)
280 (return (Scm_UVectorSet v SCM_UVECTOR_U8 i val (Scm_ClampMode clamp))))
281 (define-cproc u8vector-ref (v::<u8vector> i::<fixnum> :optional fallback)
282 :fast-flonum
283 (setter u8vector-set!)
284 (return (Scm_VMUVectorRef v SCM_UVECTOR_U8 i fallback)))
285
286 (define-cproc s16vector-set! (v::<s16vector> i::<fixnum> val :optional clamp)
287 (return (Scm_UVectorSet v SCM_UVECTOR_S16 i val (Scm_ClampMode clamp))))
288 (define-cproc s16vector-ref (v::<s16vector> i::<fixnum> :optional fallback)
289 :fast-flonum
290 (setter s16vector-set!)
291 (return (Scm_VMUVectorRef v SCM_UVECTOR_S16 i fallback)))
292
293 (define-cproc u16vector-set! (v::<u16vector> i::<fixnum> val :optional clamp)
294 (return (Scm_UVectorSet v SCM_UVECTOR_U16 i val (Scm_ClampMode clamp))))
295 (define-cproc u16vector-ref (v::<u16vector> i::<fixnum> :optional fallback)
296 :fast-flonum
297 (setter u16vector-set!)
298 (return (Scm_VMUVectorRef v SCM_UVECTOR_U16 i fallback)))
299
300 (define-cproc s32vector-set! (v::<s32vector> i::<fixnum> val :optional clamp)
301 (return (Scm_UVectorSet v SCM_UVECTOR_S32 i val (Scm_ClampMode clamp))))
302 (define-cproc s32vector-ref (v::<s32vector> i::<fixnum> :optional fallback)
303 :fast-flonum
304 (setter s32vector-set!)
305 (return (Scm_VMUVectorRef v SCM_UVECTOR_S32 i fallback)))
306
307 (define-cproc u32vector-set! (v::<u32vector> i::<fixnum> val :optional clamp)
308 (return (Scm_UVectorSet v SCM_UVECTOR_U32 i val (Scm_ClampMode clamp))))
309 (define-cproc u32vector-ref (v::<u32vector> i::<fixnum> :optional fallback)
310 :fast-flonum
311 (setter u32vector-set!)
312 (return (Scm_VMUVectorRef v SCM_UVECTOR_U32 i fallback)))
313
314 (define-cproc s64vector-set! (v::<s64vector> i::<fixnum> val :optional clamp)
315 (return (Scm_UVectorSet v SCM_UVECTOR_S64 i val (Scm_ClampMode clamp))))
316 (define-cproc s64vector-ref (v::<s64vector> i::<fixnum> :optional fallback)
317 :fast-flonum
318 (setter s64vector-set!)
319 (return (Scm_VMUVectorRef v SCM_UVECTOR_S64 i fallback)))
320
321 (define-cproc u64vector-set! (v::<u64vector> i::<fixnum> val :optional clamp)
322 (return (Scm_UVectorSet v SCM_UVECTOR_U64 i val (Scm_ClampMode clamp))))
323 (define-cproc u64vector-ref (v::<u64vector> i::<fixnum> :optional fallback)
324 :fast-flonum
325 (setter u64vector-set!)
326 (return (Scm_VMUVectorRef v SCM_UVECTOR_U64 i fallback)))
327
328 (define-cproc f16vector-set! (v::<f16vector> i::<fixnum> val :optional clamp)
329 (return (Scm_UVectorSet v SCM_UVECTOR_F16 i val (Scm_ClampMode clamp))))
330 (define-cproc f16vector-ref (v::<f16vector> i::<fixnum> :optional fallback)
331 :fast-flonum
332 (setter f16vector-set!)
333 (return (Scm_VMUVectorRef v SCM_UVECTOR_F16 i fallback)))
334
335 (define-cproc f32vector-set! (v::<f32vector> i::<fixnum> val :optional clamp)
336 (return (Scm_UVectorSet v SCM_UVECTOR_F32 i val (Scm_ClampMode clamp))))
337 (define-cproc f32vector-ref (v::<f32vector> i::<fixnum> :optional fallback)
338 :fast-flonum
339 (setter f32vector-set!)
340 (return (Scm_VMUVectorRef v SCM_UVECTOR_F32 i fallback)))
341
342 (define-cproc f64vector-set! (v::<f64vector> i::<fixnum> val :optional clamp)
343 (return (Scm_UVectorSet v SCM_UVECTOR_F64 i val (Scm_ClampMode clamp))))
344 (define-cproc f64vector-ref (v::<f64vector> i::<fixnum> :optional fallback)
345 :fast-flonum
346 (setter f64vector-set!)
347 (return (Scm_VMUVectorRef v SCM_UVECTOR_F64 i fallback)))
348
349 (define-cproc c32vector-set! (v::<c32vector> i::<fixnum> val :optional clamp)
350 (return (Scm_UVectorSet v SCM_UVECTOR_C32 i val (Scm_ClampMode clamp))))
351 (define-cproc c32vector-ref (v::<c32vector> i::<fixnum> :optional fallback)
352 :fast-flonum
353 (setter c32vector-set!)
354 (return (Scm_VMUVectorRef v SCM_UVECTOR_C32 i fallback)))
355
356 (define-cproc c64vector-set! (v::<c64vector> i::<fixnum> val :optional clamp)
357 (return (Scm_UVectorSet v SCM_UVECTOR_C64 i val (Scm_ClampMode clamp))))
358 (define-cproc c64vector-ref (v::<c64vector> i::<fixnum> :optional fallback)
359 :fast-flonum
360 (setter c64vector-set!)
361 (return (Scm_VMUVectorRef v SCM_UVECTOR_C64 i fallback)))
362
363 (define-cproc c128vector-set! (v::<c128vector> i::<fixnum> val :optional clamp)
364 (return (Scm_UVectorSet v SCM_UVECTOR_C128 i val (Scm_ClampMode clamp))))
365 (define-cproc c128vector-ref (v::<c128vector> i::<fixnum> :optional fallback)
366 :fast-flonum
367 (setter c128vector-set!)
368 (return (Scm_VMUVectorRef v SCM_UVECTOR_C128 i fallback)))
369
370 (define-cproc uvector-set! (v::<uvector> i::<fixnum> val :optional clamp)
371 ::<void> :fast-flonum
372 (Scm_UVectorSet v (Scm_UVectorType (Scm_ClassOf (SCM_OBJ v))) i val
373 (Scm_ClampMode clamp)))
374 (define-cproc uvector-ref (v::<uvector> i::<fixnum> :optional fallback)
375 :fast-flonum
376 (setter uvector-set!)
377 (return (Scm_VMUVectorRef v (Scm_UVectorType (Scm_ClassOf (SCM_OBJ v)))
378 i fallback)))
379 (define-cproc uvector-length (v::<uvector>) ::<ulong> :constant
380 SCM_UVECTOR_SIZE)
381 (define-cproc uvector-immutable? (v::<uvector>) ::<boolean>
382 SCM_UVECTOR_IMMUTABLE_P)
383 (define-cproc uvector? (obj) ::<boolean> :constant
384 SCM_UVECTORP)
385
386 (define-cproc u8vector? (x) ::<boolean> SCM_U8VECTORP)
387 (define-cproc s8vector? (x) ::<boolean> SCM_S8VECTORP)
388 (define-cproc u16vector? (x) ::<boolean> SCM_U16VECTORP)
389 (define-cproc s16vector? (x) ::<boolean> SCM_S16VECTORP)
390 (define-cproc u32vector? (x) ::<boolean> SCM_U32VECTORP)
391 (define-cproc s32vector? (x) ::<boolean> SCM_S32VECTORP)
392 (define-cproc u64vector? (x) ::<boolean> SCM_U64VECTORP)
393 (define-cproc s64vector? (x) ::<boolean> SCM_S64VECTORP)
394 (define-cproc f16vector? (x) ::<boolean> SCM_F16VECTORP)
395 (define-cproc f32vector? (x) ::<boolean> SCM_F32VECTORP)
396 (define-cproc f64vector? (x) ::<boolean> SCM_F64VECTORP)
397 (define-cproc c32vector? (x) ::<boolean> SCM_C32VECTORP)
398 (define-cproc c64vector? (x) ::<boolean> SCM_C64VECTORP)
399 (define-cproc c128vector? (x) ::<boolean> SCM_C128VECTORP)
400
401 (define-cproc make-view-uvector (mem klass::<class> length::<integer>?
402 :optional (offset::<fixnum> 0)
403 (immutable?::<boolean> #f))
404 (unless (SCM_MEMORY_REGION_P mem)
405 (SCM_TYPE_ERROR mem "<memory-region>"))
406 (let* ([len::ScmSmallInt 0])
407 (cond [(SCM_FALSEP length) (set! len -1)]
408 [(SCM_INTP length) (set! len (SCM_INT_VALUE length))]
409 [else (Scm_Error "length is out of range: %S" length)])
410 (return (Scm_MakeViewUVector (SCM_MEMORY_REGION mem)
411 klass len offset immutable?))))
412
413 ;; string <-> uvector
414
415 ;; String operations
416 (inline-stub
417 ;; A common operation to extract range of char* from the input string S.
418 ;; START and END may be adjusted.
419 ;; SP and EP are const char* variable that gets start and end pointers.
420 (define-cise-stmt with-input-string-pointers
421 [(_ (s start end sp ep) . body)
422 (let ([sb (gensym)] [size (gensym)] [len (gensym)] [ss (gensym)])
423 `(let* ([,sb :: (const ScmStringBody*) (SCM_STRING_BODY ,s)]
424 [,size :: ScmSize (SCM_STRING_BODY_SIZE ,sb)]
425 [,len :: ScmSize (SCM_STRING_BODY_LENGTH ,sb)]
426 [,ss :: (const char*) (SCM_STRING_BODY_START ,sb)]
427 [_ (SCM_CHECK_START_END ,start ,end (cast int ,len))]
428 [,sp :: (const char*)
429 (?: (== ,start 0)
430 ,ss
431 (Scm_StringBodyPosition ,sb ,start))]
432 [,ep :: (const char*)
433 (?: (== ,end ,len)
434 (+ ,ss ,size)
435 (Scm_StringBodyPosition ,sb ,end))])
436 ,@body))])
437
438 (define-cfn string->bytevector (klass::ScmClass*
439 s::ScmString*
440 start::ScmSmallInt
441 end::ScmSmallInt
442 immutable::int)
443 :static
444 (with-input-string-pointers (s start end sp ep)
445 (let* ([buf::char* NULL])
446 (if immutable
447 (set! buf (cast char* sp)) ; Eek! drop const qualifier
448 (begin
449 (set! buf (SCM_NEW_ATOMIC2 (char*) (- ep sp)))
450 (memcpy buf sp (- ep sp))))
451 (return (Scm_MakeUVectorFull klass (cast ScmSmallInt (- ep sp)) buf
452 immutable NULL)))))
453
454 (define-cproc string->s8vector
455 (s::<string>
456 :optional (start::<fixnum> 0) (end::<fixnum> -1) (immutable?::<boolean> #f))
457 (return (string->bytevector SCM_CLASS_S8VECTOR s start end immutable?)))
458
459 (define-cproc string->u8vector
460 (s::<string>
461 :optional (start::<fixnum> 0) (end::<fixnum> -1) (immutable?::<boolean> #f))
462 (return (string->bytevector SCM_CLASS_U8VECTOR s start end immutable?)))
463
464 (define-cfn string->bytevector! (v::ScmUVector*
465 tstart::ScmSmallInt
466 s::ScmString*
467 start::ScmSmallInt
468 end::ScmSmallInt)
469 :static
470 (let* ([tlen::ScmSmallInt (SCM_UVECTOR_SIZE v)])
471 (when (and (>= tstart 0) (< tstart tlen))
472 (SCM_UVECTOR_CHECK_MUTABLE v)
473 (with-input-string-pointers (s start end sp ep)
474 (let* ([buf::(char*) (+ (cast char* (SCM_UVECTOR_ELEMENTS v)) tstart)])
475 (if (> (- tlen tstart) (- ep sp))
476 (memcpy buf sp (- ep sp))
477 (memcpy buf sp (- tlen tstart))))))
478 (return (SCM_OBJ v))))
479
480 (define-cproc string->s8vector! (v::<s8vector>
481 tstart::<fixnum>
482 s::<string>
483 :optional (start::<fixnum> 0)
484 (end::<fixnum> -1))
485 (return (string->bytevector! (SCM_UVECTOR v) tstart s start end)))
486
487 (define-cproc string->u8vector! (v::<u8vector>
488 tstart::<fixnum>
489 s::<string>
490 :optional (start::<fixnum> 0)
491 (end::<fixnum> -1))
492 (return (string->bytevector! (SCM_UVECTOR v) tstart s start end)))
493
494 (define-cfn bytevector->string (v::ScmUVector*
495 start::ScmSmallInt
496 end::ScmSmallInt
497 term)
498 :static
499 (let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)])
500 ;; We automatically avoid copying the string contents when the
501 ;; following conditions are met:
502 ;; * The source vector is immutable
503 ;; * The owner of source vector is NULL (If there's an owner such as
504 ;; mmap handle, it isn't desirable if a string points to the memory
505 ;; without keeping ownership info.)
506 ;; * The resulting string is not a small fraction of a large vector.
507 ;; If so, we may waste space by retaining large chunk of memory
508 ;; most of which won't be ever used. Here we use some heuristics:
509 ;; - If the source vector is not small (>= 256)
510 ;; - and the string covers only a fraction (1/5) or less,
511 ;; - then we copy the content.
512 ;; NB: We may add a flag that force the content to be shared, for
513 ;; the programs that really want to avoid allocation.
514 (SCM_CHECK_START_END start end len)
515 (let* ([flags::int (?: (and (SCM_UVECTOR_IMMUTABLE_P v)
516 (== (-> v owner) NULL)
517 (not (and (>= len 256)
518 (<= (- end start) (/ len 5)))))
519 0
520 SCM_STRING_COPYING)])
521 (when (SCM_INTP term)
522 (let* ([terminator::u_char (logand #xff (SCM_INT_VALUE term))]
523 [i::ScmSmallInt])
524 (for [(set! i start) (< i end) (post++ i)]
525 (when (== terminator
526 (aref (cast u_char* (SCM_UVECTOR_ELEMENTS v)) i))
527 (set! end i)
528 (break)))))
529 (return (Scm_MakeString (+ (cast char* (SCM_UVECTOR_ELEMENTS v)) start)
530 (- end start) -1 flags)))))
531
532 (define-cproc s8vector->string (v::<s8vector>
533 :optional (start::<fixnum> 0)
534 (end::<fixnum> -1)
535 (terminator #f))
536 (return (bytevector->string (SCM_UVECTOR v) start end terminator)))
537
538 (define-cproc u8vector->string (v::<u8vector>
539 :optional (start::<fixnum> 0)
540 (end::<fixnum> -1)
541 (terminator #f))
542 (return (bytevector->string (SCM_UVECTOR v) start end terminator)))
543
544 (define-cfn string->wordvector (klass::ScmClass* s::ScmString*
545 start::ScmSmallInt end::ScmSmallInt
546 endian::ScmObj)
547 :static
548 (unless (SCM_SYMBOLP endian)
549 (set! endian (Scm_DefaultEndian)))
550 (with-input-string-pointers (s start end sp ep)
551 (let* ([v (Scm_MakeUVector klass (- end start) NULL)]
552 [eltp::uint32_t* (cast uint32_t* (SCM_UVECTOR_ELEMENTS v))]
553 [i::ScmSmallInt 0]
554 [do_swap::int (SWAP_REQUIRED endian)])
555 (for [() (< sp ep) (post++ i)]
556 (let* ([ch::ScmChar])
557 (SCM_CHAR_GET sp ch)
558 (if do_swap
559 (let* ([v::swap_u32_t])
560 (set! (ref v val) (cast uint32_t ch))
561 (SWAP_4 v)
562 (set! (aref eltp i) (ref v val)))
563 (set! (aref eltp i) (cast uint32_t ch)))
564 (+= sp (SCM_CHAR_NBYTES ch))))
565 (return v))))
566
567 (define-cproc string->s32vector (s::<string>
568 :optional (start::<fixnum> 0)
569 (end::<fixnum> -1)
570 endian)
571 (return (string->wordvector SCM_CLASS_S32VECTOR s start end endian)))
572
573 (define-cproc string->u32vector (s::<string>
574 :optional (start::<fixnum> 0)
575 (end::<fixnum> -1)
576 endian)
577 (return (string->wordvector SCM_CLASS_U32VECTOR s start end endian)))
578
579 (define-cfn string->wordvector! (v::ScmUVector*
580 tstart::ScmSmallInt
581 s::ScmString*
582 start::ScmSmallInt
583 end::ScmSmallInt
584 endian::ScmObj)
585 :static
586 (unless (SCM_SYMBOLP endian)
587 (set! endian (Scm_DefaultEndian)))
588 (let* ([tlen::ScmSmallInt (SCM_UVECTOR_SIZE v)])
589 (when (and (>= tstart 0) (< tstart tlen))
590 (SCM_UVECTOR_CHECK_MUTABLE v)
591 (with-input-string-pointers (s start end sp ep)
592 (let* ([buf::uint32_t* (cast uint32_t* (SCM_UVECTOR_ELEMENTS v))]
593 [i::ScmSmallInt tstart]
594 [do_swap::int (SWAP_REQUIRED endian)])
595 (for [() (and (< sp ep) (< i tlen)) (post++ i)]
596 (let* ([ch::ScmChar])
597 (SCM_CHAR_GET sp ch)
598 (if do_swap
599 (let* ([v::swap_u32_t])
600 (set! (ref v val) (cast uint32_t ch))
601 (SWAP_4 v)
602 (set! (aref buf i) (ref v val)))
603 (set! (aref buf i) (cast uint32_t ch)))
604 (+= sp (SCM_CHAR_NBYTES ch)))))))
605 (return (SCM_OBJ v))))
606
607 (define-cproc string->s32vector! (v::<s32vector>
608 tstart::<fixnum>
609 s::<string>
610 :optional (start::<fixnum> 0)
611 (end::<fixnum> -1)
612 endian)
613 (return (string->wordvector! (SCM_UVECTOR v) tstart s start end endian)))
614
615 (define-cproc string->u32vector! (v::<u32vector>
616 tstart::<fixnum>
617 s::<string>
618 :optional (start::<fixnum> 0)
619 (end::<fixnum> -1)
620 endian)
621 (return (string->wordvector! (SCM_UVECTOR v) tstart s start end endian)))
622
623 (define-cfn wordvector->string (v::ScmUVector*
624 start::ScmSmallInt
625 end::ScmSmallInt
626 term
627 endian)
628 :static
629 (unless (SCM_SYMBOLP endian)
630 (set! endian (Scm_DefaultEndian)))
631 (let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)]
632 [s (Scm_MakeOutputStringPort FALSE)]
633 [do_swap::int (SWAP_REQUIRED endian)])
634 (SCM_CHECK_START_END start end len)
635 (let* ([eltp::int32_t* (cast int32_t* (SCM_UVECTOR_ELEMENTS v))])
636 (while (< start end)
637 (let* ([ch::ScmChar]
638 [val::uint32_t (aref eltp (post++ start))])
639 (if do_swap
640 (let* ([v::swap_u32_t])
641 (set! (ref v val) val)
642 (SWAP_4 v)
643 (set! ch (cast ScmChar (ref v val))))
644 (set! ch (cast ScmChar val)))
645 (when (and (SCM_INTP term)
646 (== (SCM_INT_VALUE term) ch))
647 (break))
648 (Scm_PutcUnsafe ch (SCM_PORT s)))))
649 (return (Scm_GetOutputStringUnsafe (SCM_PORT s) 0))))
650
651 (define-cproc s32vector->string (v::<s32vector>
652 :optional (start::<fixnum> 0)
653 (end::<fixnum> -1)
654 (terminator #f)
655 endian)
656 (return (wordvector->string (SCM_UVECTOR v) start end terminator endian)))
657
658 (define-cproc u32vector->string (v::<u32vector>
659 :optional (start::<fixnum> 0)
660 (end::<fixnum> -1)
661 (terminator #f)
662 endian)
663 (return (wordvector->string (SCM_UVECTOR v) start end terminator endian)))
664 )
665
666 ;;;
667 ;;; Bitvectors
668 ;;;
669
670 (define-cproc bitvector? (obj) ::<boolean> SCM_BITVECTORP) ;SRFI-178
671 (define-cproc bitvector-length (v::<bitvector>) ::<int> ;SRFI-178
672 SCM_BITVECTOR_SIZE)
673
674 (define-cproc bitvector-any-value? (v::<bitvector> bit
675 :optional (start::<fixnum> 0)
676 (end::<fixnum> -1))
677 ::<boolean>
678 (let* ([b::int (Scm_Bit2Int bit)])
679 (SCM_CHECK_START_END start end (SCM_BITVECTOR_SIZE v))
680 (if b
681 (return (Scm_BitsAny (SCM_BITVECTOR_BITS v) start end))
682 (return (not (Scm_BitsEvery (SCM_BITVECTOR_BITS v) start end))))))
683
684 (define-cproc bitvector-every-value? (v::<bitvector> bit
685 :optional (start::<fixnum> 0)
686 (end::<fixnum> -1))
687 ::<boolean>
688 (let* ([b::int (Scm_Bit2Int bit)])
689 (SCM_CHECK_START_END start end (SCM_BITVECTOR_SIZE v))
690 (if b
691 (return (Scm_BitsEvery (SCM_BITVECTOR_BITS v) start end))
692 (return (not (Scm_BitsAny (SCM_BITVECTOR_BITS v) start end))))))
693
694 (define-cproc make-bitvector (len::<fixnum> :optional (init #f)) ;SRFI-178
695 Scm_MakeBitvector)
696 (define-cproc bitvector (:rest bits) Scm_ListToBitvector) ;SRFI-178
697 (define-cproc list->bitvector (bits) Scm_ListToBitvector) ;SRFI-178
698
699 (define-cproc string->bitvector (s::<string>) ;SRFI-178
700 (return (Scm_StringToBitvector s TRUE)))
701 (define-cproc bitvector->string (v::<bitvector>) ;SRFI-178
702 (return (Scm_BitvectorToString v TRUE)))
703
704 (define-cproc bit->integer (bit) ::<int> Scm_Bit2Int) ;SRFI-178
705 (define-cproc bit->boolean (bit) ::<boolean> Scm_Bit2Int) ;SRFI-178
706
707 (define-cproc bitvector-set! (v::<bitvector> i::<fixnum> b) ::<void> ;SRFI-178
708 (when (or (< i 0) (>= i (SCM_BITVECTOR_SIZE v)))
709 (Scm_Error "bitvector index out of range: %ld" i))
710 (SCM_BITVECTOR_CHECK_MUTABLE v)
711 (if (Scm_Bit2Int b)
712 (SCM_BITS_SET (SCM_BITVECTOR_BITS v) i)
713 (SCM_BITS_RESET (SCM_BITVECTOR_BITS v) i)))
714
715 (define-cproc bitvector-ref/int (v::<bitvector> i::<fixnum> ;SRFI-178
716 :optional fallback)
717 (setter bitvector-set!)
718 (when (or (< i 0) (>= i (SCM_BITVECTOR_SIZE v)))
719 (if (SCM_UNBOUNDP fallback)
720 (Scm_Error "bitvector index out of range: %ld" i)
721 (return fallback)))
722 (return (?: (SCM_BITS_TEST (SCM_BITVECTOR_BITS v) i)
723 (SCM_MAKE_INT 1)
724 (SCM_MAKE_INT 0))))
725
726 (define-cproc bitvector-ref/bool (v::<bitvector> i::<fixnum> ;SRFI-178
727 :optional fallback)
728 (setter bitvector-set!)
729 (when (or (< i 0) (>= i (SCM_BITVECTOR_SIZE v)))
730 (if (SCM_UNBOUNDP fallback)
731 (Scm_Error "bitvector index out of range: %ld" i)
732 (return fallback)))
733 (return (?: (SCM_BITS_TEST (SCM_BITVECTOR_BITS v) i) SCM_TRUE SCM_FALSE)))
734
735 (define-cproc bitvector-copy (v::<bitvector>
736 :optional (start::<fixnum> 0)
737 (end::<fixnum> -1)) ;SRFI-178
738 Scm_BitvectorCopy)
739
740 (define-cproc bitvector-copy! (dest::<bitvector>
741 dstart::<fixnum>
742 src::<bitvector>
743 :optional (start::<fixnum> 0)
744 (end::<fixnum> -1)) ;SRFI-178
745 Scm_BitvectorCopyX)
746
747 ;;;
748 ;;; Flat vector API (interact with underlying C array)
749 ;;;
750
751 (select-module gauche)
752
753 (inline-stub
754 (.define common_eqv (a b) (== a b))
755 (.define common_lt (a b) (< a b))
756
757 (.define hc_eqv (a b) (and (== (ref a r) (ref b r))
758 (== (ref a i) (ref b i))))
759 (.define hc_lt (a b) (or (< (ref a r) (ref b r))
760 (and (== (ref a r) (ref b r))
761 (< (ref a i) (ref b i)))))
762
763 (.define fc_lt (a b) (or (< (crealf a) (crealf b))
764 (and (== (crealf a) (crealf b))
765 (< (cimagf a) (cimagf b)))))
766 (.define dc_lt (a b) (or (< (creal a) (creal b))
767 (and (== (creal a) (creal b))
768 (< (cimag a) (cimag b)))))
769
770 (define-cise-stmt %binary-search
771 [(_ elttype eq lt)
772 `(let* ([esize::u_int (+ skip 1)]
773 [nume::size_t (/ len esize)]
774 [k::size_t (/ nume 2)]
775 [hi::size_t nume]
776 [lo::size_t 0])
777 (while (< lo hi)
778 (let* ([v:: ,elttype (aref vec (* k esize))])
779 (cond [(,eq v key) (return (* k esize))]
780 [(,lt v key)
781 (set! lo k) (set! k (+ lo (/ (- hi lo) 2)))
782 (when (== lo k) (break))]
783 [else
784 (set! hi k) (set! k (+ lo (/ (- hi lo) 2)))])))
785 (when floor
786 (if (== lo hi)
787 (set! (* floor) (cast (size_t) -1))
788 (set! (* floor) (* lo esize))))
789 (when ceil
790 (if (== hi nume)
791 (set! (* ceil) (cast (size_t) -1))
792 (set! (* ceil) (* hi esize))))
793 (return (cast (size_t) -1)))])
794
795 (define-cfn Scm_BinarySearchS8 (vec::(const int8_t*)
796 len::size_t
797 key::int8_t
798 skip::u_int
799 floor::size_t*
800 ceil::size_t*)
801 ::size_t (%binary-search int8_t common-eqv common-lt))
802
803 (define-cfn Scm_BinarySearchU8 (vec::(const uint8_t*)
804 len::size_t
805 key::uint8_t
806 skip::u_int
807 floor::size_t*
808 ceil::size_t*)
809 ::size_t (%binary-search uint8_t common-eqv common-lt))
810
811 (define-cfn Scm_BinarySearchS16 (vec::(const int16_t*)
812 len::size_t
813 key::int16_t
814 skip::u_int
815 floor::size_t*
816 ceil::size_t*)
817 ::size_t (%binary-search int16_t common-eqv common-lt))
818
819 (define-cfn Scm_BinarySearchU16 (vec::(const uint16_t*)
820 len::size_t
821 key::uint16_t
822 skip::u_int
823 floor::size_t*
824 ceil::size_t*)
825 ::size_t (%binary-search uint16_t common-eqv common-lt))
826
827 (define-cfn Scm_BinarySearchS32 (vec::(const int32_t*)
828 len::size_t
829 key::int32_t
830 skip::u_int
831 floor::size_t*
832 ceil::size_t*)
833 ::size_t (%binary-search int32_t common-eqv common-lt))
834
835 (define-cfn Scm_BinarySearchU32 (vec::(const uint32_t*)
836 len::size_t
837 key::uint32_t
838 skip::u_int
839 floor::size_t*
840 ceil::size_t*)
841 ::size_t (%binary-search uint32_t common-eqv common-lt))
842
843 (define-cfn Scm_BinarySearchS64 (vec::(const int64_t*)
844 len::size_t
845 key::int64_t
846 skip::u_int
847 floor::size_t*
848 ceil::size_t*)
849 ::size_t (%binary-search int64_t common-eqv common-lt))
850
851 (define-cfn Scm_BinarySearchU64 (vec::(const uint64_t*)
852 len::size_t
853 key::uint64_t
854 skip::u_int
855 floor::size_t*
856 ceil::size_t*)
857 ::size_t (%binary-search uint64_t common-eqv common-lt))
858
859 (define-cfn Scm_BinarySearchF16 (vec::(const ScmHalfFloat*)
860 len::size_t
861 key::ScmHalfFloat
862 skip::u_int
863 floor::size_t*
864 ceil::size_t*)
865 ::size_t (%binary-search ScmHalfFloat common-eqv common-lt))
866
867 (define-cfn Scm_BinarySearchF32 (vec::(const float*)
868 len::size_t
869 key::float
870 skip::u_int
871 floor::size_t*
872 ceil::size_t*)
873 ::size_t (%binary-search float common-eqv common-lt))
874
875 (define-cfn Scm_BinarySearchF64 (vec::(const double*)
876 len::size_t
877 key::double
878 skip::u_int
879 floor::size_t*
880 ceil::size_t*)
881 ::size_t (%binary-search double common-eqv common-lt))
882
883 (define-cfn Scm_BinarySearchC32 (vec::(const ScmHalfComplex*)
884 len::size_t
885 key::ScmHalfComplex
886 skip::u_int
887 floor::size_t*
888 ceil::size_t*)
889 ::size_t (%binary-search ScmHalfComplex hc-eqv hc-lt))
890
891 (define-cfn Scm_BinarySearchC64 (vec::(const ScmFloatComplex*)
892 len::size_t
893 key::(ScmFloatComplex)
894 skip::u_int
895 floor::size_t*
896 ceil::size_t*)
897 ::size_t (%binary-search (ScmFloatComplex) common-eqv fc-lt))
898
899 (define-cfn Scm_BinarySearchC128 (vec::(const ScmDoubleComplex*)
900 len::size_t
901 key::(ScmDoubleComplex)
902 skip::u_int
903 floor::size_t*
904 ceil::size_t*)
905 ::size_t (%binary-search (ScmDoubleComplex) common-eqv dc-lt))
906 )