/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- clamp_arg
- uvlib_s8vectorP
- uvlib_make_s8vector
- uvlib_s8vector
- uvlib_s8vector_length
- uvlib_s8vector_ref
- uvlib_s8vector_setX
- uvlib_s8vector_copy
- uvlib_s8vector_copyX
- uvlib_s8vector_TOlist
- uvlib_list_TOs8vector
- uvlib_s8vector_fillX
- uvlib_s8vector_TOvector
- uvlib_vector_TOs8vector
- uvlib_u8vectorP
- uvlib_make_u8vector
- uvlib_u8vector
- uvlib_u8vector_length
- uvlib_u8vector_ref
- uvlib_u8vector_setX
- uvlib_u8vector_copy
- uvlib_u8vector_copyX
- uvlib_u8vector_TOlist
- uvlib_list_TOu8vector
- uvlib_u8vector_fillX
- uvlib_u8vector_TOvector
- uvlib_vector_TOu8vector
- uvlib_s16vectorP
- uvlib_make_s16vector
- uvlib_s16vector
- uvlib_s16vector_length
- uvlib_s16vector_ref
- uvlib_s16vector_setX
- uvlib_s16vector_copy
- uvlib_s16vector_copyX
- uvlib_s16vector_TOlist
- uvlib_list_TOs16vector
- uvlib_s16vector_fillX
- uvlib_s16vector_TOvector
- uvlib_vector_TOs16vector
- uvlib_u16vectorP
- uvlib_make_u16vector
- uvlib_u16vector
- uvlib_u16vector_length
- uvlib_u16vector_ref
- uvlib_u16vector_setX
- uvlib_u16vector_copy
- uvlib_u16vector_copyX
- uvlib_u16vector_TOlist
- uvlib_list_TOu16vector
- uvlib_u16vector_fillX
- uvlib_u16vector_TOvector
- uvlib_vector_TOu16vector
- uvlib_s32vectorP
- uvlib_make_s32vector
- uvlib_s32vector
- uvlib_s32vector_length
- uvlib_s32vector_ref
- uvlib_s32vector_setX
- uvlib_s32vector_copy
- uvlib_s32vector_copyX
- uvlib_s32vector_TOlist
- uvlib_list_TOs32vector
- uvlib_s32vector_fillX
- uvlib_s32vector_TOvector
- uvlib_vector_TOs32vector
- uvlib_u32vectorP
- uvlib_make_u32vector
- uvlib_u32vector
- uvlib_u32vector_length
- uvlib_u32vector_ref
- uvlib_u32vector_setX
- uvlib_u32vector_copy
- uvlib_u32vector_copyX
- uvlib_u32vector_TOlist
- uvlib_list_TOu32vector
- uvlib_u32vector_fillX
- uvlib_u32vector_TOvector
- uvlib_vector_TOu32vector
- uvlib_s64vectorP
- uvlib_make_s64vector
- uvlib_s64vector
- uvlib_s64vector_length
- uvlib_s64vector_ref
- uvlib_s64vector_setX
- uvlib_s64vector_copy
- uvlib_s64vector_copyX
- uvlib_s64vector_TOlist
- uvlib_list_TOs64vector
- uvlib_s64vector_fillX
- uvlib_s64vector_TOvector
- uvlib_vector_TOs64vector
- uvlib_u64vectorP
- uvlib_make_u64vector
- uvlib_u64vector
- uvlib_u64vector_length
- uvlib_u64vector_ref
- uvlib_u64vector_setX
- uvlib_u64vector_copy
- uvlib_u64vector_copyX
- uvlib_u64vector_TOlist
- uvlib_list_TOu64vector
- uvlib_u64vector_fillX
- uvlib_u64vector_TOvector
- uvlib_vector_TOu64vector
- uvlib_f32vectorP
- uvlib_make_f32vector
- uvlib_f32vector
- uvlib_f32vector_length
- uvlib_f32vector_ref
- uvlib_f32vector_setX
- uvlib_f32vector_copy
- uvlib_f32vector_copyX
- uvlib_f32vector_TOlist
- uvlib_list_TOf32vector
- uvlib_f32vector_fillX
- uvlib_f32vector_TOvector
- uvlib_vector_TOf32vector
- uvlib_f64vectorP
- uvlib_make_f64vector
- uvlib_f64vector
- uvlib_f64vector_length
- uvlib_f64vector_ref
- uvlib_f64vector_setX
- uvlib_f64vector_copy
- uvlib_f64vector_copyX
- uvlib_f64vector_TOlist
- uvlib_list_TOf64vector
- uvlib_f64vector_fillX
- uvlib_f64vector_TOvector
- uvlib_vector_TOf64vector
- uvlib_s8vector_add
- uvlib_s8vector_addX
- uvlib_u8vector_add
- uvlib_u8vector_addX
- uvlib_s16vector_add
- uvlib_s16vector_addX
- uvlib_u16vector_add
- uvlib_u16vector_addX
- uvlib_s32vector_add
- uvlib_s32vector_addX
- uvlib_u32vector_add
- uvlib_u32vector_addX
- uvlib_s64vector_add
- uvlib_s64vector_addX
- uvlib_u64vector_add
- uvlib_u64vector_addX
- uvlib_f32vector_add
- uvlib_f32vector_addX
- uvlib_f64vector_add
- uvlib_f64vector_addX
- uvlib_s8vector_sub
- uvlib_s8vector_subX
- uvlib_u8vector_sub
- uvlib_u8vector_subX
- uvlib_s16vector_sub
- uvlib_s16vector_subX
- uvlib_u16vector_sub
- uvlib_u16vector_subX
- uvlib_s32vector_sub
- uvlib_s32vector_subX
- uvlib_u32vector_sub
- uvlib_u32vector_subX
- uvlib_s64vector_sub
- uvlib_s64vector_subX
- uvlib_u64vector_sub
- uvlib_u64vector_subX
- uvlib_f32vector_sub
- uvlib_f32vector_subX
- uvlib_f64vector_sub
- uvlib_f64vector_subX
- uvlib_s8vector_mul
- uvlib_s8vector_mulX
- uvlib_u8vector_mul
- uvlib_u8vector_mulX
- uvlib_s16vector_mul
- uvlib_s16vector_mulX
- uvlib_u16vector_mul
- uvlib_u16vector_mulX
- uvlib_s32vector_mul
- uvlib_s32vector_mulX
- uvlib_u32vector_mul
- uvlib_u32vector_mulX
- uvlib_s64vector_mul
- uvlib_s64vector_mulX
- uvlib_u64vector_mul
- uvlib_u64vector_mulX
- uvlib_f32vector_mul
- uvlib_f32vector_mulX
- uvlib_f64vector_mul
- uvlib_f64vector_mulX
- uvlib_f32vector_div
- uvlib_f32vector_divX
- uvlib_f64vector_div
- uvlib_f64vector_divX
- uvlib_s8vector_and
- uvlib_s8vector_andX
- uvlib_s8vector_ior
- uvlib_s8vector_iorX
- uvlib_s8vector_xor
- uvlib_s8vector_xorX
- uvlib_u8vector_and
- uvlib_u8vector_andX
- uvlib_u8vector_ior
- uvlib_u8vector_iorX
- uvlib_u8vector_xor
- uvlib_u8vector_xorX
- uvlib_s16vector_and
- uvlib_s16vector_andX
- uvlib_s16vector_ior
- uvlib_s16vector_iorX
- uvlib_s16vector_xor
- uvlib_s16vector_xorX
- uvlib_u16vector_and
- uvlib_u16vector_andX
- uvlib_u16vector_ior
- uvlib_u16vector_iorX
- uvlib_u16vector_xor
- uvlib_u16vector_xorX
- uvlib_s32vector_and
- uvlib_s32vector_andX
- uvlib_s32vector_ior
- uvlib_s32vector_iorX
- uvlib_s32vector_xor
- uvlib_s32vector_xorX
- uvlib_u32vector_and
- uvlib_u32vector_andX
- uvlib_u32vector_ior
- uvlib_u32vector_iorX
- uvlib_u32vector_xor
- uvlib_u32vector_xorX
- uvlib_s64vector_and
- uvlib_s64vector_andX
- uvlib_s64vector_ior
- uvlib_s64vector_iorX
- uvlib_s64vector_xor
- uvlib_s64vector_xorX
- uvlib_u64vector_and
- uvlib_u64vector_andX
- uvlib_u64vector_ior
- uvlib_u64vector_iorX
- uvlib_u64vector_xor
- uvlib_u64vector_xorX
- uvlib_s8vector_dot
- uvlib_u8vector_dot
- uvlib_s16vector_dot
- uvlib_u16vector_dot
- uvlib_s32vector_dot
- uvlib_u32vector_dot
- uvlib_s64vector_dot
- uvlib_u64vector_dot
- uvlib_f32vector_dot
- uvlib_f64vector_dot
- uvlib_s8vector_range_check
- uvlib_s8vector_clamp
- uvlib_s8vector_clampX
- uvlib_u8vector_range_check
- uvlib_u8vector_clamp
- uvlib_u8vector_clampX
- uvlib_s16vector_range_check
- uvlib_s16vector_clamp
- uvlib_s16vector_clampX
- uvlib_u16vector_range_check
- uvlib_u16vector_clamp
- uvlib_u16vector_clampX
- uvlib_s32vector_range_check
- uvlib_s32vector_clamp
- uvlib_s32vector_clampX
- uvlib_u32vector_range_check
- uvlib_u32vector_clamp
- uvlib_u32vector_clampX
- uvlib_s64vector_range_check
- uvlib_s64vector_clamp
- uvlib_s64vector_clampX
- uvlib_u64vector_range_check
- uvlib_u64vector_clamp
- uvlib_u64vector_clampX
- uvlib_f32vector_range_check
- uvlib_f32vector_clamp
- uvlib_f32vector_clampX
- uvlib_f64vector_range_check
- uvlib_f64vector_clamp
- uvlib_f64vector_clampX
- uvlib_s16vector_swap_bytes
- uvlib_s16vector_swap_bytesX
- uvlib_u16vector_swap_bytes
- uvlib_u16vector_swap_bytesX
- uvlib_s32vector_swap_bytes
- uvlib_s32vector_swap_bytesX
- uvlib_u32vector_swap_bytes
- uvlib_u32vector_swap_bytesX
- uvlib_s64vector_swap_bytes
- uvlib_s64vector_swap_bytesX
- uvlib_u64vector_swap_bytes
- uvlib_u64vector_swap_bytesX
- uvlib_f32vector_swap_bytes
- uvlib_f32vector_swap_bytesX
- uvlib_f64vector_swap_bytes
- uvlib_f64vector_swap_bytesX
- uvlib_uvector_alias
- uvlib_uvector_swap_bytes
- uvlib_uvector_swap_bytesX
- uvlib_read_blockX
- uvlib_write_block
- string_to_bytevector
- uvlib_string_TOs8vector
- uvlib_string_TOu8vector
- string_to_bytevectorX
- uvlib_string_TOs8vectorX
- uvlib_string_TOu8vectorX
- bytevector_to_string
- uvlib_s8vector_TOstring
- uvlib_u8vector_TOstring
- string_to_wordvector
- uvlib_string_TOs32vector
- uvlib_string_TOu32vector
- wordvector_to_string
- uvlib_s32vector_TOstring
- uvlib_u32vector_TOstring
- Scm_Init_uvlib
1 /* Generated by genstub. Do not edit. */
2 #include <gauche.h>
3 #if defined(__CYGWIN__) || defined(__MINGW32__)
4 #define SCM_CGEN_CONST /*empty*/
5 #else
6 #define SCM_CGEN_CONST const
7 #endif
8
9 #include <math.h>
10 #include "gauche/uvector.h"
11 #include "uvectorP.h"
12
13 static SCM_DEFINE_STRING_CONST(sym_both__NAME, "both", 4, 4);
14 static ScmObj sym_both = SCM_UNBOUND;
15 static SCM_DEFINE_STRING_CONST(sym_high__NAME, "high", 4, 4);
16 static ScmObj sym_high = SCM_UNBOUND;
17 static SCM_DEFINE_STRING_CONST(sym_low__NAME, "low", 3, 3);
18 static ScmObj sym_low = SCM_UNBOUND;
19 static int clamp_arg(ScmObj clamp)
20 {
21 if (SCM_EQ(clamp, sym_both)) return SCM_CLAMP_BOTH;
22 else if (SCM_EQ(clamp, sym_low)) return SCM_CLAMP_LO;
23 else if (SCM_EQ(clamp, sym_high)) return SCM_CLAMP_HI;
24 if (!SCM_FALSEP(clamp) && !SCM_UNBOUNDP(clamp))
25 Scm_Error("clamp argument must be either 'both, 'high, 'low or #f, but got %S", clamp);
26 return SCM_CLAMP_ERROR;
27 }
28
29 static ScmObj uvlib_s8vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
30 {
31 ScmObj obj_scm;
32 ScmObj obj;
33 SCM_ENTER_SUBR("s8vector?");
34 obj_scm = SCM_ARGREF(0);
35 obj = (obj_scm);
36 {
37 {
38 int SCM_RESULT;
39 SCM_RESULT = SCM_S8VECTORP(obj);
40 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
41 }
42 }
43 }
44
45 static SCM_DEFINE_STRING_CONST(uvlib_s8vectorP__NAME, "s8vector?", 9, 9);
46 static SCM_DEFINE_SUBR(uvlib_s8vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s8vectorP__NAME), uvlib_s8vectorP, NULL, NULL);
47
48 static ScmObj uvlib_make_s8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
49 {
50 ScmObj length_scm;
51 int length;
52 ScmObj fill_scm;
53 ScmObj fill;
54 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
55 SCM_ENTER_SUBR("make-s8vector");
56 if (Scm_Length(SCM_OPTARGS) > 1)
57 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
58 length_scm = SCM_ARGREF(0);
59 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
60 length = SCM_INT_VALUE(length_scm);
61 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
62 else {
63 fill_scm = SCM_CAR(SCM_OPTARGS);
64 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
65 }
66 fill = (fill_scm);
67 {
68 signed char filler;
69 filler = s8unbox(fill, SCM_CLAMP_ERROR);
70 SCM_RETURN(Scm_MakeS8Vector(length, filler));
71 }
72 }
73
74 static SCM_DEFINE_STRING_CONST(uvlib_make_s8vector__NAME, "make-s8vector", 13, 13);
75 static SCM_DEFINE_SUBR(uvlib_make_s8vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s8vector__NAME), uvlib_make_s8vector, NULL, NULL);
76
77 static ScmObj uvlib_s8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
78 {
79 ScmObj args_scm;
80 ScmObj args;
81 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
82 SCM_ENTER_SUBR("s8vector");
83 args_scm = SCM_OPTARGS;
84 args = (args_scm);
85 {
86 SCM_RETURN(Scm_ListToS8Vector(args, SCM_CLAMP_ERROR));
87 }
88 }
89
90 static SCM_DEFINE_STRING_CONST(uvlib_s8vector__NAME, "s8vector", 8, 8);
91 static SCM_DEFINE_SUBR(uvlib_s8vector__STUB, 0, 1, SCM_OBJ(&uvlib_s8vector__NAME), uvlib_s8vector, NULL, NULL);
92
93 static ScmObj uvlib_s8vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
94 {
95 ScmObj v_scm;
96 ScmS8Vector* v;
97 SCM_ENTER_SUBR("s8vector-length");
98 v_scm = SCM_ARGREF(0);
99 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
100 v = SCM_S8VECTOR(v_scm);
101 {
102 SCM_RETURN(SCM_MAKE_INT(SCM_S8VECTOR_SIZE(v)));
103 }
104 }
105
106 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_length__NAME, "s8vector-length", 15, 15);
107 static SCM_DEFINE_SUBR(uvlib_s8vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s8vector_length__NAME), uvlib_s8vector_length, NULL, NULL);
108
109 static ScmObj uvlib_s8vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
110 {
111 ScmObj v_scm;
112 ScmS8Vector* v;
113 ScmObj i_scm;
114 int i;
115 ScmObj fallback_scm;
116 ScmObj fallback;
117 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
118 SCM_ENTER_SUBR("s8vector-ref");
119 if (Scm_Length(SCM_OPTARGS) > 1)
120 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
121 v_scm = SCM_ARGREF(0);
122 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
123 v = SCM_S8VECTOR(v_scm);
124 i_scm = SCM_ARGREF(1);
125 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
126 i = SCM_INT_VALUE(i_scm);
127 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
128 else {
129 fallback_scm = SCM_CAR(SCM_OPTARGS);
130 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
131 }
132 fallback = (fallback_scm);
133 {
134 SCM_RETURN(Scm_S8VectorRef(v, i, fallback));
135 }
136 }
137
138 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_ref__NAME, "s8vector-ref", 12, 12);
139 static SCM_DEFINE_SUBR(uvlib_s8vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_ref__NAME), uvlib_s8vector_ref, NULL, NULL);
140
141 static ScmObj uvlib_s8vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
142 {
143 ScmObj v_scm;
144 ScmS8Vector* v;
145 ScmObj i_scm;
146 int i;
147 ScmObj val_scm;
148 ScmObj val;
149 ScmObj clamp_scm;
150 ScmObj clamp;
151 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
152 SCM_ENTER_SUBR("s8vector-set!");
153 if (Scm_Length(SCM_OPTARGS) > 1)
154 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
155 v_scm = SCM_ARGREF(0);
156 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
157 v = SCM_S8VECTOR(v_scm);
158 i_scm = SCM_ARGREF(1);
159 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
160 i = SCM_INT_VALUE(i_scm);
161 val_scm = SCM_ARGREF(2);
162 val = (val_scm);
163 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
164 else {
165 clamp_scm = SCM_CAR(SCM_OPTARGS);
166 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
167 }
168 clamp = (clamp_scm);
169 {
170 SCM_RETURN(Scm_S8VectorSet(v, i, val, clamp_arg(clamp)));
171 }
172 }
173
174 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_setX__NAME, "s8vector-set!", 13, 13);
175 static SCM_DEFINE_SUBR(uvlib_s8vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s8vector_setX__NAME), uvlib_s8vector_setX, NULL, NULL);
176
177 static ScmObj uvlib_s8vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
178 {
179 ScmObj v_scm;
180 ScmS8Vector* v;
181 ScmObj start_scm;
182 int start;
183 ScmObj end_scm;
184 int end;
185 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
186 SCM_ENTER_SUBR("s8vector-copy");
187 if (Scm_Length(SCM_OPTARGS) > 2)
188 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
189 v_scm = SCM_ARGREF(0);
190 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
191 v = SCM_S8VECTOR(v_scm);
192 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
193 else {
194 start_scm = SCM_CAR(SCM_OPTARGS);
195 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
196 }
197 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
198 start = SCM_INT_VALUE(start_scm);
199 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
200 else {
201 end_scm = SCM_CAR(SCM_OPTARGS);
202 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
203 }
204 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
205 end = SCM_INT_VALUE(end_scm);
206 {
207 {
208 ScmObj SCM_RESULT;
209 SCM_RESULT = Scm_S8VectorCopy(v, start, end);
210 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
211 }
212 }
213 }
214
215 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_copy__NAME, "s8vector-copy", 13, 13);
216 static SCM_DEFINE_SUBR(uvlib_s8vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_copy__NAME), uvlib_s8vector_copy, NULL, NULL);
217
218 static ScmObj uvlib_s8vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
219 {
220 ScmObj dst_scm;
221 ScmS8Vector* dst;
222 ScmObj dstart_scm;
223 ScmObj dstart;
224 ScmObj src_scm;
225 ScmObj src;
226 ScmObj sstart_scm;
227 int sstart;
228 ScmObj send_scm;
229 int send;
230 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
231 SCM_ENTER_SUBR("s8vector-copy!");
232 if (Scm_Length(SCM_OPTARGS) > 3)
233 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
234 dst_scm = SCM_ARGREF(0);
235 if (!SCM_S8VECTORP(dst_scm)) Scm_Error("<s8vector> required, but got %S", dst_scm);
236 dst = SCM_S8VECTOR(dst_scm);
237 dstart_scm = SCM_ARGREF(1);
238 dstart = (dstart_scm);
239 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
240 else {
241 src_scm = SCM_CAR(SCM_OPTARGS);
242 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
243 }
244 src = (src_scm);
245 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
246 else {
247 sstart_scm = SCM_CAR(SCM_OPTARGS);
248 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
249 }
250 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
251 sstart = Scm_GetInteger(sstart_scm);
252 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
253 else {
254 send_scm = SCM_CAR(SCM_OPTARGS);
255 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
256 }
257 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
258 send = Scm_GetInteger(send_scm);
259 {
260 if (SCM_INTEGERP(dstart)) {
261 /* new API */
262 if (!SCM_S8VECTORP(src)) {
263 Scm_Error("s8vector-copy!: argument is not a matching uvector: %S",
264 src);
265 }
266 SCM_RETURN(Scm_S8VectorCopyX(dst, Scm_GetInteger(dstart),
267 SCM_S8VECTOR(src), sstart, send));
268 } else if (SCM_S8VECTORP(dstart)) {
269 /* old API */
270 SCM_RETURN(Scm_S8VectorCopyX(dst, 0, SCM_S8VECTOR(dstart), 0, -1));
271 } else {
272 Scm_Error("integer required, but got %S", dstart);
273 SCM_RETURN(SCM_UNDEFINED);
274 }
275 }
276 }
277
278 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_copyX__NAME, "s8vector-copy!", 14, 14);
279 static SCM_DEFINE_SUBR(uvlib_s8vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_copyX__NAME), uvlib_s8vector_copyX, NULL, NULL);
280
281 static ScmObj uvlib_s8vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
282 {
283 ScmObj v_scm;
284 ScmS8Vector* v;
285 ScmObj start_scm;
286 int start;
287 ScmObj end_scm;
288 int end;
289 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
290 SCM_ENTER_SUBR("s8vector->list");
291 if (Scm_Length(SCM_OPTARGS) > 2)
292 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
293 v_scm = SCM_ARGREF(0);
294 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
295 v = SCM_S8VECTOR(v_scm);
296 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
297 else {
298 start_scm = SCM_CAR(SCM_OPTARGS);
299 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
300 }
301 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
302 start = SCM_INT_VALUE(start_scm);
303 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
304 else {
305 end_scm = SCM_CAR(SCM_OPTARGS);
306 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
307 }
308 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
309 end = SCM_INT_VALUE(end_scm);
310 {
311 {
312 ScmObj SCM_RESULT;
313 SCM_RESULT = Scm_S8VectorToList(v, start, end);
314 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
315 }
316 }
317 }
318
319 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOlist__NAME, "s8vector->list", 14, 14);
320 static SCM_DEFINE_SUBR(uvlib_s8vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOlist__NAME), uvlib_s8vector_TOlist, NULL, NULL);
321
322 static ScmObj uvlib_list_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
323 {
324 ScmObj l_scm;
325 ScmObj l;
326 ScmObj clamp_scm;
327 ScmObj clamp;
328 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
329 SCM_ENTER_SUBR("list->s8vector");
330 if (Scm_Length(SCM_OPTARGS) > 1)
331 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
332 l_scm = SCM_ARGREF(0);
333 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
334 l = (l_scm);
335 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
336 else {
337 clamp_scm = SCM_CAR(SCM_OPTARGS);
338 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
339 }
340 clamp = (clamp_scm);
341 {
342 SCM_RETURN(Scm_ListToS8Vector(l, clamp_arg(clamp)));
343 }
344 }
345
346 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs8vector__NAME, "list->s8vector", 14, 14);
347 static SCM_DEFINE_SUBR(uvlib_list_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs8vector__NAME), uvlib_list_TOs8vector, NULL, NULL);
348
349 static ScmObj uvlib_s8vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
350 {
351 ScmObj v_scm;
352 ScmS8Vector* v;
353 ScmObj val_scm;
354 ScmObj val;
355 ScmObj start_scm;
356 int start;
357 ScmObj end_scm;
358 int end;
359 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
360 SCM_ENTER_SUBR("s8vector-fill!");
361 if (Scm_Length(SCM_OPTARGS) > 2)
362 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
363 v_scm = SCM_ARGREF(0);
364 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
365 v = SCM_S8VECTOR(v_scm);
366 val_scm = SCM_ARGREF(1);
367 val = (val_scm);
368 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
369 else {
370 start_scm = SCM_CAR(SCM_OPTARGS);
371 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
372 }
373 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
374 start = SCM_INT_VALUE(start_scm);
375 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
376 else {
377 end_scm = SCM_CAR(SCM_OPTARGS);
378 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
379 }
380 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
381 end = SCM_INT_VALUE(end_scm);
382 {
383 signed char filler;
384 filler = s8unbox(val, SCM_CLAMP_ERROR);
385 SCM_RETURN(Scm_S8VectorFill(v, filler, start, end));
386 }
387 }
388
389 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_fillX__NAME, "s8vector-fill!", 14, 14);
390 static SCM_DEFINE_SUBR(uvlib_s8vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_fillX__NAME), uvlib_s8vector_fillX, NULL, NULL);
391
392 static ScmObj uvlib_s8vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
393 {
394 ScmObj v_scm;
395 ScmS8Vector* v;
396 ScmObj start_scm;
397 int start;
398 ScmObj end_scm;
399 int end;
400 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
401 SCM_ENTER_SUBR("s8vector->vector");
402 if (Scm_Length(SCM_OPTARGS) > 2)
403 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
404 v_scm = SCM_ARGREF(0);
405 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
406 v = SCM_S8VECTOR(v_scm);
407 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
408 else {
409 start_scm = SCM_CAR(SCM_OPTARGS);
410 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
411 }
412 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
413 start = SCM_INT_VALUE(start_scm);
414 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
415 else {
416 end_scm = SCM_CAR(SCM_OPTARGS);
417 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
418 }
419 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
420 end = SCM_INT_VALUE(end_scm);
421 {
422 {
423 ScmObj SCM_RESULT;
424 SCM_RESULT = Scm_S8VectorToVector(v, start, end);
425 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
426 }
427 }
428 }
429
430 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOvector__NAME, "s8vector->vector", 16, 16);
431 static SCM_DEFINE_SUBR(uvlib_s8vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOvector__NAME), uvlib_s8vector_TOvector, NULL, NULL);
432
433 static ScmObj uvlib_vector_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
434 {
435 ScmObj v_scm;
436 ScmVector* v;
437 ScmObj start_scm;
438 int start;
439 ScmObj end_scm;
440 int end;
441 ScmObj clamp_scm;
442 ScmObj clamp;
443 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
444 SCM_ENTER_SUBR("vector->s8vector");
445 if (Scm_Length(SCM_OPTARGS) > 3)
446 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
447 v_scm = SCM_ARGREF(0);
448 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
449 v = SCM_VECTOR(v_scm);
450 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
451 else {
452 start_scm = SCM_CAR(SCM_OPTARGS);
453 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
454 }
455 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
456 start = SCM_INT_VALUE(start_scm);
457 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
458 else {
459 end_scm = SCM_CAR(SCM_OPTARGS);
460 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
461 }
462 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
463 end = SCM_INT_VALUE(end_scm);
464 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
465 else {
466 clamp_scm = SCM_CAR(SCM_OPTARGS);
467 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
468 }
469 clamp = (clamp_scm);
470 {
471 SCM_RETURN(Scm_VectorToS8Vector(v, start, end, clamp_arg(clamp)));
472 }
473 }
474
475 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs8vector__NAME, "vector->s8vector", 16, 16);
476 static SCM_DEFINE_SUBR(uvlib_vector_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs8vector__NAME), uvlib_vector_TOs8vector, NULL, NULL);
477
478 static ScmObj uvlib_u8vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
479 {
480 ScmObj obj_scm;
481 ScmObj obj;
482 SCM_ENTER_SUBR("u8vector?");
483 obj_scm = SCM_ARGREF(0);
484 obj = (obj_scm);
485 {
486 {
487 int SCM_RESULT;
488 SCM_RESULT = SCM_U8VECTORP(obj);
489 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
490 }
491 }
492 }
493
494 static SCM_DEFINE_STRING_CONST(uvlib_u8vectorP__NAME, "u8vector?", 9, 9);
495 static SCM_DEFINE_SUBR(uvlib_u8vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u8vectorP__NAME), uvlib_u8vectorP, NULL, NULL);
496
497 static ScmObj uvlib_make_u8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
498 {
499 ScmObj length_scm;
500 int length;
501 ScmObj fill_scm;
502 ScmObj fill;
503 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
504 SCM_ENTER_SUBR("make-u8vector");
505 if (Scm_Length(SCM_OPTARGS) > 1)
506 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
507 length_scm = SCM_ARGREF(0);
508 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
509 length = SCM_INT_VALUE(length_scm);
510 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
511 else {
512 fill_scm = SCM_CAR(SCM_OPTARGS);
513 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
514 }
515 fill = (fill_scm);
516 {
517 unsigned char filler;
518 filler = u8unbox(fill, SCM_CLAMP_ERROR);
519 SCM_RETURN(Scm_MakeU8Vector(length, filler));
520 }
521 }
522
523 static SCM_DEFINE_STRING_CONST(uvlib_make_u8vector__NAME, "make-u8vector", 13, 13);
524 static SCM_DEFINE_SUBR(uvlib_make_u8vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u8vector__NAME), uvlib_make_u8vector, NULL, NULL);
525
526 static ScmObj uvlib_u8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
527 {
528 ScmObj args_scm;
529 ScmObj args;
530 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
531 SCM_ENTER_SUBR("u8vector");
532 args_scm = SCM_OPTARGS;
533 args = (args_scm);
534 {
535 SCM_RETURN(Scm_ListToU8Vector(args, SCM_CLAMP_ERROR));
536 }
537 }
538
539 static SCM_DEFINE_STRING_CONST(uvlib_u8vector__NAME, "u8vector", 8, 8);
540 static SCM_DEFINE_SUBR(uvlib_u8vector__STUB, 0, 1, SCM_OBJ(&uvlib_u8vector__NAME), uvlib_u8vector, NULL, NULL);
541
542 static ScmObj uvlib_u8vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
543 {
544 ScmObj v_scm;
545 ScmU8Vector* v;
546 SCM_ENTER_SUBR("u8vector-length");
547 v_scm = SCM_ARGREF(0);
548 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
549 v = SCM_U8VECTOR(v_scm);
550 {
551 SCM_RETURN(SCM_MAKE_INT(SCM_U8VECTOR_SIZE(v)));
552 }
553 }
554
555 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_length__NAME, "u8vector-length", 15, 15);
556 static SCM_DEFINE_SUBR(uvlib_u8vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u8vector_length__NAME), uvlib_u8vector_length, NULL, NULL);
557
558 static ScmObj uvlib_u8vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
559 {
560 ScmObj v_scm;
561 ScmU8Vector* v;
562 ScmObj i_scm;
563 int i;
564 ScmObj fallback_scm;
565 ScmObj fallback;
566 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
567 SCM_ENTER_SUBR("u8vector-ref");
568 if (Scm_Length(SCM_OPTARGS) > 1)
569 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
570 v_scm = SCM_ARGREF(0);
571 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
572 v = SCM_U8VECTOR(v_scm);
573 i_scm = SCM_ARGREF(1);
574 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
575 i = SCM_INT_VALUE(i_scm);
576 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
577 else {
578 fallback_scm = SCM_CAR(SCM_OPTARGS);
579 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
580 }
581 fallback = (fallback_scm);
582 {
583 SCM_RETURN(Scm_U8VectorRef(v, i, fallback));
584 }
585 }
586
587 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_ref__NAME, "u8vector-ref", 12, 12);
588 static SCM_DEFINE_SUBR(uvlib_u8vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_ref__NAME), uvlib_u8vector_ref, NULL, NULL);
589
590 static ScmObj uvlib_u8vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
591 {
592 ScmObj v_scm;
593 ScmU8Vector* v;
594 ScmObj i_scm;
595 int i;
596 ScmObj val_scm;
597 ScmObj val;
598 ScmObj clamp_scm;
599 ScmObj clamp;
600 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
601 SCM_ENTER_SUBR("u8vector-set!");
602 if (Scm_Length(SCM_OPTARGS) > 1)
603 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
604 v_scm = SCM_ARGREF(0);
605 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
606 v = SCM_U8VECTOR(v_scm);
607 i_scm = SCM_ARGREF(1);
608 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
609 i = SCM_INT_VALUE(i_scm);
610 val_scm = SCM_ARGREF(2);
611 val = (val_scm);
612 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
613 else {
614 clamp_scm = SCM_CAR(SCM_OPTARGS);
615 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
616 }
617 clamp = (clamp_scm);
618 {
619 SCM_RETURN(Scm_U8VectorSet(v, i, val, clamp_arg(clamp)));
620 }
621 }
622
623 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_setX__NAME, "u8vector-set!", 13, 13);
624 static SCM_DEFINE_SUBR(uvlib_u8vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u8vector_setX__NAME), uvlib_u8vector_setX, NULL, NULL);
625
626 static ScmObj uvlib_u8vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
627 {
628 ScmObj v_scm;
629 ScmU8Vector* v;
630 ScmObj start_scm;
631 int start;
632 ScmObj end_scm;
633 int end;
634 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
635 SCM_ENTER_SUBR("u8vector-copy");
636 if (Scm_Length(SCM_OPTARGS) > 2)
637 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
638 v_scm = SCM_ARGREF(0);
639 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
640 v = SCM_U8VECTOR(v_scm);
641 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
642 else {
643 start_scm = SCM_CAR(SCM_OPTARGS);
644 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
645 }
646 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
647 start = SCM_INT_VALUE(start_scm);
648 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
649 else {
650 end_scm = SCM_CAR(SCM_OPTARGS);
651 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
652 }
653 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
654 end = SCM_INT_VALUE(end_scm);
655 {
656 {
657 ScmObj SCM_RESULT;
658 SCM_RESULT = Scm_U8VectorCopy(v, start, end);
659 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
660 }
661 }
662 }
663
664 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_copy__NAME, "u8vector-copy", 13, 13);
665 static SCM_DEFINE_SUBR(uvlib_u8vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_copy__NAME), uvlib_u8vector_copy, NULL, NULL);
666
667 static ScmObj uvlib_u8vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
668 {
669 ScmObj dst_scm;
670 ScmU8Vector* dst;
671 ScmObj dstart_scm;
672 ScmObj dstart;
673 ScmObj src_scm;
674 ScmObj src;
675 ScmObj sstart_scm;
676 int sstart;
677 ScmObj send_scm;
678 int send;
679 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
680 SCM_ENTER_SUBR("u8vector-copy!");
681 if (Scm_Length(SCM_OPTARGS) > 3)
682 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
683 dst_scm = SCM_ARGREF(0);
684 if (!SCM_U8VECTORP(dst_scm)) Scm_Error("<u8vector> required, but got %S", dst_scm);
685 dst = SCM_U8VECTOR(dst_scm);
686 dstart_scm = SCM_ARGREF(1);
687 dstart = (dstart_scm);
688 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
689 else {
690 src_scm = SCM_CAR(SCM_OPTARGS);
691 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
692 }
693 src = (src_scm);
694 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
695 else {
696 sstart_scm = SCM_CAR(SCM_OPTARGS);
697 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
698 }
699 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
700 sstart = Scm_GetInteger(sstart_scm);
701 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
702 else {
703 send_scm = SCM_CAR(SCM_OPTARGS);
704 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
705 }
706 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
707 send = Scm_GetInteger(send_scm);
708 {
709 if (SCM_INTEGERP(dstart)) {
710 /* new API */
711 if (!SCM_U8VECTORP(src)) {
712 Scm_Error("u8vector-copy!: argument is not a matching uvector: %S",
713 src);
714 }
715 SCM_RETURN(Scm_U8VectorCopyX(dst, Scm_GetInteger(dstart),
716 SCM_U8VECTOR(src), sstart, send));
717 } else if (SCM_U8VECTORP(dstart)) {
718 /* old API */
719 SCM_RETURN(Scm_U8VectorCopyX(dst, 0, SCM_U8VECTOR(dstart), 0, -1));
720 } else {
721 Scm_Error("integer required, but got %S", dstart);
722 SCM_RETURN(SCM_UNDEFINED);
723 }
724 }
725 }
726
727 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_copyX__NAME, "u8vector-copy!", 14, 14);
728 static SCM_DEFINE_SUBR(uvlib_u8vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_copyX__NAME), uvlib_u8vector_copyX, NULL, NULL);
729
730 static ScmObj uvlib_u8vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
731 {
732 ScmObj v_scm;
733 ScmU8Vector* v;
734 ScmObj start_scm;
735 int start;
736 ScmObj end_scm;
737 int end;
738 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
739 SCM_ENTER_SUBR("u8vector->list");
740 if (Scm_Length(SCM_OPTARGS) > 2)
741 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
742 v_scm = SCM_ARGREF(0);
743 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
744 v = SCM_U8VECTOR(v_scm);
745 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
746 else {
747 start_scm = SCM_CAR(SCM_OPTARGS);
748 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
749 }
750 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
751 start = SCM_INT_VALUE(start_scm);
752 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
753 else {
754 end_scm = SCM_CAR(SCM_OPTARGS);
755 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
756 }
757 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
758 end = SCM_INT_VALUE(end_scm);
759 {
760 {
761 ScmObj SCM_RESULT;
762 SCM_RESULT = Scm_U8VectorToList(v, start, end);
763 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
764 }
765 }
766 }
767
768 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOlist__NAME, "u8vector->list", 14, 14);
769 static SCM_DEFINE_SUBR(uvlib_u8vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOlist__NAME), uvlib_u8vector_TOlist, NULL, NULL);
770
771 static ScmObj uvlib_list_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
772 {
773 ScmObj l_scm;
774 ScmObj l;
775 ScmObj clamp_scm;
776 ScmObj clamp;
777 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
778 SCM_ENTER_SUBR("list->u8vector");
779 if (Scm_Length(SCM_OPTARGS) > 1)
780 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
781 l_scm = SCM_ARGREF(0);
782 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
783 l = (l_scm);
784 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
785 else {
786 clamp_scm = SCM_CAR(SCM_OPTARGS);
787 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
788 }
789 clamp = (clamp_scm);
790 {
791 SCM_RETURN(Scm_ListToU8Vector(l, clamp_arg(clamp)));
792 }
793 }
794
795 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu8vector__NAME, "list->u8vector", 14, 14);
796 static SCM_DEFINE_SUBR(uvlib_list_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu8vector__NAME), uvlib_list_TOu8vector, NULL, NULL);
797
798 static ScmObj uvlib_u8vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
799 {
800 ScmObj v_scm;
801 ScmU8Vector* v;
802 ScmObj val_scm;
803 ScmObj val;
804 ScmObj start_scm;
805 int start;
806 ScmObj end_scm;
807 int end;
808 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
809 SCM_ENTER_SUBR("u8vector-fill!");
810 if (Scm_Length(SCM_OPTARGS) > 2)
811 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
812 v_scm = SCM_ARGREF(0);
813 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
814 v = SCM_U8VECTOR(v_scm);
815 val_scm = SCM_ARGREF(1);
816 val = (val_scm);
817 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
818 else {
819 start_scm = SCM_CAR(SCM_OPTARGS);
820 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
821 }
822 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
823 start = SCM_INT_VALUE(start_scm);
824 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
825 else {
826 end_scm = SCM_CAR(SCM_OPTARGS);
827 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
828 }
829 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
830 end = SCM_INT_VALUE(end_scm);
831 {
832 unsigned char filler;
833 filler = u8unbox(val, SCM_CLAMP_ERROR);
834 SCM_RETURN(Scm_U8VectorFill(v, filler, start, end));
835 }
836 }
837
838 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_fillX__NAME, "u8vector-fill!", 14, 14);
839 static SCM_DEFINE_SUBR(uvlib_u8vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_fillX__NAME), uvlib_u8vector_fillX, NULL, NULL);
840
841 static ScmObj uvlib_u8vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
842 {
843 ScmObj v_scm;
844 ScmU8Vector* v;
845 ScmObj start_scm;
846 int start;
847 ScmObj end_scm;
848 int end;
849 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
850 SCM_ENTER_SUBR("u8vector->vector");
851 if (Scm_Length(SCM_OPTARGS) > 2)
852 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
853 v_scm = SCM_ARGREF(0);
854 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
855 v = SCM_U8VECTOR(v_scm);
856 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
857 else {
858 start_scm = SCM_CAR(SCM_OPTARGS);
859 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
860 }
861 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
862 start = SCM_INT_VALUE(start_scm);
863 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
864 else {
865 end_scm = SCM_CAR(SCM_OPTARGS);
866 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
867 }
868 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
869 end = SCM_INT_VALUE(end_scm);
870 {
871 {
872 ScmObj SCM_RESULT;
873 SCM_RESULT = Scm_U8VectorToVector(v, start, end);
874 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
875 }
876 }
877 }
878
879 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOvector__NAME, "u8vector->vector", 16, 16);
880 static SCM_DEFINE_SUBR(uvlib_u8vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOvector__NAME), uvlib_u8vector_TOvector, NULL, NULL);
881
882 static ScmObj uvlib_vector_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
883 {
884 ScmObj v_scm;
885 ScmVector* v;
886 ScmObj start_scm;
887 int start;
888 ScmObj end_scm;
889 int end;
890 ScmObj clamp_scm;
891 ScmObj clamp;
892 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
893 SCM_ENTER_SUBR("vector->u8vector");
894 if (Scm_Length(SCM_OPTARGS) > 3)
895 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
896 v_scm = SCM_ARGREF(0);
897 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
898 v = SCM_VECTOR(v_scm);
899 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
900 else {
901 start_scm = SCM_CAR(SCM_OPTARGS);
902 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
903 }
904 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
905 start = SCM_INT_VALUE(start_scm);
906 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
907 else {
908 end_scm = SCM_CAR(SCM_OPTARGS);
909 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
910 }
911 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
912 end = SCM_INT_VALUE(end_scm);
913 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
914 else {
915 clamp_scm = SCM_CAR(SCM_OPTARGS);
916 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
917 }
918 clamp = (clamp_scm);
919 {
920 SCM_RETURN(Scm_VectorToU8Vector(v, start, end, clamp_arg(clamp)));
921 }
922 }
923
924 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu8vector__NAME, "vector->u8vector", 16, 16);
925 static SCM_DEFINE_SUBR(uvlib_vector_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu8vector__NAME), uvlib_vector_TOu8vector, NULL, NULL);
926
927 static ScmObj uvlib_s16vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
928 {
929 ScmObj obj_scm;
930 ScmObj obj;
931 SCM_ENTER_SUBR("s16vector?");
932 obj_scm = SCM_ARGREF(0);
933 obj = (obj_scm);
934 {
935 {
936 int SCM_RESULT;
937 SCM_RESULT = SCM_S16VECTORP(obj);
938 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
939 }
940 }
941 }
942
943 static SCM_DEFINE_STRING_CONST(uvlib_s16vectorP__NAME, "s16vector?", 10, 10);
944 static SCM_DEFINE_SUBR(uvlib_s16vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s16vectorP__NAME), uvlib_s16vectorP, NULL, NULL);
945
946 static ScmObj uvlib_make_s16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
947 {
948 ScmObj length_scm;
949 int length;
950 ScmObj fill_scm;
951 ScmObj fill;
952 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
953 SCM_ENTER_SUBR("make-s16vector");
954 if (Scm_Length(SCM_OPTARGS) > 1)
955 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
956 length_scm = SCM_ARGREF(0);
957 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
958 length = SCM_INT_VALUE(length_scm);
959 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
960 else {
961 fill_scm = SCM_CAR(SCM_OPTARGS);
962 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
963 }
964 fill = (fill_scm);
965 {
966 short filler;
967 filler = s16unbox(fill, SCM_CLAMP_ERROR);
968 SCM_RETURN(Scm_MakeS16Vector(length, filler));
969 }
970 }
971
972 static SCM_DEFINE_STRING_CONST(uvlib_make_s16vector__NAME, "make-s16vector", 14, 14);
973 static SCM_DEFINE_SUBR(uvlib_make_s16vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s16vector__NAME), uvlib_make_s16vector, NULL, NULL);
974
975 static ScmObj uvlib_s16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
976 {
977 ScmObj args_scm;
978 ScmObj args;
979 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
980 SCM_ENTER_SUBR("s16vector");
981 args_scm = SCM_OPTARGS;
982 args = (args_scm);
983 {
984 SCM_RETURN(Scm_ListToS16Vector(args, SCM_CLAMP_ERROR));
985 }
986 }
987
988 static SCM_DEFINE_STRING_CONST(uvlib_s16vector__NAME, "s16vector", 9, 9);
989 static SCM_DEFINE_SUBR(uvlib_s16vector__STUB, 0, 1, SCM_OBJ(&uvlib_s16vector__NAME), uvlib_s16vector, NULL, NULL);
990
991 static ScmObj uvlib_s16vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
992 {
993 ScmObj v_scm;
994 ScmS16Vector* v;
995 SCM_ENTER_SUBR("s16vector-length");
996 v_scm = SCM_ARGREF(0);
997 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
998 v = SCM_S16VECTOR(v_scm);
999 {
1000 SCM_RETURN(SCM_MAKE_INT(SCM_S16VECTOR_SIZE(v)));
1001 }
1002 }
1003
1004 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_length__NAME, "s16vector-length", 16, 16);
1005 static SCM_DEFINE_SUBR(uvlib_s16vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_length__NAME), uvlib_s16vector_length, NULL, NULL);
1006
1007 static ScmObj uvlib_s16vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1008 {
1009 ScmObj v_scm;
1010 ScmS16Vector* v;
1011 ScmObj i_scm;
1012 int i;
1013 ScmObj fallback_scm;
1014 ScmObj fallback;
1015 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1016 SCM_ENTER_SUBR("s16vector-ref");
1017 if (Scm_Length(SCM_OPTARGS) > 1)
1018 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1019 v_scm = SCM_ARGREF(0);
1020 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1021 v = SCM_S16VECTOR(v_scm);
1022 i_scm = SCM_ARGREF(1);
1023 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1024 i = SCM_INT_VALUE(i_scm);
1025 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1026 else {
1027 fallback_scm = SCM_CAR(SCM_OPTARGS);
1028 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1029 }
1030 fallback = (fallback_scm);
1031 {
1032 SCM_RETURN(Scm_S16VectorRef(v, i, fallback));
1033 }
1034 }
1035
1036 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_ref__NAME, "s16vector-ref", 13, 13);
1037 static SCM_DEFINE_SUBR(uvlib_s16vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_ref__NAME), uvlib_s16vector_ref, NULL, NULL);
1038
1039 static ScmObj uvlib_s16vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1040 {
1041 ScmObj v_scm;
1042 ScmS16Vector* v;
1043 ScmObj i_scm;
1044 int i;
1045 ScmObj val_scm;
1046 ScmObj val;
1047 ScmObj clamp_scm;
1048 ScmObj clamp;
1049 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1050 SCM_ENTER_SUBR("s16vector-set!");
1051 if (Scm_Length(SCM_OPTARGS) > 1)
1052 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1053 v_scm = SCM_ARGREF(0);
1054 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1055 v = SCM_S16VECTOR(v_scm);
1056 i_scm = SCM_ARGREF(1);
1057 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1058 i = SCM_INT_VALUE(i_scm);
1059 val_scm = SCM_ARGREF(2);
1060 val = (val_scm);
1061 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1062 else {
1063 clamp_scm = SCM_CAR(SCM_OPTARGS);
1064 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1065 }
1066 clamp = (clamp_scm);
1067 {
1068 SCM_RETURN(Scm_S16VectorSet(v, i, val, clamp_arg(clamp)));
1069 }
1070 }
1071
1072 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_setX__NAME, "s16vector-set!", 14, 14);
1073 static SCM_DEFINE_SUBR(uvlib_s16vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s16vector_setX__NAME), uvlib_s16vector_setX, NULL, NULL);
1074
1075 static ScmObj uvlib_s16vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1076 {
1077 ScmObj v_scm;
1078 ScmS16Vector* v;
1079 ScmObj start_scm;
1080 int start;
1081 ScmObj end_scm;
1082 int end;
1083 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1084 SCM_ENTER_SUBR("s16vector-copy");
1085 if (Scm_Length(SCM_OPTARGS) > 2)
1086 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1087 v_scm = SCM_ARGREF(0);
1088 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1089 v = SCM_S16VECTOR(v_scm);
1090 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1091 else {
1092 start_scm = SCM_CAR(SCM_OPTARGS);
1093 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1094 }
1095 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1096 start = SCM_INT_VALUE(start_scm);
1097 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1098 else {
1099 end_scm = SCM_CAR(SCM_OPTARGS);
1100 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1101 }
1102 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1103 end = SCM_INT_VALUE(end_scm);
1104 {
1105 {
1106 ScmObj SCM_RESULT;
1107 SCM_RESULT = Scm_S16VectorCopy(v, start, end);
1108 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1109 }
1110 }
1111 }
1112
1113 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_copy__NAME, "s16vector-copy", 14, 14);
1114 static SCM_DEFINE_SUBR(uvlib_s16vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_copy__NAME), uvlib_s16vector_copy, NULL, NULL);
1115
1116 static ScmObj uvlib_s16vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1117 {
1118 ScmObj dst_scm;
1119 ScmS16Vector* dst;
1120 ScmObj dstart_scm;
1121 ScmObj dstart;
1122 ScmObj src_scm;
1123 ScmObj src;
1124 ScmObj sstart_scm;
1125 int sstart;
1126 ScmObj send_scm;
1127 int send;
1128 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1129 SCM_ENTER_SUBR("s16vector-copy!");
1130 if (Scm_Length(SCM_OPTARGS) > 3)
1131 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1132 dst_scm = SCM_ARGREF(0);
1133 if (!SCM_S16VECTORP(dst_scm)) Scm_Error("<s16vector> required, but got %S", dst_scm);
1134 dst = SCM_S16VECTOR(dst_scm);
1135 dstart_scm = SCM_ARGREF(1);
1136 dstart = (dstart_scm);
1137 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
1138 else {
1139 src_scm = SCM_CAR(SCM_OPTARGS);
1140 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1141 }
1142 src = (src_scm);
1143 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
1144 else {
1145 sstart_scm = SCM_CAR(SCM_OPTARGS);
1146 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1147 }
1148 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
1149 sstart = Scm_GetInteger(sstart_scm);
1150 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
1151 else {
1152 send_scm = SCM_CAR(SCM_OPTARGS);
1153 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1154 }
1155 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
1156 send = Scm_GetInteger(send_scm);
1157 {
1158 if (SCM_INTEGERP(dstart)) {
1159 /* new API */
1160 if (!SCM_S16VECTORP(src)) {
1161 Scm_Error("s16vector-copy!: argument is not a matching uvector: %S",
1162 src);
1163 }
1164 SCM_RETURN(Scm_S16VectorCopyX(dst, Scm_GetInteger(dstart),
1165 SCM_S16VECTOR(src), sstart, send));
1166 } else if (SCM_S16VECTORP(dstart)) {
1167 /* old API */
1168 SCM_RETURN(Scm_S16VectorCopyX(dst, 0, SCM_S16VECTOR(dstart), 0, -1));
1169 } else {
1170 Scm_Error("integer required, but got %S", dstart);
1171 SCM_RETURN(SCM_UNDEFINED);
1172 }
1173 }
1174 }
1175
1176 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_copyX__NAME, "s16vector-copy!", 15, 15);
1177 static SCM_DEFINE_SUBR(uvlib_s16vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_copyX__NAME), uvlib_s16vector_copyX, NULL, NULL);
1178
1179 static ScmObj uvlib_s16vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1180 {
1181 ScmObj v_scm;
1182 ScmS16Vector* v;
1183 ScmObj start_scm;
1184 int start;
1185 ScmObj end_scm;
1186 int end;
1187 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1188 SCM_ENTER_SUBR("s16vector->list");
1189 if (Scm_Length(SCM_OPTARGS) > 2)
1190 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1191 v_scm = SCM_ARGREF(0);
1192 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1193 v = SCM_S16VECTOR(v_scm);
1194 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1195 else {
1196 start_scm = SCM_CAR(SCM_OPTARGS);
1197 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1198 }
1199 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1200 start = SCM_INT_VALUE(start_scm);
1201 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1202 else {
1203 end_scm = SCM_CAR(SCM_OPTARGS);
1204 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1205 }
1206 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1207 end = SCM_INT_VALUE(end_scm);
1208 {
1209 {
1210 ScmObj SCM_RESULT;
1211 SCM_RESULT = Scm_S16VectorToList(v, start, end);
1212 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1213 }
1214 }
1215 }
1216
1217 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_TOlist__NAME, "s16vector->list", 15, 15);
1218 static SCM_DEFINE_SUBR(uvlib_s16vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_TOlist__NAME), uvlib_s16vector_TOlist, NULL, NULL);
1219
1220 static ScmObj uvlib_list_TOs16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1221 {
1222 ScmObj l_scm;
1223 ScmObj l;
1224 ScmObj clamp_scm;
1225 ScmObj clamp;
1226 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1227 SCM_ENTER_SUBR("list->s16vector");
1228 if (Scm_Length(SCM_OPTARGS) > 1)
1229 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1230 l_scm = SCM_ARGREF(0);
1231 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
1232 l = (l_scm);
1233 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1234 else {
1235 clamp_scm = SCM_CAR(SCM_OPTARGS);
1236 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1237 }
1238 clamp = (clamp_scm);
1239 {
1240 SCM_RETURN(Scm_ListToS16Vector(l, clamp_arg(clamp)));
1241 }
1242 }
1243
1244 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs16vector__NAME, "list->s16vector", 15, 15);
1245 static SCM_DEFINE_SUBR(uvlib_list_TOs16vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs16vector__NAME), uvlib_list_TOs16vector, NULL, NULL);
1246
1247 static ScmObj uvlib_s16vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1248 {
1249 ScmObj v_scm;
1250 ScmS16Vector* v;
1251 ScmObj val_scm;
1252 ScmObj val;
1253 ScmObj start_scm;
1254 int start;
1255 ScmObj end_scm;
1256 int end;
1257 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1258 SCM_ENTER_SUBR("s16vector-fill!");
1259 if (Scm_Length(SCM_OPTARGS) > 2)
1260 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1261 v_scm = SCM_ARGREF(0);
1262 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1263 v = SCM_S16VECTOR(v_scm);
1264 val_scm = SCM_ARGREF(1);
1265 val = (val_scm);
1266 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1267 else {
1268 start_scm = SCM_CAR(SCM_OPTARGS);
1269 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1270 }
1271 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1272 start = SCM_INT_VALUE(start_scm);
1273 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1274 else {
1275 end_scm = SCM_CAR(SCM_OPTARGS);
1276 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1277 }
1278 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1279 end = SCM_INT_VALUE(end_scm);
1280 {
1281 short filler;
1282 filler = s16unbox(val, SCM_CLAMP_ERROR);
1283 SCM_RETURN(Scm_S16VectorFill(v, filler, start, end));
1284 }
1285 }
1286
1287 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_fillX__NAME, "s16vector-fill!", 15, 15);
1288 static SCM_DEFINE_SUBR(uvlib_s16vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_fillX__NAME), uvlib_s16vector_fillX, NULL, NULL);
1289
1290 static ScmObj uvlib_s16vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1291 {
1292 ScmObj v_scm;
1293 ScmS16Vector* v;
1294 ScmObj start_scm;
1295 int start;
1296 ScmObj end_scm;
1297 int end;
1298 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1299 SCM_ENTER_SUBR("s16vector->vector");
1300 if (Scm_Length(SCM_OPTARGS) > 2)
1301 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1302 v_scm = SCM_ARGREF(0);
1303 if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1304 v = SCM_S16VECTOR(v_scm);
1305 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1306 else {
1307 start_scm = SCM_CAR(SCM_OPTARGS);
1308 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1309 }
1310 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1311 start = SCM_INT_VALUE(start_scm);
1312 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1313 else {
1314 end_scm = SCM_CAR(SCM_OPTARGS);
1315 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1316 }
1317 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1318 end = SCM_INT_VALUE(end_scm);
1319 {
1320 {
1321 ScmObj SCM_RESULT;
1322 SCM_RESULT = Scm_S16VectorToVector(v, start, end);
1323 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1324 }
1325 }
1326 }
1327
1328 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_TOvector__NAME, "s16vector->vector", 17, 17);
1329 static SCM_DEFINE_SUBR(uvlib_s16vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_TOvector__NAME), uvlib_s16vector_TOvector, NULL, NULL);
1330
1331 static ScmObj uvlib_vector_TOs16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1332 {
1333 ScmObj v_scm;
1334 ScmVector* v;
1335 ScmObj start_scm;
1336 int start;
1337 ScmObj end_scm;
1338 int end;
1339 ScmObj clamp_scm;
1340 ScmObj clamp;
1341 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1342 SCM_ENTER_SUBR("vector->s16vector");
1343 if (Scm_Length(SCM_OPTARGS) > 3)
1344 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1345 v_scm = SCM_ARGREF(0);
1346 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
1347 v = SCM_VECTOR(v_scm);
1348 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1349 else {
1350 start_scm = SCM_CAR(SCM_OPTARGS);
1351 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1352 }
1353 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1354 start = SCM_INT_VALUE(start_scm);
1355 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1356 else {
1357 end_scm = SCM_CAR(SCM_OPTARGS);
1358 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1359 }
1360 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1361 end = SCM_INT_VALUE(end_scm);
1362 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1363 else {
1364 clamp_scm = SCM_CAR(SCM_OPTARGS);
1365 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1366 }
1367 clamp = (clamp_scm);
1368 {
1369 SCM_RETURN(Scm_VectorToS16Vector(v, start, end, clamp_arg(clamp)));
1370 }
1371 }
1372
1373 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs16vector__NAME, "vector->s16vector", 17, 17);
1374 static SCM_DEFINE_SUBR(uvlib_vector_TOs16vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs16vector__NAME), uvlib_vector_TOs16vector, NULL, NULL);
1375
1376 static ScmObj uvlib_u16vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1377 {
1378 ScmObj obj_scm;
1379 ScmObj obj;
1380 SCM_ENTER_SUBR("u16vector?");
1381 obj_scm = SCM_ARGREF(0);
1382 obj = (obj_scm);
1383 {
1384 {
1385 int SCM_RESULT;
1386 SCM_RESULT = SCM_U16VECTORP(obj);
1387 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1388 }
1389 }
1390 }
1391
1392 static SCM_DEFINE_STRING_CONST(uvlib_u16vectorP__NAME, "u16vector?", 10, 10);
1393 static SCM_DEFINE_SUBR(uvlib_u16vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u16vectorP__NAME), uvlib_u16vectorP, NULL, NULL);
1394
1395 static ScmObj uvlib_make_u16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1396 {
1397 ScmObj length_scm;
1398 int length;
1399 ScmObj fill_scm;
1400 ScmObj fill;
1401 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1402 SCM_ENTER_SUBR("make-u16vector");
1403 if (Scm_Length(SCM_OPTARGS) > 1)
1404 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1405 length_scm = SCM_ARGREF(0);
1406 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
1407 length = SCM_INT_VALUE(length_scm);
1408 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
1409 else {
1410 fill_scm = SCM_CAR(SCM_OPTARGS);
1411 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1412 }
1413 fill = (fill_scm);
1414 {
1415 unsigned short filler;
1416 filler = u16unbox(fill, SCM_CLAMP_ERROR);
1417 SCM_RETURN(Scm_MakeU16Vector(length, filler));
1418 }
1419 }
1420
1421 static SCM_DEFINE_STRING_CONST(uvlib_make_u16vector__NAME, "make-u16vector", 14, 14);
1422 static SCM_DEFINE_SUBR(uvlib_make_u16vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u16vector__NAME), uvlib_make_u16vector, NULL, NULL);
1423
1424 static ScmObj uvlib_u16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1425 {
1426 ScmObj args_scm;
1427 ScmObj args;
1428 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1429 SCM_ENTER_SUBR("u16vector");
1430 args_scm = SCM_OPTARGS;
1431 args = (args_scm);
1432 {
1433 SCM_RETURN(Scm_ListToU16Vector(args, SCM_CLAMP_ERROR));
1434 }
1435 }
1436
1437 static SCM_DEFINE_STRING_CONST(uvlib_u16vector__NAME, "u16vector", 9, 9);
1438 static SCM_DEFINE_SUBR(uvlib_u16vector__STUB, 0, 1, SCM_OBJ(&uvlib_u16vector__NAME), uvlib_u16vector, NULL, NULL);
1439
1440 static ScmObj uvlib_u16vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1441 {
1442 ScmObj v_scm;
1443 ScmU16Vector* v;
1444 SCM_ENTER_SUBR("u16vector-length");
1445 v_scm = SCM_ARGREF(0);
1446 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1447 v = SCM_U16VECTOR(v_scm);
1448 {
1449 SCM_RETURN(SCM_MAKE_INT(SCM_U16VECTOR_SIZE(v)));
1450 }
1451 }
1452
1453 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_length__NAME, "u16vector-length", 16, 16);
1454 static SCM_DEFINE_SUBR(uvlib_u16vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_length__NAME), uvlib_u16vector_length, NULL, NULL);
1455
1456 static ScmObj uvlib_u16vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1457 {
1458 ScmObj v_scm;
1459 ScmU16Vector* v;
1460 ScmObj i_scm;
1461 int i;
1462 ScmObj fallback_scm;
1463 ScmObj fallback;
1464 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1465 SCM_ENTER_SUBR("u16vector-ref");
1466 if (Scm_Length(SCM_OPTARGS) > 1)
1467 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1468 v_scm = SCM_ARGREF(0);
1469 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1470 v = SCM_U16VECTOR(v_scm);
1471 i_scm = SCM_ARGREF(1);
1472 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1473 i = SCM_INT_VALUE(i_scm);
1474 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1475 else {
1476 fallback_scm = SCM_CAR(SCM_OPTARGS);
1477 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1478 }
1479 fallback = (fallback_scm);
1480 {
1481 SCM_RETURN(Scm_U16VectorRef(v, i, fallback));
1482 }
1483 }
1484
1485 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_ref__NAME, "u16vector-ref", 13, 13);
1486 static SCM_DEFINE_SUBR(uvlib_u16vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_ref__NAME), uvlib_u16vector_ref, NULL, NULL);
1487
1488 static ScmObj uvlib_u16vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1489 {
1490 ScmObj v_scm;
1491 ScmU16Vector* v;
1492 ScmObj i_scm;
1493 int i;
1494 ScmObj val_scm;
1495 ScmObj val;
1496 ScmObj clamp_scm;
1497 ScmObj clamp;
1498 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1499 SCM_ENTER_SUBR("u16vector-set!");
1500 if (Scm_Length(SCM_OPTARGS) > 1)
1501 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1502 v_scm = SCM_ARGREF(0);
1503 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1504 v = SCM_U16VECTOR(v_scm);
1505 i_scm = SCM_ARGREF(1);
1506 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1507 i = SCM_INT_VALUE(i_scm);
1508 val_scm = SCM_ARGREF(2);
1509 val = (val_scm);
1510 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1511 else {
1512 clamp_scm = SCM_CAR(SCM_OPTARGS);
1513 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1514 }
1515 clamp = (clamp_scm);
1516 {
1517 SCM_RETURN(Scm_U16VectorSet(v, i, val, clamp_arg(clamp)));
1518 }
1519 }
1520
1521 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_setX__NAME, "u16vector-set!", 14, 14);
1522 static SCM_DEFINE_SUBR(uvlib_u16vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u16vector_setX__NAME), uvlib_u16vector_setX, NULL, NULL);
1523
1524 static ScmObj uvlib_u16vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1525 {
1526 ScmObj v_scm;
1527 ScmU16Vector* v;
1528 ScmObj start_scm;
1529 int start;
1530 ScmObj end_scm;
1531 int end;
1532 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1533 SCM_ENTER_SUBR("u16vector-copy");
1534 if (Scm_Length(SCM_OPTARGS) > 2)
1535 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1536 v_scm = SCM_ARGREF(0);
1537 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1538 v = SCM_U16VECTOR(v_scm);
1539 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1540 else {
1541 start_scm = SCM_CAR(SCM_OPTARGS);
1542 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1543 }
1544 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1545 start = SCM_INT_VALUE(start_scm);
1546 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1547 else {
1548 end_scm = SCM_CAR(SCM_OPTARGS);
1549 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1550 }
1551 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1552 end = SCM_INT_VALUE(end_scm);
1553 {
1554 {
1555 ScmObj SCM_RESULT;
1556 SCM_RESULT = Scm_U16VectorCopy(v, start, end);
1557 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1558 }
1559 }
1560 }
1561
1562 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_copy__NAME, "u16vector-copy", 14, 14);
1563 static SCM_DEFINE_SUBR(uvlib_u16vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_copy__NAME), uvlib_u16vector_copy, NULL, NULL);
1564
1565 static ScmObj uvlib_u16vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1566 {
1567 ScmObj dst_scm;
1568 ScmU16Vector* dst;
1569 ScmObj dstart_scm;
1570 ScmObj dstart;
1571 ScmObj src_scm;
1572 ScmObj src;
1573 ScmObj sstart_scm;
1574 int sstart;
1575 ScmObj send_scm;
1576 int send;
1577 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1578 SCM_ENTER_SUBR("u16vector-copy!");
1579 if (Scm_Length(SCM_OPTARGS) > 3)
1580 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1581 dst_scm = SCM_ARGREF(0);
1582 if (!SCM_U16VECTORP(dst_scm)) Scm_Error("<u16vector> required, but got %S", dst_scm);
1583 dst = SCM_U16VECTOR(dst_scm);
1584 dstart_scm = SCM_ARGREF(1);
1585 dstart = (dstart_scm);
1586 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
1587 else {
1588 src_scm = SCM_CAR(SCM_OPTARGS);
1589 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1590 }
1591 src = (src_scm);
1592 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
1593 else {
1594 sstart_scm = SCM_CAR(SCM_OPTARGS);
1595 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1596 }
1597 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
1598 sstart = Scm_GetInteger(sstart_scm);
1599 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
1600 else {
1601 send_scm = SCM_CAR(SCM_OPTARGS);
1602 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1603 }
1604 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
1605 send = Scm_GetInteger(send_scm);
1606 {
1607 if (SCM_INTEGERP(dstart)) {
1608 /* new API */
1609 if (!SCM_U16VECTORP(src)) {
1610 Scm_Error("u16vector-copy!: argument is not a matching uvector: %S",
1611 src);
1612 }
1613 SCM_RETURN(Scm_U16VectorCopyX(dst, Scm_GetInteger(dstart),
1614 SCM_U16VECTOR(src), sstart, send));
1615 } else if (SCM_U16VECTORP(dstart)) {
1616 /* old API */
1617 SCM_RETURN(Scm_U16VectorCopyX(dst, 0, SCM_U16VECTOR(dstart), 0, -1));
1618 } else {
1619 Scm_Error("integer required, but got %S", dstart);
1620 SCM_RETURN(SCM_UNDEFINED);
1621 }
1622 }
1623 }
1624
1625 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_copyX__NAME, "u16vector-copy!", 15, 15);
1626 static SCM_DEFINE_SUBR(uvlib_u16vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_copyX__NAME), uvlib_u16vector_copyX, NULL, NULL);
1627
1628 static ScmObj uvlib_u16vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1629 {
1630 ScmObj v_scm;
1631 ScmU16Vector* v;
1632 ScmObj start_scm;
1633 int start;
1634 ScmObj end_scm;
1635 int end;
1636 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1637 SCM_ENTER_SUBR("u16vector->list");
1638 if (Scm_Length(SCM_OPTARGS) > 2)
1639 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1640 v_scm = SCM_ARGREF(0);
1641 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1642 v = SCM_U16VECTOR(v_scm);
1643 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1644 else {
1645 start_scm = SCM_CAR(SCM_OPTARGS);
1646 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1647 }
1648 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1649 start = SCM_INT_VALUE(start_scm);
1650 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1651 else {
1652 end_scm = SCM_CAR(SCM_OPTARGS);
1653 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1654 }
1655 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1656 end = SCM_INT_VALUE(end_scm);
1657 {
1658 {
1659 ScmObj SCM_RESULT;
1660 SCM_RESULT = Scm_U16VectorToList(v, start, end);
1661 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1662 }
1663 }
1664 }
1665
1666 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_TOlist__NAME, "u16vector->list", 15, 15);
1667 static SCM_DEFINE_SUBR(uvlib_u16vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_TOlist__NAME), uvlib_u16vector_TOlist, NULL, NULL);
1668
1669 static ScmObj uvlib_list_TOu16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1670 {
1671 ScmObj l_scm;
1672 ScmObj l;
1673 ScmObj clamp_scm;
1674 ScmObj clamp;
1675 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1676 SCM_ENTER_SUBR("list->u16vector");
1677 if (Scm_Length(SCM_OPTARGS) > 1)
1678 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1679 l_scm = SCM_ARGREF(0);
1680 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
1681 l = (l_scm);
1682 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1683 else {
1684 clamp_scm = SCM_CAR(SCM_OPTARGS);
1685 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1686 }
1687 clamp = (clamp_scm);
1688 {
1689 SCM_RETURN(Scm_ListToU16Vector(l, clamp_arg(clamp)));
1690 }
1691 }
1692
1693 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu16vector__NAME, "list->u16vector", 15, 15);
1694 static SCM_DEFINE_SUBR(uvlib_list_TOu16vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu16vector__NAME), uvlib_list_TOu16vector, NULL, NULL);
1695
1696 static ScmObj uvlib_u16vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1697 {
1698 ScmObj v_scm;
1699 ScmU16Vector* v;
1700 ScmObj val_scm;
1701 ScmObj val;
1702 ScmObj start_scm;
1703 int start;
1704 ScmObj end_scm;
1705 int end;
1706 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1707 SCM_ENTER_SUBR("u16vector-fill!");
1708 if (Scm_Length(SCM_OPTARGS) > 2)
1709 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1710 v_scm = SCM_ARGREF(0);
1711 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1712 v = SCM_U16VECTOR(v_scm);
1713 val_scm = SCM_ARGREF(1);
1714 val = (val_scm);
1715 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1716 else {
1717 start_scm = SCM_CAR(SCM_OPTARGS);
1718 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1719 }
1720 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1721 start = SCM_INT_VALUE(start_scm);
1722 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1723 else {
1724 end_scm = SCM_CAR(SCM_OPTARGS);
1725 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1726 }
1727 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1728 end = SCM_INT_VALUE(end_scm);
1729 {
1730 unsigned short filler;
1731 filler = u16unbox(val, SCM_CLAMP_ERROR);
1732 SCM_RETURN(Scm_U16VectorFill(v, filler, start, end));
1733 }
1734 }
1735
1736 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_fillX__NAME, "u16vector-fill!", 15, 15);
1737 static SCM_DEFINE_SUBR(uvlib_u16vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_fillX__NAME), uvlib_u16vector_fillX, NULL, NULL);
1738
1739 static ScmObj uvlib_u16vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1740 {
1741 ScmObj v_scm;
1742 ScmU16Vector* v;
1743 ScmObj start_scm;
1744 int start;
1745 ScmObj end_scm;
1746 int end;
1747 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1748 SCM_ENTER_SUBR("u16vector->vector");
1749 if (Scm_Length(SCM_OPTARGS) > 2)
1750 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1751 v_scm = SCM_ARGREF(0);
1752 if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1753 v = SCM_U16VECTOR(v_scm);
1754 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1755 else {
1756 start_scm = SCM_CAR(SCM_OPTARGS);
1757 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1758 }
1759 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1760 start = SCM_INT_VALUE(start_scm);
1761 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1762 else {
1763 end_scm = SCM_CAR(SCM_OPTARGS);
1764 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1765 }
1766 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1767 end = SCM_INT_VALUE(end_scm);
1768 {
1769 {
1770 ScmObj SCM_RESULT;
1771 SCM_RESULT = Scm_U16VectorToVector(v, start, end);
1772 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1773 }
1774 }
1775 }
1776
1777 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_TOvector__NAME, "u16vector->vector", 17, 17);
1778 static SCM_DEFINE_SUBR(uvlib_u16vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_TOvector__NAME), uvlib_u16vector_TOvector, NULL, NULL);
1779
1780 static ScmObj uvlib_vector_TOu16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1781 {
1782 ScmObj v_scm;
1783 ScmVector* v;
1784 ScmObj start_scm;
1785 int start;
1786 ScmObj end_scm;
1787 int end;
1788 ScmObj clamp_scm;
1789 ScmObj clamp;
1790 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1791 SCM_ENTER_SUBR("vector->u16vector");
1792 if (Scm_Length(SCM_OPTARGS) > 3)
1793 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1794 v_scm = SCM_ARGREF(0);
1795 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
1796 v = SCM_VECTOR(v_scm);
1797 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1798 else {
1799 start_scm = SCM_CAR(SCM_OPTARGS);
1800 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1801 }
1802 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1803 start = SCM_INT_VALUE(start_scm);
1804 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1805 else {
1806 end_scm = SCM_CAR(SCM_OPTARGS);
1807 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1808 }
1809 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1810 end = SCM_INT_VALUE(end_scm);
1811 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1812 else {
1813 clamp_scm = SCM_CAR(SCM_OPTARGS);
1814 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1815 }
1816 clamp = (clamp_scm);
1817 {
1818 SCM_RETURN(Scm_VectorToU16Vector(v, start, end, clamp_arg(clamp)));
1819 }
1820 }
1821
1822 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu16vector__NAME, "vector->u16vector", 17, 17);
1823 static SCM_DEFINE_SUBR(uvlib_vector_TOu16vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu16vector__NAME), uvlib_vector_TOu16vector, NULL, NULL);
1824
1825 static ScmObj uvlib_s32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1826 {
1827 ScmObj obj_scm;
1828 ScmObj obj;
1829 SCM_ENTER_SUBR("s32vector?");
1830 obj_scm = SCM_ARGREF(0);
1831 obj = (obj_scm);
1832 {
1833 {
1834 int SCM_RESULT;
1835 SCM_RESULT = SCM_S32VECTORP(obj);
1836 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1837 }
1838 }
1839 }
1840
1841 static SCM_DEFINE_STRING_CONST(uvlib_s32vectorP__NAME, "s32vector?", 10, 10);
1842 static SCM_DEFINE_SUBR(uvlib_s32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s32vectorP__NAME), uvlib_s32vectorP, NULL, NULL);
1843
1844 static ScmObj uvlib_make_s32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1845 {
1846 ScmObj length_scm;
1847 int length;
1848 ScmObj fill_scm;
1849 ScmObj fill;
1850 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1851 SCM_ENTER_SUBR("make-s32vector");
1852 if (Scm_Length(SCM_OPTARGS) > 1)
1853 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1854 length_scm = SCM_ARGREF(0);
1855 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
1856 length = SCM_INT_VALUE(length_scm);
1857 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
1858 else {
1859 fill_scm = SCM_CAR(SCM_OPTARGS);
1860 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1861 }
1862 fill = (fill_scm);
1863 {
1864 ScmInt32 filler;
1865 filler = Scm_GetInteger32Clamp(fill, SCM_CLAMP_ERROR, NULL);
1866 SCM_RETURN(Scm_MakeS32Vector(length, filler));
1867 }
1868 }
1869
1870 static SCM_DEFINE_STRING_CONST(uvlib_make_s32vector__NAME, "make-s32vector", 14, 14);
1871 static SCM_DEFINE_SUBR(uvlib_make_s32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s32vector__NAME), uvlib_make_s32vector, NULL, NULL);
1872
1873 static ScmObj uvlib_s32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1874 {
1875 ScmObj args_scm;
1876 ScmObj args;
1877 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1878 SCM_ENTER_SUBR("s32vector");
1879 args_scm = SCM_OPTARGS;
1880 args = (args_scm);
1881 {
1882 SCM_RETURN(Scm_ListToS32Vector(args, SCM_CLAMP_ERROR));
1883 }
1884 }
1885
1886 static SCM_DEFINE_STRING_CONST(uvlib_s32vector__NAME, "s32vector", 9, 9);
1887 static SCM_DEFINE_SUBR(uvlib_s32vector__STUB, 0, 1, SCM_OBJ(&uvlib_s32vector__NAME), uvlib_s32vector, NULL, NULL);
1888
1889 static ScmObj uvlib_s32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1890 {
1891 ScmObj v_scm;
1892 ScmS32Vector* v;
1893 SCM_ENTER_SUBR("s32vector-length");
1894 v_scm = SCM_ARGREF(0);
1895 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1896 v = SCM_S32VECTOR(v_scm);
1897 {
1898 SCM_RETURN(SCM_MAKE_INT(SCM_S32VECTOR_SIZE(v)));
1899 }
1900 }
1901
1902 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_length__NAME, "s32vector-length", 16, 16);
1903 static SCM_DEFINE_SUBR(uvlib_s32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_length__NAME), uvlib_s32vector_length, NULL, NULL);
1904
1905 static ScmObj uvlib_s32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1906 {
1907 ScmObj v_scm;
1908 ScmS32Vector* v;
1909 ScmObj i_scm;
1910 int i;
1911 ScmObj fallback_scm;
1912 ScmObj fallback;
1913 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1914 SCM_ENTER_SUBR("s32vector-ref");
1915 if (Scm_Length(SCM_OPTARGS) > 1)
1916 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1917 v_scm = SCM_ARGREF(0);
1918 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1919 v = SCM_S32VECTOR(v_scm);
1920 i_scm = SCM_ARGREF(1);
1921 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1922 i = SCM_INT_VALUE(i_scm);
1923 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1924 else {
1925 fallback_scm = SCM_CAR(SCM_OPTARGS);
1926 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1927 }
1928 fallback = (fallback_scm);
1929 {
1930 SCM_RETURN(Scm_S32VectorRef(v, i, fallback));
1931 }
1932 }
1933
1934 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_ref__NAME, "s32vector-ref", 13, 13);
1935 static SCM_DEFINE_SUBR(uvlib_s32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_ref__NAME), uvlib_s32vector_ref, NULL, NULL);
1936
1937 static ScmObj uvlib_s32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1938 {
1939 ScmObj v_scm;
1940 ScmS32Vector* v;
1941 ScmObj i_scm;
1942 int i;
1943 ScmObj val_scm;
1944 ScmObj val;
1945 ScmObj clamp_scm;
1946 ScmObj clamp;
1947 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1948 SCM_ENTER_SUBR("s32vector-set!");
1949 if (Scm_Length(SCM_OPTARGS) > 1)
1950 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1951 v_scm = SCM_ARGREF(0);
1952 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1953 v = SCM_S32VECTOR(v_scm);
1954 i_scm = SCM_ARGREF(1);
1955 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1956 i = SCM_INT_VALUE(i_scm);
1957 val_scm = SCM_ARGREF(2);
1958 val = (val_scm);
1959 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1960 else {
1961 clamp_scm = SCM_CAR(SCM_OPTARGS);
1962 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1963 }
1964 clamp = (clamp_scm);
1965 {
1966 SCM_RETURN(Scm_S32VectorSet(v, i, val, clamp_arg(clamp)));
1967 }
1968 }
1969
1970 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_setX__NAME, "s32vector-set!", 14, 14);
1971 static SCM_DEFINE_SUBR(uvlib_s32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s32vector_setX__NAME), uvlib_s32vector_setX, NULL, NULL);
1972
1973 static ScmObj uvlib_s32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1974 {
1975 ScmObj v_scm;
1976 ScmS32Vector* v;
1977 ScmObj start_scm;
1978 int start;
1979 ScmObj end_scm;
1980 int end;
1981 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1982 SCM_ENTER_SUBR("s32vector-copy");
1983 if (Scm_Length(SCM_OPTARGS) > 2)
1984 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1985 v_scm = SCM_ARGREF(0);
1986 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1987 v = SCM_S32VECTOR(v_scm);
1988 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1989 else {
1990 start_scm = SCM_CAR(SCM_OPTARGS);
1991 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1992 }
1993 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1994 start = SCM_INT_VALUE(start_scm);
1995 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1996 else {
1997 end_scm = SCM_CAR(SCM_OPTARGS);
1998 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1999 }
2000 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2001 end = SCM_INT_VALUE(end_scm);
2002 {
2003 {
2004 ScmObj SCM_RESULT;
2005 SCM_RESULT = Scm_S32VectorCopy(v, start, end);
2006 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2007 }
2008 }
2009 }
2010
2011 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_copy__NAME, "s32vector-copy", 14, 14);
2012 static SCM_DEFINE_SUBR(uvlib_s32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_copy__NAME), uvlib_s32vector_copy, NULL, NULL);
2013
2014 static ScmObj uvlib_s32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2015 {
2016 ScmObj dst_scm;
2017 ScmS32Vector* dst;
2018 ScmObj dstart_scm;
2019 ScmObj dstart;
2020 ScmObj src_scm;
2021 ScmObj src;
2022 ScmObj sstart_scm;
2023 int sstart;
2024 ScmObj send_scm;
2025 int send;
2026 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2027 SCM_ENTER_SUBR("s32vector-copy!");
2028 if (Scm_Length(SCM_OPTARGS) > 3)
2029 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2030 dst_scm = SCM_ARGREF(0);
2031 if (!SCM_S32VECTORP(dst_scm)) Scm_Error("<s32vector> required, but got %S", dst_scm);
2032 dst = SCM_S32VECTOR(dst_scm);
2033 dstart_scm = SCM_ARGREF(1);
2034 dstart = (dstart_scm);
2035 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2036 else {
2037 src_scm = SCM_CAR(SCM_OPTARGS);
2038 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2039 }
2040 src = (src_scm);
2041 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2042 else {
2043 sstart_scm = SCM_CAR(SCM_OPTARGS);
2044 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2045 }
2046 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2047 sstart = Scm_GetInteger(sstart_scm);
2048 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2049 else {
2050 send_scm = SCM_CAR(SCM_OPTARGS);
2051 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2052 }
2053 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2054 send = Scm_GetInteger(send_scm);
2055 {
2056 if (SCM_INTEGERP(dstart)) {
2057 /* new API */
2058 if (!SCM_S32VECTORP(src)) {
2059 Scm_Error("s32vector-copy!: argument is not a matching uvector: %S",
2060 src);
2061 }
2062 SCM_RETURN(Scm_S32VectorCopyX(dst, Scm_GetInteger(dstart),
2063 SCM_S32VECTOR(src), sstart, send));
2064 } else if (SCM_S32VECTORP(dstart)) {
2065 /* old API */
2066 SCM_RETURN(Scm_S32VectorCopyX(dst, 0, SCM_S32VECTOR(dstart), 0, -1));
2067 } else {
2068 Scm_Error("integer required, but got %S", dstart);
2069 SCM_RETURN(SCM_UNDEFINED);
2070 }
2071 }
2072 }
2073
2074 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_copyX__NAME, "s32vector-copy!", 15, 15);
2075 static SCM_DEFINE_SUBR(uvlib_s32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_copyX__NAME), uvlib_s32vector_copyX, NULL, NULL);
2076
2077 static ScmObj uvlib_s32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2078 {
2079 ScmObj v_scm;
2080 ScmS32Vector* v;
2081 ScmObj start_scm;
2082 int start;
2083 ScmObj end_scm;
2084 int end;
2085 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2086 SCM_ENTER_SUBR("s32vector->list");
2087 if (Scm_Length(SCM_OPTARGS) > 2)
2088 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2089 v_scm = SCM_ARGREF(0);
2090 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2091 v = SCM_S32VECTOR(v_scm);
2092 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2093 else {
2094 start_scm = SCM_CAR(SCM_OPTARGS);
2095 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2096 }
2097 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2098 start = SCM_INT_VALUE(start_scm);
2099 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2100 else {
2101 end_scm = SCM_CAR(SCM_OPTARGS);
2102 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2103 }
2104 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2105 end = SCM_INT_VALUE(end_scm);
2106 {
2107 {
2108 ScmObj SCM_RESULT;
2109 SCM_RESULT = Scm_S32VectorToList(v, start, end);
2110 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2111 }
2112 }
2113 }
2114
2115 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOlist__NAME, "s32vector->list", 15, 15);
2116 static SCM_DEFINE_SUBR(uvlib_s32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOlist__NAME), uvlib_s32vector_TOlist, NULL, NULL);
2117
2118 static ScmObj uvlib_list_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2119 {
2120 ScmObj l_scm;
2121 ScmObj l;
2122 ScmObj clamp_scm;
2123 ScmObj clamp;
2124 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2125 SCM_ENTER_SUBR("list->s32vector");
2126 if (Scm_Length(SCM_OPTARGS) > 1)
2127 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2128 l_scm = SCM_ARGREF(0);
2129 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
2130 l = (l_scm);
2131 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2132 else {
2133 clamp_scm = SCM_CAR(SCM_OPTARGS);
2134 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2135 }
2136 clamp = (clamp_scm);
2137 {
2138 SCM_RETURN(Scm_ListToS32Vector(l, clamp_arg(clamp)));
2139 }
2140 }
2141
2142 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs32vector__NAME, "list->s32vector", 15, 15);
2143 static SCM_DEFINE_SUBR(uvlib_list_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs32vector__NAME), uvlib_list_TOs32vector, NULL, NULL);
2144
2145 static ScmObj uvlib_s32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2146 {
2147 ScmObj v_scm;
2148 ScmS32Vector* v;
2149 ScmObj val_scm;
2150 ScmObj val;
2151 ScmObj start_scm;
2152 int start;
2153 ScmObj end_scm;
2154 int end;
2155 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2156 SCM_ENTER_SUBR("s32vector-fill!");
2157 if (Scm_Length(SCM_OPTARGS) > 2)
2158 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2159 v_scm = SCM_ARGREF(0);
2160 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2161 v = SCM_S32VECTOR(v_scm);
2162 val_scm = SCM_ARGREF(1);
2163 val = (val_scm);
2164 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2165 else {
2166 start_scm = SCM_CAR(SCM_OPTARGS);
2167 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2168 }
2169 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2170 start = SCM_INT_VALUE(start_scm);
2171 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2172 else {
2173 end_scm = SCM_CAR(SCM_OPTARGS);
2174 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2175 }
2176 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2177 end = SCM_INT_VALUE(end_scm);
2178 {
2179 ScmInt32 filler;
2180 filler = Scm_GetInteger32Clamp(val, SCM_CLAMP_ERROR, NULL);
2181 SCM_RETURN(Scm_S32VectorFill(v, filler, start, end));
2182 }
2183 }
2184
2185 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_fillX__NAME, "s32vector-fill!", 15, 15);
2186 static SCM_DEFINE_SUBR(uvlib_s32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_fillX__NAME), uvlib_s32vector_fillX, NULL, NULL);
2187
2188 static ScmObj uvlib_s32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2189 {
2190 ScmObj v_scm;
2191 ScmS32Vector* v;
2192 ScmObj start_scm;
2193 int start;
2194 ScmObj end_scm;
2195 int end;
2196 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2197 SCM_ENTER_SUBR("s32vector->vector");
2198 if (Scm_Length(SCM_OPTARGS) > 2)
2199 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2200 v_scm = SCM_ARGREF(0);
2201 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2202 v = SCM_S32VECTOR(v_scm);
2203 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2204 else {
2205 start_scm = SCM_CAR(SCM_OPTARGS);
2206 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2207 }
2208 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2209 start = SCM_INT_VALUE(start_scm);
2210 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2211 else {
2212 end_scm = SCM_CAR(SCM_OPTARGS);
2213 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2214 }
2215 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2216 end = SCM_INT_VALUE(end_scm);
2217 {
2218 {
2219 ScmObj SCM_RESULT;
2220 SCM_RESULT = Scm_S32VectorToVector(v, start, end);
2221 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2222 }
2223 }
2224 }
2225
2226 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOvector__NAME, "s32vector->vector", 17, 17);
2227 static SCM_DEFINE_SUBR(uvlib_s32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOvector__NAME), uvlib_s32vector_TOvector, NULL, NULL);
2228
2229 static ScmObj uvlib_vector_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2230 {
2231 ScmObj v_scm;
2232 ScmVector* v;
2233 ScmObj start_scm;
2234 int start;
2235 ScmObj end_scm;
2236 int end;
2237 ScmObj clamp_scm;
2238 ScmObj clamp;
2239 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2240 SCM_ENTER_SUBR("vector->s32vector");
2241 if (Scm_Length(SCM_OPTARGS) > 3)
2242 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2243 v_scm = SCM_ARGREF(0);
2244 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
2245 v = SCM_VECTOR(v_scm);
2246 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2247 else {
2248 start_scm = SCM_CAR(SCM_OPTARGS);
2249 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2250 }
2251 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2252 start = SCM_INT_VALUE(start_scm);
2253 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2254 else {
2255 end_scm = SCM_CAR(SCM_OPTARGS);
2256 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2257 }
2258 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2259 end = SCM_INT_VALUE(end_scm);
2260 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2261 else {
2262 clamp_scm = SCM_CAR(SCM_OPTARGS);
2263 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2264 }
2265 clamp = (clamp_scm);
2266 {
2267 SCM_RETURN(Scm_VectorToS32Vector(v, start, end, clamp_arg(clamp)));
2268 }
2269 }
2270
2271 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs32vector__NAME, "vector->s32vector", 17, 17);
2272 static SCM_DEFINE_SUBR(uvlib_vector_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs32vector__NAME), uvlib_vector_TOs32vector, NULL, NULL);
2273
2274 static ScmObj uvlib_u32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2275 {
2276 ScmObj obj_scm;
2277 ScmObj obj;
2278 SCM_ENTER_SUBR("u32vector?");
2279 obj_scm = SCM_ARGREF(0);
2280 obj = (obj_scm);
2281 {
2282 {
2283 int SCM_RESULT;
2284 SCM_RESULT = SCM_U32VECTORP(obj);
2285 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2286 }
2287 }
2288 }
2289
2290 static SCM_DEFINE_STRING_CONST(uvlib_u32vectorP__NAME, "u32vector?", 10, 10);
2291 static SCM_DEFINE_SUBR(uvlib_u32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u32vectorP__NAME), uvlib_u32vectorP, NULL, NULL);
2292
2293 static ScmObj uvlib_make_u32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2294 {
2295 ScmObj length_scm;
2296 int length;
2297 ScmObj fill_scm;
2298 ScmObj fill;
2299 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2300 SCM_ENTER_SUBR("make-u32vector");
2301 if (Scm_Length(SCM_OPTARGS) > 1)
2302 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2303 length_scm = SCM_ARGREF(0);
2304 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
2305 length = SCM_INT_VALUE(length_scm);
2306 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
2307 else {
2308 fill_scm = SCM_CAR(SCM_OPTARGS);
2309 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2310 }
2311 fill = (fill_scm);
2312 {
2313 ScmUInt32 filler;
2314 filler = Scm_GetIntegerU32Clamp(fill, SCM_CLAMP_ERROR, NULL);
2315 SCM_RETURN(Scm_MakeU32Vector(length, filler));
2316 }
2317 }
2318
2319 static SCM_DEFINE_STRING_CONST(uvlib_make_u32vector__NAME, "make-u32vector", 14, 14);
2320 static SCM_DEFINE_SUBR(uvlib_make_u32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u32vector__NAME), uvlib_make_u32vector, NULL, NULL);
2321
2322 static ScmObj uvlib_u32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2323 {
2324 ScmObj args_scm;
2325 ScmObj args;
2326 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2327 SCM_ENTER_SUBR("u32vector");
2328 args_scm = SCM_OPTARGS;
2329 args = (args_scm);
2330 {
2331 SCM_RETURN(Scm_ListToU32Vector(args, SCM_CLAMP_ERROR));
2332 }
2333 }
2334
2335 static SCM_DEFINE_STRING_CONST(uvlib_u32vector__NAME, "u32vector", 9, 9);
2336 static SCM_DEFINE_SUBR(uvlib_u32vector__STUB, 0, 1, SCM_OBJ(&uvlib_u32vector__NAME), uvlib_u32vector, NULL, NULL);
2337
2338 static ScmObj uvlib_u32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2339 {
2340 ScmObj v_scm;
2341 ScmU32Vector* v;
2342 SCM_ENTER_SUBR("u32vector-length");
2343 v_scm = SCM_ARGREF(0);
2344 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2345 v = SCM_U32VECTOR(v_scm);
2346 {
2347 SCM_RETURN(SCM_MAKE_INT(SCM_U32VECTOR_SIZE(v)));
2348 }
2349 }
2350
2351 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_length__NAME, "u32vector-length", 16, 16);
2352 static SCM_DEFINE_SUBR(uvlib_u32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_length__NAME), uvlib_u32vector_length, NULL, NULL);
2353
2354 static ScmObj uvlib_u32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2355 {
2356 ScmObj v_scm;
2357 ScmU32Vector* v;
2358 ScmObj i_scm;
2359 int i;
2360 ScmObj fallback_scm;
2361 ScmObj fallback;
2362 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2363 SCM_ENTER_SUBR("u32vector-ref");
2364 if (Scm_Length(SCM_OPTARGS) > 1)
2365 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2366 v_scm = SCM_ARGREF(0);
2367 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2368 v = SCM_U32VECTOR(v_scm);
2369 i_scm = SCM_ARGREF(1);
2370 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2371 i = SCM_INT_VALUE(i_scm);
2372 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
2373 else {
2374 fallback_scm = SCM_CAR(SCM_OPTARGS);
2375 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2376 }
2377 fallback = (fallback_scm);
2378 {
2379 SCM_RETURN(Scm_U32VectorRef(v, i, fallback));
2380 }
2381 }
2382
2383 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_ref__NAME, "u32vector-ref", 13, 13);
2384 static SCM_DEFINE_SUBR(uvlib_u32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_ref__NAME), uvlib_u32vector_ref, NULL, NULL);
2385
2386 static ScmObj uvlib_u32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2387 {
2388 ScmObj v_scm;
2389 ScmU32Vector* v;
2390 ScmObj i_scm;
2391 int i;
2392 ScmObj val_scm;
2393 ScmObj val;
2394 ScmObj clamp_scm;
2395 ScmObj clamp;
2396 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2397 SCM_ENTER_SUBR("u32vector-set!");
2398 if (Scm_Length(SCM_OPTARGS) > 1)
2399 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2400 v_scm = SCM_ARGREF(0);
2401 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2402 v = SCM_U32VECTOR(v_scm);
2403 i_scm = SCM_ARGREF(1);
2404 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2405 i = SCM_INT_VALUE(i_scm);
2406 val_scm = SCM_ARGREF(2);
2407 val = (val_scm);
2408 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2409 else {
2410 clamp_scm = SCM_CAR(SCM_OPTARGS);
2411 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2412 }
2413 clamp = (clamp_scm);
2414 {
2415 SCM_RETURN(Scm_U32VectorSet(v, i, val, clamp_arg(clamp)));
2416 }
2417 }
2418
2419 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_setX__NAME, "u32vector-set!", 14, 14);
2420 static SCM_DEFINE_SUBR(uvlib_u32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u32vector_setX__NAME), uvlib_u32vector_setX, NULL, NULL);
2421
2422 static ScmObj uvlib_u32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2423 {
2424 ScmObj v_scm;
2425 ScmU32Vector* v;
2426 ScmObj start_scm;
2427 int start;
2428 ScmObj end_scm;
2429 int end;
2430 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2431 SCM_ENTER_SUBR("u32vector-copy");
2432 if (Scm_Length(SCM_OPTARGS) > 2)
2433 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2434 v_scm = SCM_ARGREF(0);
2435 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2436 v = SCM_U32VECTOR(v_scm);
2437 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2438 else {
2439 start_scm = SCM_CAR(SCM_OPTARGS);
2440 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2441 }
2442 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2443 start = SCM_INT_VALUE(start_scm);
2444 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2445 else {
2446 end_scm = SCM_CAR(SCM_OPTARGS);
2447 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2448 }
2449 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2450 end = SCM_INT_VALUE(end_scm);
2451 {
2452 {
2453 ScmObj SCM_RESULT;
2454 SCM_RESULT = Scm_U32VectorCopy(v, start, end);
2455 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2456 }
2457 }
2458 }
2459
2460 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_copy__NAME, "u32vector-copy", 14, 14);
2461 static SCM_DEFINE_SUBR(uvlib_u32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_copy__NAME), uvlib_u32vector_copy, NULL, NULL);
2462
2463 static ScmObj uvlib_u32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2464 {
2465 ScmObj dst_scm;
2466 ScmU32Vector* dst;
2467 ScmObj dstart_scm;
2468 ScmObj dstart;
2469 ScmObj src_scm;
2470 ScmObj src;
2471 ScmObj sstart_scm;
2472 int sstart;
2473 ScmObj send_scm;
2474 int send;
2475 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2476 SCM_ENTER_SUBR("u32vector-copy!");
2477 if (Scm_Length(SCM_OPTARGS) > 3)
2478 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2479 dst_scm = SCM_ARGREF(0);
2480 if (!SCM_U32VECTORP(dst_scm)) Scm_Error("<u32vector> required, but got %S", dst_scm);
2481 dst = SCM_U32VECTOR(dst_scm);
2482 dstart_scm = SCM_ARGREF(1);
2483 dstart = (dstart_scm);
2484 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2485 else {
2486 src_scm = SCM_CAR(SCM_OPTARGS);
2487 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2488 }
2489 src = (src_scm);
2490 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2491 else {
2492 sstart_scm = SCM_CAR(SCM_OPTARGS);
2493 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2494 }
2495 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2496 sstart = Scm_GetInteger(sstart_scm);
2497 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2498 else {
2499 send_scm = SCM_CAR(SCM_OPTARGS);
2500 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2501 }
2502 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2503 send = Scm_GetInteger(send_scm);
2504 {
2505 if (SCM_INTEGERP(dstart)) {
2506 /* new API */
2507 if (!SCM_U32VECTORP(src)) {
2508 Scm_Error("u32vector-copy!: argument is not a matching uvector: %S",
2509 src);
2510 }
2511 SCM_RETURN(Scm_U32VectorCopyX(dst, Scm_GetInteger(dstart),
2512 SCM_U32VECTOR(src), sstart, send));
2513 } else if (SCM_U32VECTORP(dstart)) {
2514 /* old API */
2515 SCM_RETURN(Scm_U32VectorCopyX(dst, 0, SCM_U32VECTOR(dstart), 0, -1));
2516 } else {
2517 Scm_Error("integer required, but got %S", dstart);
2518 SCM_RETURN(SCM_UNDEFINED);
2519 }
2520 }
2521 }
2522
2523 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_copyX__NAME, "u32vector-copy!", 15, 15);
2524 static SCM_DEFINE_SUBR(uvlib_u32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_copyX__NAME), uvlib_u32vector_copyX, NULL, NULL);
2525
2526 static ScmObj uvlib_u32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2527 {
2528 ScmObj v_scm;
2529 ScmU32Vector* v;
2530 ScmObj start_scm;
2531 int start;
2532 ScmObj end_scm;
2533 int end;
2534 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2535 SCM_ENTER_SUBR("u32vector->list");
2536 if (Scm_Length(SCM_OPTARGS) > 2)
2537 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2538 v_scm = SCM_ARGREF(0);
2539 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2540 v = SCM_U32VECTOR(v_scm);
2541 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2542 else {
2543 start_scm = SCM_CAR(SCM_OPTARGS);
2544 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2545 }
2546 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2547 start = SCM_INT_VALUE(start_scm);
2548 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2549 else {
2550 end_scm = SCM_CAR(SCM_OPTARGS);
2551 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2552 }
2553 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2554 end = SCM_INT_VALUE(end_scm);
2555 {
2556 {
2557 ScmObj SCM_RESULT;
2558 SCM_RESULT = Scm_U32VectorToList(v, start, end);
2559 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2560 }
2561 }
2562 }
2563
2564 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOlist__NAME, "u32vector->list", 15, 15);
2565 static SCM_DEFINE_SUBR(uvlib_u32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOlist__NAME), uvlib_u32vector_TOlist, NULL, NULL);
2566
2567 static ScmObj uvlib_list_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2568 {
2569 ScmObj l_scm;
2570 ScmObj l;
2571 ScmObj clamp_scm;
2572 ScmObj clamp;
2573 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2574 SCM_ENTER_SUBR("list->u32vector");
2575 if (Scm_Length(SCM_OPTARGS) > 1)
2576 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2577 l_scm = SCM_ARGREF(0);
2578 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
2579 l = (l_scm);
2580 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2581 else {
2582 clamp_scm = SCM_CAR(SCM_OPTARGS);
2583 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2584 }
2585 clamp = (clamp_scm);
2586 {
2587 SCM_RETURN(Scm_ListToU32Vector(l, clamp_arg(clamp)));
2588 }
2589 }
2590
2591 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu32vector__NAME, "list->u32vector", 15, 15);
2592 static SCM_DEFINE_SUBR(uvlib_list_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu32vector__NAME), uvlib_list_TOu32vector, NULL, NULL);
2593
2594 static ScmObj uvlib_u32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2595 {
2596 ScmObj v_scm;
2597 ScmU32Vector* v;
2598 ScmObj val_scm;
2599 ScmObj val;
2600 ScmObj start_scm;
2601 int start;
2602 ScmObj end_scm;
2603 int end;
2604 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2605 SCM_ENTER_SUBR("u32vector-fill!");
2606 if (Scm_Length(SCM_OPTARGS) > 2)
2607 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2608 v_scm = SCM_ARGREF(0);
2609 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2610 v = SCM_U32VECTOR(v_scm);
2611 val_scm = SCM_ARGREF(1);
2612 val = (val_scm);
2613 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2614 else {
2615 start_scm = SCM_CAR(SCM_OPTARGS);
2616 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2617 }
2618 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2619 start = SCM_INT_VALUE(start_scm);
2620 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2621 else {
2622 end_scm = SCM_CAR(SCM_OPTARGS);
2623 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2624 }
2625 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2626 end = SCM_INT_VALUE(end_scm);
2627 {
2628 ScmUInt32 filler;
2629 filler = Scm_GetIntegerU32Clamp(val, SCM_CLAMP_ERROR, NULL);
2630 SCM_RETURN(Scm_U32VectorFill(v, filler, start, end));
2631 }
2632 }
2633
2634 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_fillX__NAME, "u32vector-fill!", 15, 15);
2635 static SCM_DEFINE_SUBR(uvlib_u32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_fillX__NAME), uvlib_u32vector_fillX, NULL, NULL);
2636
2637 static ScmObj uvlib_u32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2638 {
2639 ScmObj v_scm;
2640 ScmU32Vector* v;
2641 ScmObj start_scm;
2642 int start;
2643 ScmObj end_scm;
2644 int end;
2645 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2646 SCM_ENTER_SUBR("u32vector->vector");
2647 if (Scm_Length(SCM_OPTARGS) > 2)
2648 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2649 v_scm = SCM_ARGREF(0);
2650 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2651 v = SCM_U32VECTOR(v_scm);
2652 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2653 else {
2654 start_scm = SCM_CAR(SCM_OPTARGS);
2655 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2656 }
2657 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2658 start = SCM_INT_VALUE(start_scm);
2659 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2660 else {
2661 end_scm = SCM_CAR(SCM_OPTARGS);
2662 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2663 }
2664 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2665 end = SCM_INT_VALUE(end_scm);
2666 {
2667 {
2668 ScmObj SCM_RESULT;
2669 SCM_RESULT = Scm_U32VectorToVector(v, start, end);
2670 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2671 }
2672 }
2673 }
2674
2675 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOvector__NAME, "u32vector->vector", 17, 17);
2676 static SCM_DEFINE_SUBR(uvlib_u32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOvector__NAME), uvlib_u32vector_TOvector, NULL, NULL);
2677
2678 static ScmObj uvlib_vector_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2679 {
2680 ScmObj v_scm;
2681 ScmVector* v;
2682 ScmObj start_scm;
2683 int start;
2684 ScmObj end_scm;
2685 int end;
2686 ScmObj clamp_scm;
2687 ScmObj clamp;
2688 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2689 SCM_ENTER_SUBR("vector->u32vector");
2690 if (Scm_Length(SCM_OPTARGS) > 3)
2691 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2692 v_scm = SCM_ARGREF(0);
2693 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
2694 v = SCM_VECTOR(v_scm);
2695 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2696 else {
2697 start_scm = SCM_CAR(SCM_OPTARGS);
2698 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2699 }
2700 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2701 start = SCM_INT_VALUE(start_scm);
2702 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2703 else {
2704 end_scm = SCM_CAR(SCM_OPTARGS);
2705 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2706 }
2707 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2708 end = SCM_INT_VALUE(end_scm);
2709 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2710 else {
2711 clamp_scm = SCM_CAR(SCM_OPTARGS);
2712 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2713 }
2714 clamp = (clamp_scm);
2715 {
2716 SCM_RETURN(Scm_VectorToU32Vector(v, start, end, clamp_arg(clamp)));
2717 }
2718 }
2719
2720 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu32vector__NAME, "vector->u32vector", 17, 17);
2721 static SCM_DEFINE_SUBR(uvlib_vector_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu32vector__NAME), uvlib_vector_TOu32vector, NULL, NULL);
2722
2723 static ScmObj uvlib_s64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2724 {
2725 ScmObj obj_scm;
2726 ScmObj obj;
2727 SCM_ENTER_SUBR("s64vector?");
2728 obj_scm = SCM_ARGREF(0);
2729 obj = (obj_scm);
2730 {
2731 {
2732 int SCM_RESULT;
2733 SCM_RESULT = SCM_S64VECTORP(obj);
2734 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2735 }
2736 }
2737 }
2738
2739 static SCM_DEFINE_STRING_CONST(uvlib_s64vectorP__NAME, "s64vector?", 10, 10);
2740 static SCM_DEFINE_SUBR(uvlib_s64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s64vectorP__NAME), uvlib_s64vectorP, NULL, NULL);
2741
2742 static ScmObj uvlib_make_s64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2743 {
2744 ScmObj length_scm;
2745 int length;
2746 ScmObj fill_scm;
2747 ScmObj fill;
2748 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2749 SCM_ENTER_SUBR("make-s64vector");
2750 if (Scm_Length(SCM_OPTARGS) > 1)
2751 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2752 length_scm = SCM_ARGREF(0);
2753 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
2754 length = SCM_INT_VALUE(length_scm);
2755 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
2756 else {
2757 fill_scm = SCM_CAR(SCM_OPTARGS);
2758 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2759 }
2760 fill = (fill_scm);
2761 {
2762 ScmInt64 filler;
2763 filler = Scm_GetInteger64Clamp(fill, SCM_CLAMP_ERROR, NULL);
2764 SCM_RETURN(Scm_MakeS64Vector(length, filler));
2765 }
2766 }
2767
2768 static SCM_DEFINE_STRING_CONST(uvlib_make_s64vector__NAME, "make-s64vector", 14, 14);
2769 static SCM_DEFINE_SUBR(uvlib_make_s64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s64vector__NAME), uvlib_make_s64vector, NULL, NULL);
2770
2771 static ScmObj uvlib_s64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2772 {
2773 ScmObj args_scm;
2774 ScmObj args;
2775 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2776 SCM_ENTER_SUBR("s64vector");
2777 args_scm = SCM_OPTARGS;
2778 args = (args_scm);
2779 {
2780 SCM_RETURN(Scm_ListToS64Vector(args, SCM_CLAMP_ERROR));
2781 }
2782 }
2783
2784 static SCM_DEFINE_STRING_CONST(uvlib_s64vector__NAME, "s64vector", 9, 9);
2785 static SCM_DEFINE_SUBR(uvlib_s64vector__STUB, 0, 1, SCM_OBJ(&uvlib_s64vector__NAME), uvlib_s64vector, NULL, NULL);
2786
2787 static ScmObj uvlib_s64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2788 {
2789 ScmObj v_scm;
2790 ScmS64Vector* v;
2791 SCM_ENTER_SUBR("s64vector-length");
2792 v_scm = SCM_ARGREF(0);
2793 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2794 v = SCM_S64VECTOR(v_scm);
2795 {
2796 SCM_RETURN(SCM_MAKE_INT(SCM_S64VECTOR_SIZE(v)));
2797 }
2798 }
2799
2800 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_length__NAME, "s64vector-length", 16, 16);
2801 static SCM_DEFINE_SUBR(uvlib_s64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_length__NAME), uvlib_s64vector_length, NULL, NULL);
2802
2803 static ScmObj uvlib_s64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2804 {
2805 ScmObj v_scm;
2806 ScmS64Vector* v;
2807 ScmObj i_scm;
2808 int i;
2809 ScmObj fallback_scm;
2810 ScmObj fallback;
2811 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2812 SCM_ENTER_SUBR("s64vector-ref");
2813 if (Scm_Length(SCM_OPTARGS) > 1)
2814 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2815 v_scm = SCM_ARGREF(0);
2816 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2817 v = SCM_S64VECTOR(v_scm);
2818 i_scm = SCM_ARGREF(1);
2819 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2820 i = SCM_INT_VALUE(i_scm);
2821 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
2822 else {
2823 fallback_scm = SCM_CAR(SCM_OPTARGS);
2824 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2825 }
2826 fallback = (fallback_scm);
2827 {
2828 SCM_RETURN(Scm_S64VectorRef(v, i, fallback));
2829 }
2830 }
2831
2832 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_ref__NAME, "s64vector-ref", 13, 13);
2833 static SCM_DEFINE_SUBR(uvlib_s64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_ref__NAME), uvlib_s64vector_ref, NULL, NULL);
2834
2835 static ScmObj uvlib_s64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2836 {
2837 ScmObj v_scm;
2838 ScmS64Vector* v;
2839 ScmObj i_scm;
2840 int i;
2841 ScmObj val_scm;
2842 ScmObj val;
2843 ScmObj clamp_scm;
2844 ScmObj clamp;
2845 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2846 SCM_ENTER_SUBR("s64vector-set!");
2847 if (Scm_Length(SCM_OPTARGS) > 1)
2848 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2849 v_scm = SCM_ARGREF(0);
2850 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2851 v = SCM_S64VECTOR(v_scm);
2852 i_scm = SCM_ARGREF(1);
2853 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2854 i = SCM_INT_VALUE(i_scm);
2855 val_scm = SCM_ARGREF(2);
2856 val = (val_scm);
2857 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2858 else {
2859 clamp_scm = SCM_CAR(SCM_OPTARGS);
2860 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2861 }
2862 clamp = (clamp_scm);
2863 {
2864 SCM_RETURN(Scm_S64VectorSet(v, i, val, clamp_arg(clamp)));
2865 }
2866 }
2867
2868 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_setX__NAME, "s64vector-set!", 14, 14);
2869 static SCM_DEFINE_SUBR(uvlib_s64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s64vector_setX__NAME), uvlib_s64vector_setX, NULL, NULL);
2870
2871 static ScmObj uvlib_s64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2872 {
2873 ScmObj v_scm;
2874 ScmS64Vector* v;
2875 ScmObj start_scm;
2876 int start;
2877 ScmObj end_scm;
2878 int end;
2879 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2880 SCM_ENTER_SUBR("s64vector-copy");
2881 if (Scm_Length(SCM_OPTARGS) > 2)
2882 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2883 v_scm = SCM_ARGREF(0);
2884 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2885 v = SCM_S64VECTOR(v_scm);
2886 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2887 else {
2888 start_scm = SCM_CAR(SCM_OPTARGS);
2889 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2890 }
2891 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2892 start = SCM_INT_VALUE(start_scm);
2893 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2894 else {
2895 end_scm = SCM_CAR(SCM_OPTARGS);
2896 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2897 }
2898 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2899 end = SCM_INT_VALUE(end_scm);
2900 {
2901 {
2902 ScmObj SCM_RESULT;
2903 SCM_RESULT = Scm_S64VectorCopy(v, start, end);
2904 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2905 }
2906 }
2907 }
2908
2909 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_copy__NAME, "s64vector-copy", 14, 14);
2910 static SCM_DEFINE_SUBR(uvlib_s64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_copy__NAME), uvlib_s64vector_copy, NULL, NULL);
2911
2912 static ScmObj uvlib_s64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2913 {
2914 ScmObj dst_scm;
2915 ScmS64Vector* dst;
2916 ScmObj dstart_scm;
2917 ScmObj dstart;
2918 ScmObj src_scm;
2919 ScmObj src;
2920 ScmObj sstart_scm;
2921 int sstart;
2922 ScmObj send_scm;
2923 int send;
2924 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2925 SCM_ENTER_SUBR("s64vector-copy!");
2926 if (Scm_Length(SCM_OPTARGS) > 3)
2927 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2928 dst_scm = SCM_ARGREF(0);
2929 if (!SCM_S64VECTORP(dst_scm)) Scm_Error("<s64vector> required, but got %S", dst_scm);
2930 dst = SCM_S64VECTOR(dst_scm);
2931 dstart_scm = SCM_ARGREF(1);
2932 dstart = (dstart_scm);
2933 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2934 else {
2935 src_scm = SCM_CAR(SCM_OPTARGS);
2936 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2937 }
2938 src = (src_scm);
2939 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2940 else {
2941 sstart_scm = SCM_CAR(SCM_OPTARGS);
2942 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2943 }
2944 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2945 sstart = Scm_GetInteger(sstart_scm);
2946 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2947 else {
2948 send_scm = SCM_CAR(SCM_OPTARGS);
2949 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2950 }
2951 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2952 send = Scm_GetInteger(send_scm);
2953 {
2954 if (SCM_INTEGERP(dstart)) {
2955 /* new API */
2956 if (!SCM_S64VECTORP(src)) {
2957 Scm_Error("s64vector-copy!: argument is not a matching uvector: %S",
2958 src);
2959 }
2960 SCM_RETURN(Scm_S64VectorCopyX(dst, Scm_GetInteger(dstart),
2961 SCM_S64VECTOR(src), sstart, send));
2962 } else if (SCM_S64VECTORP(dstart)) {
2963 /* old API */
2964 SCM_RETURN(Scm_S64VectorCopyX(dst, 0, SCM_S64VECTOR(dstart), 0, -1));
2965 } else {
2966 Scm_Error("integer required, but got %S", dstart);
2967 SCM_RETURN(SCM_UNDEFINED);
2968 }
2969 }
2970 }
2971
2972 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_copyX__NAME, "s64vector-copy!", 15, 15);
2973 static SCM_DEFINE_SUBR(uvlib_s64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_copyX__NAME), uvlib_s64vector_copyX, NULL, NULL);
2974
2975 static ScmObj uvlib_s64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2976 {
2977 ScmObj v_scm;
2978 ScmS64Vector* v;
2979 ScmObj start_scm;
2980 int start;
2981 ScmObj end_scm;
2982 int end;
2983 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2984 SCM_ENTER_SUBR("s64vector->list");
2985 if (Scm_Length(SCM_OPTARGS) > 2)
2986 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2987 v_scm = SCM_ARGREF(0);
2988 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2989 v = SCM_S64VECTOR(v_scm);
2990 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2991 else {
2992 start_scm = SCM_CAR(SCM_OPTARGS);
2993 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2994 }
2995 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2996 start = SCM_INT_VALUE(start_scm);
2997 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2998 else {
2999 end_scm = SCM_CAR(SCM_OPTARGS);
3000 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3001 }
3002 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3003 end = SCM_INT_VALUE(end_scm);
3004 {
3005 {
3006 ScmObj SCM_RESULT;
3007 SCM_RESULT = Scm_S64VectorToList(v, start, end);
3008 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3009 }
3010 }
3011 }
3012
3013 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_TOlist__NAME, "s64vector->list", 15, 15);
3014 static SCM_DEFINE_SUBR(uvlib_s64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_TOlist__NAME), uvlib_s64vector_TOlist, NULL, NULL);
3015
3016 static ScmObj uvlib_list_TOs64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3017 {
3018 ScmObj l_scm;
3019 ScmObj l;
3020 ScmObj clamp_scm;
3021 ScmObj clamp;
3022 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3023 SCM_ENTER_SUBR("list->s64vector");
3024 if (Scm_Length(SCM_OPTARGS) > 1)
3025 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3026 l_scm = SCM_ARGREF(0);
3027 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3028 l = (l_scm);
3029 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3030 else {
3031 clamp_scm = SCM_CAR(SCM_OPTARGS);
3032 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3033 }
3034 clamp = (clamp_scm);
3035 {
3036 SCM_RETURN(Scm_ListToS64Vector(l, clamp_arg(clamp)));
3037 }
3038 }
3039
3040 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs64vector__NAME, "list->s64vector", 15, 15);
3041 static SCM_DEFINE_SUBR(uvlib_list_TOs64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs64vector__NAME), uvlib_list_TOs64vector, NULL, NULL);
3042
3043 static ScmObj uvlib_s64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3044 {
3045 ScmObj v_scm;
3046 ScmS64Vector* v;
3047 ScmObj val_scm;
3048 ScmObj val;
3049 ScmObj start_scm;
3050 int start;
3051 ScmObj end_scm;
3052 int end;
3053 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3054 SCM_ENTER_SUBR("s64vector-fill!");
3055 if (Scm_Length(SCM_OPTARGS) > 2)
3056 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3057 v_scm = SCM_ARGREF(0);
3058 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
3059 v = SCM_S64VECTOR(v_scm);
3060 val_scm = SCM_ARGREF(1);
3061 val = (val_scm);
3062 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3063 else {
3064 start_scm = SCM_CAR(SCM_OPTARGS);
3065 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3066 }
3067 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3068 start = SCM_INT_VALUE(start_scm);
3069 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3070 else {
3071 end_scm = SCM_CAR(SCM_OPTARGS);
3072 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3073 }
3074 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3075 end = SCM_INT_VALUE(end_scm);
3076 {
3077 ScmInt64 filler;
3078 filler = Scm_GetInteger64Clamp(val, SCM_CLAMP_ERROR, NULL);
3079 SCM_RETURN(Scm_S64VectorFill(v, filler, start, end));
3080 }
3081 }
3082
3083 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_fillX__NAME, "s64vector-fill!", 15, 15);
3084 static SCM_DEFINE_SUBR(uvlib_s64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_fillX__NAME), uvlib_s64vector_fillX, NULL, NULL);
3085
3086 static ScmObj uvlib_s64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3087 {
3088 ScmObj v_scm;
3089 ScmS64Vector* v;
3090 ScmObj start_scm;
3091 int start;
3092 ScmObj end_scm;
3093 int end;
3094 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3095 SCM_ENTER_SUBR("s64vector->vector");
3096 if (Scm_Length(SCM_OPTARGS) > 2)
3097 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3098 v_scm = SCM_ARGREF(0);
3099 if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
3100 v = SCM_S64VECTOR(v_scm);
3101 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3102 else {
3103 start_scm = SCM_CAR(SCM_OPTARGS);
3104 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3105 }
3106 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3107 start = SCM_INT_VALUE(start_scm);
3108 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3109 else {
3110 end_scm = SCM_CAR(SCM_OPTARGS);
3111 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3112 }
3113 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3114 end = SCM_INT_VALUE(end_scm);
3115 {
3116 {
3117 ScmObj SCM_RESULT;
3118 SCM_RESULT = Scm_S64VectorToVector(v, start, end);
3119 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3120 }
3121 }
3122 }
3123
3124 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_TOvector__NAME, "s64vector->vector", 17, 17);
3125 static SCM_DEFINE_SUBR(uvlib_s64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_TOvector__NAME), uvlib_s64vector_TOvector, NULL, NULL);
3126
3127 static ScmObj uvlib_vector_TOs64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3128 {
3129 ScmObj v_scm;
3130 ScmVector* v;
3131 ScmObj start_scm;
3132 int start;
3133 ScmObj end_scm;
3134 int end;
3135 ScmObj clamp_scm;
3136 ScmObj clamp;
3137 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3138 SCM_ENTER_SUBR("vector->s64vector");
3139 if (Scm_Length(SCM_OPTARGS) > 3)
3140 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3141 v_scm = SCM_ARGREF(0);
3142 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
3143 v = SCM_VECTOR(v_scm);
3144 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3145 else {
3146 start_scm = SCM_CAR(SCM_OPTARGS);
3147 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3148 }
3149 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3150 start = SCM_INT_VALUE(start_scm);
3151 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3152 else {
3153 end_scm = SCM_CAR(SCM_OPTARGS);
3154 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3155 }
3156 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3157 end = SCM_INT_VALUE(end_scm);
3158 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3159 else {
3160 clamp_scm = SCM_CAR(SCM_OPTARGS);
3161 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3162 }
3163 clamp = (clamp_scm);
3164 {
3165 SCM_RETURN(Scm_VectorToS64Vector(v, start, end, clamp_arg(clamp)));
3166 }
3167 }
3168
3169 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs64vector__NAME, "vector->s64vector", 17, 17);
3170 static SCM_DEFINE_SUBR(uvlib_vector_TOs64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs64vector__NAME), uvlib_vector_TOs64vector, NULL, NULL);
3171
3172 static ScmObj uvlib_u64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3173 {
3174 ScmObj obj_scm;
3175 ScmObj obj;
3176 SCM_ENTER_SUBR("u64vector?");
3177 obj_scm = SCM_ARGREF(0);
3178 obj = (obj_scm);
3179 {
3180 {
3181 int SCM_RESULT;
3182 SCM_RESULT = SCM_U64VECTORP(obj);
3183 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3184 }
3185 }
3186 }
3187
3188 static SCM_DEFINE_STRING_CONST(uvlib_u64vectorP__NAME, "u64vector?", 10, 10);
3189 static SCM_DEFINE_SUBR(uvlib_u64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u64vectorP__NAME), uvlib_u64vectorP, NULL, NULL);
3190
3191 static ScmObj uvlib_make_u64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3192 {
3193 ScmObj length_scm;
3194 int length;
3195 ScmObj fill_scm;
3196 ScmObj fill;
3197 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3198 SCM_ENTER_SUBR("make-u64vector");
3199 if (Scm_Length(SCM_OPTARGS) > 1)
3200 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3201 length_scm = SCM_ARGREF(0);
3202 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
3203 length = SCM_INT_VALUE(length_scm);
3204 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
3205 else {
3206 fill_scm = SCM_CAR(SCM_OPTARGS);
3207 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3208 }
3209 fill = (fill_scm);
3210 {
3211 ScmUInt64 filler;
3212 filler = Scm_GetIntegerU64Clamp(fill, SCM_CLAMP_ERROR, NULL);
3213 SCM_RETURN(Scm_MakeU64Vector(length, filler));
3214 }
3215 }
3216
3217 static SCM_DEFINE_STRING_CONST(uvlib_make_u64vector__NAME, "make-u64vector", 14, 14);
3218 static SCM_DEFINE_SUBR(uvlib_make_u64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u64vector__NAME), uvlib_make_u64vector, NULL, NULL);
3219
3220 static ScmObj uvlib_u64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3221 {
3222 ScmObj args_scm;
3223 ScmObj args;
3224 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3225 SCM_ENTER_SUBR("u64vector");
3226 args_scm = SCM_OPTARGS;
3227 args = (args_scm);
3228 {
3229 SCM_RETURN(Scm_ListToU64Vector(args, SCM_CLAMP_ERROR));
3230 }
3231 }
3232
3233 static SCM_DEFINE_STRING_CONST(uvlib_u64vector__NAME, "u64vector", 9, 9);
3234 static SCM_DEFINE_SUBR(uvlib_u64vector__STUB, 0, 1, SCM_OBJ(&uvlib_u64vector__NAME), uvlib_u64vector, NULL, NULL);
3235
3236 static ScmObj uvlib_u64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3237 {
3238 ScmObj v_scm;
3239 ScmU64Vector* v;
3240 SCM_ENTER_SUBR("u64vector-length");
3241 v_scm = SCM_ARGREF(0);
3242 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3243 v = SCM_U64VECTOR(v_scm);
3244 {
3245 SCM_RETURN(SCM_MAKE_INT(SCM_U64VECTOR_SIZE(v)));
3246 }
3247 }
3248
3249 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_length__NAME, "u64vector-length", 16, 16);
3250 static SCM_DEFINE_SUBR(uvlib_u64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_length__NAME), uvlib_u64vector_length, NULL, NULL);
3251
3252 static ScmObj uvlib_u64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3253 {
3254 ScmObj v_scm;
3255 ScmU64Vector* v;
3256 ScmObj i_scm;
3257 int i;
3258 ScmObj fallback_scm;
3259 ScmObj fallback;
3260 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3261 SCM_ENTER_SUBR("u64vector-ref");
3262 if (Scm_Length(SCM_OPTARGS) > 1)
3263 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3264 v_scm = SCM_ARGREF(0);
3265 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3266 v = SCM_U64VECTOR(v_scm);
3267 i_scm = SCM_ARGREF(1);
3268 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3269 i = SCM_INT_VALUE(i_scm);
3270 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
3271 else {
3272 fallback_scm = SCM_CAR(SCM_OPTARGS);
3273 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3274 }
3275 fallback = (fallback_scm);
3276 {
3277 SCM_RETURN(Scm_U64VectorRef(v, i, fallback));
3278 }
3279 }
3280
3281 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_ref__NAME, "u64vector-ref", 13, 13);
3282 static SCM_DEFINE_SUBR(uvlib_u64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_ref__NAME), uvlib_u64vector_ref, NULL, NULL);
3283
3284 static ScmObj uvlib_u64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3285 {
3286 ScmObj v_scm;
3287 ScmU64Vector* v;
3288 ScmObj i_scm;
3289 int i;
3290 ScmObj val_scm;
3291 ScmObj val;
3292 ScmObj clamp_scm;
3293 ScmObj clamp;
3294 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3295 SCM_ENTER_SUBR("u64vector-set!");
3296 if (Scm_Length(SCM_OPTARGS) > 1)
3297 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3298 v_scm = SCM_ARGREF(0);
3299 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3300 v = SCM_U64VECTOR(v_scm);
3301 i_scm = SCM_ARGREF(1);
3302 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3303 i = SCM_INT_VALUE(i_scm);
3304 val_scm = SCM_ARGREF(2);
3305 val = (val_scm);
3306 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3307 else {
3308 clamp_scm = SCM_CAR(SCM_OPTARGS);
3309 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3310 }
3311 clamp = (clamp_scm);
3312 {
3313 SCM_RETURN(Scm_U64VectorSet(v, i, val, clamp_arg(clamp)));
3314 }
3315 }
3316
3317 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_setX__NAME, "u64vector-set!", 14, 14);
3318 static SCM_DEFINE_SUBR(uvlib_u64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u64vector_setX__NAME), uvlib_u64vector_setX, NULL, NULL);
3319
3320 static ScmObj uvlib_u64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3321 {
3322 ScmObj v_scm;
3323 ScmU64Vector* v;
3324 ScmObj start_scm;
3325 int start;
3326 ScmObj end_scm;
3327 int end;
3328 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3329 SCM_ENTER_SUBR("u64vector-copy");
3330 if (Scm_Length(SCM_OPTARGS) > 2)
3331 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3332 v_scm = SCM_ARGREF(0);
3333 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3334 v = SCM_U64VECTOR(v_scm);
3335 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3336 else {
3337 start_scm = SCM_CAR(SCM_OPTARGS);
3338 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3339 }
3340 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3341 start = SCM_INT_VALUE(start_scm);
3342 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3343 else {
3344 end_scm = SCM_CAR(SCM_OPTARGS);
3345 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3346 }
3347 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3348 end = SCM_INT_VALUE(end_scm);
3349 {
3350 {
3351 ScmObj SCM_RESULT;
3352 SCM_RESULT = Scm_U64VectorCopy(v, start, end);
3353 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3354 }
3355 }
3356 }
3357
3358 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_copy__NAME, "u64vector-copy", 14, 14);
3359 static SCM_DEFINE_SUBR(uvlib_u64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_copy__NAME), uvlib_u64vector_copy, NULL, NULL);
3360
3361 static ScmObj uvlib_u64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3362 {
3363 ScmObj dst_scm;
3364 ScmU64Vector* dst;
3365 ScmObj dstart_scm;
3366 ScmObj dstart;
3367 ScmObj src_scm;
3368 ScmObj src;
3369 ScmObj sstart_scm;
3370 int sstart;
3371 ScmObj send_scm;
3372 int send;
3373 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3374 SCM_ENTER_SUBR("u64vector-copy!");
3375 if (Scm_Length(SCM_OPTARGS) > 3)
3376 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3377 dst_scm = SCM_ARGREF(0);
3378 if (!SCM_U64VECTORP(dst_scm)) Scm_Error("<u64vector> required, but got %S", dst_scm);
3379 dst = SCM_U64VECTOR(dst_scm);
3380 dstart_scm = SCM_ARGREF(1);
3381 dstart = (dstart_scm);
3382 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
3383 else {
3384 src_scm = SCM_CAR(SCM_OPTARGS);
3385 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3386 }
3387 src = (src_scm);
3388 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
3389 else {
3390 sstart_scm = SCM_CAR(SCM_OPTARGS);
3391 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3392 }
3393 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
3394 sstart = Scm_GetInteger(sstart_scm);
3395 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
3396 else {
3397 send_scm = SCM_CAR(SCM_OPTARGS);
3398 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3399 }
3400 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
3401 send = Scm_GetInteger(send_scm);
3402 {
3403 if (SCM_INTEGERP(dstart)) {
3404 /* new API */
3405 if (!SCM_U64VECTORP(src)) {
3406 Scm_Error("u64vector-copy!: argument is not a matching uvector: %S",
3407 src);
3408 }
3409 SCM_RETURN(Scm_U64VectorCopyX(dst, Scm_GetInteger(dstart),
3410 SCM_U64VECTOR(src), sstart, send));
3411 } else if (SCM_U64VECTORP(dstart)) {
3412 /* old API */
3413 SCM_RETURN(Scm_U64VectorCopyX(dst, 0, SCM_U64VECTOR(dstart), 0, -1));
3414 } else {
3415 Scm_Error("integer required, but got %S", dstart);
3416 SCM_RETURN(SCM_UNDEFINED);
3417 }
3418 }
3419 }
3420
3421 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_copyX__NAME, "u64vector-copy!", 15, 15);
3422 static SCM_DEFINE_SUBR(uvlib_u64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_copyX__NAME), uvlib_u64vector_copyX, NULL, NULL);
3423
3424 static ScmObj uvlib_u64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3425 {
3426 ScmObj v_scm;
3427 ScmU64Vector* v;
3428 ScmObj start_scm;
3429 int start;
3430 ScmObj end_scm;
3431 int end;
3432 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3433 SCM_ENTER_SUBR("u64vector->list");
3434 if (Scm_Length(SCM_OPTARGS) > 2)
3435 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3436 v_scm = SCM_ARGREF(0);
3437 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3438 v = SCM_U64VECTOR(v_scm);
3439 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3440 else {
3441 start_scm = SCM_CAR(SCM_OPTARGS);
3442 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3443 }
3444 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3445 start = SCM_INT_VALUE(start_scm);
3446 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3447 else {
3448 end_scm = SCM_CAR(SCM_OPTARGS);
3449 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3450 }
3451 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3452 end = SCM_INT_VALUE(end_scm);
3453 {
3454 {
3455 ScmObj SCM_RESULT;
3456 SCM_RESULT = Scm_U64VectorToList(v, start, end);
3457 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3458 }
3459 }
3460 }
3461
3462 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_TOlist__NAME, "u64vector->list", 15, 15);
3463 static SCM_DEFINE_SUBR(uvlib_u64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_TOlist__NAME), uvlib_u64vector_TOlist, NULL, NULL);
3464
3465 static ScmObj uvlib_list_TOu64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3466 {
3467 ScmObj l_scm;
3468 ScmObj l;
3469 ScmObj clamp_scm;
3470 ScmObj clamp;
3471 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3472 SCM_ENTER_SUBR("list->u64vector");
3473 if (Scm_Length(SCM_OPTARGS) > 1)
3474 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3475 l_scm = SCM_ARGREF(0);
3476 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3477 l = (l_scm);
3478 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3479 else {
3480 clamp_scm = SCM_CAR(SCM_OPTARGS);
3481 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3482 }
3483 clamp = (clamp_scm);
3484 {
3485 SCM_RETURN(Scm_ListToU64Vector(l, clamp_arg(clamp)));
3486 }
3487 }
3488
3489 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu64vector__NAME, "list->u64vector", 15, 15);
3490 static SCM_DEFINE_SUBR(uvlib_list_TOu64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu64vector__NAME), uvlib_list_TOu64vector, NULL, NULL);
3491
3492 static ScmObj uvlib_u64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3493 {
3494 ScmObj v_scm;
3495 ScmU64Vector* v;
3496 ScmObj val_scm;
3497 ScmObj val;
3498 ScmObj start_scm;
3499 int start;
3500 ScmObj end_scm;
3501 int end;
3502 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3503 SCM_ENTER_SUBR("u64vector-fill!");
3504 if (Scm_Length(SCM_OPTARGS) > 2)
3505 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3506 v_scm = SCM_ARGREF(0);
3507 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3508 v = SCM_U64VECTOR(v_scm);
3509 val_scm = SCM_ARGREF(1);
3510 val = (val_scm);
3511 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3512 else {
3513 start_scm = SCM_CAR(SCM_OPTARGS);
3514 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3515 }
3516 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3517 start = SCM_INT_VALUE(start_scm);
3518 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3519 else {
3520 end_scm = SCM_CAR(SCM_OPTARGS);
3521 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3522 }
3523 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3524 end = SCM_INT_VALUE(end_scm);
3525 {
3526 ScmUInt64 filler;
3527 filler = Scm_GetIntegerU64Clamp(val, SCM_CLAMP_ERROR, NULL);
3528 SCM_RETURN(Scm_U64VectorFill(v, filler, start, end));
3529 }
3530 }
3531
3532 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_fillX__NAME, "u64vector-fill!", 15, 15);
3533 static SCM_DEFINE_SUBR(uvlib_u64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_fillX__NAME), uvlib_u64vector_fillX, NULL, NULL);
3534
3535 static ScmObj uvlib_u64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3536 {
3537 ScmObj v_scm;
3538 ScmU64Vector* v;
3539 ScmObj start_scm;
3540 int start;
3541 ScmObj end_scm;
3542 int end;
3543 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3544 SCM_ENTER_SUBR("u64vector->vector");
3545 if (Scm_Length(SCM_OPTARGS) > 2)
3546 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3547 v_scm = SCM_ARGREF(0);
3548 if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3549 v = SCM_U64VECTOR(v_scm);
3550 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3551 else {
3552 start_scm = SCM_CAR(SCM_OPTARGS);
3553 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3554 }
3555 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3556 start = SCM_INT_VALUE(start_scm);
3557 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3558 else {
3559 end_scm = SCM_CAR(SCM_OPTARGS);
3560 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3561 }
3562 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3563 end = SCM_INT_VALUE(end_scm);
3564 {
3565 {
3566 ScmObj SCM_RESULT;
3567 SCM_RESULT = Scm_U64VectorToVector(v, start, end);
3568 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3569 }
3570 }
3571 }
3572
3573 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_TOvector__NAME, "u64vector->vector", 17, 17);
3574 static SCM_DEFINE_SUBR(uvlib_u64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_TOvector__NAME), uvlib_u64vector_TOvector, NULL, NULL);
3575
3576 static ScmObj uvlib_vector_TOu64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3577 {
3578 ScmObj v_scm;
3579 ScmVector* v;
3580 ScmObj start_scm;
3581 int start;
3582 ScmObj end_scm;
3583 int end;
3584 ScmObj clamp_scm;
3585 ScmObj clamp;
3586 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3587 SCM_ENTER_SUBR("vector->u64vector");
3588 if (Scm_Length(SCM_OPTARGS) > 3)
3589 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3590 v_scm = SCM_ARGREF(0);
3591 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
3592 v = SCM_VECTOR(v_scm);
3593 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3594 else {
3595 start_scm = SCM_CAR(SCM_OPTARGS);
3596 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3597 }
3598 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3599 start = SCM_INT_VALUE(start_scm);
3600 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3601 else {
3602 end_scm = SCM_CAR(SCM_OPTARGS);
3603 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3604 }
3605 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3606 end = SCM_INT_VALUE(end_scm);
3607 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3608 else {
3609 clamp_scm = SCM_CAR(SCM_OPTARGS);
3610 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3611 }
3612 clamp = (clamp_scm);
3613 {
3614 SCM_RETURN(Scm_VectorToU64Vector(v, start, end, clamp_arg(clamp)));
3615 }
3616 }
3617
3618 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu64vector__NAME, "vector->u64vector", 17, 17);
3619 static SCM_DEFINE_SUBR(uvlib_vector_TOu64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu64vector__NAME), uvlib_vector_TOu64vector, NULL, NULL);
3620
3621 static ScmObj uvlib_f32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3622 {
3623 ScmObj obj_scm;
3624 ScmObj obj;
3625 SCM_ENTER_SUBR("f32vector?");
3626 obj_scm = SCM_ARGREF(0);
3627 obj = (obj_scm);
3628 {
3629 {
3630 int SCM_RESULT;
3631 SCM_RESULT = SCM_F32VECTORP(obj);
3632 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3633 }
3634 }
3635 }
3636
3637 static SCM_DEFINE_STRING_CONST(uvlib_f32vectorP__NAME, "f32vector?", 10, 10);
3638 static SCM_DEFINE_SUBR(uvlib_f32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_f32vectorP__NAME), uvlib_f32vectorP, NULL, NULL);
3639
3640 static ScmObj uvlib_make_f32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3641 {
3642 ScmObj length_scm;
3643 int length;
3644 ScmObj fill_scm;
3645 ScmObj fill;
3646 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3647 SCM_ENTER_SUBR("make-f32vector");
3648 if (Scm_Length(SCM_OPTARGS) > 1)
3649 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3650 length_scm = SCM_ARGREF(0);
3651 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
3652 length = SCM_INT_VALUE(length_scm);
3653 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
3654 else {
3655 fill_scm = SCM_CAR(SCM_OPTARGS);
3656 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3657 }
3658 fill = (fill_scm);
3659 {
3660 float filler;
3661 filler = (float)Scm_GetDouble(fill);
3662 SCM_RETURN(Scm_MakeF32Vector(length, filler));
3663 }
3664 }
3665
3666 static SCM_DEFINE_STRING_CONST(uvlib_make_f32vector__NAME, "make-f32vector", 14, 14);
3667 static SCM_DEFINE_SUBR(uvlib_make_f32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_f32vector__NAME), uvlib_make_f32vector, NULL, NULL);
3668
3669 static ScmObj uvlib_f32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3670 {
3671 ScmObj args_scm;
3672 ScmObj args;
3673 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3674 SCM_ENTER_SUBR("f32vector");
3675 args_scm = SCM_OPTARGS;
3676 args = (args_scm);
3677 {
3678 SCM_RETURN(Scm_ListToF32Vector(args, SCM_CLAMP_ERROR));
3679 }
3680 }
3681
3682 static SCM_DEFINE_STRING_CONST(uvlib_f32vector__NAME, "f32vector", 9, 9);
3683 static SCM_DEFINE_SUBR(uvlib_f32vector__STUB, 0, 1, SCM_OBJ(&uvlib_f32vector__NAME), uvlib_f32vector, NULL, NULL);
3684
3685 static ScmObj uvlib_f32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3686 {
3687 ScmObj v_scm;
3688 ScmF32Vector* v;
3689 SCM_ENTER_SUBR("f32vector-length");
3690 v_scm = SCM_ARGREF(0);
3691 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3692 v = SCM_F32VECTOR(v_scm);
3693 {
3694 SCM_RETURN(SCM_MAKE_INT(SCM_F32VECTOR_SIZE(v)));
3695 }
3696 }
3697
3698 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_length__NAME, "f32vector-length", 16, 16);
3699 static SCM_DEFINE_SUBR(uvlib_f32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_length__NAME), uvlib_f32vector_length, NULL, NULL);
3700
3701 static ScmObj uvlib_f32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3702 {
3703 ScmObj v_scm;
3704 ScmF32Vector* v;
3705 ScmObj i_scm;
3706 int i;
3707 ScmObj fallback_scm;
3708 ScmObj fallback;
3709 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3710 SCM_ENTER_SUBR("f32vector-ref");
3711 if (Scm_Length(SCM_OPTARGS) > 1)
3712 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3713 v_scm = SCM_ARGREF(0);
3714 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3715 v = SCM_F32VECTOR(v_scm);
3716 i_scm = SCM_ARGREF(1);
3717 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3718 i = SCM_INT_VALUE(i_scm);
3719 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
3720 else {
3721 fallback_scm = SCM_CAR(SCM_OPTARGS);
3722 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3723 }
3724 fallback = (fallback_scm);
3725 {
3726 SCM_RETURN(Scm_F32VectorRef(v, i, fallback));
3727 }
3728 }
3729
3730 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_ref__NAME, "f32vector-ref", 13, 13);
3731 static SCM_DEFINE_SUBR(uvlib_f32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_ref__NAME), uvlib_f32vector_ref, NULL, NULL);
3732
3733 static ScmObj uvlib_f32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3734 {
3735 ScmObj v_scm;
3736 ScmF32Vector* v;
3737 ScmObj i_scm;
3738 int i;
3739 ScmObj val_scm;
3740 ScmObj val;
3741 ScmObj clamp_scm;
3742 ScmObj clamp;
3743 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3744 SCM_ENTER_SUBR("f32vector-set!");
3745 if (Scm_Length(SCM_OPTARGS) > 1)
3746 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3747 v_scm = SCM_ARGREF(0);
3748 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3749 v = SCM_F32VECTOR(v_scm);
3750 i_scm = SCM_ARGREF(1);
3751 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3752 i = SCM_INT_VALUE(i_scm);
3753 val_scm = SCM_ARGREF(2);
3754 val = (val_scm);
3755 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3756 else {
3757 clamp_scm = SCM_CAR(SCM_OPTARGS);
3758 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3759 }
3760 clamp = (clamp_scm);
3761 {
3762 SCM_RETURN(Scm_F32VectorSet(v, i, val, clamp_arg(clamp)));
3763 }
3764 }
3765
3766 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_setX__NAME, "f32vector-set!", 14, 14);
3767 static SCM_DEFINE_SUBR(uvlib_f32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_f32vector_setX__NAME), uvlib_f32vector_setX, NULL, NULL);
3768
3769 static ScmObj uvlib_f32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3770 {
3771 ScmObj v_scm;
3772 ScmF32Vector* v;
3773 ScmObj start_scm;
3774 int start;
3775 ScmObj end_scm;
3776 int end;
3777 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3778 SCM_ENTER_SUBR("f32vector-copy");
3779 if (Scm_Length(SCM_OPTARGS) > 2)
3780 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3781 v_scm = SCM_ARGREF(0);
3782 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3783 v = SCM_F32VECTOR(v_scm);
3784 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3785 else {
3786 start_scm = SCM_CAR(SCM_OPTARGS);
3787 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3788 }
3789 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3790 start = SCM_INT_VALUE(start_scm);
3791 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3792 else {
3793 end_scm = SCM_CAR(SCM_OPTARGS);
3794 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3795 }
3796 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3797 end = SCM_INT_VALUE(end_scm);
3798 {
3799 {
3800 ScmObj SCM_RESULT;
3801 SCM_RESULT = Scm_F32VectorCopy(v, start, end);
3802 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3803 }
3804 }
3805 }
3806
3807 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_copy__NAME, "f32vector-copy", 14, 14);
3808 static SCM_DEFINE_SUBR(uvlib_f32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_copy__NAME), uvlib_f32vector_copy, NULL, NULL);
3809
3810 static ScmObj uvlib_f32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3811 {
3812 ScmObj dst_scm;
3813 ScmF32Vector* dst;
3814 ScmObj dstart_scm;
3815 ScmObj dstart;
3816 ScmObj src_scm;
3817 ScmObj src;
3818 ScmObj sstart_scm;
3819 int sstart;
3820 ScmObj send_scm;
3821 int send;
3822 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3823 SCM_ENTER_SUBR("f32vector-copy!");
3824 if (Scm_Length(SCM_OPTARGS) > 3)
3825 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3826 dst_scm = SCM_ARGREF(0);
3827 if (!SCM_F32VECTORP(dst_scm)) Scm_Error("<f32vector> required, but got %S", dst_scm);
3828 dst = SCM_F32VECTOR(dst_scm);
3829 dstart_scm = SCM_ARGREF(1);
3830 dstart = (dstart_scm);
3831 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
3832 else {
3833 src_scm = SCM_CAR(SCM_OPTARGS);
3834 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3835 }
3836 src = (src_scm);
3837 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
3838 else {
3839 sstart_scm = SCM_CAR(SCM_OPTARGS);
3840 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3841 }
3842 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
3843 sstart = Scm_GetInteger(sstart_scm);
3844 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
3845 else {
3846 send_scm = SCM_CAR(SCM_OPTARGS);
3847 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3848 }
3849 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
3850 send = Scm_GetInteger(send_scm);
3851 {
3852 if (SCM_INTEGERP(dstart)) {
3853 /* new API */
3854 if (!SCM_F32VECTORP(src)) {
3855 Scm_Error("f32vector-copy!: argument is not a matching uvector: %S",
3856 src);
3857 }
3858 SCM_RETURN(Scm_F32VectorCopyX(dst, Scm_GetInteger(dstart),
3859 SCM_F32VECTOR(src), sstart, send));
3860 } else if (SCM_F32VECTORP(dstart)) {
3861 /* old API */
3862 SCM_RETURN(Scm_F32VectorCopyX(dst, 0, SCM_F32VECTOR(dstart), 0, -1));
3863 } else {
3864 Scm_Error("integer required, but got %S", dstart);
3865 SCM_RETURN(SCM_UNDEFINED);
3866 }
3867 }
3868 }
3869
3870 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_copyX__NAME, "f32vector-copy!", 15, 15);
3871 static SCM_DEFINE_SUBR(uvlib_f32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_copyX__NAME), uvlib_f32vector_copyX, NULL, NULL);
3872
3873 static ScmObj uvlib_f32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3874 {
3875 ScmObj v_scm;
3876 ScmF32Vector* v;
3877 ScmObj start_scm;
3878 int start;
3879 ScmObj end_scm;
3880 int end;
3881 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3882 SCM_ENTER_SUBR("f32vector->list");
3883 if (Scm_Length(SCM_OPTARGS) > 2)
3884 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3885 v_scm = SCM_ARGREF(0);
3886 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3887 v = SCM_F32VECTOR(v_scm);
3888 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3889 else {
3890 start_scm = SCM_CAR(SCM_OPTARGS);
3891 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3892 }
3893 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3894 start = SCM_INT_VALUE(start_scm);
3895 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3896 else {
3897 end_scm = SCM_CAR(SCM_OPTARGS);
3898 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3899 }
3900 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3901 end = SCM_INT_VALUE(end_scm);
3902 {
3903 {
3904 ScmObj SCM_RESULT;
3905 SCM_RESULT = Scm_F32VectorToList(v, start, end);
3906 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3907 }
3908 }
3909 }
3910
3911 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_TOlist__NAME, "f32vector->list", 15, 15);
3912 static SCM_DEFINE_SUBR(uvlib_f32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_TOlist__NAME), uvlib_f32vector_TOlist, NULL, NULL);
3913
3914 static ScmObj uvlib_list_TOf32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3915 {
3916 ScmObj l_scm;
3917 ScmObj l;
3918 ScmObj clamp_scm;
3919 ScmObj clamp;
3920 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3921 SCM_ENTER_SUBR("list->f32vector");
3922 if (Scm_Length(SCM_OPTARGS) > 1)
3923 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3924 l_scm = SCM_ARGREF(0);
3925 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3926 l = (l_scm);
3927 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3928 else {
3929 clamp_scm = SCM_CAR(SCM_OPTARGS);
3930 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3931 }
3932 clamp = (clamp_scm);
3933 {
3934 SCM_RETURN(Scm_ListToF32Vector(l, clamp_arg(clamp)));
3935 }
3936 }
3937
3938 static SCM_DEFINE_STRING_CONST(uvlib_list_TOf32vector__NAME, "list->f32vector", 15, 15);
3939 static SCM_DEFINE_SUBR(uvlib_list_TOf32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOf32vector__NAME), uvlib_list_TOf32vector, NULL, NULL);
3940
3941 static ScmObj uvlib_f32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3942 {
3943 ScmObj v_scm;
3944 ScmF32Vector* v;
3945 ScmObj val_scm;
3946 ScmObj val;
3947 ScmObj start_scm;
3948 int start;
3949 ScmObj end_scm;
3950 int end;
3951 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3952 SCM_ENTER_SUBR("f32vector-fill!");
3953 if (Scm_Length(SCM_OPTARGS) > 2)
3954 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3955 v_scm = SCM_ARGREF(0);
3956 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3957 v = SCM_F32VECTOR(v_scm);
3958 val_scm = SCM_ARGREF(1);
3959 val = (val_scm);
3960 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3961 else {
3962 start_scm = SCM_CAR(SCM_OPTARGS);
3963 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3964 }
3965 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3966 start = SCM_INT_VALUE(start_scm);
3967 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3968 else {
3969 end_scm = SCM_CAR(SCM_OPTARGS);
3970 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3971 }
3972 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3973 end = SCM_INT_VALUE(end_scm);
3974 {
3975 float filler;
3976 filler = (float)Scm_GetDouble(val);
3977 SCM_RETURN(Scm_F32VectorFill(v, filler, start, end));
3978 }
3979 }
3980
3981 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_fillX__NAME, "f32vector-fill!", 15, 15);
3982 static SCM_DEFINE_SUBR(uvlib_f32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_fillX__NAME), uvlib_f32vector_fillX, NULL, NULL);
3983
3984 static ScmObj uvlib_f32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3985 {
3986 ScmObj v_scm;
3987 ScmF32Vector* v;
3988 ScmObj start_scm;
3989 int start;
3990 ScmObj end_scm;
3991 int end;
3992 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3993 SCM_ENTER_SUBR("f32vector->vector");
3994 if (Scm_Length(SCM_OPTARGS) > 2)
3995 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3996 v_scm = SCM_ARGREF(0);
3997 if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3998 v = SCM_F32VECTOR(v_scm);
3999 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4000 else {
4001 start_scm = SCM_CAR(SCM_OPTARGS);
4002 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4003 }
4004 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4005 start = SCM_INT_VALUE(start_scm);
4006 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4007 else {
4008 end_scm = SCM_CAR(SCM_OPTARGS);
4009 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4010 }
4011 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4012 end = SCM_INT_VALUE(end_scm);
4013 {
4014 {
4015 ScmObj SCM_RESULT;
4016 SCM_RESULT = Scm_F32VectorToVector(v, start, end);
4017 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4018 }
4019 }
4020 }
4021
4022 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_TOvector__NAME, "f32vector->vector", 17, 17);
4023 static SCM_DEFINE_SUBR(uvlib_f32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_TOvector__NAME), uvlib_f32vector_TOvector, NULL, NULL);
4024
4025 static ScmObj uvlib_vector_TOf32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4026 {
4027 ScmObj v_scm;
4028 ScmVector* v;
4029 ScmObj start_scm;
4030 int start;
4031 ScmObj end_scm;
4032 int end;
4033 ScmObj clamp_scm;
4034 ScmObj clamp;
4035 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4036 SCM_ENTER_SUBR("vector->f32vector");
4037 if (Scm_Length(SCM_OPTARGS) > 3)
4038 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4039 v_scm = SCM_ARGREF(0);
4040 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
4041 v = SCM_VECTOR(v_scm);
4042 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4043 else {
4044 start_scm = SCM_CAR(SCM_OPTARGS);
4045 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4046 }
4047 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4048 start = SCM_INT_VALUE(start_scm);
4049 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4050 else {
4051 end_scm = SCM_CAR(SCM_OPTARGS);
4052 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4053 }
4054 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4055 end = SCM_INT_VALUE(end_scm);
4056 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4057 else {
4058 clamp_scm = SCM_CAR(SCM_OPTARGS);
4059 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4060 }
4061 clamp = (clamp_scm);
4062 {
4063 SCM_RETURN(Scm_VectorToF32Vector(v, start, end, clamp_arg(clamp)));
4064 }
4065 }
4066
4067 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOf32vector__NAME, "vector->f32vector", 17, 17);
4068 static SCM_DEFINE_SUBR(uvlib_vector_TOf32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOf32vector__NAME), uvlib_vector_TOf32vector, NULL, NULL);
4069
4070 static ScmObj uvlib_f64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4071 {
4072 ScmObj obj_scm;
4073 ScmObj obj;
4074 SCM_ENTER_SUBR("f64vector?");
4075 obj_scm = SCM_ARGREF(0);
4076 obj = (obj_scm);
4077 {
4078 {
4079 int SCM_RESULT;
4080 SCM_RESULT = SCM_F64VECTORP(obj);
4081 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
4082 }
4083 }
4084 }
4085
4086 static SCM_DEFINE_STRING_CONST(uvlib_f64vectorP__NAME, "f64vector?", 10, 10);
4087 static SCM_DEFINE_SUBR(uvlib_f64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_f64vectorP__NAME), uvlib_f64vectorP, NULL, NULL);
4088
4089 static ScmObj uvlib_make_f64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4090 {
4091 ScmObj length_scm;
4092 int length;
4093 ScmObj fill_scm;
4094 ScmObj fill;
4095 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4096 SCM_ENTER_SUBR("make-f64vector");
4097 if (Scm_Length(SCM_OPTARGS) > 1)
4098 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4099 length_scm = SCM_ARGREF(0);
4100 if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
4101 length = SCM_INT_VALUE(length_scm);
4102 if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
4103 else {
4104 fill_scm = SCM_CAR(SCM_OPTARGS);
4105 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4106 }
4107 fill = (fill_scm);
4108 {
4109 double filler;
4110 filler = Scm_GetDouble(fill);
4111 SCM_RETURN(Scm_MakeF64Vector(length, filler));
4112 }
4113 }
4114
4115 static SCM_DEFINE_STRING_CONST(uvlib_make_f64vector__NAME, "make-f64vector", 14, 14);
4116 static SCM_DEFINE_SUBR(uvlib_make_f64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_f64vector__NAME), uvlib_make_f64vector, NULL, NULL);
4117
4118 static ScmObj uvlib_f64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4119 {
4120 ScmObj args_scm;
4121 ScmObj args;
4122 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4123 SCM_ENTER_SUBR("f64vector");
4124 args_scm = SCM_OPTARGS;
4125 args = (args_scm);
4126 {
4127 SCM_RETURN(Scm_ListToF64Vector(args, SCM_CLAMP_ERROR));
4128 }
4129 }
4130
4131 static SCM_DEFINE_STRING_CONST(uvlib_f64vector__NAME, "f64vector", 9, 9);
4132 static SCM_DEFINE_SUBR(uvlib_f64vector__STUB, 0, 1, SCM_OBJ(&uvlib_f64vector__NAME), uvlib_f64vector, NULL, NULL);
4133
4134 static ScmObj uvlib_f64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4135 {
4136 ScmObj v_scm;
4137 ScmF64Vector* v;
4138 SCM_ENTER_SUBR("f64vector-length");
4139 v_scm = SCM_ARGREF(0);
4140 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4141 v = SCM_F64VECTOR(v_scm);
4142 {
4143 SCM_RETURN(SCM_MAKE_INT(SCM_F64VECTOR_SIZE(v)));
4144 }
4145 }
4146
4147 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_length__NAME, "f64vector-length", 16, 16);
4148 static SCM_DEFINE_SUBR(uvlib_f64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_length__NAME), uvlib_f64vector_length, NULL, NULL);
4149
4150 static ScmObj uvlib_f64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4151 {
4152 ScmObj v_scm;
4153 ScmF64Vector* v;
4154 ScmObj i_scm;
4155 int i;
4156 ScmObj fallback_scm;
4157 ScmObj fallback;
4158 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4159 SCM_ENTER_SUBR("f64vector-ref");
4160 if (Scm_Length(SCM_OPTARGS) > 1)
4161 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4162 v_scm = SCM_ARGREF(0);
4163 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4164 v = SCM_F64VECTOR(v_scm);
4165 i_scm = SCM_ARGREF(1);
4166 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
4167 i = SCM_INT_VALUE(i_scm);
4168 if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
4169 else {
4170 fallback_scm = SCM_CAR(SCM_OPTARGS);
4171 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4172 }
4173 fallback = (fallback_scm);
4174 {
4175 SCM_RETURN(Scm_F64VectorRef(v, i, fallback));
4176 }
4177 }
4178
4179 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_ref__NAME, "f64vector-ref", 13, 13);
4180 static SCM_DEFINE_SUBR(uvlib_f64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_ref__NAME), uvlib_f64vector_ref, NULL, NULL);
4181
4182 static ScmObj uvlib_f64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4183 {
4184 ScmObj v_scm;
4185 ScmF64Vector* v;
4186 ScmObj i_scm;
4187 int i;
4188 ScmObj val_scm;
4189 ScmObj val;
4190 ScmObj clamp_scm;
4191 ScmObj clamp;
4192 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4193 SCM_ENTER_SUBR("f64vector-set!");
4194 if (Scm_Length(SCM_OPTARGS) > 1)
4195 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4196 v_scm = SCM_ARGREF(0);
4197 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4198 v = SCM_F64VECTOR(v_scm);
4199 i_scm = SCM_ARGREF(1);
4200 if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
4201 i = SCM_INT_VALUE(i_scm);
4202 val_scm = SCM_ARGREF(2);
4203 val = (val_scm);
4204 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4205 else {
4206 clamp_scm = SCM_CAR(SCM_OPTARGS);
4207 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4208 }
4209 clamp = (clamp_scm);
4210 {
4211 SCM_RETURN(Scm_F64VectorSet(v, i, val, clamp_arg(clamp)));
4212 }
4213 }
4214
4215 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_setX__NAME, "f64vector-set!", 14, 14);
4216 static SCM_DEFINE_SUBR(uvlib_f64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_f64vector_setX__NAME), uvlib_f64vector_setX, NULL, NULL);
4217
4218 static ScmObj uvlib_f64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4219 {
4220 ScmObj v_scm;
4221 ScmF64Vector* v;
4222 ScmObj start_scm;
4223 int start;
4224 ScmObj end_scm;
4225 int end;
4226 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4227 SCM_ENTER_SUBR("f64vector-copy");
4228 if (Scm_Length(SCM_OPTARGS) > 2)
4229 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4230 v_scm = SCM_ARGREF(0);
4231 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4232 v = SCM_F64VECTOR(v_scm);
4233 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4234 else {
4235 start_scm = SCM_CAR(SCM_OPTARGS);
4236 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4237 }
4238 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4239 start = SCM_INT_VALUE(start_scm);
4240 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4241 else {
4242 end_scm = SCM_CAR(SCM_OPTARGS);
4243 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4244 }
4245 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4246 end = SCM_INT_VALUE(end_scm);
4247 {
4248 {
4249 ScmObj SCM_RESULT;
4250 SCM_RESULT = Scm_F64VectorCopy(v, start, end);
4251 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4252 }
4253 }
4254 }
4255
4256 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_copy__NAME, "f64vector-copy", 14, 14);
4257 static SCM_DEFINE_SUBR(uvlib_f64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_copy__NAME), uvlib_f64vector_copy, NULL, NULL);
4258
4259 static ScmObj uvlib_f64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4260 {
4261 ScmObj dst_scm;
4262 ScmF64Vector* dst;
4263 ScmObj dstart_scm;
4264 ScmObj dstart;
4265 ScmObj src_scm;
4266 ScmObj src;
4267 ScmObj sstart_scm;
4268 int sstart;
4269 ScmObj send_scm;
4270 int send;
4271 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4272 SCM_ENTER_SUBR("f64vector-copy!");
4273 if (Scm_Length(SCM_OPTARGS) > 3)
4274 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4275 dst_scm = SCM_ARGREF(0);
4276 if (!SCM_F64VECTORP(dst_scm)) Scm_Error("<f64vector> required, but got %S", dst_scm);
4277 dst = SCM_F64VECTOR(dst_scm);
4278 dstart_scm = SCM_ARGREF(1);
4279 dstart = (dstart_scm);
4280 if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
4281 else {
4282 src_scm = SCM_CAR(SCM_OPTARGS);
4283 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4284 }
4285 src = (src_scm);
4286 if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
4287 else {
4288 sstart_scm = SCM_CAR(SCM_OPTARGS);
4289 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4290 }
4291 if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
4292 sstart = Scm_GetInteger(sstart_scm);
4293 if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
4294 else {
4295 send_scm = SCM_CAR(SCM_OPTARGS);
4296 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4297 }
4298 if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
4299 send = Scm_GetInteger(send_scm);
4300 {
4301 if (SCM_INTEGERP(dstart)) {
4302 /* new API */
4303 if (!SCM_F64VECTORP(src)) {
4304 Scm_Error("f64vector-copy!: argument is not a matching uvector: %S",
4305 src);
4306 }
4307 SCM_RETURN(Scm_F64VectorCopyX(dst, Scm_GetInteger(dstart),
4308 SCM_F64VECTOR(src), sstart, send));
4309 } else if (SCM_F64VECTORP(dstart)) {
4310 /* old API */
4311 SCM_RETURN(Scm_F64VectorCopyX(dst, 0, SCM_F64VECTOR(dstart), 0, -1));
4312 } else {
4313 Scm_Error("integer required, but got %S", dstart);
4314 SCM_RETURN(SCM_UNDEFINED);
4315 }
4316 }
4317 }
4318
4319 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_copyX__NAME, "f64vector-copy!", 15, 15);
4320 static SCM_DEFINE_SUBR(uvlib_f64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_copyX__NAME), uvlib_f64vector_copyX, NULL, NULL);
4321
4322 static ScmObj uvlib_f64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4323 {
4324 ScmObj v_scm;
4325 ScmF64Vector* v;
4326 ScmObj start_scm;
4327 int start;
4328 ScmObj end_scm;
4329 int end;
4330 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4331 SCM_ENTER_SUBR("f64vector->list");
4332 if (Scm_Length(SCM_OPTARGS) > 2)
4333 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4334 v_scm = SCM_ARGREF(0);
4335 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4336 v = SCM_F64VECTOR(v_scm);
4337 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4338 else {
4339 start_scm = SCM_CAR(SCM_OPTARGS);
4340 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4341 }
4342 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4343 start = SCM_INT_VALUE(start_scm);
4344 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4345 else {
4346 end_scm = SCM_CAR(SCM_OPTARGS);
4347 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4348 }
4349 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4350 end = SCM_INT_VALUE(end_scm);
4351 {
4352 {
4353 ScmObj SCM_RESULT;
4354 SCM_RESULT = Scm_F64VectorToList(v, start, end);
4355 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4356 }
4357 }
4358 }
4359
4360 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_TOlist__NAME, "f64vector->list", 15, 15);
4361 static SCM_DEFINE_SUBR(uvlib_f64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_TOlist__NAME), uvlib_f64vector_TOlist, NULL, NULL);
4362
4363 static ScmObj uvlib_list_TOf64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4364 {
4365 ScmObj l_scm;
4366 ScmObj l;
4367 ScmObj clamp_scm;
4368 ScmObj clamp;
4369 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4370 SCM_ENTER_SUBR("list->f64vector");
4371 if (Scm_Length(SCM_OPTARGS) > 1)
4372 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4373 l_scm = SCM_ARGREF(0);
4374 if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
4375 l = (l_scm);
4376 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4377 else {
4378 clamp_scm = SCM_CAR(SCM_OPTARGS);
4379 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4380 }
4381 clamp = (clamp_scm);
4382 {
4383 SCM_RETURN(Scm_ListToF64Vector(l, clamp_arg(clamp)));
4384 }
4385 }
4386
4387 static SCM_DEFINE_STRING_CONST(uvlib_list_TOf64vector__NAME, "list->f64vector", 15, 15);
4388 static SCM_DEFINE_SUBR(uvlib_list_TOf64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOf64vector__NAME), uvlib_list_TOf64vector, NULL, NULL);
4389
4390 static ScmObj uvlib_f64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4391 {
4392 ScmObj v_scm;
4393 ScmF64Vector* v;
4394 ScmObj val_scm;
4395 ScmObj val;
4396 ScmObj start_scm;
4397 int start;
4398 ScmObj end_scm;
4399 int end;
4400 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4401 SCM_ENTER_SUBR("f64vector-fill!");
4402 if (Scm_Length(SCM_OPTARGS) > 2)
4403 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4404 v_scm = SCM_ARGREF(0);
4405 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4406 v = SCM_F64VECTOR(v_scm);
4407 val_scm = SCM_ARGREF(1);
4408 val = (val_scm);
4409 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4410 else {
4411 start_scm = SCM_CAR(SCM_OPTARGS);
4412 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4413 }
4414 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4415 start = SCM_INT_VALUE(start_scm);
4416 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4417 else {
4418 end_scm = SCM_CAR(SCM_OPTARGS);
4419 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4420 }
4421 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4422 end = SCM_INT_VALUE(end_scm);
4423 {
4424 double filler;
4425 filler = Scm_GetDouble(val);
4426 SCM_RETURN(Scm_F64VectorFill(v, filler, start, end));
4427 }
4428 }
4429
4430 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_fillX__NAME, "f64vector-fill!", 15, 15);
4431 static SCM_DEFINE_SUBR(uvlib_f64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_fillX__NAME), uvlib_f64vector_fillX, NULL, NULL);
4432
4433 static ScmObj uvlib_f64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4434 {
4435 ScmObj v_scm;
4436 ScmF64Vector* v;
4437 ScmObj start_scm;
4438 int start;
4439 ScmObj end_scm;
4440 int end;
4441 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4442 SCM_ENTER_SUBR("f64vector->vector");
4443 if (Scm_Length(SCM_OPTARGS) > 2)
4444 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4445 v_scm = SCM_ARGREF(0);
4446 if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4447 v = SCM_F64VECTOR(v_scm);
4448 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4449 else {
4450 start_scm = SCM_CAR(SCM_OPTARGS);
4451 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4452 }
4453 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4454 start = SCM_INT_VALUE(start_scm);
4455 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4456 else {
4457 end_scm = SCM_CAR(SCM_OPTARGS);
4458 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4459 }
4460 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4461 end = SCM_INT_VALUE(end_scm);
4462 {
4463 {
4464 ScmObj SCM_RESULT;
4465 SCM_RESULT = Scm_F64VectorToVector(v, start, end);
4466 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4467 }
4468 }
4469 }
4470
4471 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_TOvector__NAME, "f64vector->vector", 17, 17);
4472 static SCM_DEFINE_SUBR(uvlib_f64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_TOvector__NAME), uvlib_f64vector_TOvector, NULL, NULL);
4473
4474 static ScmObj uvlib_vector_TOf64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4475 {
4476 ScmObj v_scm;
4477 ScmVector* v;
4478 ScmObj start_scm;
4479 int start;
4480 ScmObj end_scm;
4481 int end;
4482 ScmObj clamp_scm;
4483 ScmObj clamp;
4484 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4485 SCM_ENTER_SUBR("vector->f64vector");
4486 if (Scm_Length(SCM_OPTARGS) > 3)
4487 Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4488 v_scm = SCM_ARGREF(0);
4489 if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
4490 v = SCM_VECTOR(v_scm);
4491 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4492 else {
4493 start_scm = SCM_CAR(SCM_OPTARGS);
4494 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4495 }
4496 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4497 start = SCM_INT_VALUE(start_scm);
4498 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4499 else {
4500 end_scm = SCM_CAR(SCM_OPTARGS);
4501 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4502 }
4503 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4504 end = SCM_INT_VALUE(end_scm);
4505 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4506 else {
4507 clamp_scm = SCM_CAR(SCM_OPTARGS);
4508 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4509 }
4510 clamp = (clamp_scm);
4511 {
4512 SCM_RETURN(Scm_VectorToF64Vector(v, start, end, clamp_arg(clamp)));
4513 }
4514 }
4515
4516 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOf64vector__NAME, "vector->f64vector", 17, 17);
4517 static SCM_DEFINE_SUBR(uvlib_vector_TOf64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOf64vector__NAME), uvlib_vector_TOf64vector, NULL, NULL);
4518
4519 static ScmObj uvlib_s8vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4520 {
4521 ScmObj v0_scm;
4522 ScmS8Vector* v0;
4523 ScmObj v1_scm;
4524 ScmObj v1;
4525 ScmObj clamp_scm;
4526 ScmObj clamp;
4527 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4528 SCM_ENTER_SUBR("s8vector-add");
4529 if (Scm_Length(SCM_OPTARGS) > 1)
4530 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4531 v0_scm = SCM_ARGREF(0);
4532 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
4533 v0 = SCM_S8VECTOR(v0_scm);
4534 v1_scm = SCM_ARGREF(1);
4535 v1 = (v1_scm);
4536 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4537 else {
4538 clamp_scm = SCM_CAR(SCM_OPTARGS);
4539 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4540 }
4541 clamp = (clamp_scm);
4542 {
4543 SCM_RETURN(Scm_S8VectorAdd(v0, v1, clamp_arg(clamp)));
4544 }
4545 }
4546
4547 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_add__NAME, "s8vector-add", 12, 12);
4548 static SCM_DEFINE_SUBR(uvlib_s8vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_add__NAME), uvlib_s8vector_add, NULL, NULL);
4549
4550 static ScmObj uvlib_s8vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4551 {
4552 ScmObj v0_scm;
4553 ScmS8Vector* v0;
4554 ScmObj v1_scm;
4555 ScmObj v1;
4556 ScmObj clamp_scm;
4557 ScmObj clamp;
4558 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4559 SCM_ENTER_SUBR("s8vector-add!");
4560 if (Scm_Length(SCM_OPTARGS) > 1)
4561 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4562 v0_scm = SCM_ARGREF(0);
4563 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
4564 v0 = SCM_S8VECTOR(v0_scm);
4565 v1_scm = SCM_ARGREF(1);
4566 v1 = (v1_scm);
4567 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4568 else {
4569 clamp_scm = SCM_CAR(SCM_OPTARGS);
4570 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4571 }
4572 clamp = (clamp_scm);
4573 {
4574 SCM_RETURN(Scm_S8VectorAddX(v0, v1, clamp_arg(clamp)));
4575 }
4576 }
4577
4578 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_addX__NAME, "s8vector-add!", 13, 13);
4579 static SCM_DEFINE_SUBR(uvlib_s8vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_addX__NAME), uvlib_s8vector_addX, NULL, NULL);
4580
4581 static ScmObj uvlib_u8vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4582 {
4583 ScmObj v0_scm;
4584 ScmU8Vector* v0;
4585 ScmObj v1_scm;
4586 ScmObj v1;
4587 ScmObj clamp_scm;
4588 ScmObj clamp;
4589 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4590 SCM_ENTER_SUBR("u8vector-add");
4591 if (Scm_Length(SCM_OPTARGS) > 1)
4592 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4593 v0_scm = SCM_ARGREF(0);
4594 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
4595 v0 = SCM_U8VECTOR(v0_scm);
4596 v1_scm = SCM_ARGREF(1);
4597 v1 = (v1_scm);
4598 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4599 else {
4600 clamp_scm = SCM_CAR(SCM_OPTARGS);
4601 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4602 }
4603 clamp = (clamp_scm);
4604 {
4605 SCM_RETURN(Scm_U8VectorAdd(v0, v1, clamp_arg(clamp)));
4606 }
4607 }
4608
4609 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_add__NAME, "u8vector-add", 12, 12);
4610 static SCM_DEFINE_SUBR(uvlib_u8vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_add__NAME), uvlib_u8vector_add, NULL, NULL);
4611
4612 static ScmObj uvlib_u8vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4613 {
4614 ScmObj v0_scm;
4615 ScmU8Vector* v0;
4616 ScmObj v1_scm;
4617 ScmObj v1;
4618 ScmObj clamp_scm;
4619 ScmObj clamp;
4620 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4621 SCM_ENTER_SUBR("u8vector-add!");
4622 if (Scm_Length(SCM_OPTARGS) > 1)
4623 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4624 v0_scm = SCM_ARGREF(0);
4625 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
4626 v0 = SCM_U8VECTOR(v0_scm);
4627 v1_scm = SCM_ARGREF(1);
4628 v1 = (v1_scm);
4629 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4630 else {
4631 clamp_scm = SCM_CAR(SCM_OPTARGS);
4632 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4633 }
4634 clamp = (clamp_scm);
4635 {
4636 SCM_RETURN(Scm_U8VectorAddX(v0, v1, clamp_arg(clamp)));
4637 }
4638 }
4639
4640 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_addX__NAME, "u8vector-add!", 13, 13);
4641 static SCM_DEFINE_SUBR(uvlib_u8vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_addX__NAME), uvlib_u8vector_addX, NULL, NULL);
4642
4643 static ScmObj uvlib_s16vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4644 {
4645 ScmObj v0_scm;
4646 ScmS16Vector* v0;
4647 ScmObj v1_scm;
4648 ScmObj v1;
4649 ScmObj clamp_scm;
4650 ScmObj clamp;
4651 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4652 SCM_ENTER_SUBR("s16vector-add");
4653 if (Scm_Length(SCM_OPTARGS) > 1)
4654 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4655 v0_scm = SCM_ARGREF(0);
4656 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
4657 v0 = SCM_S16VECTOR(v0_scm);
4658 v1_scm = SCM_ARGREF(1);
4659 v1 = (v1_scm);
4660 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4661 else {
4662 clamp_scm = SCM_CAR(SCM_OPTARGS);
4663 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4664 }
4665 clamp = (clamp_scm);
4666 {
4667 SCM_RETURN(Scm_S16VectorAdd(v0, v1, clamp_arg(clamp)));
4668 }
4669 }
4670
4671 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_add__NAME, "s16vector-add", 13, 13);
4672 static SCM_DEFINE_SUBR(uvlib_s16vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_add__NAME), uvlib_s16vector_add, NULL, NULL);
4673
4674 static ScmObj uvlib_s16vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4675 {
4676 ScmObj v0_scm;
4677 ScmS16Vector* v0;
4678 ScmObj v1_scm;
4679 ScmObj v1;
4680 ScmObj clamp_scm;
4681 ScmObj clamp;
4682 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4683 SCM_ENTER_SUBR("s16vector-add!");
4684 if (Scm_Length(SCM_OPTARGS) > 1)
4685 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4686 v0_scm = SCM_ARGREF(0);
4687 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
4688 v0 = SCM_S16VECTOR(v0_scm);
4689 v1_scm = SCM_ARGREF(1);
4690 v1 = (v1_scm);
4691 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4692 else {
4693 clamp_scm = SCM_CAR(SCM_OPTARGS);
4694 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4695 }
4696 clamp = (clamp_scm);
4697 {
4698 SCM_RETURN(Scm_S16VectorAddX(v0, v1, clamp_arg(clamp)));
4699 }
4700 }
4701
4702 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_addX__NAME, "s16vector-add!", 14, 14);
4703 static SCM_DEFINE_SUBR(uvlib_s16vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_addX__NAME), uvlib_s16vector_addX, NULL, NULL);
4704
4705 static ScmObj uvlib_u16vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4706 {
4707 ScmObj v0_scm;
4708 ScmU16Vector* v0;
4709 ScmObj v1_scm;
4710 ScmObj v1;
4711 ScmObj clamp_scm;
4712 ScmObj clamp;
4713 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4714 SCM_ENTER_SUBR("u16vector-add");
4715 if (Scm_Length(SCM_OPTARGS) > 1)
4716 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4717 v0_scm = SCM_ARGREF(0);
4718 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
4719 v0 = SCM_U16VECTOR(v0_scm);
4720 v1_scm = SCM_ARGREF(1);
4721 v1 = (v1_scm);
4722 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4723 else {
4724 clamp_scm = SCM_CAR(SCM_OPTARGS);
4725 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4726 }
4727 clamp = (clamp_scm);
4728 {
4729 SCM_RETURN(Scm_U16VectorAdd(v0, v1, clamp_arg(clamp)));
4730 }
4731 }
4732
4733 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_add__NAME, "u16vector-add", 13, 13);
4734 static SCM_DEFINE_SUBR(uvlib_u16vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_add__NAME), uvlib_u16vector_add, NULL, NULL);
4735
4736 static ScmObj uvlib_u16vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4737 {
4738 ScmObj v0_scm;
4739 ScmU16Vector* v0;
4740 ScmObj v1_scm;
4741 ScmObj v1;
4742 ScmObj clamp_scm;
4743 ScmObj clamp;
4744 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4745 SCM_ENTER_SUBR("u16vector-add!");
4746 if (Scm_Length(SCM_OPTARGS) > 1)
4747 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4748 v0_scm = SCM_ARGREF(0);
4749 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
4750 v0 = SCM_U16VECTOR(v0_scm);
4751 v1_scm = SCM_ARGREF(1);
4752 v1 = (v1_scm);
4753 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4754 else {
4755 clamp_scm = SCM_CAR(SCM_OPTARGS);
4756 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4757 }
4758 clamp = (clamp_scm);
4759 {
4760 SCM_RETURN(Scm_U16VectorAddX(v0, v1, clamp_arg(clamp)));
4761 }
4762 }
4763
4764 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_addX__NAME, "u16vector-add!", 14, 14);
4765 static SCM_DEFINE_SUBR(uvlib_u16vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_addX__NAME), uvlib_u16vector_addX, NULL, NULL);
4766
4767 static ScmObj uvlib_s32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4768 {
4769 ScmObj v0_scm;
4770 ScmS32Vector* v0;
4771 ScmObj v1_scm;
4772 ScmObj v1;
4773 ScmObj clamp_scm;
4774 ScmObj clamp;
4775 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4776 SCM_ENTER_SUBR("s32vector-add");
4777 if (Scm_Length(SCM_OPTARGS) > 1)
4778 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4779 v0_scm = SCM_ARGREF(0);
4780 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
4781 v0 = SCM_S32VECTOR(v0_scm);
4782 v1_scm = SCM_ARGREF(1);
4783 v1 = (v1_scm);
4784 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4785 else {
4786 clamp_scm = SCM_CAR(SCM_OPTARGS);
4787 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4788 }
4789 clamp = (clamp_scm);
4790 {
4791 SCM_RETURN(Scm_S32VectorAdd(v0, v1, clamp_arg(clamp)));
4792 }
4793 }
4794
4795 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_add__NAME, "s32vector-add", 13, 13);
4796 static SCM_DEFINE_SUBR(uvlib_s32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_add__NAME), uvlib_s32vector_add, NULL, NULL);
4797
4798 static ScmObj uvlib_s32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4799 {
4800 ScmObj v0_scm;
4801 ScmS32Vector* v0;
4802 ScmObj v1_scm;
4803 ScmObj v1;
4804 ScmObj clamp_scm;
4805 ScmObj clamp;
4806 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4807 SCM_ENTER_SUBR("s32vector-add!");
4808 if (Scm_Length(SCM_OPTARGS) > 1)
4809 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4810 v0_scm = SCM_ARGREF(0);
4811 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
4812 v0 = SCM_S32VECTOR(v0_scm);
4813 v1_scm = SCM_ARGREF(1);
4814 v1 = (v1_scm);
4815 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4816 else {
4817 clamp_scm = SCM_CAR(SCM_OPTARGS);
4818 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4819 }
4820 clamp = (clamp_scm);
4821 {
4822 SCM_RETURN(Scm_S32VectorAddX(v0, v1, clamp_arg(clamp)));
4823 }
4824 }
4825
4826 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_addX__NAME, "s32vector-add!", 14, 14);
4827 static SCM_DEFINE_SUBR(uvlib_s32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_addX__NAME), uvlib_s32vector_addX, NULL, NULL);
4828
4829 static ScmObj uvlib_u32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4830 {
4831 ScmObj v0_scm;
4832 ScmU32Vector* v0;
4833 ScmObj v1_scm;
4834 ScmObj v1;
4835 ScmObj clamp_scm;
4836 ScmObj clamp;
4837 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4838 SCM_ENTER_SUBR("u32vector-add");
4839 if (Scm_Length(SCM_OPTARGS) > 1)
4840 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4841 v0_scm = SCM_ARGREF(0);
4842 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
4843 v0 = SCM_U32VECTOR(v0_scm);
4844 v1_scm = SCM_ARGREF(1);
4845 v1 = (v1_scm);
4846 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4847 else {
4848 clamp_scm = SCM_CAR(SCM_OPTARGS);
4849 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4850 }
4851 clamp = (clamp_scm);
4852 {
4853 SCM_RETURN(Scm_U32VectorAdd(v0, v1, clamp_arg(clamp)));
4854 }
4855 }
4856
4857 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_add__NAME, "u32vector-add", 13, 13);
4858 static SCM_DEFINE_SUBR(uvlib_u32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_add__NAME), uvlib_u32vector_add, NULL, NULL);
4859
4860 static ScmObj uvlib_u32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4861 {
4862 ScmObj v0_scm;
4863 ScmU32Vector* v0;
4864 ScmObj v1_scm;
4865 ScmObj v1;
4866 ScmObj clamp_scm;
4867 ScmObj clamp;
4868 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4869 SCM_ENTER_SUBR("u32vector-add!");
4870 if (Scm_Length(SCM_OPTARGS) > 1)
4871 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4872 v0_scm = SCM_ARGREF(0);
4873 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
4874 v0 = SCM_U32VECTOR(v0_scm);
4875 v1_scm = SCM_ARGREF(1);
4876 v1 = (v1_scm);
4877 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4878 else {
4879 clamp_scm = SCM_CAR(SCM_OPTARGS);
4880 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4881 }
4882 clamp = (clamp_scm);
4883 {
4884 SCM_RETURN(Scm_U32VectorAddX(v0, v1, clamp_arg(clamp)));
4885 }
4886 }
4887
4888 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_addX__NAME, "u32vector-add!", 14, 14);
4889 static SCM_DEFINE_SUBR(uvlib_u32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_addX__NAME), uvlib_u32vector_addX, NULL, NULL);
4890
4891 static ScmObj uvlib_s64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4892 {
4893 ScmObj v0_scm;
4894 ScmS64Vector* v0;
4895 ScmObj v1_scm;
4896 ScmObj v1;
4897 ScmObj clamp_scm;
4898 ScmObj clamp;
4899 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4900 SCM_ENTER_SUBR("s64vector-add");
4901 if (Scm_Length(SCM_OPTARGS) > 1)
4902 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4903 v0_scm = SCM_ARGREF(0);
4904 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
4905 v0 = SCM_S64VECTOR(v0_scm);
4906 v1_scm = SCM_ARGREF(1);
4907 v1 = (v1_scm);
4908 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4909 else {
4910 clamp_scm = SCM_CAR(SCM_OPTARGS);
4911 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4912 }
4913 clamp = (clamp_scm);
4914 {
4915 SCM_RETURN(Scm_S64VectorAdd(v0, v1, clamp_arg(clamp)));
4916 }
4917 }
4918
4919 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_add__NAME, "s64vector-add", 13, 13);
4920 static SCM_DEFINE_SUBR(uvlib_s64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_add__NAME), uvlib_s64vector_add, NULL, NULL);
4921
4922 static ScmObj uvlib_s64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4923 {
4924 ScmObj v0_scm;
4925 ScmS64Vector* v0;
4926 ScmObj v1_scm;
4927 ScmObj v1;
4928 ScmObj clamp_scm;
4929 ScmObj clamp;
4930 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4931 SCM_ENTER_SUBR("s64vector-add!");
4932 if (Scm_Length(SCM_OPTARGS) > 1)
4933 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4934 v0_scm = SCM_ARGREF(0);
4935 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
4936 v0 = SCM_S64VECTOR(v0_scm);
4937 v1_scm = SCM_ARGREF(1);
4938 v1 = (v1_scm);
4939 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4940 else {
4941 clamp_scm = SCM_CAR(SCM_OPTARGS);
4942 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4943 }
4944 clamp = (clamp_scm);
4945 {
4946 SCM_RETURN(Scm_S64VectorAddX(v0, v1, clamp_arg(clamp)));
4947 }
4948 }
4949
4950 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_addX__NAME, "s64vector-add!", 14, 14);
4951 static SCM_DEFINE_SUBR(uvlib_s64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_addX__NAME), uvlib_s64vector_addX, NULL, NULL);
4952
4953 static ScmObj uvlib_u64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4954 {
4955 ScmObj v0_scm;
4956 ScmU64Vector* v0;
4957 ScmObj v1_scm;
4958 ScmObj v1;
4959 ScmObj clamp_scm;
4960 ScmObj clamp;
4961 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4962 SCM_ENTER_SUBR("u64vector-add");
4963 if (Scm_Length(SCM_OPTARGS) > 1)
4964 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4965 v0_scm = SCM_ARGREF(0);
4966 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
4967 v0 = SCM_U64VECTOR(v0_scm);
4968 v1_scm = SCM_ARGREF(1);
4969 v1 = (v1_scm);
4970 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4971 else {
4972 clamp_scm = SCM_CAR(SCM_OPTARGS);
4973 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4974 }
4975 clamp = (clamp_scm);
4976 {
4977 SCM_RETURN(Scm_U64VectorAdd(v0, v1, clamp_arg(clamp)));
4978 }
4979 }
4980
4981 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_add__NAME, "u64vector-add", 13, 13);
4982 static SCM_DEFINE_SUBR(uvlib_u64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_add__NAME), uvlib_u64vector_add, NULL, NULL);
4983
4984 static ScmObj uvlib_u64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4985 {
4986 ScmObj v0_scm;
4987 ScmU64Vector* v0;
4988 ScmObj v1_scm;
4989 ScmObj v1;
4990 ScmObj clamp_scm;
4991 ScmObj clamp;
4992 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4993 SCM_ENTER_SUBR("u64vector-add!");
4994 if (Scm_Length(SCM_OPTARGS) > 1)
4995 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4996 v0_scm = SCM_ARGREF(0);
4997 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
4998 v0 = SCM_U64VECTOR(v0_scm);
4999 v1_scm = SCM_ARGREF(1);
5000 v1 = (v1_scm);
5001 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5002 else {
5003 clamp_scm = SCM_CAR(SCM_OPTARGS);
5004 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5005 }
5006 clamp = (clamp_scm);
5007 {
5008 SCM_RETURN(Scm_U64VectorAddX(v0, v1, clamp_arg(clamp)));
5009 }
5010 }
5011
5012 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_addX__NAME, "u64vector-add!", 14, 14);
5013 static SCM_DEFINE_SUBR(uvlib_u64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_addX__NAME), uvlib_u64vector_addX, NULL, NULL);
5014
5015 static ScmObj uvlib_f32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5016 {
5017 ScmObj v0_scm;
5018 ScmF32Vector* v0;
5019 ScmObj v1_scm;
5020 ScmObj v1;
5021 ScmObj clamp_scm;
5022 ScmObj clamp;
5023 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5024 SCM_ENTER_SUBR("f32vector-add");
5025 if (Scm_Length(SCM_OPTARGS) > 1)
5026 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5027 v0_scm = SCM_ARGREF(0);
5028 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5029 v0 = SCM_F32VECTOR(v0_scm);
5030 v1_scm = SCM_ARGREF(1);
5031 v1 = (v1_scm);
5032 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5033 else {
5034 clamp_scm = SCM_CAR(SCM_OPTARGS);
5035 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5036 }
5037 clamp = (clamp_scm);
5038 {
5039 SCM_RETURN(Scm_F32VectorAdd(v0, v1, clamp_arg(clamp)));
5040 }
5041 }
5042
5043 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_add__NAME, "f32vector-add", 13, 13);
5044 static SCM_DEFINE_SUBR(uvlib_f32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_add__NAME), uvlib_f32vector_add, NULL, NULL);
5045
5046 static ScmObj uvlib_f32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5047 {
5048 ScmObj v0_scm;
5049 ScmF32Vector* v0;
5050 ScmObj v1_scm;
5051 ScmObj v1;
5052 ScmObj clamp_scm;
5053 ScmObj clamp;
5054 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5055 SCM_ENTER_SUBR("f32vector-add!");
5056 if (Scm_Length(SCM_OPTARGS) > 1)
5057 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5058 v0_scm = SCM_ARGREF(0);
5059 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5060 v0 = SCM_F32VECTOR(v0_scm);
5061 v1_scm = SCM_ARGREF(1);
5062 v1 = (v1_scm);
5063 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5064 else {
5065 clamp_scm = SCM_CAR(SCM_OPTARGS);
5066 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5067 }
5068 clamp = (clamp_scm);
5069 {
5070 SCM_RETURN(Scm_F32VectorAddX(v0, v1, clamp_arg(clamp)));
5071 }
5072 }
5073
5074 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_addX__NAME, "f32vector-add!", 14, 14);
5075 static SCM_DEFINE_SUBR(uvlib_f32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_addX__NAME), uvlib_f32vector_addX, NULL, NULL);
5076
5077 static ScmObj uvlib_f64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5078 {
5079 ScmObj v0_scm;
5080 ScmF64Vector* v0;
5081 ScmObj v1_scm;
5082 ScmObj v1;
5083 ScmObj clamp_scm;
5084 ScmObj clamp;
5085 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5086 SCM_ENTER_SUBR("f64vector-add");
5087 if (Scm_Length(SCM_OPTARGS) > 1)
5088 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5089 v0_scm = SCM_ARGREF(0);
5090 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5091 v0 = SCM_F64VECTOR(v0_scm);
5092 v1_scm = SCM_ARGREF(1);
5093 v1 = (v1_scm);
5094 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5095 else {
5096 clamp_scm = SCM_CAR(SCM_OPTARGS);
5097 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5098 }
5099 clamp = (clamp_scm);
5100 {
5101 SCM_RETURN(Scm_F64VectorAdd(v0, v1, clamp_arg(clamp)));
5102 }
5103 }
5104
5105 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_add__NAME, "f64vector-add", 13, 13);
5106 static SCM_DEFINE_SUBR(uvlib_f64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_add__NAME), uvlib_f64vector_add, NULL, NULL);
5107
5108 static ScmObj uvlib_f64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5109 {
5110 ScmObj v0_scm;
5111 ScmF64Vector* v0;
5112 ScmObj v1_scm;
5113 ScmObj v1;
5114 ScmObj clamp_scm;
5115 ScmObj clamp;
5116 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5117 SCM_ENTER_SUBR("f64vector-add!");
5118 if (Scm_Length(SCM_OPTARGS) > 1)
5119 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5120 v0_scm = SCM_ARGREF(0);
5121 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5122 v0 = SCM_F64VECTOR(v0_scm);
5123 v1_scm = SCM_ARGREF(1);
5124 v1 = (v1_scm);
5125 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5126 else {
5127 clamp_scm = SCM_CAR(SCM_OPTARGS);
5128 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5129 }
5130 clamp = (clamp_scm);
5131 {
5132 SCM_RETURN(Scm_F64VectorAddX(v0, v1, clamp_arg(clamp)));
5133 }
5134 }
5135
5136 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_addX__NAME, "f64vector-add!", 14, 14);
5137 static SCM_DEFINE_SUBR(uvlib_f64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_addX__NAME), uvlib_f64vector_addX, NULL, NULL);
5138
5139 static ScmObj uvlib_s8vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5140 {
5141 ScmObj v0_scm;
5142 ScmS8Vector* v0;
5143 ScmObj v1_scm;
5144 ScmObj v1;
5145 ScmObj clamp_scm;
5146 ScmObj clamp;
5147 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5148 SCM_ENTER_SUBR("s8vector-sub");
5149 if (Scm_Length(SCM_OPTARGS) > 1)
5150 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5151 v0_scm = SCM_ARGREF(0);
5152 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5153 v0 = SCM_S8VECTOR(v0_scm);
5154 v1_scm = SCM_ARGREF(1);
5155 v1 = (v1_scm);
5156 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5157 else {
5158 clamp_scm = SCM_CAR(SCM_OPTARGS);
5159 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5160 }
5161 clamp = (clamp_scm);
5162 {
5163 SCM_RETURN(Scm_S8VectorSub(v0, v1, clamp_arg(clamp)));
5164 }
5165 }
5166
5167 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_sub__NAME, "s8vector-sub", 12, 12);
5168 static SCM_DEFINE_SUBR(uvlib_s8vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_sub__NAME), uvlib_s8vector_sub, NULL, NULL);
5169
5170 static ScmObj uvlib_s8vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5171 {
5172 ScmObj v0_scm;
5173 ScmS8Vector* v0;
5174 ScmObj v1_scm;
5175 ScmObj v1;
5176 ScmObj clamp_scm;
5177 ScmObj clamp;
5178 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5179 SCM_ENTER_SUBR("s8vector-sub!");
5180 if (Scm_Length(SCM_OPTARGS) > 1)
5181 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5182 v0_scm = SCM_ARGREF(0);
5183 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5184 v0 = SCM_S8VECTOR(v0_scm);
5185 v1_scm = SCM_ARGREF(1);
5186 v1 = (v1_scm);
5187 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5188 else {
5189 clamp_scm = SCM_CAR(SCM_OPTARGS);
5190 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5191 }
5192 clamp = (clamp_scm);
5193 {
5194 SCM_RETURN(Scm_S8VectorSubX(v0, v1, clamp_arg(clamp)));
5195 }
5196 }
5197
5198 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_subX__NAME, "s8vector-sub!", 13, 13);
5199 static SCM_DEFINE_SUBR(uvlib_s8vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_subX__NAME), uvlib_s8vector_subX, NULL, NULL);
5200
5201 static ScmObj uvlib_u8vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5202 {
5203 ScmObj v0_scm;
5204 ScmU8Vector* v0;
5205 ScmObj v1_scm;
5206 ScmObj v1;
5207 ScmObj clamp_scm;
5208 ScmObj clamp;
5209 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5210 SCM_ENTER_SUBR("u8vector-sub");
5211 if (Scm_Length(SCM_OPTARGS) > 1)
5212 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5213 v0_scm = SCM_ARGREF(0);
5214 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5215 v0 = SCM_U8VECTOR(v0_scm);
5216 v1_scm = SCM_ARGREF(1);
5217 v1 = (v1_scm);
5218 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5219 else {
5220 clamp_scm = SCM_CAR(SCM_OPTARGS);
5221 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5222 }
5223 clamp = (clamp_scm);
5224 {
5225 SCM_RETURN(Scm_U8VectorSub(v0, v1, clamp_arg(clamp)));
5226 }
5227 }
5228
5229 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_sub__NAME, "u8vector-sub", 12, 12);
5230 static SCM_DEFINE_SUBR(uvlib_u8vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_sub__NAME), uvlib_u8vector_sub, NULL, NULL);
5231
5232 static ScmObj uvlib_u8vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5233 {
5234 ScmObj v0_scm;
5235 ScmU8Vector* v0;
5236 ScmObj v1_scm;
5237 ScmObj v1;
5238 ScmObj clamp_scm;
5239 ScmObj clamp;
5240 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5241 SCM_ENTER_SUBR("u8vector-sub!");
5242 if (Scm_Length(SCM_OPTARGS) > 1)
5243 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5244 v0_scm = SCM_ARGREF(0);
5245 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5246 v0 = SCM_U8VECTOR(v0_scm);
5247 v1_scm = SCM_ARGREF(1);
5248 v1 = (v1_scm);
5249 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5250 else {
5251 clamp_scm = SCM_CAR(SCM_OPTARGS);
5252 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5253 }
5254 clamp = (clamp_scm);
5255 {
5256 SCM_RETURN(Scm_U8VectorSubX(v0, v1, clamp_arg(clamp)));
5257 }
5258 }
5259
5260 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_subX__NAME, "u8vector-sub!", 13, 13);
5261 static SCM_DEFINE_SUBR(uvlib_u8vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_subX__NAME), uvlib_u8vector_subX, NULL, NULL);
5262
5263 static ScmObj uvlib_s16vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5264 {
5265 ScmObj v0_scm;
5266 ScmS16Vector* v0;
5267 ScmObj v1_scm;
5268 ScmObj v1;
5269 ScmObj clamp_scm;
5270 ScmObj clamp;
5271 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5272 SCM_ENTER_SUBR("s16vector-sub");
5273 if (Scm_Length(SCM_OPTARGS) > 1)
5274 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5275 v0_scm = SCM_ARGREF(0);
5276 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5277 v0 = SCM_S16VECTOR(v0_scm);
5278 v1_scm = SCM_ARGREF(1);
5279 v1 = (v1_scm);
5280 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5281 else {
5282 clamp_scm = SCM_CAR(SCM_OPTARGS);
5283 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5284 }
5285 clamp = (clamp_scm);
5286 {
5287 SCM_RETURN(Scm_S16VectorSub(v0, v1, clamp_arg(clamp)));
5288 }
5289 }
5290
5291 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_sub__NAME, "s16vector-sub", 13, 13);
5292 static SCM_DEFINE_SUBR(uvlib_s16vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_sub__NAME), uvlib_s16vector_sub, NULL, NULL);
5293
5294 static ScmObj uvlib_s16vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5295 {
5296 ScmObj v0_scm;
5297 ScmS16Vector* v0;
5298 ScmObj v1_scm;
5299 ScmObj v1;
5300 ScmObj clamp_scm;
5301 ScmObj clamp;
5302 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5303 SCM_ENTER_SUBR("s16vector-sub!");
5304 if (Scm_Length(SCM_OPTARGS) > 1)
5305 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5306 v0_scm = SCM_ARGREF(0);
5307 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5308 v0 = SCM_S16VECTOR(v0_scm);
5309 v1_scm = SCM_ARGREF(1);
5310 v1 = (v1_scm);
5311 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5312 else {
5313 clamp_scm = SCM_CAR(SCM_OPTARGS);
5314 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5315 }
5316 clamp = (clamp_scm);
5317 {
5318 SCM_RETURN(Scm_S16VectorSubX(v0, v1, clamp_arg(clamp)));
5319 }
5320 }
5321
5322 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_subX__NAME, "s16vector-sub!", 14, 14);
5323 static SCM_DEFINE_SUBR(uvlib_s16vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_subX__NAME), uvlib_s16vector_subX, NULL, NULL);
5324
5325 static ScmObj uvlib_u16vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5326 {
5327 ScmObj v0_scm;
5328 ScmU16Vector* v0;
5329 ScmObj v1_scm;
5330 ScmObj v1;
5331 ScmObj clamp_scm;
5332 ScmObj clamp;
5333 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5334 SCM_ENTER_SUBR("u16vector-sub");
5335 if (Scm_Length(SCM_OPTARGS) > 1)
5336 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5337 v0_scm = SCM_ARGREF(0);
5338 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5339 v0 = SCM_U16VECTOR(v0_scm);
5340 v1_scm = SCM_ARGREF(1);
5341 v1 = (v1_scm);
5342 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5343 else {
5344 clamp_scm = SCM_CAR(SCM_OPTARGS);
5345 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5346 }
5347 clamp = (clamp_scm);
5348 {
5349 SCM_RETURN(Scm_U16VectorSub(v0, v1, clamp_arg(clamp)));
5350 }
5351 }
5352
5353 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_sub__NAME, "u16vector-sub", 13, 13);
5354 static SCM_DEFINE_SUBR(uvlib_u16vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_sub__NAME), uvlib_u16vector_sub, NULL, NULL);
5355
5356 static ScmObj uvlib_u16vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5357 {
5358 ScmObj v0_scm;
5359 ScmU16Vector* v0;
5360 ScmObj v1_scm;
5361 ScmObj v1;
5362 ScmObj clamp_scm;
5363 ScmObj clamp;
5364 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5365 SCM_ENTER_SUBR("u16vector-sub!");
5366 if (Scm_Length(SCM_OPTARGS) > 1)
5367 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5368 v0_scm = SCM_ARGREF(0);
5369 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5370 v0 = SCM_U16VECTOR(v0_scm);
5371 v1_scm = SCM_ARGREF(1);
5372 v1 = (v1_scm);
5373 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5374 else {
5375 clamp_scm = SCM_CAR(SCM_OPTARGS);
5376 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5377 }
5378 clamp = (clamp_scm);
5379 {
5380 SCM_RETURN(Scm_U16VectorSubX(v0, v1, clamp_arg(clamp)));
5381 }
5382 }
5383
5384 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_subX__NAME, "u16vector-sub!", 14, 14);
5385 static SCM_DEFINE_SUBR(uvlib_u16vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_subX__NAME), uvlib_u16vector_subX, NULL, NULL);
5386
5387 static ScmObj uvlib_s32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5388 {
5389 ScmObj v0_scm;
5390 ScmS32Vector* v0;
5391 ScmObj v1_scm;
5392 ScmObj v1;
5393 ScmObj clamp_scm;
5394 ScmObj clamp;
5395 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5396 SCM_ENTER_SUBR("s32vector-sub");
5397 if (Scm_Length(SCM_OPTARGS) > 1)
5398 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5399 v0_scm = SCM_ARGREF(0);
5400 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
5401 v0 = SCM_S32VECTOR(v0_scm);
5402 v1_scm = SCM_ARGREF(1);
5403 v1 = (v1_scm);
5404 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5405 else {
5406 clamp_scm = SCM_CAR(SCM_OPTARGS);
5407 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5408 }
5409 clamp = (clamp_scm);
5410 {
5411 SCM_RETURN(Scm_S32VectorSub(v0, v1, clamp_arg(clamp)));
5412 }
5413 }
5414
5415 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_sub__NAME, "s32vector-sub", 13, 13);
5416 static SCM_DEFINE_SUBR(uvlib_s32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_sub__NAME), uvlib_s32vector_sub, NULL, NULL);
5417
5418 static ScmObj uvlib_s32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5419 {
5420 ScmObj v0_scm;
5421 ScmS32Vector* v0;
5422 ScmObj v1_scm;
5423 ScmObj v1;
5424 ScmObj clamp_scm;
5425 ScmObj clamp;
5426 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5427 SCM_ENTER_SUBR("s32vector-sub!");
5428 if (Scm_Length(SCM_OPTARGS) > 1)
5429 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5430 v0_scm = SCM_ARGREF(0);
5431 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
5432 v0 = SCM_S32VECTOR(v0_scm);
5433 v1_scm = SCM_ARGREF(1);
5434 v1 = (v1_scm);
5435 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5436 else {
5437 clamp_scm = SCM_CAR(SCM_OPTARGS);
5438 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5439 }
5440 clamp = (clamp_scm);
5441 {
5442 SCM_RETURN(Scm_S32VectorSubX(v0, v1, clamp_arg(clamp)));
5443 }
5444 }
5445
5446 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_subX__NAME, "s32vector-sub!", 14, 14);
5447 static SCM_DEFINE_SUBR(uvlib_s32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_subX__NAME), uvlib_s32vector_subX, NULL, NULL);
5448
5449 static ScmObj uvlib_u32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5450 {
5451 ScmObj v0_scm;
5452 ScmU32Vector* v0;
5453 ScmObj v1_scm;
5454 ScmObj v1;
5455 ScmObj clamp_scm;
5456 ScmObj clamp;
5457 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5458 SCM_ENTER_SUBR("u32vector-sub");
5459 if (Scm_Length(SCM_OPTARGS) > 1)
5460 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5461 v0_scm = SCM_ARGREF(0);
5462 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
5463 v0 = SCM_U32VECTOR(v0_scm);
5464 v1_scm = SCM_ARGREF(1);
5465 v1 = (v1_scm);
5466 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5467 else {
5468 clamp_scm = SCM_CAR(SCM_OPTARGS);
5469 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5470 }
5471 clamp = (clamp_scm);
5472 {
5473 SCM_RETURN(Scm_U32VectorSub(v0, v1, clamp_arg(clamp)));
5474 }
5475 }
5476
5477 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_sub__NAME, "u32vector-sub", 13, 13);
5478 static SCM_DEFINE_SUBR(uvlib_u32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_sub__NAME), uvlib_u32vector_sub, NULL, NULL);
5479
5480 static ScmObj uvlib_u32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5481 {
5482 ScmObj v0_scm;
5483 ScmU32Vector* v0;
5484 ScmObj v1_scm;
5485 ScmObj v1;
5486 ScmObj clamp_scm;
5487 ScmObj clamp;
5488 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5489 SCM_ENTER_SUBR("u32vector-sub!");
5490 if (Scm_Length(SCM_OPTARGS) > 1)
5491 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5492 v0_scm = SCM_ARGREF(0);
5493 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
5494 v0 = SCM_U32VECTOR(v0_scm);
5495 v1_scm = SCM_ARGREF(1);
5496 v1 = (v1_scm);
5497 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5498 else {
5499 clamp_scm = SCM_CAR(SCM_OPTARGS);
5500 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5501 }
5502 clamp = (clamp_scm);
5503 {
5504 SCM_RETURN(Scm_U32VectorSubX(v0, v1, clamp_arg(clamp)));
5505 }
5506 }
5507
5508 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_subX__NAME, "u32vector-sub!", 14, 14);
5509 static SCM_DEFINE_SUBR(uvlib_u32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_subX__NAME), uvlib_u32vector_subX, NULL, NULL);
5510
5511 static ScmObj uvlib_s64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5512 {
5513 ScmObj v0_scm;
5514 ScmS64Vector* v0;
5515 ScmObj v1_scm;
5516 ScmObj v1;
5517 ScmObj clamp_scm;
5518 ScmObj clamp;
5519 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5520 SCM_ENTER_SUBR("s64vector-sub");
5521 if (Scm_Length(SCM_OPTARGS) > 1)
5522 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5523 v0_scm = SCM_ARGREF(0);
5524 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
5525 v0 = SCM_S64VECTOR(v0_scm);
5526 v1_scm = SCM_ARGREF(1);
5527 v1 = (v1_scm);
5528 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5529 else {
5530 clamp_scm = SCM_CAR(SCM_OPTARGS);
5531 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5532 }
5533 clamp = (clamp_scm);
5534 {
5535 SCM_RETURN(Scm_S64VectorSub(v0, v1, clamp_arg(clamp)));
5536 }
5537 }
5538
5539 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_sub__NAME, "s64vector-sub", 13, 13);
5540 static SCM_DEFINE_SUBR(uvlib_s64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_sub__NAME), uvlib_s64vector_sub, NULL, NULL);
5541
5542 static ScmObj uvlib_s64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5543 {
5544 ScmObj v0_scm;
5545 ScmS64Vector* v0;
5546 ScmObj v1_scm;
5547 ScmObj v1;
5548 ScmObj clamp_scm;
5549 ScmObj clamp;
5550 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5551 SCM_ENTER_SUBR("s64vector-sub!");
5552 if (Scm_Length(SCM_OPTARGS) > 1)
5553 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5554 v0_scm = SCM_ARGREF(0);
5555 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
5556 v0 = SCM_S64VECTOR(v0_scm);
5557 v1_scm = SCM_ARGREF(1);
5558 v1 = (v1_scm);
5559 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5560 else {
5561 clamp_scm = SCM_CAR(SCM_OPTARGS);
5562 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5563 }
5564 clamp = (clamp_scm);
5565 {
5566 SCM_RETURN(Scm_S64VectorSubX(v0, v1, clamp_arg(clamp)));
5567 }
5568 }
5569
5570 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_subX__NAME, "s64vector-sub!", 14, 14);
5571 static SCM_DEFINE_SUBR(uvlib_s64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_subX__NAME), uvlib_s64vector_subX, NULL, NULL);
5572
5573 static ScmObj uvlib_u64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5574 {
5575 ScmObj v0_scm;
5576 ScmU64Vector* v0;
5577 ScmObj v1_scm;
5578 ScmObj v1;
5579 ScmObj clamp_scm;
5580 ScmObj clamp;
5581 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5582 SCM_ENTER_SUBR("u64vector-sub");
5583 if (Scm_Length(SCM_OPTARGS) > 1)
5584 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5585 v0_scm = SCM_ARGREF(0);
5586 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
5587 v0 = SCM_U64VECTOR(v0_scm);
5588 v1_scm = SCM_ARGREF(1);
5589 v1 = (v1_scm);
5590 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5591 else {
5592 clamp_scm = SCM_CAR(SCM_OPTARGS);
5593 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5594 }
5595 clamp = (clamp_scm);
5596 {
5597 SCM_RETURN(Scm_U64VectorSub(v0, v1, clamp_arg(clamp)));
5598 }
5599 }
5600
5601 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_sub__NAME, "u64vector-sub", 13, 13);
5602 static SCM_DEFINE_SUBR(uvlib_u64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_sub__NAME), uvlib_u64vector_sub, NULL, NULL);
5603
5604 static ScmObj uvlib_u64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5605 {
5606 ScmObj v0_scm;
5607 ScmU64Vector* v0;
5608 ScmObj v1_scm;
5609 ScmObj v1;
5610 ScmObj clamp_scm;
5611 ScmObj clamp;
5612 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5613 SCM_ENTER_SUBR("u64vector-sub!");
5614 if (Scm_Length(SCM_OPTARGS) > 1)
5615 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5616 v0_scm = SCM_ARGREF(0);
5617 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
5618 v0 = SCM_U64VECTOR(v0_scm);
5619 v1_scm = SCM_ARGREF(1);
5620 v1 = (v1_scm);
5621 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5622 else {
5623 clamp_scm = SCM_CAR(SCM_OPTARGS);
5624 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5625 }
5626 clamp = (clamp_scm);
5627 {
5628 SCM_RETURN(Scm_U64VectorSubX(v0, v1, clamp_arg(clamp)));
5629 }
5630 }
5631
5632 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_subX__NAME, "u64vector-sub!", 14, 14);
5633 static SCM_DEFINE_SUBR(uvlib_u64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_subX__NAME), uvlib_u64vector_subX, NULL, NULL);
5634
5635 static ScmObj uvlib_f32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5636 {
5637 ScmObj v0_scm;
5638 ScmF32Vector* v0;
5639 ScmObj v1_scm;
5640 ScmObj v1;
5641 ScmObj clamp_scm;
5642 ScmObj clamp;
5643 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5644 SCM_ENTER_SUBR("f32vector-sub");
5645 if (Scm_Length(SCM_OPTARGS) > 1)
5646 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5647 v0_scm = SCM_ARGREF(0);
5648 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5649 v0 = SCM_F32VECTOR(v0_scm);
5650 v1_scm = SCM_ARGREF(1);
5651 v1 = (v1_scm);
5652 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5653 else {
5654 clamp_scm = SCM_CAR(SCM_OPTARGS);
5655 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5656 }
5657 clamp = (clamp_scm);
5658 {
5659 SCM_RETURN(Scm_F32VectorSub(v0, v1, clamp_arg(clamp)));
5660 }
5661 }
5662
5663 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_sub__NAME, "f32vector-sub", 13, 13);
5664 static SCM_DEFINE_SUBR(uvlib_f32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_sub__NAME), uvlib_f32vector_sub, NULL, NULL);
5665
5666 static ScmObj uvlib_f32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5667 {
5668 ScmObj v0_scm;
5669 ScmF32Vector* v0;
5670 ScmObj v1_scm;
5671 ScmObj v1;
5672 ScmObj clamp_scm;
5673 ScmObj clamp;
5674 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5675 SCM_ENTER_SUBR("f32vector-sub!");
5676 if (Scm_Length(SCM_OPTARGS) > 1)
5677 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5678 v0_scm = SCM_ARGREF(0);
5679 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5680 v0 = SCM_F32VECTOR(v0_scm);
5681 v1_scm = SCM_ARGREF(1);
5682 v1 = (v1_scm);
5683 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5684 else {
5685 clamp_scm = SCM_CAR(SCM_OPTARGS);
5686 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5687 }
5688 clamp = (clamp_scm);
5689 {
5690 SCM_RETURN(Scm_F32VectorSubX(v0, v1, clamp_arg(clamp)));
5691 }
5692 }
5693
5694 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_subX__NAME, "f32vector-sub!", 14, 14);
5695 static SCM_DEFINE_SUBR(uvlib_f32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_subX__NAME), uvlib_f32vector_subX, NULL, NULL);
5696
5697 static ScmObj uvlib_f64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5698 {
5699 ScmObj v0_scm;
5700 ScmF64Vector* v0;
5701 ScmObj v1_scm;
5702 ScmObj v1;
5703 ScmObj clamp_scm;
5704 ScmObj clamp;
5705 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5706 SCM_ENTER_SUBR("f64vector-sub");
5707 if (Scm_Length(SCM_OPTARGS) > 1)
5708 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5709 v0_scm = SCM_ARGREF(0);
5710 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5711 v0 = SCM_F64VECTOR(v0_scm);
5712 v1_scm = SCM_ARGREF(1);
5713 v1 = (v1_scm);
5714 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5715 else {
5716 clamp_scm = SCM_CAR(SCM_OPTARGS);
5717 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5718 }
5719 clamp = (clamp_scm);
5720 {
5721 SCM_RETURN(Scm_F64VectorSub(v0, v1, clamp_arg(clamp)));
5722 }
5723 }
5724
5725 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_sub__NAME, "f64vector-sub", 13, 13);
5726 static SCM_DEFINE_SUBR(uvlib_f64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_sub__NAME), uvlib_f64vector_sub, NULL, NULL);
5727
5728 static ScmObj uvlib_f64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5729 {
5730 ScmObj v0_scm;
5731 ScmF64Vector* v0;
5732 ScmObj v1_scm;
5733 ScmObj v1;
5734 ScmObj clamp_scm;
5735 ScmObj clamp;
5736 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5737 SCM_ENTER_SUBR("f64vector-sub!");
5738 if (Scm_Length(SCM_OPTARGS) > 1)
5739 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5740 v0_scm = SCM_ARGREF(0);
5741 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5742 v0 = SCM_F64VECTOR(v0_scm);
5743 v1_scm = SCM_ARGREF(1);
5744 v1 = (v1_scm);
5745 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5746 else {
5747 clamp_scm = SCM_CAR(SCM_OPTARGS);
5748 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5749 }
5750 clamp = (clamp_scm);
5751 {
5752 SCM_RETURN(Scm_F64VectorSubX(v0, v1, clamp_arg(clamp)));
5753 }
5754 }
5755
5756 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_subX__NAME, "f64vector-sub!", 14, 14);
5757 static SCM_DEFINE_SUBR(uvlib_f64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_subX__NAME), uvlib_f64vector_subX, NULL, NULL);
5758
5759 static ScmObj uvlib_s8vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5760 {
5761 ScmObj v0_scm;
5762 ScmS8Vector* v0;
5763 ScmObj v1_scm;
5764 ScmObj v1;
5765 ScmObj clamp_scm;
5766 ScmObj clamp;
5767 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5768 SCM_ENTER_SUBR("s8vector-mul");
5769 if (Scm_Length(SCM_OPTARGS) > 1)
5770 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5771 v0_scm = SCM_ARGREF(0);
5772 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5773 v0 = SCM_S8VECTOR(v0_scm);
5774 v1_scm = SCM_ARGREF(1);
5775 v1 = (v1_scm);
5776 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5777 else {
5778 clamp_scm = SCM_CAR(SCM_OPTARGS);
5779 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5780 }
5781 clamp = (clamp_scm);
5782 {
5783 SCM_RETURN(Scm_S8VectorMul(v0, v1, clamp_arg(clamp)));
5784 }
5785 }
5786
5787 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_mul__NAME, "s8vector-mul", 12, 12);
5788 static SCM_DEFINE_SUBR(uvlib_s8vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_mul__NAME), uvlib_s8vector_mul, NULL, NULL);
5789
5790 static ScmObj uvlib_s8vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5791 {
5792 ScmObj v0_scm;
5793 ScmS8Vector* v0;
5794 ScmObj v1_scm;
5795 ScmObj v1;
5796 ScmObj clamp_scm;
5797 ScmObj clamp;
5798 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5799 SCM_ENTER_SUBR("s8vector-mul!");
5800 if (Scm_Length(SCM_OPTARGS) > 1)
5801 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5802 v0_scm = SCM_ARGREF(0);
5803 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5804 v0 = SCM_S8VECTOR(v0_scm);
5805 v1_scm = SCM_ARGREF(1);
5806 v1 = (v1_scm);
5807 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5808 else {
5809 clamp_scm = SCM_CAR(SCM_OPTARGS);
5810 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5811 }
5812 clamp = (clamp_scm);
5813 {
5814 SCM_RETURN(Scm_S8VectorMulX(v0, v1, clamp_arg(clamp)));
5815 }
5816 }
5817
5818 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_mulX__NAME, "s8vector-mul!", 13, 13);
5819 static SCM_DEFINE_SUBR(uvlib_s8vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_mulX__NAME), uvlib_s8vector_mulX, NULL, NULL);
5820
5821 static ScmObj uvlib_u8vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5822 {
5823 ScmObj v0_scm;
5824 ScmU8Vector* v0;
5825 ScmObj v1_scm;
5826 ScmObj v1;
5827 ScmObj clamp_scm;
5828 ScmObj clamp;
5829 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5830 SCM_ENTER_SUBR("u8vector-mul");
5831 if (Scm_Length(SCM_OPTARGS) > 1)
5832 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5833 v0_scm = SCM_ARGREF(0);
5834 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5835 v0 = SCM_U8VECTOR(v0_scm);
5836 v1_scm = SCM_ARGREF(1);
5837 v1 = (v1_scm);
5838 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5839 else {
5840 clamp_scm = SCM_CAR(SCM_OPTARGS);
5841 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5842 }
5843 clamp = (clamp_scm);
5844 {
5845 SCM_RETURN(Scm_U8VectorMul(v0, v1, clamp_arg(clamp)));
5846 }
5847 }
5848
5849 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_mul__NAME, "u8vector-mul", 12, 12);
5850 static SCM_DEFINE_SUBR(uvlib_u8vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_mul__NAME), uvlib_u8vector_mul, NULL, NULL);
5851
5852 static ScmObj uvlib_u8vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5853 {
5854 ScmObj v0_scm;
5855 ScmU8Vector* v0;
5856 ScmObj v1_scm;
5857 ScmObj v1;
5858 ScmObj clamp_scm;
5859 ScmObj clamp;
5860 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5861 SCM_ENTER_SUBR("u8vector-mul!");
5862 if (Scm_Length(SCM_OPTARGS) > 1)
5863 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5864 v0_scm = SCM_ARGREF(0);
5865 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5866 v0 = SCM_U8VECTOR(v0_scm);
5867 v1_scm = SCM_ARGREF(1);
5868 v1 = (v1_scm);
5869 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5870 else {
5871 clamp_scm = SCM_CAR(SCM_OPTARGS);
5872 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5873 }
5874 clamp = (clamp_scm);
5875 {
5876 SCM_RETURN(Scm_U8VectorMulX(v0, v1, clamp_arg(clamp)));
5877 }
5878 }
5879
5880 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_mulX__NAME, "u8vector-mul!", 13, 13);
5881 static SCM_DEFINE_SUBR(uvlib_u8vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_mulX__NAME), uvlib_u8vector_mulX, NULL, NULL);
5882
5883 static ScmObj uvlib_s16vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5884 {
5885 ScmObj v0_scm;
5886 ScmS16Vector* v0;
5887 ScmObj v1_scm;
5888 ScmObj v1;
5889 ScmObj clamp_scm;
5890 ScmObj clamp;
5891 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5892 SCM_ENTER_SUBR("s16vector-mul");
5893 if (Scm_Length(SCM_OPTARGS) > 1)
5894 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5895 v0_scm = SCM_ARGREF(0);
5896 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5897 v0 = SCM_S16VECTOR(v0_scm);
5898 v1_scm = SCM_ARGREF(1);
5899 v1 = (v1_scm);
5900 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5901 else {
5902 clamp_scm = SCM_CAR(SCM_OPTARGS);
5903 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5904 }
5905 clamp = (clamp_scm);
5906 {
5907 SCM_RETURN(Scm_S16VectorMul(v0, v1, clamp_arg(clamp)));
5908 }
5909 }
5910
5911 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_mul__NAME, "s16vector-mul", 13, 13);
5912 static SCM_DEFINE_SUBR(uvlib_s16vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_mul__NAME), uvlib_s16vector_mul, NULL, NULL);
5913
5914 static ScmObj uvlib_s16vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5915 {
5916 ScmObj v0_scm;
5917 ScmS16Vector* v0;
5918 ScmObj v1_scm;
5919 ScmObj v1;
5920 ScmObj clamp_scm;
5921 ScmObj clamp;
5922 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5923 SCM_ENTER_SUBR("s16vector-mul!");
5924 if (Scm_Length(SCM_OPTARGS) > 1)
5925 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5926 v0_scm = SCM_ARGREF(0);
5927 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5928 v0 = SCM_S16VECTOR(v0_scm);
5929 v1_scm = SCM_ARGREF(1);
5930 v1 = (v1_scm);
5931 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5932 else {
5933 clamp_scm = SCM_CAR(SCM_OPTARGS);
5934 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5935 }
5936 clamp = (clamp_scm);
5937 {
5938 SCM_RETURN(Scm_S16VectorMulX(v0, v1, clamp_arg(clamp)));
5939 }
5940 }
5941
5942 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_mulX__NAME, "s16vector-mul!", 14, 14);
5943 static SCM_DEFINE_SUBR(uvlib_s16vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_mulX__NAME), uvlib_s16vector_mulX, NULL, NULL);
5944
5945 static ScmObj uvlib_u16vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5946 {
5947 ScmObj v0_scm;
5948 ScmU16Vector* v0;
5949 ScmObj v1_scm;
5950 ScmObj v1;
5951 ScmObj clamp_scm;
5952 ScmObj clamp;
5953 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5954 SCM_ENTER_SUBR("u16vector-mul");
5955 if (Scm_Length(SCM_OPTARGS) > 1)
5956 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5957 v0_scm = SCM_ARGREF(0);
5958 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5959 v0 = SCM_U16VECTOR(v0_scm);
5960 v1_scm = SCM_ARGREF(1);
5961 v1 = (v1_scm);
5962 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5963 else {
5964 clamp_scm = SCM_CAR(SCM_OPTARGS);
5965 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5966 }
5967 clamp = (clamp_scm);
5968 {
5969 SCM_RETURN(Scm_U16VectorMul(v0, v1, clamp_arg(clamp)));
5970 }
5971 }
5972
5973 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_mul__NAME, "u16vector-mul", 13, 13);
5974 static SCM_DEFINE_SUBR(uvlib_u16vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_mul__NAME), uvlib_u16vector_mul, NULL, NULL);
5975
5976 static ScmObj uvlib_u16vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5977 {
5978 ScmObj v0_scm;
5979 ScmU16Vector* v0;
5980 ScmObj v1_scm;
5981 ScmObj v1;
5982 ScmObj clamp_scm;
5983 ScmObj clamp;
5984 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5985 SCM_ENTER_SUBR("u16vector-mul!");
5986 if (Scm_Length(SCM_OPTARGS) > 1)
5987 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5988 v0_scm = SCM_ARGREF(0);
5989 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5990 v0 = SCM_U16VECTOR(v0_scm);
5991 v1_scm = SCM_ARGREF(1);
5992 v1 = (v1_scm);
5993 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5994 else {
5995 clamp_scm = SCM_CAR(SCM_OPTARGS);
5996 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5997 }
5998 clamp = (clamp_scm);
5999 {
6000 SCM_RETURN(Scm_U16VectorMulX(v0, v1, clamp_arg(clamp)));
6001 }
6002 }
6003
6004 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_mulX__NAME, "u16vector-mul!", 14, 14);
6005 static SCM_DEFINE_SUBR(uvlib_u16vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_mulX__NAME), uvlib_u16vector_mulX, NULL, NULL);
6006
6007 static ScmObj uvlib_s32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6008 {
6009 ScmObj v0_scm;
6010 ScmS32Vector* v0;
6011 ScmObj v1_scm;
6012 ScmObj v1;
6013 ScmObj clamp_scm;
6014 ScmObj clamp;
6015 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6016 SCM_ENTER_SUBR("s32vector-mul");
6017 if (Scm_Length(SCM_OPTARGS) > 1)
6018 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6019 v0_scm = SCM_ARGREF(0);
6020 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6021 v0 = SCM_S32VECTOR(v0_scm);
6022 v1_scm = SCM_ARGREF(1);
6023 v1 = (v1_scm);
6024 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6025 else {
6026 clamp_scm = SCM_CAR(SCM_OPTARGS);
6027 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6028 }
6029 clamp = (clamp_scm);
6030 {
6031 SCM_RETURN(Scm_S32VectorMul(v0, v1, clamp_arg(clamp)));
6032 }
6033 }
6034
6035 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_mul__NAME, "s32vector-mul", 13, 13);
6036 static SCM_DEFINE_SUBR(uvlib_s32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_mul__NAME), uvlib_s32vector_mul, NULL, NULL);
6037
6038 static ScmObj uvlib_s32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6039 {
6040 ScmObj v0_scm;
6041 ScmS32Vector* v0;
6042 ScmObj v1_scm;
6043 ScmObj v1;
6044 ScmObj clamp_scm;
6045 ScmObj clamp;
6046 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6047 SCM_ENTER_SUBR("s32vector-mul!");
6048 if (Scm_Length(SCM_OPTARGS) > 1)
6049 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6050 v0_scm = SCM_ARGREF(0);
6051 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6052 v0 = SCM_S32VECTOR(v0_scm);
6053 v1_scm = SCM_ARGREF(1);
6054 v1 = (v1_scm);
6055 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6056 else {
6057 clamp_scm = SCM_CAR(SCM_OPTARGS);
6058 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6059 }
6060 clamp = (clamp_scm);
6061 {
6062 SCM_RETURN(Scm_S32VectorMulX(v0, v1, clamp_arg(clamp)));
6063 }
6064 }
6065
6066 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_mulX__NAME, "s32vector-mul!", 14, 14);
6067 static SCM_DEFINE_SUBR(uvlib_s32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_mulX__NAME), uvlib_s32vector_mulX, NULL, NULL);
6068
6069 static ScmObj uvlib_u32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6070 {
6071 ScmObj v0_scm;
6072 ScmU32Vector* v0;
6073 ScmObj v1_scm;
6074 ScmObj v1;
6075 ScmObj clamp_scm;
6076 ScmObj clamp;
6077 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6078 SCM_ENTER_SUBR("u32vector-mul");
6079 if (Scm_Length(SCM_OPTARGS) > 1)
6080 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6081 v0_scm = SCM_ARGREF(0);
6082 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
6083 v0 = SCM_U32VECTOR(v0_scm);
6084 v1_scm = SCM_ARGREF(1);
6085 v1 = (v1_scm);
6086 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6087 else {
6088 clamp_scm = SCM_CAR(SCM_OPTARGS);
6089 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6090 }
6091 clamp = (clamp_scm);
6092 {
6093 SCM_RETURN(Scm_U32VectorMul(v0, v1, clamp_arg(clamp)));
6094 }
6095 }
6096
6097 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_mul__NAME, "u32vector-mul", 13, 13);
6098 static SCM_DEFINE_SUBR(uvlib_u32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_mul__NAME), uvlib_u32vector_mul, NULL, NULL);
6099
6100 static ScmObj uvlib_u32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6101 {
6102 ScmObj v0_scm;
6103 ScmU32Vector* v0;
6104 ScmObj v1_scm;
6105 ScmObj v1;
6106 ScmObj clamp_scm;
6107 ScmObj clamp;
6108 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6109 SCM_ENTER_SUBR("u32vector-mul!");
6110 if (Scm_Length(SCM_OPTARGS) > 1)
6111 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6112 v0_scm = SCM_ARGREF(0);
6113 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
6114 v0 = SCM_U32VECTOR(v0_scm);
6115 v1_scm = SCM_ARGREF(1);
6116 v1 = (v1_scm);
6117 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6118 else {
6119 clamp_scm = SCM_CAR(SCM_OPTARGS);
6120 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6121 }
6122 clamp = (clamp_scm);
6123 {
6124 SCM_RETURN(Scm_U32VectorMulX(v0, v1, clamp_arg(clamp)));
6125 }
6126 }
6127
6128 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_mulX__NAME, "u32vector-mul!", 14, 14);
6129 static SCM_DEFINE_SUBR(uvlib_u32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_mulX__NAME), uvlib_u32vector_mulX, NULL, NULL);
6130
6131 static ScmObj uvlib_s64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6132 {
6133 ScmObj v0_scm;
6134 ScmS64Vector* v0;
6135 ScmObj v1_scm;
6136 ScmObj v1;
6137 ScmObj clamp_scm;
6138 ScmObj clamp;
6139 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6140 SCM_ENTER_SUBR("s64vector-mul");
6141 if (Scm_Length(SCM_OPTARGS) > 1)
6142 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6143 v0_scm = SCM_ARGREF(0);
6144 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
6145 v0 = SCM_S64VECTOR(v0_scm);
6146 v1_scm = SCM_ARGREF(1);
6147 v1 = (v1_scm);
6148 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6149 else {
6150 clamp_scm = SCM_CAR(SCM_OPTARGS);
6151 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6152 }
6153 clamp = (clamp_scm);
6154 {
6155 SCM_RETURN(Scm_S64VectorMul(v0, v1, clamp_arg(clamp)));
6156 }
6157 }
6158
6159 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_mul__NAME, "s64vector-mul", 13, 13);
6160 static SCM_DEFINE_SUBR(uvlib_s64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_mul__NAME), uvlib_s64vector_mul, NULL, NULL);
6161
6162 static ScmObj uvlib_s64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6163 {
6164 ScmObj v0_scm;
6165 ScmS64Vector* v0;
6166 ScmObj v1_scm;
6167 ScmObj v1;
6168 ScmObj clamp_scm;
6169 ScmObj clamp;
6170 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6171 SCM_ENTER_SUBR("s64vector-mul!");
6172 if (Scm_Length(SCM_OPTARGS) > 1)
6173 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6174 v0_scm = SCM_ARGREF(0);
6175 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
6176 v0 = SCM_S64VECTOR(v0_scm);
6177 v1_scm = SCM_ARGREF(1);
6178 v1 = (v1_scm);
6179 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6180 else {
6181 clamp_scm = SCM_CAR(SCM_OPTARGS);
6182 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6183 }
6184 clamp = (clamp_scm);
6185 {
6186 SCM_RETURN(Scm_S64VectorMulX(v0, v1, clamp_arg(clamp)));
6187 }
6188 }
6189
6190 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_mulX__NAME, "s64vector-mul!", 14, 14);
6191 static SCM_DEFINE_SUBR(uvlib_s64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_mulX__NAME), uvlib_s64vector_mulX, NULL, NULL);
6192
6193 static ScmObj uvlib_u64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6194 {
6195 ScmObj v0_scm;
6196 ScmU64Vector* v0;
6197 ScmObj v1_scm;
6198 ScmObj v1;
6199 ScmObj clamp_scm;
6200 ScmObj clamp;
6201 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6202 SCM_ENTER_SUBR("u64vector-mul");
6203 if (Scm_Length(SCM_OPTARGS) > 1)
6204 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6205 v0_scm = SCM_ARGREF(0);
6206 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
6207 v0 = SCM_U64VECTOR(v0_scm);
6208 v1_scm = SCM_ARGREF(1);
6209 v1 = (v1_scm);
6210 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6211 else {
6212 clamp_scm = SCM_CAR(SCM_OPTARGS);
6213 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6214 }
6215 clamp = (clamp_scm);
6216 {
6217 SCM_RETURN(Scm_U64VectorMul(v0, v1, clamp_arg(clamp)));
6218 }
6219 }
6220
6221 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_mul__NAME, "u64vector-mul", 13, 13);
6222 static SCM_DEFINE_SUBR(uvlib_u64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_mul__NAME), uvlib_u64vector_mul, NULL, NULL);
6223
6224 static ScmObj uvlib_u64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6225 {
6226 ScmObj v0_scm;
6227 ScmU64Vector* v0;
6228 ScmObj v1_scm;
6229 ScmObj v1;
6230 ScmObj clamp_scm;
6231 ScmObj clamp;
6232 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6233 SCM_ENTER_SUBR("u64vector-mul!");
6234 if (Scm_Length(SCM_OPTARGS) > 1)
6235 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6236 v0_scm = SCM_ARGREF(0);
6237 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
6238 v0 = SCM_U64VECTOR(v0_scm);
6239 v1_scm = SCM_ARGREF(1);
6240 v1 = (v1_scm);
6241 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6242 else {
6243 clamp_scm = SCM_CAR(SCM_OPTARGS);
6244 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6245 }
6246 clamp = (clamp_scm);
6247 {
6248 SCM_RETURN(Scm_U64VectorMulX(v0, v1, clamp_arg(clamp)));
6249 }
6250 }
6251
6252 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_mulX__NAME, "u64vector-mul!", 14, 14);
6253 static SCM_DEFINE_SUBR(uvlib_u64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_mulX__NAME), uvlib_u64vector_mulX, NULL, NULL);
6254
6255 static ScmObj uvlib_f32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6256 {
6257 ScmObj v0_scm;
6258 ScmF32Vector* v0;
6259 ScmObj v1_scm;
6260 ScmObj v1;
6261 ScmObj clamp_scm;
6262 ScmObj clamp;
6263 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6264 SCM_ENTER_SUBR("f32vector-mul");
6265 if (Scm_Length(SCM_OPTARGS) > 1)
6266 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6267 v0_scm = SCM_ARGREF(0);
6268 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6269 v0 = SCM_F32VECTOR(v0_scm);
6270 v1_scm = SCM_ARGREF(1);
6271 v1 = (v1_scm);
6272 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6273 else {
6274 clamp_scm = SCM_CAR(SCM_OPTARGS);
6275 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6276 }
6277 clamp = (clamp_scm);
6278 {
6279 SCM_RETURN(Scm_F32VectorMul(v0, v1, clamp_arg(clamp)));
6280 }
6281 }
6282
6283 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_mul__NAME, "f32vector-mul", 13, 13);
6284 static SCM_DEFINE_SUBR(uvlib_f32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_mul__NAME), uvlib_f32vector_mul, NULL, NULL);
6285
6286 static ScmObj uvlib_f32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6287 {
6288 ScmObj v0_scm;
6289 ScmF32Vector* v0;
6290 ScmObj v1_scm;
6291 ScmObj v1;
6292 ScmObj clamp_scm;
6293 ScmObj clamp;
6294 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6295 SCM_ENTER_SUBR("f32vector-mul!");
6296 if (Scm_Length(SCM_OPTARGS) > 1)
6297 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6298 v0_scm = SCM_ARGREF(0);
6299 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6300 v0 = SCM_F32VECTOR(v0_scm);
6301 v1_scm = SCM_ARGREF(1);
6302 v1 = (v1_scm);
6303 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6304 else {
6305 clamp_scm = SCM_CAR(SCM_OPTARGS);
6306 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6307 }
6308 clamp = (clamp_scm);
6309 {
6310 SCM_RETURN(Scm_F32VectorMulX(v0, v1, clamp_arg(clamp)));
6311 }
6312 }
6313
6314 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_mulX__NAME, "f32vector-mul!", 14, 14);
6315 static SCM_DEFINE_SUBR(uvlib_f32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_mulX__NAME), uvlib_f32vector_mulX, NULL, NULL);
6316
6317 static ScmObj uvlib_f64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6318 {
6319 ScmObj v0_scm;
6320 ScmF64Vector* v0;
6321 ScmObj v1_scm;
6322 ScmObj v1;
6323 ScmObj clamp_scm;
6324 ScmObj clamp;
6325 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6326 SCM_ENTER_SUBR("f64vector-mul");
6327 if (Scm_Length(SCM_OPTARGS) > 1)
6328 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6329 v0_scm = SCM_ARGREF(0);
6330 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6331 v0 = SCM_F64VECTOR(v0_scm);
6332 v1_scm = SCM_ARGREF(1);
6333 v1 = (v1_scm);
6334 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6335 else {
6336 clamp_scm = SCM_CAR(SCM_OPTARGS);
6337 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6338 }
6339 clamp = (clamp_scm);
6340 {
6341 SCM_RETURN(Scm_F64VectorMul(v0, v1, clamp_arg(clamp)));
6342 }
6343 }
6344
6345 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_mul__NAME, "f64vector-mul", 13, 13);
6346 static SCM_DEFINE_SUBR(uvlib_f64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_mul__NAME), uvlib_f64vector_mul, NULL, NULL);
6347
6348 static ScmObj uvlib_f64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6349 {
6350 ScmObj v0_scm;
6351 ScmF64Vector* v0;
6352 ScmObj v1_scm;
6353 ScmObj v1;
6354 ScmObj clamp_scm;
6355 ScmObj clamp;
6356 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6357 SCM_ENTER_SUBR("f64vector-mul!");
6358 if (Scm_Length(SCM_OPTARGS) > 1)
6359 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6360 v0_scm = SCM_ARGREF(0);
6361 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6362 v0 = SCM_F64VECTOR(v0_scm);
6363 v1_scm = SCM_ARGREF(1);
6364 v1 = (v1_scm);
6365 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6366 else {
6367 clamp_scm = SCM_CAR(SCM_OPTARGS);
6368 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6369 }
6370 clamp = (clamp_scm);
6371 {
6372 SCM_RETURN(Scm_F64VectorMulX(v0, v1, clamp_arg(clamp)));
6373 }
6374 }
6375
6376 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_mulX__NAME, "f64vector-mul!", 14, 14);
6377 static SCM_DEFINE_SUBR(uvlib_f64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_mulX__NAME), uvlib_f64vector_mulX, NULL, NULL);
6378
6379 static ScmObj uvlib_f32vector_div(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6380 {
6381 ScmObj v0_scm;
6382 ScmF32Vector* v0;
6383 ScmObj v1_scm;
6384 ScmObj v1;
6385 ScmObj clamp_scm;
6386 ScmObj clamp;
6387 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6388 SCM_ENTER_SUBR("f32vector-div");
6389 if (Scm_Length(SCM_OPTARGS) > 1)
6390 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6391 v0_scm = SCM_ARGREF(0);
6392 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6393 v0 = SCM_F32VECTOR(v0_scm);
6394 v1_scm = SCM_ARGREF(1);
6395 v1 = (v1_scm);
6396 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6397 else {
6398 clamp_scm = SCM_CAR(SCM_OPTARGS);
6399 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6400 }
6401 clamp = (clamp_scm);
6402 {
6403 SCM_RETURN(Scm_F32VectorDiv(v0, v1, clamp_arg(clamp)));
6404 }
6405 }
6406
6407 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_div__NAME, "f32vector-div", 13, 13);
6408 static SCM_DEFINE_SUBR(uvlib_f32vector_div__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_div__NAME), uvlib_f32vector_div, NULL, NULL);
6409
6410 static ScmObj uvlib_f32vector_divX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6411 {
6412 ScmObj v0_scm;
6413 ScmF32Vector* v0;
6414 ScmObj v1_scm;
6415 ScmObj v1;
6416 ScmObj clamp_scm;
6417 ScmObj clamp;
6418 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6419 SCM_ENTER_SUBR("f32vector-div!");
6420 if (Scm_Length(SCM_OPTARGS) > 1)
6421 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6422 v0_scm = SCM_ARGREF(0);
6423 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6424 v0 = SCM_F32VECTOR(v0_scm);
6425 v1_scm = SCM_ARGREF(1);
6426 v1 = (v1_scm);
6427 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6428 else {
6429 clamp_scm = SCM_CAR(SCM_OPTARGS);
6430 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6431 }
6432 clamp = (clamp_scm);
6433 {
6434 SCM_RETURN(Scm_F32VectorDivX(v0, v1, clamp_arg(clamp)));
6435 }
6436 }
6437
6438 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_divX__NAME, "f32vector-div!", 14, 14);
6439 static SCM_DEFINE_SUBR(uvlib_f32vector_divX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_divX__NAME), uvlib_f32vector_divX, NULL, NULL);
6440
6441 static ScmObj uvlib_f64vector_div(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6442 {
6443 ScmObj v0_scm;
6444 ScmF64Vector* v0;
6445 ScmObj v1_scm;
6446 ScmObj v1;
6447 ScmObj clamp_scm;
6448 ScmObj clamp;
6449 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6450 SCM_ENTER_SUBR("f64vector-div");
6451 if (Scm_Length(SCM_OPTARGS) > 1)
6452 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6453 v0_scm = SCM_ARGREF(0);
6454 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6455 v0 = SCM_F64VECTOR(v0_scm);
6456 v1_scm = SCM_ARGREF(1);
6457 v1 = (v1_scm);
6458 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6459 else {
6460 clamp_scm = SCM_CAR(SCM_OPTARGS);
6461 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6462 }
6463 clamp = (clamp_scm);
6464 {
6465 SCM_RETURN(Scm_F64VectorDiv(v0, v1, clamp_arg(clamp)));
6466 }
6467 }
6468
6469 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_div__NAME, "f64vector-div", 13, 13);
6470 static SCM_DEFINE_SUBR(uvlib_f64vector_div__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_div__NAME), uvlib_f64vector_div, NULL, NULL);
6471
6472 static ScmObj uvlib_f64vector_divX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6473 {
6474 ScmObj v0_scm;
6475 ScmF64Vector* v0;
6476 ScmObj v1_scm;
6477 ScmObj v1;
6478 ScmObj clamp_scm;
6479 ScmObj clamp;
6480 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6481 SCM_ENTER_SUBR("f64vector-div!");
6482 if (Scm_Length(SCM_OPTARGS) > 1)
6483 Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6484 v0_scm = SCM_ARGREF(0);
6485 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6486 v0 = SCM_F64VECTOR(v0_scm);
6487 v1_scm = SCM_ARGREF(1);
6488 v1 = (v1_scm);
6489 if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6490 else {
6491 clamp_scm = SCM_CAR(SCM_OPTARGS);
6492 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6493 }
6494 clamp = (clamp_scm);
6495 {
6496 SCM_RETURN(Scm_F64VectorDivX(v0, v1, clamp_arg(clamp)));
6497 }
6498 }
6499
6500 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_divX__NAME, "f64vector-div!", 14, 14);
6501 static SCM_DEFINE_SUBR(uvlib_f64vector_divX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_divX__NAME), uvlib_f64vector_divX, NULL, NULL);
6502
6503 static ScmObj uvlib_s8vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6504 {
6505 ScmObj v0_scm;
6506 ScmS8Vector* v0;
6507 ScmObj v1_scm;
6508 ScmObj v1;
6509 SCM_ENTER_SUBR("s8vector-and");
6510 v0_scm = SCM_ARGREF(0);
6511 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6512 v0 = SCM_S8VECTOR(v0_scm);
6513 v1_scm = SCM_ARGREF(1);
6514 v1 = (v1_scm);
6515 {
6516 SCM_RETURN(Scm_S8VectorAnd(v0, v1));
6517 }
6518 }
6519
6520 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_and__NAME, "s8vector-and", 12, 12);
6521 static SCM_DEFINE_SUBR(uvlib_s8vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_and__NAME), uvlib_s8vector_and, NULL, NULL);
6522
6523 static ScmObj uvlib_s8vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6524 {
6525 ScmObj v0_scm;
6526 ScmS8Vector* v0;
6527 ScmObj v1_scm;
6528 ScmObj v1;
6529 SCM_ENTER_SUBR("s8vector-and!");
6530 v0_scm = SCM_ARGREF(0);
6531 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6532 v0 = SCM_S8VECTOR(v0_scm);
6533 v1_scm = SCM_ARGREF(1);
6534 v1 = (v1_scm);
6535 {
6536 SCM_RETURN(Scm_S8VectorAndX(v0, v1));
6537 }
6538 }
6539
6540 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_andX__NAME, "s8vector-and!", 13, 13);
6541 static SCM_DEFINE_SUBR(uvlib_s8vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_andX__NAME), uvlib_s8vector_andX, NULL, NULL);
6542
6543 static ScmObj uvlib_s8vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6544 {
6545 ScmObj v0_scm;
6546 ScmS8Vector* v0;
6547 ScmObj v1_scm;
6548 ScmObj v1;
6549 SCM_ENTER_SUBR("s8vector-ior");
6550 v0_scm = SCM_ARGREF(0);
6551 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6552 v0 = SCM_S8VECTOR(v0_scm);
6553 v1_scm = SCM_ARGREF(1);
6554 v1 = (v1_scm);
6555 {
6556 SCM_RETURN(Scm_S8VectorIor(v0, v1));
6557 }
6558 }
6559
6560 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_ior__NAME, "s8vector-ior", 12, 12);
6561 static SCM_DEFINE_SUBR(uvlib_s8vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_ior__NAME), uvlib_s8vector_ior, NULL, NULL);
6562
6563 static ScmObj uvlib_s8vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6564 {
6565 ScmObj v0_scm;
6566 ScmS8Vector* v0;
6567 ScmObj v1_scm;
6568 ScmObj v1;
6569 SCM_ENTER_SUBR("s8vector-ior!");
6570 v0_scm = SCM_ARGREF(0);
6571 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6572 v0 = SCM_S8VECTOR(v0_scm);
6573 v1_scm = SCM_ARGREF(1);
6574 v1 = (v1_scm);
6575 {
6576 SCM_RETURN(Scm_S8VectorIorX(v0, v1));
6577 }
6578 }
6579
6580 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_iorX__NAME, "s8vector-ior!", 13, 13);
6581 static SCM_DEFINE_SUBR(uvlib_s8vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_iorX__NAME), uvlib_s8vector_iorX, NULL, NULL);
6582
6583 static ScmObj uvlib_s8vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6584 {
6585 ScmObj v0_scm;
6586 ScmS8Vector* v0;
6587 ScmObj v1_scm;
6588 ScmObj v1;
6589 SCM_ENTER_SUBR("s8vector-xor");
6590 v0_scm = SCM_ARGREF(0);
6591 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6592 v0 = SCM_S8VECTOR(v0_scm);
6593 v1_scm = SCM_ARGREF(1);
6594 v1 = (v1_scm);
6595 {
6596 SCM_RETURN(Scm_S8VectorXor(v0, v1));
6597 }
6598 }
6599
6600 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_xor__NAME, "s8vector-xor", 12, 12);
6601 static SCM_DEFINE_SUBR(uvlib_s8vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_xor__NAME), uvlib_s8vector_xor, NULL, NULL);
6602
6603 static ScmObj uvlib_s8vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6604 {
6605 ScmObj v0_scm;
6606 ScmS8Vector* v0;
6607 ScmObj v1_scm;
6608 ScmObj v1;
6609 SCM_ENTER_SUBR("s8vector-xor!");
6610 v0_scm = SCM_ARGREF(0);
6611 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6612 v0 = SCM_S8VECTOR(v0_scm);
6613 v1_scm = SCM_ARGREF(1);
6614 v1 = (v1_scm);
6615 {
6616 SCM_RETURN(Scm_S8VectorXorX(v0, v1));
6617 }
6618 }
6619
6620 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_xorX__NAME, "s8vector-xor!", 13, 13);
6621 static SCM_DEFINE_SUBR(uvlib_s8vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_xorX__NAME), uvlib_s8vector_xorX, NULL, NULL);
6622
6623 static ScmObj uvlib_u8vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6624 {
6625 ScmObj v0_scm;
6626 ScmU8Vector* v0;
6627 ScmObj v1_scm;
6628 ScmObj v1;
6629 SCM_ENTER_SUBR("u8vector-and");
6630 v0_scm = SCM_ARGREF(0);
6631 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6632 v0 = SCM_U8VECTOR(v0_scm);
6633 v1_scm = SCM_ARGREF(1);
6634 v1 = (v1_scm);
6635 {
6636 SCM_RETURN(Scm_U8VectorAnd(v0, v1));
6637 }
6638 }
6639
6640 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_and__NAME, "u8vector-and", 12, 12);
6641 static SCM_DEFINE_SUBR(uvlib_u8vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_and__NAME), uvlib_u8vector_and, NULL, NULL);
6642
6643 static ScmObj uvlib_u8vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6644 {
6645 ScmObj v0_scm;
6646 ScmU8Vector* v0;
6647 ScmObj v1_scm;
6648 ScmObj v1;
6649 SCM_ENTER_SUBR("u8vector-and!");
6650 v0_scm = SCM_ARGREF(0);
6651 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6652 v0 = SCM_U8VECTOR(v0_scm);
6653 v1_scm = SCM_ARGREF(1);
6654 v1 = (v1_scm);
6655 {
6656 SCM_RETURN(Scm_U8VectorAndX(v0, v1));
6657 }
6658 }
6659
6660 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_andX__NAME, "u8vector-and!", 13, 13);
6661 static SCM_DEFINE_SUBR(uvlib_u8vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_andX__NAME), uvlib_u8vector_andX, NULL, NULL);
6662
6663 static ScmObj uvlib_u8vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6664 {
6665 ScmObj v0_scm;
6666 ScmU8Vector* v0;
6667 ScmObj v1_scm;
6668 ScmObj v1;
6669 SCM_ENTER_SUBR("u8vector-ior");
6670 v0_scm = SCM_ARGREF(0);
6671 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6672 v0 = SCM_U8VECTOR(v0_scm);
6673 v1_scm = SCM_ARGREF(1);
6674 v1 = (v1_scm);
6675 {
6676 SCM_RETURN(Scm_U8VectorIor(v0, v1));
6677 }
6678 }
6679
6680 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_ior__NAME, "u8vector-ior", 12, 12);
6681 static SCM_DEFINE_SUBR(uvlib_u8vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_ior__NAME), uvlib_u8vector_ior, NULL, NULL);
6682
6683 static ScmObj uvlib_u8vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6684 {
6685 ScmObj v0_scm;
6686 ScmU8Vector* v0;
6687 ScmObj v1_scm;
6688 ScmObj v1;
6689 SCM_ENTER_SUBR("u8vector-ior!");
6690 v0_scm = SCM_ARGREF(0);
6691 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6692 v0 = SCM_U8VECTOR(v0_scm);
6693 v1_scm = SCM_ARGREF(1);
6694 v1 = (v1_scm);
6695 {
6696 SCM_RETURN(Scm_U8VectorIorX(v0, v1));
6697 }
6698 }
6699
6700 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_iorX__NAME, "u8vector-ior!", 13, 13);
6701 static SCM_DEFINE_SUBR(uvlib_u8vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_iorX__NAME), uvlib_u8vector_iorX, NULL, NULL);
6702
6703 static ScmObj uvlib_u8vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6704 {
6705 ScmObj v0_scm;
6706 ScmU8Vector* v0;
6707 ScmObj v1_scm;
6708 ScmObj v1;
6709 SCM_ENTER_SUBR("u8vector-xor");
6710 v0_scm = SCM_ARGREF(0);
6711 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6712 v0 = SCM_U8VECTOR(v0_scm);
6713 v1_scm = SCM_ARGREF(1);
6714 v1 = (v1_scm);
6715 {
6716 SCM_RETURN(Scm_U8VectorXor(v0, v1));
6717 }
6718 }
6719
6720 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_xor__NAME, "u8vector-xor", 12, 12);
6721 static SCM_DEFINE_SUBR(uvlib_u8vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_xor__NAME), uvlib_u8vector_xor, NULL, NULL);
6722
6723 static ScmObj uvlib_u8vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6724 {
6725 ScmObj v0_scm;
6726 ScmU8Vector* v0;
6727 ScmObj v1_scm;
6728 ScmObj v1;
6729 SCM_ENTER_SUBR("u8vector-xor!");
6730 v0_scm = SCM_ARGREF(0);
6731 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6732 v0 = SCM_U8VECTOR(v0_scm);
6733 v1_scm = SCM_ARGREF(1);
6734 v1 = (v1_scm);
6735 {
6736 SCM_RETURN(Scm_U8VectorXorX(v0, v1));
6737 }
6738 }
6739
6740 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_xorX__NAME, "u8vector-xor!", 13, 13);
6741 static SCM_DEFINE_SUBR(uvlib_u8vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_xorX__NAME), uvlib_u8vector_xorX, NULL, NULL);
6742
6743 static ScmObj uvlib_s16vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6744 {
6745 ScmObj v0_scm;
6746 ScmS16Vector* v0;
6747 ScmObj v1_scm;
6748 ScmObj v1;
6749 SCM_ENTER_SUBR("s16vector-and");
6750 v0_scm = SCM_ARGREF(0);
6751 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6752 v0 = SCM_S16VECTOR(v0_scm);
6753 v1_scm = SCM_ARGREF(1);
6754 v1 = (v1_scm);
6755 {
6756 SCM_RETURN(Scm_S16VectorAnd(v0, v1));
6757 }
6758 }
6759
6760 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_and__NAME, "s16vector-and", 13, 13);
6761 static SCM_DEFINE_SUBR(uvlib_s16vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_and__NAME), uvlib_s16vector_and, NULL, NULL);
6762
6763 static ScmObj uvlib_s16vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6764 {
6765 ScmObj v0_scm;
6766 ScmS16Vector* v0;
6767 ScmObj v1_scm;
6768 ScmObj v1;
6769 SCM_ENTER_SUBR("s16vector-and!");
6770 v0_scm = SCM_ARGREF(0);
6771 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6772 v0 = SCM_S16VECTOR(v0_scm);
6773 v1_scm = SCM_ARGREF(1);
6774 v1 = (v1_scm);
6775 {
6776 SCM_RETURN(Scm_S16VectorAndX(v0, v1));
6777 }
6778 }
6779
6780 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_andX__NAME, "s16vector-and!", 14, 14);
6781 static SCM_DEFINE_SUBR(uvlib_s16vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_andX__NAME), uvlib_s16vector_andX, NULL, NULL);
6782
6783 static ScmObj uvlib_s16vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6784 {
6785 ScmObj v0_scm;
6786 ScmS16Vector* v0;
6787 ScmObj v1_scm;
6788 ScmObj v1;
6789 SCM_ENTER_SUBR("s16vector-ior");
6790 v0_scm = SCM_ARGREF(0);
6791 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6792 v0 = SCM_S16VECTOR(v0_scm);
6793 v1_scm = SCM_ARGREF(1);
6794 v1 = (v1_scm);
6795 {
6796 SCM_RETURN(Scm_S16VectorIor(v0, v1));
6797 }
6798 }
6799
6800 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_ior__NAME, "s16vector-ior", 13, 13);
6801 static SCM_DEFINE_SUBR(uvlib_s16vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_ior__NAME), uvlib_s16vector_ior, NULL, NULL);
6802
6803 static ScmObj uvlib_s16vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6804 {
6805 ScmObj v0_scm;
6806 ScmS16Vector* v0;
6807 ScmObj v1_scm;
6808 ScmObj v1;
6809 SCM_ENTER_SUBR("s16vector-ior!");
6810 v0_scm = SCM_ARGREF(0);
6811 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6812 v0 = SCM_S16VECTOR(v0_scm);
6813 v1_scm = SCM_ARGREF(1);
6814 v1 = (v1_scm);
6815 {
6816 SCM_RETURN(Scm_S16VectorIorX(v0, v1));
6817 }
6818 }
6819
6820 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_iorX__NAME, "s16vector-ior!", 14, 14);
6821 static SCM_DEFINE_SUBR(uvlib_s16vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_iorX__NAME), uvlib_s16vector_iorX, NULL, NULL);
6822
6823 static ScmObj uvlib_s16vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6824 {
6825 ScmObj v0_scm;
6826 ScmS16Vector* v0;
6827 ScmObj v1_scm;
6828 ScmObj v1;
6829 SCM_ENTER_SUBR("s16vector-xor");
6830 v0_scm = SCM_ARGREF(0);
6831 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6832 v0 = SCM_S16VECTOR(v0_scm);
6833 v1_scm = SCM_ARGREF(1);
6834 v1 = (v1_scm);
6835 {
6836 SCM_RETURN(Scm_S16VectorXor(v0, v1));
6837 }
6838 }
6839
6840 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_xor__NAME, "s16vector-xor", 13, 13);
6841 static SCM_DEFINE_SUBR(uvlib_s16vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_xor__NAME), uvlib_s16vector_xor, NULL, NULL);
6842
6843 static ScmObj uvlib_s16vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6844 {
6845 ScmObj v0_scm;
6846 ScmS16Vector* v0;
6847 ScmObj v1_scm;
6848 ScmObj v1;
6849 SCM_ENTER_SUBR("s16vector-xor!");
6850 v0_scm = SCM_ARGREF(0);
6851 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6852 v0 = SCM_S16VECTOR(v0_scm);
6853 v1_scm = SCM_ARGREF(1);
6854 v1 = (v1_scm);
6855 {
6856 SCM_RETURN(Scm_S16VectorXorX(v0, v1));
6857 }
6858 }
6859
6860 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_xorX__NAME, "s16vector-xor!", 14, 14);
6861 static SCM_DEFINE_SUBR(uvlib_s16vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_xorX__NAME), uvlib_s16vector_xorX, NULL, NULL);
6862
6863 static ScmObj uvlib_u16vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6864 {
6865 ScmObj v0_scm;
6866 ScmU16Vector* v0;
6867 ScmObj v1_scm;
6868 ScmObj v1;
6869 SCM_ENTER_SUBR("u16vector-and");
6870 v0_scm = SCM_ARGREF(0);
6871 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6872 v0 = SCM_U16VECTOR(v0_scm);
6873 v1_scm = SCM_ARGREF(1);
6874 v1 = (v1_scm);
6875 {
6876 SCM_RETURN(Scm_U16VectorAnd(v0, v1));
6877 }
6878 }
6879
6880 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_and__NAME, "u16vector-and", 13, 13);
6881 static SCM_DEFINE_SUBR(uvlib_u16vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_and__NAME), uvlib_u16vector_and, NULL, NULL);
6882
6883 static ScmObj uvlib_u16vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6884 {
6885 ScmObj v0_scm;
6886 ScmU16Vector* v0;
6887 ScmObj v1_scm;
6888 ScmObj v1;
6889 SCM_ENTER_SUBR("u16vector-and!");
6890 v0_scm = SCM_ARGREF(0);
6891 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6892 v0 = SCM_U16VECTOR(v0_scm);
6893 v1_scm = SCM_ARGREF(1);
6894 v1 = (v1_scm);
6895 {
6896 SCM_RETURN(Scm_U16VectorAndX(v0, v1));
6897 }
6898 }
6899
6900 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_andX__NAME, "u16vector-and!", 14, 14);
6901 static SCM_DEFINE_SUBR(uvlib_u16vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_andX__NAME), uvlib_u16vector_andX, NULL, NULL);
6902
6903 static ScmObj uvlib_u16vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6904 {
6905 ScmObj v0_scm;
6906 ScmU16Vector* v0;
6907 ScmObj v1_scm;
6908 ScmObj v1;
6909 SCM_ENTER_SUBR("u16vector-ior");
6910 v0_scm = SCM_ARGREF(0);
6911 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6912 v0 = SCM_U16VECTOR(v0_scm);
6913 v1_scm = SCM_ARGREF(1);
6914 v1 = (v1_scm);
6915 {
6916 SCM_RETURN(Scm_U16VectorIor(v0, v1));
6917 }
6918 }
6919
6920 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_ior__NAME, "u16vector-ior", 13, 13);
6921 static SCM_DEFINE_SUBR(uvlib_u16vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_ior__NAME), uvlib_u16vector_ior, NULL, NULL);
6922
6923 static ScmObj uvlib_u16vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6924 {
6925 ScmObj v0_scm;
6926 ScmU16Vector* v0;
6927 ScmObj v1_scm;
6928 ScmObj v1;
6929 SCM_ENTER_SUBR("u16vector-ior!");
6930 v0_scm = SCM_ARGREF(0);
6931 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6932 v0 = SCM_U16VECTOR(v0_scm);
6933 v1_scm = SCM_ARGREF(1);
6934 v1 = (v1_scm);
6935 {
6936 SCM_RETURN(Scm_U16VectorIorX(v0, v1));
6937 }
6938 }
6939
6940 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_iorX__NAME, "u16vector-ior!", 14, 14);
6941 static SCM_DEFINE_SUBR(uvlib_u16vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_iorX__NAME), uvlib_u16vector_iorX, NULL, NULL);
6942
6943 static ScmObj uvlib_u16vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6944 {
6945 ScmObj v0_scm;
6946 ScmU16Vector* v0;
6947 ScmObj v1_scm;
6948 ScmObj v1;
6949 SCM_ENTER_SUBR("u16vector-xor");
6950 v0_scm = SCM_ARGREF(0);
6951 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6952 v0 = SCM_U16VECTOR(v0_scm);
6953 v1_scm = SCM_ARGREF(1);
6954 v1 = (v1_scm);
6955 {
6956 SCM_RETURN(Scm_U16VectorXor(v0, v1));
6957 }
6958 }
6959
6960 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_xor__NAME, "u16vector-xor", 13, 13);
6961 static SCM_DEFINE_SUBR(uvlib_u16vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_xor__NAME), uvlib_u16vector_xor, NULL, NULL);
6962
6963 static ScmObj uvlib_u16vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6964 {
6965 ScmObj v0_scm;
6966 ScmU16Vector* v0;
6967 ScmObj v1_scm;
6968 ScmObj v1;
6969 SCM_ENTER_SUBR("u16vector-xor!");
6970 v0_scm = SCM_ARGREF(0);
6971 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6972 v0 = SCM_U16VECTOR(v0_scm);
6973 v1_scm = SCM_ARGREF(1);
6974 v1 = (v1_scm);
6975 {
6976 SCM_RETURN(Scm_U16VectorXorX(v0, v1));
6977 }
6978 }
6979
6980 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_xorX__NAME, "u16vector-xor!", 14, 14);
6981 static SCM_DEFINE_SUBR(uvlib_u16vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_xorX__NAME), uvlib_u16vector_xorX, NULL, NULL);
6982
6983 static ScmObj uvlib_s32vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6984 {
6985 ScmObj v0_scm;
6986 ScmS32Vector* v0;
6987 ScmObj v1_scm;
6988 ScmObj v1;
6989 SCM_ENTER_SUBR("s32vector-and");
6990 v0_scm = SCM_ARGREF(0);
6991 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6992 v0 = SCM_S32VECTOR(v0_scm);
6993 v1_scm = SCM_ARGREF(1);
6994 v1 = (v1_scm);
6995 {
6996 SCM_RETURN(Scm_S32VectorAnd(v0, v1));
6997 }
6998 }
6999
7000 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_and__NAME, "s32vector-and", 13, 13);
7001 static SCM_DEFINE_SUBR(uvlib_s32vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_and__NAME), uvlib_s32vector_and, NULL, NULL);
7002
7003 static ScmObj uvlib_s32vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7004 {
7005 ScmObj v0_scm;
7006 ScmS32Vector* v0;
7007 ScmObj v1_scm;
7008 ScmObj v1;
7009 SCM_ENTER_SUBR("s32vector-and!");
7010 v0_scm = SCM_ARGREF(0);
7011 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7012 v0 = SCM_S32VECTOR(v0_scm);
7013 v1_scm = SCM_ARGREF(1);
7014 v1 = (v1_scm);
7015 {
7016 SCM_RETURN(Scm_S32VectorAndX(v0, v1));
7017 }
7018 }
7019
7020 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_andX__NAME, "s32vector-and!", 14, 14);
7021 static SCM_DEFINE_SUBR(uvlib_s32vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_andX__NAME), uvlib_s32vector_andX, NULL, NULL);
7022
7023 static ScmObj uvlib_s32vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7024 {
7025 ScmObj v0_scm;
7026 ScmS32Vector* v0;
7027 ScmObj v1_scm;
7028 ScmObj v1;
7029 SCM_ENTER_SUBR("s32vector-ior");
7030 v0_scm = SCM_ARGREF(0);
7031 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7032 v0 = SCM_S32VECTOR(v0_scm);
7033 v1_scm = SCM_ARGREF(1);
7034 v1 = (v1_scm);
7035 {
7036 SCM_RETURN(Scm_S32VectorIor(v0, v1));
7037 }
7038 }
7039
7040 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_ior__NAME, "s32vector-ior", 13, 13);
7041 static SCM_DEFINE_SUBR(uvlib_s32vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_ior__NAME), uvlib_s32vector_ior, NULL, NULL);
7042
7043 static ScmObj uvlib_s32vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7044 {
7045 ScmObj v0_scm;
7046 ScmS32Vector* v0;
7047 ScmObj v1_scm;
7048 ScmObj v1;
7049 SCM_ENTER_SUBR("s32vector-ior!");
7050 v0_scm = SCM_ARGREF(0);
7051 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7052 v0 = SCM_S32VECTOR(v0_scm);
7053 v1_scm = SCM_ARGREF(1);
7054 v1 = (v1_scm);
7055 {
7056 SCM_RETURN(Scm_S32VectorIorX(v0, v1));
7057 }
7058 }
7059
7060 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_iorX__NAME, "s32vector-ior!", 14, 14);
7061 static SCM_DEFINE_SUBR(uvlib_s32vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_iorX__NAME), uvlib_s32vector_iorX, NULL, NULL);
7062
7063 static ScmObj uvlib_s32vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7064 {
7065 ScmObj v0_scm;
7066 ScmS32Vector* v0;
7067 ScmObj v1_scm;
7068 ScmObj v1;
7069 SCM_ENTER_SUBR("s32vector-xor");
7070 v0_scm = SCM_ARGREF(0);
7071 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7072 v0 = SCM_S32VECTOR(v0_scm);
7073 v1_scm = SCM_ARGREF(1);
7074 v1 = (v1_scm);
7075 {
7076 SCM_RETURN(Scm_S32VectorXor(v0, v1));
7077 }
7078 }
7079
7080 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_xor__NAME, "s32vector-xor", 13, 13);
7081 static SCM_DEFINE_SUBR(uvlib_s32vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_xor__NAME), uvlib_s32vector_xor, NULL, NULL);
7082
7083 static ScmObj uvlib_s32vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7084 {
7085 ScmObj v0_scm;
7086 ScmS32Vector* v0;
7087 ScmObj v1_scm;
7088 ScmObj v1;
7089 SCM_ENTER_SUBR("s32vector-xor!");
7090 v0_scm = SCM_ARGREF(0);
7091 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7092 v0 = SCM_S32VECTOR(v0_scm);
7093 v1_scm = SCM_ARGREF(1);
7094 v1 = (v1_scm);
7095 {
7096 SCM_RETURN(Scm_S32VectorXorX(v0, v1));
7097 }
7098 }
7099
7100 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_xorX__NAME, "s32vector-xor!", 14, 14);
7101 static SCM_DEFINE_SUBR(uvlib_s32vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_xorX__NAME), uvlib_s32vector_xorX, NULL, NULL);
7102
7103 static ScmObj uvlib_u32vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7104 {
7105 ScmObj v0_scm;
7106 ScmU32Vector* v0;
7107 ScmObj v1_scm;
7108 ScmObj v1;
7109 SCM_ENTER_SUBR("u32vector-and");
7110 v0_scm = SCM_ARGREF(0);
7111 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7112 v0 = SCM_U32VECTOR(v0_scm);
7113 v1_scm = SCM_ARGREF(1);
7114 v1 = (v1_scm);
7115 {
7116 SCM_RETURN(Scm_U32VectorAnd(v0, v1));
7117 }
7118 }
7119
7120 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_and__NAME, "u32vector-and", 13, 13);
7121 static SCM_DEFINE_SUBR(uvlib_u32vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_and__NAME), uvlib_u32vector_and, NULL, NULL);
7122
7123 static ScmObj uvlib_u32vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7124 {
7125 ScmObj v0_scm;
7126 ScmU32Vector* v0;
7127 ScmObj v1_scm;
7128 ScmObj v1;
7129 SCM_ENTER_SUBR("u32vector-and!");
7130 v0_scm = SCM_ARGREF(0);
7131 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7132 v0 = SCM_U32VECTOR(v0_scm);
7133 v1_scm = SCM_ARGREF(1);
7134 v1 = (v1_scm);
7135 {
7136 SCM_RETURN(Scm_U32VectorAndX(v0, v1));
7137 }
7138 }
7139
7140 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_andX__NAME, "u32vector-and!", 14, 14);
7141 static SCM_DEFINE_SUBR(uvlib_u32vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_andX__NAME), uvlib_u32vector_andX, NULL, NULL);
7142
7143 static ScmObj uvlib_u32vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7144 {
7145 ScmObj v0_scm;
7146 ScmU32Vector* v0;
7147 ScmObj v1_scm;
7148 ScmObj v1;
7149 SCM_ENTER_SUBR("u32vector-ior");
7150 v0_scm = SCM_ARGREF(0);
7151 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7152 v0 = SCM_U32VECTOR(v0_scm);
7153 v1_scm = SCM_ARGREF(1);
7154 v1 = (v1_scm);
7155 {
7156 SCM_RETURN(Scm_U32VectorIor(v0, v1));
7157 }
7158 }
7159
7160 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_ior__NAME, "u32vector-ior", 13, 13);
7161 static SCM_DEFINE_SUBR(uvlib_u32vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_ior__NAME), uvlib_u32vector_ior, NULL, NULL);
7162
7163 static ScmObj uvlib_u32vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7164 {
7165 ScmObj v0_scm;
7166 ScmU32Vector* v0;
7167 ScmObj v1_scm;
7168 ScmObj v1;
7169 SCM_ENTER_SUBR("u32vector-ior!");
7170 v0_scm = SCM_ARGREF(0);
7171 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7172 v0 = SCM_U32VECTOR(v0_scm);
7173 v1_scm = SCM_ARGREF(1);
7174 v1 = (v1_scm);
7175 {
7176 SCM_RETURN(Scm_U32VectorIorX(v0, v1));
7177 }
7178 }
7179
7180 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_iorX__NAME, "u32vector-ior!", 14, 14);
7181 static SCM_DEFINE_SUBR(uvlib_u32vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_iorX__NAME), uvlib_u32vector_iorX, NULL, NULL);
7182
7183 static ScmObj uvlib_u32vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7184 {
7185 ScmObj v0_scm;
7186 ScmU32Vector* v0;
7187 ScmObj v1_scm;
7188 ScmObj v1;
7189 SCM_ENTER_SUBR("u32vector-xor");
7190 v0_scm = SCM_ARGREF(0);
7191 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7192 v0 = SCM_U32VECTOR(v0_scm);
7193 v1_scm = SCM_ARGREF(1);
7194 v1 = (v1_scm);
7195 {
7196 SCM_RETURN(Scm_U32VectorXor(v0, v1));
7197 }
7198 }
7199
7200 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_xor__NAME, "u32vector-xor", 13, 13);
7201 static SCM_DEFINE_SUBR(uvlib_u32vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_xor__NAME), uvlib_u32vector_xor, NULL, NULL);
7202
7203 static ScmObj uvlib_u32vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7204 {
7205 ScmObj v0_scm;
7206 ScmU32Vector* v0;
7207 ScmObj v1_scm;
7208 ScmObj v1;
7209 SCM_ENTER_SUBR("u32vector-xor!");
7210 v0_scm = SCM_ARGREF(0);
7211 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7212 v0 = SCM_U32VECTOR(v0_scm);
7213 v1_scm = SCM_ARGREF(1);
7214 v1 = (v1_scm);
7215 {
7216 SCM_RETURN(Scm_U32VectorXorX(v0, v1));
7217 }
7218 }
7219
7220 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_xorX__NAME, "u32vector-xor!", 14, 14);
7221 static SCM_DEFINE_SUBR(uvlib_u32vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_xorX__NAME), uvlib_u32vector_xorX, NULL, NULL);
7222
7223 static ScmObj uvlib_s64vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7224 {
7225 ScmObj v0_scm;
7226 ScmS64Vector* v0;
7227 ScmObj v1_scm;
7228 ScmObj v1;
7229 SCM_ENTER_SUBR("s64vector-and");
7230 v0_scm = SCM_ARGREF(0);
7231 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7232 v0 = SCM_S64VECTOR(v0_scm);
7233 v1_scm = SCM_ARGREF(1);
7234 v1 = (v1_scm);
7235 {
7236 SCM_RETURN(Scm_S64VectorAnd(v0, v1));
7237 }
7238 }
7239
7240 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_and__NAME, "s64vector-and", 13, 13);
7241 static SCM_DEFINE_SUBR(uvlib_s64vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_and__NAME), uvlib_s64vector_and, NULL, NULL);
7242
7243 static ScmObj uvlib_s64vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7244 {
7245 ScmObj v0_scm;
7246 ScmS64Vector* v0;
7247 ScmObj v1_scm;
7248 ScmObj v1;
7249 SCM_ENTER_SUBR("s64vector-and!");
7250 v0_scm = SCM_ARGREF(0);
7251 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7252 v0 = SCM_S64VECTOR(v0_scm);
7253 v1_scm = SCM_ARGREF(1);
7254 v1 = (v1_scm);
7255 {
7256 SCM_RETURN(Scm_S64VectorAndX(v0, v1));
7257 }
7258 }
7259
7260 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_andX__NAME, "s64vector-and!", 14, 14);
7261 static SCM_DEFINE_SUBR(uvlib_s64vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_andX__NAME), uvlib_s64vector_andX, NULL, NULL);
7262
7263 static ScmObj uvlib_s64vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7264 {
7265 ScmObj v0_scm;
7266 ScmS64Vector* v0;
7267 ScmObj v1_scm;
7268 ScmObj v1;
7269 SCM_ENTER_SUBR("s64vector-ior");
7270 v0_scm = SCM_ARGREF(0);
7271 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7272 v0 = SCM_S64VECTOR(v0_scm);
7273 v1_scm = SCM_ARGREF(1);
7274 v1 = (v1_scm);
7275 {
7276 SCM_RETURN(Scm_S64VectorIor(v0, v1));
7277 }
7278 }
7279
7280 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_ior__NAME, "s64vector-ior", 13, 13);
7281 static SCM_DEFINE_SUBR(uvlib_s64vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_ior__NAME), uvlib_s64vector_ior, NULL, NULL);
7282
7283 static ScmObj uvlib_s64vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7284 {
7285 ScmObj v0_scm;
7286 ScmS64Vector* v0;
7287 ScmObj v1_scm;
7288 ScmObj v1;
7289 SCM_ENTER_SUBR("s64vector-ior!");
7290 v0_scm = SCM_ARGREF(0);
7291 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7292 v0 = SCM_S64VECTOR(v0_scm);
7293 v1_scm = SCM_ARGREF(1);
7294 v1 = (v1_scm);
7295 {
7296 SCM_RETURN(Scm_S64VectorIorX(v0, v1));
7297 }
7298 }
7299
7300 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_iorX__NAME, "s64vector-ior!", 14, 14);
7301 static SCM_DEFINE_SUBR(uvlib_s64vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_iorX__NAME), uvlib_s64vector_iorX, NULL, NULL);
7302
7303 static ScmObj uvlib_s64vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7304 {
7305 ScmObj v0_scm;
7306 ScmS64Vector* v0;
7307 ScmObj v1_scm;
7308 ScmObj v1;
7309 SCM_ENTER_SUBR("s64vector-xor");
7310 v0_scm = SCM_ARGREF(0);
7311 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7312 v0 = SCM_S64VECTOR(v0_scm);
7313 v1_scm = SCM_ARGREF(1);
7314 v1 = (v1_scm);
7315 {
7316 SCM_RETURN(Scm_S64VectorXor(v0, v1));
7317 }
7318 }
7319
7320 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_xor__NAME, "s64vector-xor", 13, 13);
7321 static SCM_DEFINE_SUBR(uvlib_s64vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_xor__NAME), uvlib_s64vector_xor, NULL, NULL);
7322
7323 static ScmObj uvlib_s64vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7324 {
7325 ScmObj v0_scm;
7326 ScmS64Vector* v0;
7327 ScmObj v1_scm;
7328 ScmObj v1;
7329 SCM_ENTER_SUBR("s64vector-xor!");
7330 v0_scm = SCM_ARGREF(0);
7331 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7332 v0 = SCM_S64VECTOR(v0_scm);
7333 v1_scm = SCM_ARGREF(1);
7334 v1 = (v1_scm);
7335 {
7336 SCM_RETURN(Scm_S64VectorXorX(v0, v1));
7337 }
7338 }
7339
7340 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_xorX__NAME, "s64vector-xor!", 14, 14);
7341 static SCM_DEFINE_SUBR(uvlib_s64vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_xorX__NAME), uvlib_s64vector_xorX, NULL, NULL);
7342
7343 static ScmObj uvlib_u64vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7344 {
7345 ScmObj v0_scm;
7346 ScmU64Vector* v0;
7347 ScmObj v1_scm;
7348 ScmObj v1;
7349 SCM_ENTER_SUBR("u64vector-and");
7350 v0_scm = SCM_ARGREF(0);
7351 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7352 v0 = SCM_U64VECTOR(v0_scm);
7353 v1_scm = SCM_ARGREF(1);
7354 v1 = (v1_scm);
7355 {
7356 SCM_RETURN(Scm_U64VectorAnd(v0, v1));
7357 }
7358 }
7359
7360 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_and__NAME, "u64vector-and", 13, 13);
7361 static SCM_DEFINE_SUBR(uvlib_u64vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_and__NAME), uvlib_u64vector_and, NULL, NULL);
7362
7363 static ScmObj uvlib_u64vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7364 {
7365 ScmObj v0_scm;
7366 ScmU64Vector* v0;
7367 ScmObj v1_scm;
7368 ScmObj v1;
7369 SCM_ENTER_SUBR("u64vector-and!");
7370 v0_scm = SCM_ARGREF(0);
7371 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7372 v0 = SCM_U64VECTOR(v0_scm);
7373 v1_scm = SCM_ARGREF(1);
7374 v1 = (v1_scm);
7375 {
7376 SCM_RETURN(Scm_U64VectorAndX(v0, v1));
7377 }
7378 }
7379
7380 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_andX__NAME, "u64vector-and!", 14, 14);
7381 static SCM_DEFINE_SUBR(uvlib_u64vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_andX__NAME), uvlib_u64vector_andX, NULL, NULL);
7382
7383 static ScmObj uvlib_u64vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7384 {
7385 ScmObj v0_scm;
7386 ScmU64Vector* v0;
7387 ScmObj v1_scm;
7388 ScmObj v1;
7389 SCM_ENTER_SUBR("u64vector-ior");
7390 v0_scm = SCM_ARGREF(0);
7391 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7392 v0 = SCM_U64VECTOR(v0_scm);
7393 v1_scm = SCM_ARGREF(1);
7394 v1 = (v1_scm);
7395 {
7396 SCM_RETURN(Scm_U64VectorIor(v0, v1));
7397 }
7398 }
7399
7400 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_ior__NAME, "u64vector-ior", 13, 13);
7401 static SCM_DEFINE_SUBR(uvlib_u64vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_ior__NAME), uvlib_u64vector_ior, NULL, NULL);
7402
7403 static ScmObj uvlib_u64vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7404 {
7405 ScmObj v0_scm;
7406 ScmU64Vector* v0;
7407 ScmObj v1_scm;
7408 ScmObj v1;
7409 SCM_ENTER_SUBR("u64vector-ior!");
7410 v0_scm = SCM_ARGREF(0);
7411 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7412 v0 = SCM_U64VECTOR(v0_scm);
7413 v1_scm = SCM_ARGREF(1);
7414 v1 = (v1_scm);
7415 {
7416 SCM_RETURN(Scm_U64VectorIorX(v0, v1));
7417 }
7418 }
7419
7420 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_iorX__NAME, "u64vector-ior!", 14, 14);
7421 static SCM_DEFINE_SUBR(uvlib_u64vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_iorX__NAME), uvlib_u64vector_iorX, NULL, NULL);
7422
7423 static ScmObj uvlib_u64vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7424 {
7425 ScmObj v0_scm;
7426 ScmU64Vector* v0;
7427 ScmObj v1_scm;
7428 ScmObj v1;
7429 SCM_ENTER_SUBR("u64vector-xor");
7430 v0_scm = SCM_ARGREF(0);
7431 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7432 v0 = SCM_U64VECTOR(v0_scm);
7433 v1_scm = SCM_ARGREF(1);
7434 v1 = (v1_scm);
7435 {
7436 SCM_RETURN(Scm_U64VectorXor(v0, v1));
7437 }
7438 }
7439
7440 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_xor__NAME, "u64vector-xor", 13, 13);
7441 static SCM_DEFINE_SUBR(uvlib_u64vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_xor__NAME), uvlib_u64vector_xor, NULL, NULL);
7442
7443 static ScmObj uvlib_u64vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7444 {
7445 ScmObj v0_scm;
7446 ScmU64Vector* v0;
7447 ScmObj v1_scm;
7448 ScmObj v1;
7449 SCM_ENTER_SUBR("u64vector-xor!");
7450 v0_scm = SCM_ARGREF(0);
7451 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7452 v0 = SCM_U64VECTOR(v0_scm);
7453 v1_scm = SCM_ARGREF(1);
7454 v1 = (v1_scm);
7455 {
7456 SCM_RETURN(Scm_U64VectorXorX(v0, v1));
7457 }
7458 }
7459
7460 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_xorX__NAME, "u64vector-xor!", 14, 14);
7461 static SCM_DEFINE_SUBR(uvlib_u64vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_xorX__NAME), uvlib_u64vector_xorX, NULL, NULL);
7462
7463 static ScmObj uvlib_s8vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7464 {
7465 ScmObj v0_scm;
7466 ScmS8Vector* v0;
7467 ScmObj v1_scm;
7468 ScmObj v1;
7469 SCM_ENTER_SUBR("s8vector-dot");
7470 v0_scm = SCM_ARGREF(0);
7471 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7472 v0 = SCM_S8VECTOR(v0_scm);
7473 v1_scm = SCM_ARGREF(1);
7474 v1 = (v1_scm);
7475 {
7476 {
7477 ScmObj SCM_RESULT;
7478 SCM_RESULT = Scm_S8VectorDotProd(v0, v1);
7479 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7480 }
7481 }
7482 }
7483
7484 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_dot__NAME, "s8vector-dot", 12, 12);
7485 static SCM_DEFINE_SUBR(uvlib_s8vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_dot__NAME), uvlib_s8vector_dot, NULL, NULL);
7486
7487 static ScmObj uvlib_u8vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7488 {
7489 ScmObj v0_scm;
7490 ScmU8Vector* v0;
7491 ScmObj v1_scm;
7492 ScmObj v1;
7493 SCM_ENTER_SUBR("u8vector-dot");
7494 v0_scm = SCM_ARGREF(0);
7495 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7496 v0 = SCM_U8VECTOR(v0_scm);
7497 v1_scm = SCM_ARGREF(1);
7498 v1 = (v1_scm);
7499 {
7500 {
7501 ScmObj SCM_RESULT;
7502 SCM_RESULT = Scm_U8VectorDotProd(v0, v1);
7503 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7504 }
7505 }
7506 }
7507
7508 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_dot__NAME, "u8vector-dot", 12, 12);
7509 static SCM_DEFINE_SUBR(uvlib_u8vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_dot__NAME), uvlib_u8vector_dot, NULL, NULL);
7510
7511 static ScmObj uvlib_s16vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7512 {
7513 ScmObj v0_scm;
7514 ScmS16Vector* v0;
7515 ScmObj v1_scm;
7516 ScmObj v1;
7517 SCM_ENTER_SUBR("s16vector-dot");
7518 v0_scm = SCM_ARGREF(0);
7519 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7520 v0 = SCM_S16VECTOR(v0_scm);
7521 v1_scm = SCM_ARGREF(1);
7522 v1 = (v1_scm);
7523 {
7524 {
7525 ScmObj SCM_RESULT;
7526 SCM_RESULT = Scm_S16VectorDotProd(v0, v1);
7527 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7528 }
7529 }
7530 }
7531
7532 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_dot__NAME, "s16vector-dot", 13, 13);
7533 static SCM_DEFINE_SUBR(uvlib_s16vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_dot__NAME), uvlib_s16vector_dot, NULL, NULL);
7534
7535 static ScmObj uvlib_u16vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7536 {
7537 ScmObj v0_scm;
7538 ScmU16Vector* v0;
7539 ScmObj v1_scm;
7540 ScmObj v1;
7541 SCM_ENTER_SUBR("u16vector-dot");
7542 v0_scm = SCM_ARGREF(0);
7543 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7544 v0 = SCM_U16VECTOR(v0_scm);
7545 v1_scm = SCM_ARGREF(1);
7546 v1 = (v1_scm);
7547 {
7548 {
7549 ScmObj SCM_RESULT;
7550 SCM_RESULT = Scm_U16VectorDotProd(v0, v1);
7551 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7552 }
7553 }
7554 }
7555
7556 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_dot__NAME, "u16vector-dot", 13, 13);
7557 static SCM_DEFINE_SUBR(uvlib_u16vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_dot__NAME), uvlib_u16vector_dot, NULL, NULL);
7558
7559 static ScmObj uvlib_s32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7560 {
7561 ScmObj v0_scm;
7562 ScmS32Vector* v0;
7563 ScmObj v1_scm;
7564 ScmObj v1;
7565 SCM_ENTER_SUBR("s32vector-dot");
7566 v0_scm = SCM_ARGREF(0);
7567 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7568 v0 = SCM_S32VECTOR(v0_scm);
7569 v1_scm = SCM_ARGREF(1);
7570 v1 = (v1_scm);
7571 {
7572 {
7573 ScmObj SCM_RESULT;
7574 SCM_RESULT = Scm_S32VectorDotProd(v0, v1);
7575 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7576 }
7577 }
7578 }
7579
7580 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_dot__NAME, "s32vector-dot", 13, 13);
7581 static SCM_DEFINE_SUBR(uvlib_s32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_dot__NAME), uvlib_s32vector_dot, NULL, NULL);
7582
7583 static ScmObj uvlib_u32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7584 {
7585 ScmObj v0_scm;
7586 ScmU32Vector* v0;
7587 ScmObj v1_scm;
7588 ScmObj v1;
7589 SCM_ENTER_SUBR("u32vector-dot");
7590 v0_scm = SCM_ARGREF(0);
7591 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7592 v0 = SCM_U32VECTOR(v0_scm);
7593 v1_scm = SCM_ARGREF(1);
7594 v1 = (v1_scm);
7595 {
7596 {
7597 ScmObj SCM_RESULT;
7598 SCM_RESULT = Scm_U32VectorDotProd(v0, v1);
7599 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7600 }
7601 }
7602 }
7603
7604 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_dot__NAME, "u32vector-dot", 13, 13);
7605 static SCM_DEFINE_SUBR(uvlib_u32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_dot__NAME), uvlib_u32vector_dot, NULL, NULL);
7606
7607 static ScmObj uvlib_s64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7608 {
7609 ScmObj v0_scm;
7610 ScmS64Vector* v0;
7611 ScmObj v1_scm;
7612 ScmObj v1;
7613 SCM_ENTER_SUBR("s64vector-dot");
7614 v0_scm = SCM_ARGREF(0);
7615 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7616 v0 = SCM_S64VECTOR(v0_scm);
7617 v1_scm = SCM_ARGREF(1);
7618 v1 = (v1_scm);
7619 {
7620 {
7621 ScmObj SCM_RESULT;
7622 SCM_RESULT = Scm_S64VectorDotProd(v0, v1);
7623 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7624 }
7625 }
7626 }
7627
7628 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_dot__NAME, "s64vector-dot", 13, 13);
7629 static SCM_DEFINE_SUBR(uvlib_s64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_dot__NAME), uvlib_s64vector_dot, NULL, NULL);
7630
7631 static ScmObj uvlib_u64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7632 {
7633 ScmObj v0_scm;
7634 ScmU64Vector* v0;
7635 ScmObj v1_scm;
7636 ScmObj v1;
7637 SCM_ENTER_SUBR("u64vector-dot");
7638 v0_scm = SCM_ARGREF(0);
7639 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7640 v0 = SCM_U64VECTOR(v0_scm);
7641 v1_scm = SCM_ARGREF(1);
7642 v1 = (v1_scm);
7643 {
7644 {
7645 ScmObj SCM_RESULT;
7646 SCM_RESULT = Scm_U64VectorDotProd(v0, v1);
7647 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7648 }
7649 }
7650 }
7651
7652 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_dot__NAME, "u64vector-dot", 13, 13);
7653 static SCM_DEFINE_SUBR(uvlib_u64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_dot__NAME), uvlib_u64vector_dot, NULL, NULL);
7654
7655 static ScmObj uvlib_f32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7656 {
7657 ScmObj v0_scm;
7658 ScmF32Vector* v0;
7659 ScmObj v1_scm;
7660 ScmObj v1;
7661 SCM_ENTER_SUBR("f32vector-dot");
7662 v0_scm = SCM_ARGREF(0);
7663 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
7664 v0 = SCM_F32VECTOR(v0_scm);
7665 v1_scm = SCM_ARGREF(1);
7666 v1 = (v1_scm);
7667 {
7668 {
7669 ScmObj SCM_RESULT;
7670 SCM_RESULT = Scm_F32VectorDotProd(v0, v1);
7671 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7672 }
7673 }
7674 }
7675
7676 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_dot__NAME, "f32vector-dot", 13, 13);
7677 static SCM_DEFINE_SUBR(uvlib_f32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_f32vector_dot__NAME), uvlib_f32vector_dot, NULL, NULL);
7678
7679 static ScmObj uvlib_f64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7680 {
7681 ScmObj v0_scm;
7682 ScmF64Vector* v0;
7683 ScmObj v1_scm;
7684 ScmObj v1;
7685 SCM_ENTER_SUBR("f64vector-dot");
7686 v0_scm = SCM_ARGREF(0);
7687 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
7688 v0 = SCM_F64VECTOR(v0_scm);
7689 v1_scm = SCM_ARGREF(1);
7690 v1 = (v1_scm);
7691 {
7692 {
7693 ScmObj SCM_RESULT;
7694 SCM_RESULT = Scm_F64VectorDotProd(v0, v1);
7695 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7696 }
7697 }
7698 }
7699
7700 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_dot__NAME, "f64vector-dot", 13, 13);
7701 static SCM_DEFINE_SUBR(uvlib_f64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_f64vector_dot__NAME), uvlib_f64vector_dot, NULL, NULL);
7702
7703 static ScmObj uvlib_s8vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7704 {
7705 ScmObj v0_scm;
7706 ScmS8Vector* v0;
7707 ScmObj min_scm;
7708 ScmObj min;
7709 ScmObj max_scm;
7710 ScmObj max;
7711 SCM_ENTER_SUBR("s8vector-range-check");
7712 v0_scm = SCM_ARGREF(0);
7713 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7714 v0 = SCM_S8VECTOR(v0_scm);
7715 min_scm = SCM_ARGREF(1);
7716 min = (min_scm);
7717 max_scm = SCM_ARGREF(2);
7718 max = (max_scm);
7719 {
7720 {
7721 ScmObj SCM_RESULT;
7722 SCM_RESULT = Scm_S8VectorRangeCheck(v0, min, max);
7723 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7724 }
7725 }
7726 }
7727
7728 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_range_check__NAME, "s8vector-range-check", 20, 20);
7729 static SCM_DEFINE_SUBR(uvlib_s8vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_range_check__NAME), uvlib_s8vector_range_check, NULL, NULL);
7730
7731 static ScmObj uvlib_s8vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7732 {
7733 ScmObj v0_scm;
7734 ScmS8Vector* v0;
7735 ScmObj min_scm;
7736 ScmObj min;
7737 ScmObj max_scm;
7738 ScmObj max;
7739 SCM_ENTER_SUBR("s8vector-clamp");
7740 v0_scm = SCM_ARGREF(0);
7741 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7742 v0 = SCM_S8VECTOR(v0_scm);
7743 min_scm = SCM_ARGREF(1);
7744 min = (min_scm);
7745 max_scm = SCM_ARGREF(2);
7746 max = (max_scm);
7747 {
7748 {
7749 ScmObj SCM_RESULT;
7750 SCM_RESULT = Scm_S8VectorClamp(v0, min, max);
7751 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7752 }
7753 }
7754 }
7755
7756 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_clamp__NAME, "s8vector-clamp", 14, 14);
7757 static SCM_DEFINE_SUBR(uvlib_s8vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_clamp__NAME), uvlib_s8vector_clamp, NULL, NULL);
7758
7759 static ScmObj uvlib_s8vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7760 {
7761 ScmObj v0_scm;
7762 ScmS8Vector* v0;
7763 ScmObj min_scm;
7764 ScmObj min;
7765 ScmObj max_scm;
7766 ScmObj max;
7767 SCM_ENTER_SUBR("s8vector-clamp!");
7768 v0_scm = SCM_ARGREF(0);
7769 if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7770 v0 = SCM_S8VECTOR(v0_scm);
7771 min_scm = SCM_ARGREF(1);
7772 min = (min_scm);
7773 max_scm = SCM_ARGREF(2);
7774 max = (max_scm);
7775 {
7776 {
7777 ScmObj SCM_RESULT;
7778 SCM_RESULT = Scm_S8VectorClampX(v0, min, max);
7779 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7780 }
7781 }
7782 }
7783
7784 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_clampX__NAME, "s8vector-clamp!", 15, 15);
7785 static SCM_DEFINE_SUBR(uvlib_s8vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_clampX__NAME), uvlib_s8vector_clampX, NULL, NULL);
7786
7787 static ScmObj uvlib_u8vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7788 {
7789 ScmObj v0_scm;
7790 ScmU8Vector* v0;
7791 ScmObj min_scm;
7792 ScmObj min;
7793 ScmObj max_scm;
7794 ScmObj max;
7795 SCM_ENTER_SUBR("u8vector-range-check");
7796 v0_scm = SCM_ARGREF(0);
7797 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7798 v0 = SCM_U8VECTOR(v0_scm);
7799 min_scm = SCM_ARGREF(1);
7800 min = (min_scm);
7801 max_scm = SCM_ARGREF(2);
7802 max = (max_scm);
7803 {
7804 {
7805 ScmObj SCM_RESULT;
7806 SCM_RESULT = Scm_U8VectorRangeCheck(v0, min, max);
7807 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7808 }
7809 }
7810 }
7811
7812 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_range_check__NAME, "u8vector-range-check", 20, 20);
7813 static SCM_DEFINE_SUBR(uvlib_u8vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_range_check__NAME), uvlib_u8vector_range_check, NULL, NULL);
7814
7815 static ScmObj uvlib_u8vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7816 {
7817 ScmObj v0_scm;
7818 ScmU8Vector* v0;
7819 ScmObj min_scm;
7820 ScmObj min;
7821 ScmObj max_scm;
7822 ScmObj max;
7823 SCM_ENTER_SUBR("u8vector-clamp");
7824 v0_scm = SCM_ARGREF(0);
7825 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7826 v0 = SCM_U8VECTOR(v0_scm);
7827 min_scm = SCM_ARGREF(1);
7828 min = (min_scm);
7829 max_scm = SCM_ARGREF(2);
7830 max = (max_scm);
7831 {
7832 {
7833 ScmObj SCM_RESULT;
7834 SCM_RESULT = Scm_U8VectorClamp(v0, min, max);
7835 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7836 }
7837 }
7838 }
7839
7840 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_clamp__NAME, "u8vector-clamp", 14, 14);
7841 static SCM_DEFINE_SUBR(uvlib_u8vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_clamp__NAME), uvlib_u8vector_clamp, NULL, NULL);
7842
7843 static ScmObj uvlib_u8vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7844 {
7845 ScmObj v0_scm;
7846 ScmU8Vector* v0;
7847 ScmObj min_scm;
7848 ScmObj min;
7849 ScmObj max_scm;
7850 ScmObj max;
7851 SCM_ENTER_SUBR("u8vector-clamp!");
7852 v0_scm = SCM_ARGREF(0);
7853 if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7854 v0 = SCM_U8VECTOR(v0_scm);
7855 min_scm = SCM_ARGREF(1);
7856 min = (min_scm);
7857 max_scm = SCM_ARGREF(2);
7858 max = (max_scm);
7859 {
7860 {
7861 ScmObj SCM_RESULT;
7862 SCM_RESULT = Scm_U8VectorClampX(v0, min, max);
7863 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7864 }
7865 }
7866 }
7867
7868 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_clampX__NAME, "u8vector-clamp!", 15, 15);
7869 static SCM_DEFINE_SUBR(uvlib_u8vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_clampX__NAME), uvlib_u8vector_clampX, NULL, NULL);
7870
7871 static ScmObj uvlib_s16vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7872 {
7873 ScmObj v0_scm;
7874 ScmS16Vector* v0;
7875 ScmObj min_scm;
7876 ScmObj min;
7877 ScmObj max_scm;
7878 ScmObj max;
7879 SCM_ENTER_SUBR("s16vector-range-check");
7880 v0_scm = SCM_ARGREF(0);
7881 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7882 v0 = SCM_S16VECTOR(v0_scm);
7883 min_scm = SCM_ARGREF(1);
7884 min = (min_scm);
7885 max_scm = SCM_ARGREF(2);
7886 max = (max_scm);
7887 {
7888 {
7889 ScmObj SCM_RESULT;
7890 SCM_RESULT = Scm_S16VectorRangeCheck(v0, min, max);
7891 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7892 }
7893 }
7894 }
7895
7896 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_range_check__NAME, "s16vector-range-check", 21, 21);
7897 static SCM_DEFINE_SUBR(uvlib_s16vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_range_check__NAME), uvlib_s16vector_range_check, NULL, NULL);
7898
7899 static ScmObj uvlib_s16vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7900 {
7901 ScmObj v0_scm;
7902 ScmS16Vector* v0;
7903 ScmObj min_scm;
7904 ScmObj min;
7905 ScmObj max_scm;
7906 ScmObj max;
7907 SCM_ENTER_SUBR("s16vector-clamp");
7908 v0_scm = SCM_ARGREF(0);
7909 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7910 v0 = SCM_S16VECTOR(v0_scm);
7911 min_scm = SCM_ARGREF(1);
7912 min = (min_scm);
7913 max_scm = SCM_ARGREF(2);
7914 max = (max_scm);
7915 {
7916 {
7917 ScmObj SCM_RESULT;
7918 SCM_RESULT = Scm_S16VectorClamp(v0, min, max);
7919 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7920 }
7921 }
7922 }
7923
7924 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_clamp__NAME, "s16vector-clamp", 15, 15);
7925 static SCM_DEFINE_SUBR(uvlib_s16vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_clamp__NAME), uvlib_s16vector_clamp, NULL, NULL);
7926
7927 static ScmObj uvlib_s16vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7928 {
7929 ScmObj v0_scm;
7930 ScmS16Vector* v0;
7931 ScmObj min_scm;
7932 ScmObj min;
7933 ScmObj max_scm;
7934 ScmObj max;
7935 SCM_ENTER_SUBR("s16vector-clamp!");
7936 v0_scm = SCM_ARGREF(0);
7937 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7938 v0 = SCM_S16VECTOR(v0_scm);
7939 min_scm = SCM_ARGREF(1);
7940 min = (min_scm);
7941 max_scm = SCM_ARGREF(2);
7942 max = (max_scm);
7943 {
7944 {
7945 ScmObj SCM_RESULT;
7946 SCM_RESULT = Scm_S16VectorClampX(v0, min, max);
7947 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7948 }
7949 }
7950 }
7951
7952 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_clampX__NAME, "s16vector-clamp!", 16, 16);
7953 static SCM_DEFINE_SUBR(uvlib_s16vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_clampX__NAME), uvlib_s16vector_clampX, NULL, NULL);
7954
7955 static ScmObj uvlib_u16vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7956 {
7957 ScmObj v0_scm;
7958 ScmU16Vector* v0;
7959 ScmObj min_scm;
7960 ScmObj min;
7961 ScmObj max_scm;
7962 ScmObj max;
7963 SCM_ENTER_SUBR("u16vector-range-check");
7964 v0_scm = SCM_ARGREF(0);
7965 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7966 v0 = SCM_U16VECTOR(v0_scm);
7967 min_scm = SCM_ARGREF(1);
7968 min = (min_scm);
7969 max_scm = SCM_ARGREF(2);
7970 max = (max_scm);
7971 {
7972 {
7973 ScmObj SCM_RESULT;
7974 SCM_RESULT = Scm_U16VectorRangeCheck(v0, min, max);
7975 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7976 }
7977 }
7978 }
7979
7980 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_range_check__NAME, "u16vector-range-check", 21, 21);
7981 static SCM_DEFINE_SUBR(uvlib_u16vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_range_check__NAME), uvlib_u16vector_range_check, NULL, NULL);
7982
7983 static ScmObj uvlib_u16vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7984 {
7985 ScmObj v0_scm;
7986 ScmU16Vector* v0;
7987 ScmObj min_scm;
7988 ScmObj min;
7989 ScmObj max_scm;
7990 ScmObj max;
7991 SCM_ENTER_SUBR("u16vector-clamp");
7992 v0_scm = SCM_ARGREF(0);
7993 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7994 v0 = SCM_U16VECTOR(v0_scm);
7995 min_scm = SCM_ARGREF(1);
7996 min = (min_scm);
7997 max_scm = SCM_ARGREF(2);
7998 max = (max_scm);
7999 {
8000 {
8001 ScmObj SCM_RESULT;
8002 SCM_RESULT = Scm_U16VectorClamp(v0, min, max);
8003 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8004 }
8005 }
8006 }
8007
8008 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_clamp__NAME, "u16vector-clamp", 15, 15);
8009 static SCM_DEFINE_SUBR(uvlib_u16vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_clamp__NAME), uvlib_u16vector_clamp, NULL, NULL);
8010
8011 static ScmObj uvlib_u16vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8012 {
8013 ScmObj v0_scm;
8014 ScmU16Vector* v0;
8015 ScmObj min_scm;
8016 ScmObj min;
8017 ScmObj max_scm;
8018 ScmObj max;
8019 SCM_ENTER_SUBR("u16vector-clamp!");
8020 v0_scm = SCM_ARGREF(0);
8021 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8022 v0 = SCM_U16VECTOR(v0_scm);
8023 min_scm = SCM_ARGREF(1);
8024 min = (min_scm);
8025 max_scm = SCM_ARGREF(2);
8026 max = (max_scm);
8027 {
8028 {
8029 ScmObj SCM_RESULT;
8030 SCM_RESULT = Scm_U16VectorClampX(v0, min, max);
8031 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8032 }
8033 }
8034 }
8035
8036 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_clampX__NAME, "u16vector-clamp!", 16, 16);
8037 static SCM_DEFINE_SUBR(uvlib_u16vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_clampX__NAME), uvlib_u16vector_clampX, NULL, NULL);
8038
8039 static ScmObj uvlib_s32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8040 {
8041 ScmObj v0_scm;
8042 ScmS32Vector* v0;
8043 ScmObj min_scm;
8044 ScmObj min;
8045 ScmObj max_scm;
8046 ScmObj max;
8047 SCM_ENTER_SUBR("s32vector-range-check");
8048 v0_scm = SCM_ARGREF(0);
8049 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8050 v0 = SCM_S32VECTOR(v0_scm);
8051 min_scm = SCM_ARGREF(1);
8052 min = (min_scm);
8053 max_scm = SCM_ARGREF(2);
8054 max = (max_scm);
8055 {
8056 {
8057 ScmObj SCM_RESULT;
8058 SCM_RESULT = Scm_S32VectorRangeCheck(v0, min, max);
8059 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8060 }
8061 }
8062 }
8063
8064 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_range_check__NAME, "s32vector-range-check", 21, 21);
8065 static SCM_DEFINE_SUBR(uvlib_s32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_range_check__NAME), uvlib_s32vector_range_check, NULL, NULL);
8066
8067 static ScmObj uvlib_s32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8068 {
8069 ScmObj v0_scm;
8070 ScmS32Vector* v0;
8071 ScmObj min_scm;
8072 ScmObj min;
8073 ScmObj max_scm;
8074 ScmObj max;
8075 SCM_ENTER_SUBR("s32vector-clamp");
8076 v0_scm = SCM_ARGREF(0);
8077 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8078 v0 = SCM_S32VECTOR(v0_scm);
8079 min_scm = SCM_ARGREF(1);
8080 min = (min_scm);
8081 max_scm = SCM_ARGREF(2);
8082 max = (max_scm);
8083 {
8084 {
8085 ScmObj SCM_RESULT;
8086 SCM_RESULT = Scm_S32VectorClamp(v0, min, max);
8087 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8088 }
8089 }
8090 }
8091
8092 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_clamp__NAME, "s32vector-clamp", 15, 15);
8093 static SCM_DEFINE_SUBR(uvlib_s32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_clamp__NAME), uvlib_s32vector_clamp, NULL, NULL);
8094
8095 static ScmObj uvlib_s32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8096 {
8097 ScmObj v0_scm;
8098 ScmS32Vector* v0;
8099 ScmObj min_scm;
8100 ScmObj min;
8101 ScmObj max_scm;
8102 ScmObj max;
8103 SCM_ENTER_SUBR("s32vector-clamp!");
8104 v0_scm = SCM_ARGREF(0);
8105 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8106 v0 = SCM_S32VECTOR(v0_scm);
8107 min_scm = SCM_ARGREF(1);
8108 min = (min_scm);
8109 max_scm = SCM_ARGREF(2);
8110 max = (max_scm);
8111 {
8112 {
8113 ScmObj SCM_RESULT;
8114 SCM_RESULT = Scm_S32VectorClampX(v0, min, max);
8115 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8116 }
8117 }
8118 }
8119
8120 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_clampX__NAME, "s32vector-clamp!", 16, 16);
8121 static SCM_DEFINE_SUBR(uvlib_s32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_clampX__NAME), uvlib_s32vector_clampX, NULL, NULL);
8122
8123 static ScmObj uvlib_u32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8124 {
8125 ScmObj v0_scm;
8126 ScmU32Vector* v0;
8127 ScmObj min_scm;
8128 ScmObj min;
8129 ScmObj max_scm;
8130 ScmObj max;
8131 SCM_ENTER_SUBR("u32vector-range-check");
8132 v0_scm = SCM_ARGREF(0);
8133 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8134 v0 = SCM_U32VECTOR(v0_scm);
8135 min_scm = SCM_ARGREF(1);
8136 min = (min_scm);
8137 max_scm = SCM_ARGREF(2);
8138 max = (max_scm);
8139 {
8140 {
8141 ScmObj SCM_RESULT;
8142 SCM_RESULT = Scm_U32VectorRangeCheck(v0, min, max);
8143 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8144 }
8145 }
8146 }
8147
8148 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_range_check__NAME, "u32vector-range-check", 21, 21);
8149 static SCM_DEFINE_SUBR(uvlib_u32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_range_check__NAME), uvlib_u32vector_range_check, NULL, NULL);
8150
8151 static ScmObj uvlib_u32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8152 {
8153 ScmObj v0_scm;
8154 ScmU32Vector* v0;
8155 ScmObj min_scm;
8156 ScmObj min;
8157 ScmObj max_scm;
8158 ScmObj max;
8159 SCM_ENTER_SUBR("u32vector-clamp");
8160 v0_scm = SCM_ARGREF(0);
8161 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8162 v0 = SCM_U32VECTOR(v0_scm);
8163 min_scm = SCM_ARGREF(1);
8164 min = (min_scm);
8165 max_scm = SCM_ARGREF(2);
8166 max = (max_scm);
8167 {
8168 {
8169 ScmObj SCM_RESULT;
8170 SCM_RESULT = Scm_U32VectorClamp(v0, min, max);
8171 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8172 }
8173 }
8174 }
8175
8176 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_clamp__NAME, "u32vector-clamp", 15, 15);
8177 static SCM_DEFINE_SUBR(uvlib_u32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_clamp__NAME), uvlib_u32vector_clamp, NULL, NULL);
8178
8179 static ScmObj uvlib_u32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8180 {
8181 ScmObj v0_scm;
8182 ScmU32Vector* v0;
8183 ScmObj min_scm;
8184 ScmObj min;
8185 ScmObj max_scm;
8186 ScmObj max;
8187 SCM_ENTER_SUBR("u32vector-clamp!");
8188 v0_scm = SCM_ARGREF(0);
8189 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8190 v0 = SCM_U32VECTOR(v0_scm);
8191 min_scm = SCM_ARGREF(1);
8192 min = (min_scm);
8193 max_scm = SCM_ARGREF(2);
8194 max = (max_scm);
8195 {
8196 {
8197 ScmObj SCM_RESULT;
8198 SCM_RESULT = Scm_U32VectorClampX(v0, min, max);
8199 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8200 }
8201 }
8202 }
8203
8204 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_clampX__NAME, "u32vector-clamp!", 16, 16);
8205 static SCM_DEFINE_SUBR(uvlib_u32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_clampX__NAME), uvlib_u32vector_clampX, NULL, NULL);
8206
8207 static ScmObj uvlib_s64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8208 {
8209 ScmObj v0_scm;
8210 ScmS64Vector* v0;
8211 ScmObj min_scm;
8212 ScmObj min;
8213 ScmObj max_scm;
8214 ScmObj max;
8215 SCM_ENTER_SUBR("s64vector-range-check");
8216 v0_scm = SCM_ARGREF(0);
8217 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8218 v0 = SCM_S64VECTOR(v0_scm);
8219 min_scm = SCM_ARGREF(1);
8220 min = (min_scm);
8221 max_scm = SCM_ARGREF(2);
8222 max = (max_scm);
8223 {
8224 {
8225 ScmObj SCM_RESULT;
8226 SCM_RESULT = Scm_S64VectorRangeCheck(v0, min, max);
8227 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8228 }
8229 }
8230 }
8231
8232 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_range_check__NAME, "s64vector-range-check", 21, 21);
8233 static SCM_DEFINE_SUBR(uvlib_s64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_range_check__NAME), uvlib_s64vector_range_check, NULL, NULL);
8234
8235 static ScmObj uvlib_s64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8236 {
8237 ScmObj v0_scm;
8238 ScmS64Vector* v0;
8239 ScmObj min_scm;
8240 ScmObj min;
8241 ScmObj max_scm;
8242 ScmObj max;
8243 SCM_ENTER_SUBR("s64vector-clamp");
8244 v0_scm = SCM_ARGREF(0);
8245 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8246 v0 = SCM_S64VECTOR(v0_scm);
8247 min_scm = SCM_ARGREF(1);
8248 min = (min_scm);
8249 max_scm = SCM_ARGREF(2);
8250 max = (max_scm);
8251 {
8252 {
8253 ScmObj SCM_RESULT;
8254 SCM_RESULT = Scm_S64VectorClamp(v0, min, max);
8255 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8256 }
8257 }
8258 }
8259
8260 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_clamp__NAME, "s64vector-clamp", 15, 15);
8261 static SCM_DEFINE_SUBR(uvlib_s64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_clamp__NAME), uvlib_s64vector_clamp, NULL, NULL);
8262
8263 static ScmObj uvlib_s64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8264 {
8265 ScmObj v0_scm;
8266 ScmS64Vector* v0;
8267 ScmObj min_scm;
8268 ScmObj min;
8269 ScmObj max_scm;
8270 ScmObj max;
8271 SCM_ENTER_SUBR("s64vector-clamp!");
8272 v0_scm = SCM_ARGREF(0);
8273 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8274 v0 = SCM_S64VECTOR(v0_scm);
8275 min_scm = SCM_ARGREF(1);
8276 min = (min_scm);
8277 max_scm = SCM_ARGREF(2);
8278 max = (max_scm);
8279 {
8280 {
8281 ScmObj SCM_RESULT;
8282 SCM_RESULT = Scm_S64VectorClampX(v0, min, max);
8283 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8284 }
8285 }
8286 }
8287
8288 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_clampX__NAME, "s64vector-clamp!", 16, 16);
8289 static SCM_DEFINE_SUBR(uvlib_s64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_clampX__NAME), uvlib_s64vector_clampX, NULL, NULL);
8290
8291 static ScmObj uvlib_u64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8292 {
8293 ScmObj v0_scm;
8294 ScmU64Vector* v0;
8295 ScmObj min_scm;
8296 ScmObj min;
8297 ScmObj max_scm;
8298 ScmObj max;
8299 SCM_ENTER_SUBR("u64vector-range-check");
8300 v0_scm = SCM_ARGREF(0);
8301 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8302 v0 = SCM_U64VECTOR(v0_scm);
8303 min_scm = SCM_ARGREF(1);
8304 min = (min_scm);
8305 max_scm = SCM_ARGREF(2);
8306 max = (max_scm);
8307 {
8308 {
8309 ScmObj SCM_RESULT;
8310 SCM_RESULT = Scm_U64VectorRangeCheck(v0, min, max);
8311 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8312 }
8313 }
8314 }
8315
8316 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_range_check__NAME, "u64vector-range-check", 21, 21);
8317 static SCM_DEFINE_SUBR(uvlib_u64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_range_check__NAME), uvlib_u64vector_range_check, NULL, NULL);
8318
8319 static ScmObj uvlib_u64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8320 {
8321 ScmObj v0_scm;
8322 ScmU64Vector* v0;
8323 ScmObj min_scm;
8324 ScmObj min;
8325 ScmObj max_scm;
8326 ScmObj max;
8327 SCM_ENTER_SUBR("u64vector-clamp");
8328 v0_scm = SCM_ARGREF(0);
8329 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8330 v0 = SCM_U64VECTOR(v0_scm);
8331 min_scm = SCM_ARGREF(1);
8332 min = (min_scm);
8333 max_scm = SCM_ARGREF(2);
8334 max = (max_scm);
8335 {
8336 {
8337 ScmObj SCM_RESULT;
8338 SCM_RESULT = Scm_U64VectorClamp(v0, min, max);
8339 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8340 }
8341 }
8342 }
8343
8344 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_clamp__NAME, "u64vector-clamp", 15, 15);
8345 static SCM_DEFINE_SUBR(uvlib_u64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_clamp__NAME), uvlib_u64vector_clamp, NULL, NULL);
8346
8347 static ScmObj uvlib_u64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8348 {
8349 ScmObj v0_scm;
8350 ScmU64Vector* v0;
8351 ScmObj min_scm;
8352 ScmObj min;
8353 ScmObj max_scm;
8354 ScmObj max;
8355 SCM_ENTER_SUBR("u64vector-clamp!");
8356 v0_scm = SCM_ARGREF(0);
8357 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8358 v0 = SCM_U64VECTOR(v0_scm);
8359 min_scm = SCM_ARGREF(1);
8360 min = (min_scm);
8361 max_scm = SCM_ARGREF(2);
8362 max = (max_scm);
8363 {
8364 {
8365 ScmObj SCM_RESULT;
8366 SCM_RESULT = Scm_U64VectorClampX(v0, min, max);
8367 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8368 }
8369 }
8370 }
8371
8372 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_clampX__NAME, "u64vector-clamp!", 16, 16);
8373 static SCM_DEFINE_SUBR(uvlib_u64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_clampX__NAME), uvlib_u64vector_clampX, NULL, NULL);
8374
8375 static ScmObj uvlib_f32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8376 {
8377 ScmObj v0_scm;
8378 ScmF32Vector* v0;
8379 ScmObj min_scm;
8380 ScmObj min;
8381 ScmObj max_scm;
8382 ScmObj max;
8383 SCM_ENTER_SUBR("f32vector-range-check");
8384 v0_scm = SCM_ARGREF(0);
8385 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8386 v0 = SCM_F32VECTOR(v0_scm);
8387 min_scm = SCM_ARGREF(1);
8388 min = (min_scm);
8389 max_scm = SCM_ARGREF(2);
8390 max = (max_scm);
8391 {
8392 {
8393 ScmObj SCM_RESULT;
8394 SCM_RESULT = Scm_F32VectorRangeCheck(v0, min, max);
8395 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8396 }
8397 }
8398 }
8399
8400 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_range_check__NAME, "f32vector-range-check", 21, 21);
8401 static SCM_DEFINE_SUBR(uvlib_f32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_range_check__NAME), uvlib_f32vector_range_check, NULL, NULL);
8402
8403 static ScmObj uvlib_f32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8404 {
8405 ScmObj v0_scm;
8406 ScmF32Vector* v0;
8407 ScmObj min_scm;
8408 ScmObj min;
8409 ScmObj max_scm;
8410 ScmObj max;
8411 SCM_ENTER_SUBR("f32vector-clamp");
8412 v0_scm = SCM_ARGREF(0);
8413 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8414 v0 = SCM_F32VECTOR(v0_scm);
8415 min_scm = SCM_ARGREF(1);
8416 min = (min_scm);
8417 max_scm = SCM_ARGREF(2);
8418 max = (max_scm);
8419 {
8420 {
8421 ScmObj SCM_RESULT;
8422 SCM_RESULT = Scm_F32VectorClamp(v0, min, max);
8423 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8424 }
8425 }
8426 }
8427
8428 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_clamp__NAME, "f32vector-clamp", 15, 15);
8429 static SCM_DEFINE_SUBR(uvlib_f32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_clamp__NAME), uvlib_f32vector_clamp, NULL, NULL);
8430
8431 static ScmObj uvlib_f32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8432 {
8433 ScmObj v0_scm;
8434 ScmF32Vector* v0;
8435 ScmObj min_scm;
8436 ScmObj min;
8437 ScmObj max_scm;
8438 ScmObj max;
8439 SCM_ENTER_SUBR("f32vector-clamp!");
8440 v0_scm = SCM_ARGREF(0);
8441 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8442 v0 = SCM_F32VECTOR(v0_scm);
8443 min_scm = SCM_ARGREF(1);
8444 min = (min_scm);
8445 max_scm = SCM_ARGREF(2);
8446 max = (max_scm);
8447 {
8448 {
8449 ScmObj SCM_RESULT;
8450 SCM_RESULT = Scm_F32VectorClampX(v0, min, max);
8451 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8452 }
8453 }
8454 }
8455
8456 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_clampX__NAME, "f32vector-clamp!", 16, 16);
8457 static SCM_DEFINE_SUBR(uvlib_f32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_clampX__NAME), uvlib_f32vector_clampX, NULL, NULL);
8458
8459 static ScmObj uvlib_f64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8460 {
8461 ScmObj v0_scm;
8462 ScmF64Vector* v0;
8463 ScmObj min_scm;
8464 ScmObj min;
8465 ScmObj max_scm;
8466 ScmObj max;
8467 SCM_ENTER_SUBR("f64vector-range-check");
8468 v0_scm = SCM_ARGREF(0);
8469 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8470 v0 = SCM_F64VECTOR(v0_scm);
8471 min_scm = SCM_ARGREF(1);
8472 min = (min_scm);
8473 max_scm = SCM_ARGREF(2);
8474 max = (max_scm);
8475 {
8476 {
8477 ScmObj SCM_RESULT;
8478 SCM_RESULT = Scm_F64VectorRangeCheck(v0, min, max);
8479 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8480 }
8481 }
8482 }
8483
8484 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_range_check__NAME, "f64vector-range-check", 21, 21);
8485 static SCM_DEFINE_SUBR(uvlib_f64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_range_check__NAME), uvlib_f64vector_range_check, NULL, NULL);
8486
8487 static ScmObj uvlib_f64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8488 {
8489 ScmObj v0_scm;
8490 ScmF64Vector* v0;
8491 ScmObj min_scm;
8492 ScmObj min;
8493 ScmObj max_scm;
8494 ScmObj max;
8495 SCM_ENTER_SUBR("f64vector-clamp");
8496 v0_scm = SCM_ARGREF(0);
8497 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8498 v0 = SCM_F64VECTOR(v0_scm);
8499 min_scm = SCM_ARGREF(1);
8500 min = (min_scm);
8501 max_scm = SCM_ARGREF(2);
8502 max = (max_scm);
8503 {
8504 {
8505 ScmObj SCM_RESULT;
8506 SCM_RESULT = Scm_F64VectorClamp(v0, min, max);
8507 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8508 }
8509 }
8510 }
8511
8512 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_clamp__NAME, "f64vector-clamp", 15, 15);
8513 static SCM_DEFINE_SUBR(uvlib_f64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_clamp__NAME), uvlib_f64vector_clamp, NULL, NULL);
8514
8515 static ScmObj uvlib_f64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8516 {
8517 ScmObj v0_scm;
8518 ScmF64Vector* v0;
8519 ScmObj min_scm;
8520 ScmObj min;
8521 ScmObj max_scm;
8522 ScmObj max;
8523 SCM_ENTER_SUBR("f64vector-clamp!");
8524 v0_scm = SCM_ARGREF(0);
8525 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8526 v0 = SCM_F64VECTOR(v0_scm);
8527 min_scm = SCM_ARGREF(1);
8528 min = (min_scm);
8529 max_scm = SCM_ARGREF(2);
8530 max = (max_scm);
8531 {
8532 {
8533 ScmObj SCM_RESULT;
8534 SCM_RESULT = Scm_F64VectorClampX(v0, min, max);
8535 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8536 }
8537 }
8538 }
8539
8540 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_clampX__NAME, "f64vector-clamp!", 16, 16);
8541 static SCM_DEFINE_SUBR(uvlib_f64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_clampX__NAME), uvlib_f64vector_clampX, NULL, NULL);
8542
8543 static ScmObj uvlib_s16vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8544 {
8545 ScmObj v0_scm;
8546 ScmS16Vector* v0;
8547 SCM_ENTER_SUBR("s16vector-swap-bytes");
8548 v0_scm = SCM_ARGREF(0);
8549 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
8550 v0 = SCM_S16VECTOR(v0_scm);
8551 {
8552 {
8553 ScmObj SCM_RESULT;
8554 SCM_RESULT = Scm_S16VectorSwapBytes(v0);
8555 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8556 }
8557 }
8558 }
8559
8560 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_swap_bytes__NAME, "s16vector-swap-bytes", 20, 20);
8561 static SCM_DEFINE_SUBR(uvlib_s16vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_swap_bytes__NAME), uvlib_s16vector_swap_bytes, NULL, NULL);
8562
8563 static ScmObj uvlib_s16vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8564 {
8565 ScmObj v0_scm;
8566 ScmS16Vector* v0;
8567 SCM_ENTER_SUBR("s16vector-swap-bytes!");
8568 v0_scm = SCM_ARGREF(0);
8569 if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
8570 v0 = SCM_S16VECTOR(v0_scm);
8571 {
8572 {
8573 ScmObj SCM_RESULT;
8574 SCM_RESULT = Scm_S16VectorSwapBytesX(v0);
8575 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8576 }
8577 }
8578 }
8579
8580 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_swap_bytesX__NAME, "s16vector-swap-bytes!", 21, 21);
8581 static SCM_DEFINE_SUBR(uvlib_s16vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_swap_bytesX__NAME), uvlib_s16vector_swap_bytesX, NULL, NULL);
8582
8583 static ScmObj uvlib_u16vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8584 {
8585 ScmObj v0_scm;
8586 ScmU16Vector* v0;
8587 SCM_ENTER_SUBR("u16vector-swap-bytes");
8588 v0_scm = SCM_ARGREF(0);
8589 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8590 v0 = SCM_U16VECTOR(v0_scm);
8591 {
8592 {
8593 ScmObj SCM_RESULT;
8594 SCM_RESULT = Scm_U16VectorSwapBytes(v0);
8595 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8596 }
8597 }
8598 }
8599
8600 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_swap_bytes__NAME, "u16vector-swap-bytes", 20, 20);
8601 static SCM_DEFINE_SUBR(uvlib_u16vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_swap_bytes__NAME), uvlib_u16vector_swap_bytes, NULL, NULL);
8602
8603 static ScmObj uvlib_u16vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8604 {
8605 ScmObj v0_scm;
8606 ScmU16Vector* v0;
8607 SCM_ENTER_SUBR("u16vector-swap-bytes!");
8608 v0_scm = SCM_ARGREF(0);
8609 if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8610 v0 = SCM_U16VECTOR(v0_scm);
8611 {
8612 {
8613 ScmObj SCM_RESULT;
8614 SCM_RESULT = Scm_U16VectorSwapBytesX(v0);
8615 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8616 }
8617 }
8618 }
8619
8620 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_swap_bytesX__NAME, "u16vector-swap-bytes!", 21, 21);
8621 static SCM_DEFINE_SUBR(uvlib_u16vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_swap_bytesX__NAME), uvlib_u16vector_swap_bytesX, NULL, NULL);
8622
8623 static ScmObj uvlib_s32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8624 {
8625 ScmObj v0_scm;
8626 ScmS32Vector* v0;
8627 SCM_ENTER_SUBR("s32vector-swap-bytes");
8628 v0_scm = SCM_ARGREF(0);
8629 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8630 v0 = SCM_S32VECTOR(v0_scm);
8631 {
8632 {
8633 ScmObj SCM_RESULT;
8634 SCM_RESULT = Scm_S32VectorSwapBytes(v0);
8635 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8636 }
8637 }
8638 }
8639
8640 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_swap_bytes__NAME, "s32vector-swap-bytes", 20, 20);
8641 static SCM_DEFINE_SUBR(uvlib_s32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_swap_bytes__NAME), uvlib_s32vector_swap_bytes, NULL, NULL);
8642
8643 static ScmObj uvlib_s32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8644 {
8645 ScmObj v0_scm;
8646 ScmS32Vector* v0;
8647 SCM_ENTER_SUBR("s32vector-swap-bytes!");
8648 v0_scm = SCM_ARGREF(0);
8649 if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8650 v0 = SCM_S32VECTOR(v0_scm);
8651 {
8652 {
8653 ScmObj SCM_RESULT;
8654 SCM_RESULT = Scm_S32VectorSwapBytesX(v0);
8655 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8656 }
8657 }
8658 }
8659
8660 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_swap_bytesX__NAME, "s32vector-swap-bytes!", 21, 21);
8661 static SCM_DEFINE_SUBR(uvlib_s32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_swap_bytesX__NAME), uvlib_s32vector_swap_bytesX, NULL, NULL);
8662
8663 static ScmObj uvlib_u32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8664 {
8665 ScmObj v0_scm;
8666 ScmU32Vector* v0;
8667 SCM_ENTER_SUBR("u32vector-swap-bytes");
8668 v0_scm = SCM_ARGREF(0);
8669 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8670 v0 = SCM_U32VECTOR(v0_scm);
8671 {
8672 {
8673 ScmObj SCM_RESULT;
8674 SCM_RESULT = Scm_U32VectorSwapBytes(v0);
8675 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8676 }
8677 }
8678 }
8679
8680 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_swap_bytes__NAME, "u32vector-swap-bytes", 20, 20);
8681 static SCM_DEFINE_SUBR(uvlib_u32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_swap_bytes__NAME), uvlib_u32vector_swap_bytes, NULL, NULL);
8682
8683 static ScmObj uvlib_u32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8684 {
8685 ScmObj v0_scm;
8686 ScmU32Vector* v0;
8687 SCM_ENTER_SUBR("u32vector-swap-bytes!");
8688 v0_scm = SCM_ARGREF(0);
8689 if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8690 v0 = SCM_U32VECTOR(v0_scm);
8691 {
8692 {
8693 ScmObj SCM_RESULT;
8694 SCM_RESULT = Scm_U32VectorSwapBytesX(v0);
8695 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8696 }
8697 }
8698 }
8699
8700 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_swap_bytesX__NAME, "u32vector-swap-bytes!", 21, 21);
8701 static SCM_DEFINE_SUBR(uvlib_u32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_swap_bytesX__NAME), uvlib_u32vector_swap_bytesX, NULL, NULL);
8702
8703 static ScmObj uvlib_s64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8704 {
8705 ScmObj v0_scm;
8706 ScmS64Vector* v0;
8707 SCM_ENTER_SUBR("s64vector-swap-bytes");
8708 v0_scm = SCM_ARGREF(0);
8709 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8710 v0 = SCM_S64VECTOR(v0_scm);
8711 {
8712 {
8713 ScmObj SCM_RESULT;
8714 SCM_RESULT = Scm_S64VectorSwapBytes(v0);
8715 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8716 }
8717 }
8718 }
8719
8720 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_swap_bytes__NAME, "s64vector-swap-bytes", 20, 20);
8721 static SCM_DEFINE_SUBR(uvlib_s64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_swap_bytes__NAME), uvlib_s64vector_swap_bytes, NULL, NULL);
8722
8723 static ScmObj uvlib_s64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8724 {
8725 ScmObj v0_scm;
8726 ScmS64Vector* v0;
8727 SCM_ENTER_SUBR("s64vector-swap-bytes!");
8728 v0_scm = SCM_ARGREF(0);
8729 if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8730 v0 = SCM_S64VECTOR(v0_scm);
8731 {
8732 {
8733 ScmObj SCM_RESULT;
8734 SCM_RESULT = Scm_S64VectorSwapBytesX(v0);
8735 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8736 }
8737 }
8738 }
8739
8740 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_swap_bytesX__NAME, "s64vector-swap-bytes!", 21, 21);
8741 static SCM_DEFINE_SUBR(uvlib_s64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_swap_bytesX__NAME), uvlib_s64vector_swap_bytesX, NULL, NULL);
8742
8743 static ScmObj uvlib_u64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8744 {
8745 ScmObj v0_scm;
8746 ScmU64Vector* v0;
8747 SCM_ENTER_SUBR("u64vector-swap-bytes");
8748 v0_scm = SCM_ARGREF(0);
8749 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8750 v0 = SCM_U64VECTOR(v0_scm);
8751 {
8752 {
8753 ScmObj SCM_RESULT;
8754 SCM_RESULT = Scm_U64VectorSwapBytes(v0);
8755 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8756 }
8757 }
8758 }
8759
8760 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_swap_bytes__NAME, "u64vector-swap-bytes", 20, 20);
8761 static SCM_DEFINE_SUBR(uvlib_u64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_swap_bytes__NAME), uvlib_u64vector_swap_bytes, NULL, NULL);
8762
8763 static ScmObj uvlib_u64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8764 {
8765 ScmObj v0_scm;
8766 ScmU64Vector* v0;
8767 SCM_ENTER_SUBR("u64vector-swap-bytes!");
8768 v0_scm = SCM_ARGREF(0);
8769 if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8770 v0 = SCM_U64VECTOR(v0_scm);
8771 {
8772 {
8773 ScmObj SCM_RESULT;
8774 SCM_RESULT = Scm_U64VectorSwapBytesX(v0);
8775 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8776 }
8777 }
8778 }
8779
8780 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_swap_bytesX__NAME, "u64vector-swap-bytes!", 21, 21);
8781 static SCM_DEFINE_SUBR(uvlib_u64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_swap_bytesX__NAME), uvlib_u64vector_swap_bytesX, NULL, NULL);
8782
8783 static ScmObj uvlib_f32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8784 {
8785 ScmObj v0_scm;
8786 ScmF32Vector* v0;
8787 SCM_ENTER_SUBR("f32vector-swap-bytes");
8788 v0_scm = SCM_ARGREF(0);
8789 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8790 v0 = SCM_F32VECTOR(v0_scm);
8791 {
8792 {
8793 ScmObj SCM_RESULT;
8794 SCM_RESULT = Scm_F32VectorSwapBytes(v0);
8795 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8796 }
8797 }
8798 }
8799
8800 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_swap_bytes__NAME, "f32vector-swap-bytes", 20, 20);
8801 static SCM_DEFINE_SUBR(uvlib_f32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_swap_bytes__NAME), uvlib_f32vector_swap_bytes, NULL, NULL);
8802
8803 static ScmObj uvlib_f32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8804 {
8805 ScmObj v0_scm;
8806 ScmF32Vector* v0;
8807 SCM_ENTER_SUBR("f32vector-swap-bytes!");
8808 v0_scm = SCM_ARGREF(0);
8809 if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8810 v0 = SCM_F32VECTOR(v0_scm);
8811 {
8812 {
8813 ScmObj SCM_RESULT;
8814 SCM_RESULT = Scm_F32VectorSwapBytesX(v0);
8815 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8816 }
8817 }
8818 }
8819
8820 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_swap_bytesX__NAME, "f32vector-swap-bytes!", 21, 21);
8821 static SCM_DEFINE_SUBR(uvlib_f32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_swap_bytesX__NAME), uvlib_f32vector_swap_bytesX, NULL, NULL);
8822
8823 static ScmObj uvlib_f64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8824 {
8825 ScmObj v0_scm;
8826 ScmF64Vector* v0;
8827 SCM_ENTER_SUBR("f64vector-swap-bytes");
8828 v0_scm = SCM_ARGREF(0);
8829 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8830 v0 = SCM_F64VECTOR(v0_scm);
8831 {
8832 {
8833 ScmObj SCM_RESULT;
8834 SCM_RESULT = Scm_F64VectorSwapBytes(v0);
8835 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8836 }
8837 }
8838 }
8839
8840 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_swap_bytes__NAME, "f64vector-swap-bytes", 20, 20);
8841 static SCM_DEFINE_SUBR(uvlib_f64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_swap_bytes__NAME), uvlib_f64vector_swap_bytes, NULL, NULL);
8842
8843 static ScmObj uvlib_f64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8844 {
8845 ScmObj v0_scm;
8846 ScmF64Vector* v0;
8847 SCM_ENTER_SUBR("f64vector-swap-bytes!");
8848 v0_scm = SCM_ARGREF(0);
8849 if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8850 v0 = SCM_F64VECTOR(v0_scm);
8851 {
8852 {
8853 ScmObj SCM_RESULT;
8854 SCM_RESULT = Scm_F64VectorSwapBytesX(v0);
8855 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8856 }
8857 }
8858 }
8859
8860 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_swap_bytesX__NAME, "f64vector-swap-bytes!", 21, 21);
8861 static SCM_DEFINE_SUBR(uvlib_f64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_swap_bytesX__NAME), uvlib_f64vector_swap_bytesX, NULL, NULL);
8862
8863 static ScmObj uvlib_uvector_alias(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8864 {
8865 ScmObj klass_scm;
8866 ScmClass* klass;
8867 ScmObj v_scm;
8868 ScmUVector* v;
8869 ScmObj start_scm;
8870 int start;
8871 ScmObj end_scm;
8872 int end;
8873 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
8874 SCM_ENTER_SUBR("uvector-alias");
8875 if (Scm_Length(SCM_OPTARGS) > 2)
8876 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
8877 klass_scm = SCM_ARGREF(0);
8878 if (!SCM_CLASSP(klass_scm)) Scm_Error("class required, but got %S", klass_scm);
8879 klass = SCM_CLASS(klass_scm);
8880 v_scm = SCM_ARGREF(1);
8881 if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8882 v = SCM_UVECTOR(v_scm);
8883 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
8884 else {
8885 start_scm = SCM_CAR(SCM_OPTARGS);
8886 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8887 }
8888 if (!SCM_EXACTP(start_scm)) Scm_Error("C integer required, but got %S", start_scm);
8889 start = Scm_GetInteger(start_scm);
8890 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
8891 else {
8892 end_scm = SCM_CAR(SCM_OPTARGS);
8893 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8894 }
8895 if (!SCM_EXACTP(end_scm)) Scm_Error("C integer required, but got %S", end_scm);
8896 end = Scm_GetInteger(end_scm);
8897 {
8898 {
8899 ScmObj SCM_RESULT;
8900 SCM_RESULT = Scm_UVectorAlias(klass, v, start, end);
8901 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8902 }
8903 }
8904 }
8905
8906 static SCM_DEFINE_STRING_CONST(uvlib_uvector_alias__NAME, "uvector-alias", 13, 13);
8907 static SCM_DEFINE_SUBR(uvlib_uvector_alias__STUB, 2, 1, SCM_OBJ(&uvlib_uvector_alias__NAME), uvlib_uvector_alias, NULL, NULL);
8908
8909 static ScmObj uvlib_uvector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8910 {
8911 ScmObj v_scm;
8912 ScmUVector* v;
8913 SCM_ENTER_SUBR("uvector-swap-bytes");
8914 v_scm = SCM_ARGREF(0);
8915 if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8916 v = SCM_UVECTOR(v_scm);
8917 {
8918 {
8919 ScmObj SCM_RESULT;
8920 SCM_RESULT = Scm_UVectorSwapBytes(v);
8921 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8922 }
8923 }
8924 }
8925
8926 static SCM_DEFINE_STRING_CONST(uvlib_uvector_swap_bytes__NAME, "uvector-swap-bytes", 18, 18);
8927 static SCM_DEFINE_SUBR(uvlib_uvector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_uvector_swap_bytes__NAME), uvlib_uvector_swap_bytes, NULL, NULL);
8928
8929 static ScmObj uvlib_uvector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8930 {
8931 ScmObj v_scm;
8932 ScmUVector* v;
8933 SCM_ENTER_SUBR("uvector-swap-bytes!");
8934 v_scm = SCM_ARGREF(0);
8935 if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8936 v = SCM_UVECTOR(v_scm);
8937 {
8938 {
8939 ScmObj SCM_RESULT;
8940 SCM_RESULT = Scm_UVectorSwapBytesX(v);
8941 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8942 }
8943 }
8944 }
8945
8946 static SCM_DEFINE_STRING_CONST(uvlib_uvector_swap_bytesX__NAME, "uvector-swap-bytes!", 19, 19);
8947 static SCM_DEFINE_SUBR(uvlib_uvector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_uvector_swap_bytesX__NAME), uvlib_uvector_swap_bytesX, NULL, NULL);
8948
8949 static ScmObj uvlib_read_blockX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8950 {
8951 ScmObj v_scm;
8952 ScmUVector* v;
8953 ScmObj port_scm;
8954 ScmPort* port;
8955 ScmObj start_scm;
8956 int start;
8957 ScmObj end_scm;
8958 int end;
8959 ScmObj endian_scm;
8960 ScmObj endian;
8961 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
8962 SCM_ENTER_SUBR("read-block!");
8963 if (Scm_Length(SCM_OPTARGS) > 4)
8964 Scm_Error("too many arguments: up to 4 is expected, %d given.", Scm_Length(SCM_OPTARGS));
8965 v_scm = SCM_ARGREF(0);
8966 if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8967 v = SCM_UVECTOR(v_scm);
8968 if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
8969 else {
8970 port_scm = SCM_CAR(SCM_OPTARGS);
8971 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8972 }
8973 if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
8974 port = SCM_PORT(port_scm);
8975 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
8976 else {
8977 start_scm = SCM_CAR(SCM_OPTARGS);
8978 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8979 }
8980 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
8981 start = SCM_INT_VALUE(start_scm);
8982 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
8983 else {
8984 end_scm = SCM_CAR(SCM_OPTARGS);
8985 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8986 }
8987 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
8988 end = SCM_INT_VALUE(end_scm);
8989 if (SCM_NULLP(SCM_OPTARGS)) endian_scm = SCM_FALSE;
8990 else {
8991 endian_scm = SCM_CAR(SCM_OPTARGS);
8992 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8993 }
8994 endian = (endian_scm);
8995 {
8996 {
8997 ScmObj SCM_RESULT;
8998 SCM_RESULT = Scm_ReadBlockX(v, port, start, end, endian);
8999 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
9000 }
9001 }
9002 }
9003
9004 static SCM_DEFINE_STRING_CONST(uvlib_read_blockX__NAME, "read-block!", 11, 11);
9005 static SCM_DEFINE_SUBR(uvlib_read_blockX__STUB, 1, 1, SCM_OBJ(&uvlib_read_blockX__NAME), uvlib_read_blockX, NULL, NULL);
9006
9007 static ScmObj uvlib_write_block(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9008 {
9009 ScmObj v_scm;
9010 ScmUVector* v;
9011 ScmObj port_scm;
9012 ScmPort* port;
9013 ScmObj start_scm;
9014 int start;
9015 ScmObj end_scm;
9016 int end;
9017 ScmObj endian_scm;
9018 ScmObj endian;
9019 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9020 SCM_ENTER_SUBR("write-block");
9021 if (Scm_Length(SCM_OPTARGS) > 4)
9022 Scm_Error("too many arguments: up to 4 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9023 v_scm = SCM_ARGREF(0);
9024 if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
9025 v = SCM_UVECTOR(v_scm);
9026 if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
9027 else {
9028 port_scm = SCM_CAR(SCM_OPTARGS);
9029 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9030 }
9031 if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
9032 port = SCM_PORT(port_scm);
9033 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9034 else {
9035 start_scm = SCM_CAR(SCM_OPTARGS);
9036 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9037 }
9038 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9039 start = SCM_INT_VALUE(start_scm);
9040 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9041 else {
9042 end_scm = SCM_CAR(SCM_OPTARGS);
9043 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9044 }
9045 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9046 end = SCM_INT_VALUE(end_scm);
9047 if (SCM_NULLP(SCM_OPTARGS)) endian_scm = SCM_FALSE;
9048 else {
9049 endian_scm = SCM_CAR(SCM_OPTARGS);
9050 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9051 }
9052 endian = (endian_scm);
9053 {
9054 {
9055 ScmObj SCM_RESULT;
9056 SCM_RESULT = Scm_WriteBlock(v, port, start, end, endian);
9057 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
9058 }
9059 }
9060 }
9061
9062 static SCM_DEFINE_STRING_CONST(uvlib_write_block__NAME, "write-block", 11, 11);
9063 static SCM_DEFINE_SUBR(uvlib_write_block__STUB, 1, 1, SCM_OBJ(&uvlib_write_block__NAME), uvlib_write_block, NULL, NULL);
9064
9065 static ScmObj string_to_bytevector(ScmClass *klass, ScmString *s, int start, int end)
9066 {
9067 u_int size, len; const char *ss, *sp, *ep; char *buf;
9068 ss = Scm_GetStringContent(s, &size, &len, NULL);
9069 SCM_CHECK_START_END(start, end, len);
9070 if (start == 0) sp = ss;
9071 else sp = Scm_StringPosition(s, start);
9072 if (end == len) ep = ss + size;
9073 else ep = Scm_StringPosition(s, end);
9074 buf = SCM_NEW_ATOMIC2(char *, ep-sp);
9075 memcpy(buf, sp, ep-sp);
9076 return Scm_MakeUVectorFull(klass, ep-sp, buf, FALSE, NULL);
9077 }
9078 static ScmObj uvlib_string_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9079 {
9080 ScmObj s_scm;
9081 ScmString* s;
9082 ScmObj start_scm;
9083 int start;
9084 ScmObj end_scm;
9085 int end;
9086 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9087 SCM_ENTER_SUBR("string->s8vector");
9088 if (Scm_Length(SCM_OPTARGS) > 2)
9089 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9090 s_scm = SCM_ARGREF(0);
9091 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9092 s = SCM_STRING(s_scm);
9093 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9094 else {
9095 start_scm = SCM_CAR(SCM_OPTARGS);
9096 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9097 }
9098 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9099 start = SCM_INT_VALUE(start_scm);
9100 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9101 else {
9102 end_scm = SCM_CAR(SCM_OPTARGS);
9103 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9104 }
9105 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9106 end = SCM_INT_VALUE(end_scm);
9107 {
9108 SCM_RETURN(string_to_bytevector(SCM_CLASS_S8VECTOR, s, start, end));
9109 }
9110 }
9111
9112 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs8vector__NAME, "string->s8vector", 16, 16);
9113 static SCM_DEFINE_SUBR(uvlib_string_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOs8vector__NAME), uvlib_string_TOs8vector, NULL, NULL);
9114
9115 static ScmObj uvlib_string_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9116 {
9117 ScmObj s_scm;
9118 ScmString* s;
9119 ScmObj start_scm;
9120 int start;
9121 ScmObj end_scm;
9122 int end;
9123 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9124 SCM_ENTER_SUBR("string->u8vector");
9125 if (Scm_Length(SCM_OPTARGS) > 2)
9126 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9127 s_scm = SCM_ARGREF(0);
9128 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9129 s = SCM_STRING(s_scm);
9130 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9131 else {
9132 start_scm = SCM_CAR(SCM_OPTARGS);
9133 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9134 }
9135 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9136 start = SCM_INT_VALUE(start_scm);
9137 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9138 else {
9139 end_scm = SCM_CAR(SCM_OPTARGS);
9140 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9141 }
9142 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9143 end = SCM_INT_VALUE(end_scm);
9144 {
9145 SCM_RETURN(string_to_bytevector(SCM_CLASS_U8VECTOR, s, start, end));
9146 }
9147 }
9148
9149 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu8vector__NAME, "string->u8vector", 16, 16);
9150 static SCM_DEFINE_SUBR(uvlib_string_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOu8vector__NAME), uvlib_string_TOu8vector, NULL, NULL);
9151
9152 static ScmObj string_to_bytevectorX(ScmUVector *v, int tstart, ScmString *s, int start, int end)
9153 {
9154 u_int size, len; const char *ss, *sp, *ep; char *buf;
9155 int tlen = SCM_UVECTOR_SIZE(v), i;
9156
9157 if (tstart >= tlen || tstart < 0) return SCM_OBJ(v);
9158 SCM_UVECTOR_CHECK_MUTABLE(v);
9159 ss = Scm_GetStringContent(s, &size, &len, NULL);
9160 SCM_CHECK_START_END(start, end, len);
9161 if (start == 0) sp = ss;
9162 else sp = Scm_StringPosition(s, start);
9163 if (end == len) ep = ss+size;
9164 else ep = Scm_StringPosition(s, end);
9165
9166 buf = (char *)SCM_UVECTOR_ELEMENTS(v) + tstart;
9167 if (tlen - tstart > ep - sp) {
9168 memcpy(buf, sp, ep - sp);
9169 } else {
9170 memcpy(buf, sp, tlen - tstart);
9171 }
9172 return SCM_OBJ(v);
9173 }
9174 static ScmObj uvlib_string_TOs8vectorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9175 {
9176 ScmObj v_scm;
9177 ScmS8Vector* v;
9178 ScmObj tstart_scm;
9179 int tstart;
9180 ScmObj s_scm;
9181 ScmString* s;
9182 ScmObj start_scm;
9183 int start;
9184 ScmObj end_scm;
9185 int end;
9186 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9187 SCM_ENTER_SUBR("string->s8vector!");
9188 if (Scm_Length(SCM_OPTARGS) > 2)
9189 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9190 v_scm = SCM_ARGREF(0);
9191 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
9192 v = SCM_S8VECTOR(v_scm);
9193 tstart_scm = SCM_ARGREF(1);
9194 if (!SCM_EXACTP(tstart_scm)) Scm_Error("C integer required, but got %S", tstart_scm);
9195 tstart = Scm_GetInteger(tstart_scm);
9196 s_scm = SCM_ARGREF(2);
9197 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9198 s = SCM_STRING(s_scm);
9199 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9200 else {
9201 start_scm = SCM_CAR(SCM_OPTARGS);
9202 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9203 }
9204 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9205 start = SCM_INT_VALUE(start_scm);
9206 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9207 else {
9208 end_scm = SCM_CAR(SCM_OPTARGS);
9209 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9210 }
9211 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9212 end = SCM_INT_VALUE(end_scm);
9213 {
9214 SCM_RETURN(string_to_bytevectorX(SCM_UVECTOR(v), tstart, s, start, end));
9215 }
9216 }
9217
9218 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs8vectorX__NAME, "string->s8vector!", 17, 17);
9219 static SCM_DEFINE_SUBR(uvlib_string_TOs8vectorX__STUB, 3, 1, SCM_OBJ(&uvlib_string_TOs8vectorX__NAME), uvlib_string_TOs8vectorX, NULL, NULL);
9220
9221 static ScmObj uvlib_string_TOu8vectorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9222 {
9223 ScmObj v_scm;
9224 ScmU8Vector* v;
9225 ScmObj tstart_scm;
9226 int tstart;
9227 ScmObj s_scm;
9228 ScmString* s;
9229 ScmObj start_scm;
9230 int start;
9231 ScmObj end_scm;
9232 int end;
9233 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9234 SCM_ENTER_SUBR("string->u8vector!");
9235 if (Scm_Length(SCM_OPTARGS) > 2)
9236 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9237 v_scm = SCM_ARGREF(0);
9238 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
9239 v = SCM_U8VECTOR(v_scm);
9240 tstart_scm = SCM_ARGREF(1);
9241 if (!SCM_EXACTP(tstart_scm)) Scm_Error("C integer required, but got %S", tstart_scm);
9242 tstart = Scm_GetInteger(tstart_scm);
9243 s_scm = SCM_ARGREF(2);
9244 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9245 s = SCM_STRING(s_scm);
9246 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9247 else {
9248 start_scm = SCM_CAR(SCM_OPTARGS);
9249 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9250 }
9251 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9252 start = SCM_INT_VALUE(start_scm);
9253 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9254 else {
9255 end_scm = SCM_CAR(SCM_OPTARGS);
9256 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9257 }
9258 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9259 end = SCM_INT_VALUE(end_scm);
9260 {
9261 SCM_RETURN(string_to_bytevectorX(SCM_UVECTOR(v), tstart, s, start, end));
9262 }
9263 }
9264
9265 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu8vectorX__NAME, "string->u8vector!", 17, 17);
9266 static SCM_DEFINE_SUBR(uvlib_string_TOu8vectorX__STUB, 3, 1, SCM_OBJ(&uvlib_string_TOu8vectorX__NAME), uvlib_string_TOu8vectorX, NULL, NULL);
9267
9268 static ScmObj bytevector_to_string(ScmUVector *v, int start, int end)
9269 {
9270 int len = SCM_UVECTOR_SIZE(v);
9271 SCM_CHECK_START_END(start, end, len);
9272 return Scm_MakeString((char *)(SCM_UVECTOR_ELEMENTS(v)+start),
9273 end-start, -1, SCM_MAKSTR_COPYING);
9274 }
9275 static ScmObj uvlib_s8vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9276 {
9277 ScmObj v_scm;
9278 ScmS8Vector* v;
9279 ScmObj start_scm;
9280 int start;
9281 ScmObj end_scm;
9282 int end;
9283 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9284 SCM_ENTER_SUBR("s8vector->string");
9285 if (Scm_Length(SCM_OPTARGS) > 2)
9286 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9287 v_scm = SCM_ARGREF(0);
9288 if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
9289 v = SCM_S8VECTOR(v_scm);
9290 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9291 else {
9292 start_scm = SCM_CAR(SCM_OPTARGS);
9293 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9294 }
9295 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9296 start = SCM_INT_VALUE(start_scm);
9297 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9298 else {
9299 end_scm = SCM_CAR(SCM_OPTARGS);
9300 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9301 }
9302 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9303 end = SCM_INT_VALUE(end_scm);
9304 {
9305 SCM_RETURN(bytevector_to_string(SCM_UVECTOR(v), start, end));
9306 }
9307 }
9308
9309 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOstring__NAME, "s8vector->string", 16, 16);
9310 static SCM_DEFINE_SUBR(uvlib_s8vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOstring__NAME), uvlib_s8vector_TOstring, NULL, NULL);
9311
9312 static ScmObj uvlib_u8vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9313 {
9314 ScmObj v_scm;
9315 ScmU8Vector* v;
9316 ScmObj start_scm;
9317 int start;
9318 ScmObj end_scm;
9319 int end;
9320 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9321 SCM_ENTER_SUBR("u8vector->string");
9322 if (Scm_Length(SCM_OPTARGS) > 2)
9323 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9324 v_scm = SCM_ARGREF(0);
9325 if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
9326 v = SCM_U8VECTOR(v_scm);
9327 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9328 else {
9329 start_scm = SCM_CAR(SCM_OPTARGS);
9330 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9331 }
9332 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9333 start = SCM_INT_VALUE(start_scm);
9334 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9335 else {
9336 end_scm = SCM_CAR(SCM_OPTARGS);
9337 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9338 }
9339 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9340 end = SCM_INT_VALUE(end_scm);
9341 {
9342 SCM_RETURN(bytevector_to_string(SCM_UVECTOR(v), start, end));
9343 }
9344 }
9345
9346 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOstring__NAME, "u8vector->string", 16, 16);
9347 static SCM_DEFINE_SUBR(uvlib_u8vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOstring__NAME), uvlib_u8vector_TOstring, NULL, NULL);
9348
9349 static ScmObj string_to_wordvector(ScmClass *klass, ScmString *s, int start, int end)
9350 {
9351 u_int size, len, i; const char *ss, *sp, *ep;
9352 ScmObj v; ScmInt32 *eltp;
9353 ss = Scm_GetStringContent(s, &size, &len, NULL);
9354 SCM_CHECK_START_END(start, end, len);
9355 if (start == 0) sp = ss;
9356 else sp = Scm_StringPosition(s, start);
9357 if (end == len) ep = ss+size;
9358 else ep = Scm_StringPosition(s, end);
9359 v = Scm_MakeUVector(klass, end - start, NULL);
9360 eltp = (ScmInt32*)SCM_UVECTOR_ELEMENTS(v);
9361 for (i=0; sp<ep; i++) {
9362 ScmChar ch;
9363 SCM_CHAR_GET(sp, ch);
9364 eltp[i] = ch;
9365 sp += SCM_CHAR_NBYTES(ch);
9366 }
9367 SCM_RETURN(v);
9368 }
9369 static ScmObj uvlib_string_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9370 {
9371 ScmObj s_scm;
9372 ScmString* s;
9373 ScmObj start_scm;
9374 int start;
9375 ScmObj end_scm;
9376 int end;
9377 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9378 SCM_ENTER_SUBR("string->s32vector");
9379 if (Scm_Length(SCM_OPTARGS) > 2)
9380 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9381 s_scm = SCM_ARGREF(0);
9382 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9383 s = SCM_STRING(s_scm);
9384 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9385 else {
9386 start_scm = SCM_CAR(SCM_OPTARGS);
9387 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9388 }
9389 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9390 start = SCM_INT_VALUE(start_scm);
9391 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9392 else {
9393 end_scm = SCM_CAR(SCM_OPTARGS);
9394 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9395 }
9396 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9397 end = SCM_INT_VALUE(end_scm);
9398 {
9399 SCM_RETURN(string_to_wordvector(SCM_CLASS_S32VECTOR, s, start, end));
9400 }
9401 }
9402
9403 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs32vector__NAME, "string->s32vector", 17, 17);
9404 static SCM_DEFINE_SUBR(uvlib_string_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOs32vector__NAME), uvlib_string_TOs32vector, NULL, NULL);
9405
9406 static ScmObj uvlib_string_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9407 {
9408 ScmObj s_scm;
9409 ScmString* s;
9410 ScmObj start_scm;
9411 int start;
9412 ScmObj end_scm;
9413 int end;
9414 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9415 SCM_ENTER_SUBR("string->u32vector");
9416 if (Scm_Length(SCM_OPTARGS) > 2)
9417 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9418 s_scm = SCM_ARGREF(0);
9419 if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9420 s = SCM_STRING(s_scm);
9421 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9422 else {
9423 start_scm = SCM_CAR(SCM_OPTARGS);
9424 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9425 }
9426 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9427 start = SCM_INT_VALUE(start_scm);
9428 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9429 else {
9430 end_scm = SCM_CAR(SCM_OPTARGS);
9431 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9432 }
9433 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9434 end = SCM_INT_VALUE(end_scm);
9435 {
9436 SCM_RETURN(string_to_wordvector(SCM_CLASS_U32VECTOR, s, start, end));
9437 }
9438 }
9439
9440 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu32vector__NAME, "string->u32vector", 17, 17);
9441 static SCM_DEFINE_SUBR(uvlib_string_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOu32vector__NAME), uvlib_string_TOu32vector, NULL, NULL);
9442
9443 static ScmObj wordvector_to_string(ScmUVector *v, int start, int end)
9444 {
9445 int len = SCM_UVECTOR_SIZE(v);
9446 ScmObj s = Scm_MakeOutputStringPort(FALSE);
9447 ScmInt32 *eltp;
9448 SCM_CHECK_START_END(start, end, len);
9449 eltp = (ScmInt32*)SCM_UVECTOR_ELEMENTS(v);
9450 for (; start < end; start++) {
9451 ScmChar ch = (ScmChar)eltp[start];
9452 Scm_PutcUnsafe(ch, SCM_PORT(s));
9453 }
9454 SCM_RETURN(Scm_GetOutputStringUnsafe(SCM_PORT(s)));
9455 }
9456 static ScmObj uvlib_s32vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9457 {
9458 ScmObj v_scm;
9459 ScmS32Vector* v;
9460 ScmObj start_scm;
9461 int start;
9462 ScmObj end_scm;
9463 int end;
9464 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9465 SCM_ENTER_SUBR("s32vector->string");
9466 if (Scm_Length(SCM_OPTARGS) > 2)
9467 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9468 v_scm = SCM_ARGREF(0);
9469 if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
9470 v = SCM_S32VECTOR(v_scm);
9471 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9472 else {
9473 start_scm = SCM_CAR(SCM_OPTARGS);
9474 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9475 }
9476 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9477 start = SCM_INT_VALUE(start_scm);
9478 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9479 else {
9480 end_scm = SCM_CAR(SCM_OPTARGS);
9481 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9482 }
9483 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9484 end = SCM_INT_VALUE(end_scm);
9485 {
9486 SCM_RETURN(wordvector_to_string(SCM_UVECTOR(v), start, end));
9487 }
9488 }
9489
9490 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOstring__NAME, "s32vector->string", 17, 17);
9491 static SCM_DEFINE_SUBR(uvlib_s32vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOstring__NAME), uvlib_s32vector_TOstring, NULL, NULL);
9492
9493 static ScmObj uvlib_u32vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9494 {
9495 ScmObj v_scm;
9496 ScmU32Vector* v;
9497 ScmObj start_scm;
9498 int start;
9499 ScmObj end_scm;
9500 int end;
9501 ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9502 SCM_ENTER_SUBR("u32vector->string");
9503 if (Scm_Length(SCM_OPTARGS) > 2)
9504 Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9505 v_scm = SCM_ARGREF(0);
9506 if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
9507 v = SCM_U32VECTOR(v_scm);
9508 if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9509 else {
9510 start_scm = SCM_CAR(SCM_OPTARGS);
9511 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9512 }
9513 if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9514 start = SCM_INT_VALUE(start_scm);
9515 if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9516 else {
9517 end_scm = SCM_CAR(SCM_OPTARGS);
9518 SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9519 }
9520 if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9521 end = SCM_INT_VALUE(end_scm);
9522 {
9523 SCM_RETURN(wordvector_to_string(SCM_UVECTOR(v), start, end));
9524 }
9525 }
9526
9527 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOstring__NAME, "u32vector->string", 17, 17);
9528 static SCM_DEFINE_SUBR(uvlib_u32vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOstring__NAME), uvlib_u32vector_TOstring, NULL, NULL);
9529
9530 void Scm_Init_uvlib(ScmModule *module)
9531 {
9532
9533 SCM_DEFINE(module, "u32vector->string", SCM_OBJ(&uvlib_u32vector_TOstring__STUB));
9534 SCM_DEFINE(module, "s32vector->string", SCM_OBJ(&uvlib_s32vector_TOstring__STUB));
9535 SCM_DEFINE(module, "string->u32vector", SCM_OBJ(&uvlib_string_TOu32vector__STUB));
9536 SCM_DEFINE(module, "string->s32vector", SCM_OBJ(&uvlib_string_TOs32vector__STUB));
9537 SCM_DEFINE(module, "u8vector->string", SCM_OBJ(&uvlib_u8vector_TOstring__STUB));
9538 SCM_DEFINE(module, "s8vector->string", SCM_OBJ(&uvlib_s8vector_TOstring__STUB));
9539 SCM_DEFINE(module, "string->u8vector!", SCM_OBJ(&uvlib_string_TOu8vectorX__STUB));
9540 SCM_DEFINE(module, "string->s8vector!", SCM_OBJ(&uvlib_string_TOs8vectorX__STUB));
9541 SCM_DEFINE(module, "string->u8vector", SCM_OBJ(&uvlib_string_TOu8vector__STUB));
9542 SCM_DEFINE(module, "string->s8vector", SCM_OBJ(&uvlib_string_TOs8vector__STUB));
9543 SCM_DEFINE(module, "write-block", SCM_OBJ(&uvlib_write_block__STUB));
9544 SCM_DEFINE(module, "read-block!", SCM_OBJ(&uvlib_read_blockX__STUB));
9545 SCM_DEFINE(module, "uvector-swap-bytes!", SCM_OBJ(&uvlib_uvector_swap_bytesX__STUB));
9546 SCM_DEFINE(module, "uvector-swap-bytes", SCM_OBJ(&uvlib_uvector_swap_bytes__STUB));
9547 SCM_DEFINE(module, "uvector-alias", SCM_OBJ(&uvlib_uvector_alias__STUB));
9548 SCM_DEFINE(module, "f64vector-swap-bytes!", SCM_OBJ(&uvlib_f64vector_swap_bytesX__STUB));
9549 SCM_DEFINE(module, "f64vector-swap-bytes", SCM_OBJ(&uvlib_f64vector_swap_bytes__STUB));
9550 SCM_DEFINE(module, "f32vector-swap-bytes!", SCM_OBJ(&uvlib_f32vector_swap_bytesX__STUB));
9551 SCM_DEFINE(module, "f32vector-swap-bytes", SCM_OBJ(&uvlib_f32vector_swap_bytes__STUB));
9552 SCM_DEFINE(module, "u64vector-swap-bytes!", SCM_OBJ(&uvlib_u64vector_swap_bytesX__STUB));
9553 SCM_DEFINE(module, "u64vector-swap-bytes", SCM_OBJ(&uvlib_u64vector_swap_bytes__STUB));
9554 SCM_DEFINE(module, "s64vector-swap-bytes!", SCM_OBJ(&uvlib_s64vector_swap_bytesX__STUB));
9555 SCM_DEFINE(module, "s64vector-swap-bytes", SCM_OBJ(&uvlib_s64vector_swap_bytes__STUB));
9556 SCM_DEFINE(module, "u32vector-swap-bytes!", SCM_OBJ(&uvlib_u32vector_swap_bytesX__STUB));
9557 SCM_DEFINE(module, "u32vector-swap-bytes", SCM_OBJ(&uvlib_u32vector_swap_bytes__STUB));
9558 SCM_DEFINE(module, "s32vector-swap-bytes!", SCM_OBJ(&uvlib_s32vector_swap_bytesX__STUB));
9559 SCM_DEFINE(module, "s32vector-swap-bytes", SCM_OBJ(&uvlib_s32vector_swap_bytes__STUB));
9560 SCM_DEFINE(module, "u16vector-swap-bytes!", SCM_OBJ(&uvlib_u16vector_swap_bytesX__STUB));
9561 SCM_DEFINE(module, "u16vector-swap-bytes", SCM_OBJ(&uvlib_u16vector_swap_bytes__STUB));
9562 SCM_DEFINE(module, "s16vector-swap-bytes!", SCM_OBJ(&uvlib_s16vector_swap_bytesX__STUB));
9563 SCM_DEFINE(module, "s16vector-swap-bytes", SCM_OBJ(&uvlib_s16vector_swap_bytes__STUB));
9564 SCM_DEFINE(module, "f64vector-clamp!", SCM_OBJ(&uvlib_f64vector_clampX__STUB));
9565 SCM_DEFINE(module, "f64vector-clamp", SCM_OBJ(&uvlib_f64vector_clamp__STUB));
9566 SCM_DEFINE(module, "f64vector-range-check", SCM_OBJ(&uvlib_f64vector_range_check__STUB));
9567 SCM_DEFINE(module, "f32vector-clamp!", SCM_OBJ(&uvlib_f32vector_clampX__STUB));
9568 SCM_DEFINE(module, "f32vector-clamp", SCM_OBJ(&uvlib_f32vector_clamp__STUB));
9569 SCM_DEFINE(module, "f32vector-range-check", SCM_OBJ(&uvlib_f32vector_range_check__STUB));
9570 SCM_DEFINE(module, "u64vector-clamp!", SCM_OBJ(&uvlib_u64vector_clampX__STUB));
9571 SCM_DEFINE(module, "u64vector-clamp", SCM_OBJ(&uvlib_u64vector_clamp__STUB));
9572 SCM_DEFINE(module, "u64vector-range-check", SCM_OBJ(&uvlib_u64vector_range_check__STUB));
9573 SCM_DEFINE(module, "s64vector-clamp!", SCM_OBJ(&uvlib_s64vector_clampX__STUB));
9574 SCM_DEFINE(module, "s64vector-clamp", SCM_OBJ(&uvlib_s64vector_clamp__STUB));
9575 SCM_DEFINE(module, "s64vector-range-check", SCM_OBJ(&uvlib_s64vector_range_check__STUB));
9576 SCM_DEFINE(module, "u32vector-clamp!", SCM_OBJ(&uvlib_u32vector_clampX__STUB));
9577 SCM_DEFINE(module, "u32vector-clamp", SCM_OBJ(&uvlib_u32vector_clamp__STUB));
9578 SCM_DEFINE(module, "u32vector-range-check", SCM_OBJ(&uvlib_u32vector_range_check__STUB));
9579 SCM_DEFINE(module, "s32vector-clamp!", SCM_OBJ(&uvlib_s32vector_clampX__STUB));
9580 SCM_DEFINE(module, "s32vector-clamp", SCM_OBJ(&uvlib_s32vector_clamp__STUB));
9581 SCM_DEFINE(module, "s32vector-range-check", SCM_OBJ(&uvlib_s32vector_range_check__STUB));
9582 SCM_DEFINE(module, "u16vector-clamp!", SCM_OBJ(&uvlib_u16vector_clampX__STUB));
9583 SCM_DEFINE(module, "u16vector-clamp", SCM_OBJ(&uvlib_u16vector_clamp__STUB));
9584 SCM_DEFINE(module, "u16vector-range-check", SCM_OBJ(&uvlib_u16vector_range_check__STUB));
9585 SCM_DEFINE(module, "s16vector-clamp!", SCM_OBJ(&uvlib_s16vector_clampX__STUB));
9586 SCM_DEFINE(module, "s16vector-clamp", SCM_OBJ(&uvlib_s16vector_clamp__STUB));
9587 SCM_DEFINE(module, "s16vector-range-check", SCM_OBJ(&uvlib_s16vector_range_check__STUB));
9588 SCM_DEFINE(module, "u8vector-clamp!", SCM_OBJ(&uvlib_u8vector_clampX__STUB));
9589 SCM_DEFINE(module, "u8vector-clamp", SCM_OBJ(&uvlib_u8vector_clamp__STUB));
9590 SCM_DEFINE(module, "u8vector-range-check", SCM_OBJ(&uvlib_u8vector_range_check__STUB));
9591 SCM_DEFINE(module, "s8vector-clamp!", SCM_OBJ(&uvlib_s8vector_clampX__STUB));
9592 SCM_DEFINE(module, "s8vector-clamp", SCM_OBJ(&uvlib_s8vector_clamp__STUB));
9593 SCM_DEFINE(module, "s8vector-range-check", SCM_OBJ(&uvlib_s8vector_range_check__STUB));
9594 SCM_DEFINE(module, "f64vector-dot", SCM_OBJ(&uvlib_f64vector_dot__STUB));
9595 SCM_DEFINE(module, "f32vector-dot", SCM_OBJ(&uvlib_f32vector_dot__STUB));
9596 SCM_DEFINE(module, "u64vector-dot", SCM_OBJ(&uvlib_u64vector_dot__STUB));
9597 SCM_DEFINE(module, "s64vector-dot", SCM_OBJ(&uvlib_s64vector_dot__STUB));
9598 SCM_DEFINE(module, "u32vector-dot", SCM_OBJ(&uvlib_u32vector_dot__STUB));
9599 SCM_DEFINE(module, "s32vector-dot", SCM_OBJ(&uvlib_s32vector_dot__STUB));
9600 SCM_DEFINE(module, "u16vector-dot", SCM_OBJ(&uvlib_u16vector_dot__STUB));
9601 SCM_DEFINE(module, "s16vector-dot", SCM_OBJ(&uvlib_s16vector_dot__STUB));
9602 SCM_DEFINE(module, "u8vector-dot", SCM_OBJ(&uvlib_u8vector_dot__STUB));
9603 SCM_DEFINE(module, "s8vector-dot", SCM_OBJ(&uvlib_s8vector_dot__STUB));
9604 SCM_DEFINE(module, "u64vector-xor!", SCM_OBJ(&uvlib_u64vector_xorX__STUB));
9605 SCM_DEFINE(module, "u64vector-xor", SCM_OBJ(&uvlib_u64vector_xor__STUB));
9606 SCM_DEFINE(module, "u64vector-ior!", SCM_OBJ(&uvlib_u64vector_iorX__STUB));
9607 SCM_DEFINE(module, "u64vector-ior", SCM_OBJ(&uvlib_u64vector_ior__STUB));
9608 SCM_DEFINE(module, "u64vector-and!", SCM_OBJ(&uvlib_u64vector_andX__STUB));
9609 SCM_DEFINE(module, "u64vector-and", SCM_OBJ(&uvlib_u64vector_and__STUB));
9610 SCM_DEFINE(module, "s64vector-xor!", SCM_OBJ(&uvlib_s64vector_xorX__STUB));
9611 SCM_DEFINE(module, "s64vector-xor", SCM_OBJ(&uvlib_s64vector_xor__STUB));
9612 SCM_DEFINE(module, "s64vector-ior!", SCM_OBJ(&uvlib_s64vector_iorX__STUB));
9613 SCM_DEFINE(module, "s64vector-ior", SCM_OBJ(&uvlib_s64vector_ior__STUB));
9614 SCM_DEFINE(module, "s64vector-and!", SCM_OBJ(&uvlib_s64vector_andX__STUB));
9615 SCM_DEFINE(module, "s64vector-and", SCM_OBJ(&uvlib_s64vector_and__STUB));
9616 SCM_DEFINE(module, "u32vector-xor!", SCM_OBJ(&uvlib_u32vector_xorX__STUB));
9617 SCM_DEFINE(module, "u32vector-xor", SCM_OBJ(&uvlib_u32vector_xor__STUB));
9618 SCM_DEFINE(module, "u32vector-ior!", SCM_OBJ(&uvlib_u32vector_iorX__STUB));
9619 SCM_DEFINE(module, "u32vector-ior", SCM_OBJ(&uvlib_u32vector_ior__STUB));
9620 SCM_DEFINE(module, "u32vector-and!", SCM_OBJ(&uvlib_u32vector_andX__STUB));
9621 SCM_DEFINE(module, "u32vector-and", SCM_OBJ(&uvlib_u32vector_and__STUB));
9622 SCM_DEFINE(module, "s32vector-xor!", SCM_OBJ(&uvlib_s32vector_xorX__STUB));
9623 SCM_DEFINE(module, "s32vector-xor", SCM_OBJ(&uvlib_s32vector_xor__STUB));
9624 SCM_DEFINE(module, "s32vector-ior!", SCM_OBJ(&uvlib_s32vector_iorX__STUB));
9625 SCM_DEFINE(module, "s32vector-ior", SCM_OBJ(&uvlib_s32vector_ior__STUB));
9626 SCM_DEFINE(module, "s32vector-and!", SCM_OBJ(&uvlib_s32vector_andX__STUB));
9627 SCM_DEFINE(module, "s32vector-and", SCM_OBJ(&uvlib_s32vector_and__STUB));
9628 SCM_DEFINE(module, "u16vector-xor!", SCM_OBJ(&uvlib_u16vector_xorX__STUB));
9629 SCM_DEFINE(module, "u16vector-xor", SCM_OBJ(&uvlib_u16vector_xor__STUB));
9630 SCM_DEFINE(module, "u16vector-ior!", SCM_OBJ(&uvlib_u16vector_iorX__STUB));
9631 SCM_DEFINE(module, "u16vector-ior", SCM_OBJ(&uvlib_u16vector_ior__STUB));
9632 SCM_DEFINE(module, "u16vector-and!", SCM_OBJ(&uvlib_u16vector_andX__STUB));
9633 SCM_DEFINE(module, "u16vector-and", SCM_OBJ(&uvlib_u16vector_and__STUB));
9634 SCM_DEFINE(module, "s16vector-xor!", SCM_OBJ(&uvlib_s16vector_xorX__STUB));
9635 SCM_DEFINE(module, "s16vector-xor", SCM_OBJ(&uvlib_s16vector_xor__STUB));
9636 SCM_DEFINE(module, "s16vector-ior!", SCM_OBJ(&uvlib_s16vector_iorX__STUB));
9637 SCM_DEFINE(module, "s16vector-ior", SCM_OBJ(&uvlib_s16vector_ior__STUB));
9638 SCM_DEFINE(module, "s16vector-and!", SCM_OBJ(&uvlib_s16vector_andX__STUB));
9639 SCM_DEFINE(module, "s16vector-and", SCM_OBJ(&uvlib_s16vector_and__STUB));
9640 SCM_DEFINE(module, "u8vector-xor!", SCM_OBJ(&uvlib_u8vector_xorX__STUB));
9641 SCM_DEFINE(module, "u8vector-xor", SCM_OBJ(&uvlib_u8vector_xor__STUB));
9642 SCM_DEFINE(module, "u8vector-ior!", SCM_OBJ(&uvlib_u8vector_iorX__STUB));
9643 SCM_DEFINE(module, "u8vector-ior", SCM_OBJ(&uvlib_u8vector_ior__STUB));
9644 SCM_DEFINE(module, "u8vector-and!", SCM_OBJ(&uvlib_u8vector_andX__STUB));
9645 SCM_DEFINE(module, "u8vector-and", SCM_OBJ(&uvlib_u8vector_and__STUB));
9646 SCM_DEFINE(module, "s8vector-xor!", SCM_OBJ(&uvlib_s8vector_xorX__STUB));
9647 SCM_DEFINE(module, "s8vector-xor", SCM_OBJ(&uvlib_s8vector_xor__STUB));
9648 SCM_DEFINE(module, "s8vector-ior!", SCM_OBJ(&uvlib_s8vector_iorX__STUB));
9649 SCM_DEFINE(module, "s8vector-ior", SCM_OBJ(&uvlib_s8vector_ior__STUB));
9650 SCM_DEFINE(module, "s8vector-and!", SCM_OBJ(&uvlib_s8vector_andX__STUB));
9651 SCM_DEFINE(module, "s8vector-and", SCM_OBJ(&uvlib_s8vector_and__STUB));
9652 SCM_DEFINE(module, "f64vector-div!", SCM_OBJ(&uvlib_f64vector_divX__STUB));
9653 SCM_DEFINE(module, "f64vector-div", SCM_OBJ(&uvlib_f64vector_div__STUB));
9654 SCM_DEFINE(module, "f32vector-div!", SCM_OBJ(&uvlib_f32vector_divX__STUB));
9655 SCM_DEFINE(module, "f32vector-div", SCM_OBJ(&uvlib_f32vector_div__STUB));
9656 SCM_DEFINE(module, "f64vector-mul!", SCM_OBJ(&uvlib_f64vector_mulX__STUB));
9657 SCM_DEFINE(module, "f64vector-mul", SCM_OBJ(&uvlib_f64vector_mul__STUB));
9658 SCM_DEFINE(module, "f32vector-mul!", SCM_OBJ(&uvlib_f32vector_mulX__STUB));
9659 SCM_DEFINE(module, "f32vector-mul", SCM_OBJ(&uvlib_f32vector_mul__STUB));
9660 SCM_DEFINE(module, "u64vector-mul!", SCM_OBJ(&uvlib_u64vector_mulX__STUB));
9661 SCM_DEFINE(module, "u64vector-mul", SCM_OBJ(&uvlib_u64vector_mul__STUB));
9662 SCM_DEFINE(module, "s64vector-mul!", SCM_OBJ(&uvlib_s64vector_mulX__STUB));
9663 SCM_DEFINE(module, "s64vector-mul", SCM_OBJ(&uvlib_s64vector_mul__STUB));
9664 SCM_DEFINE(module, "u32vector-mul!", SCM_OBJ(&uvlib_u32vector_mulX__STUB));
9665 SCM_DEFINE(module, "u32vector-mul", SCM_OBJ(&uvlib_u32vector_mul__STUB));
9666 SCM_DEFINE(module, "s32vector-mul!", SCM_OBJ(&uvlib_s32vector_mulX__STUB));
9667 SCM_DEFINE(module, "s32vector-mul", SCM_OBJ(&uvlib_s32vector_mul__STUB));
9668 SCM_DEFINE(module, "u16vector-mul!", SCM_OBJ(&uvlib_u16vector_mulX__STUB));
9669 SCM_DEFINE(module, "u16vector-mul", SCM_OBJ(&uvlib_u16vector_mul__STUB));
9670 SCM_DEFINE(module, "s16vector-mul!", SCM_OBJ(&uvlib_s16vector_mulX__STUB));
9671 SCM_DEFINE(module, "s16vector-mul", SCM_OBJ(&uvlib_s16vector_mul__STUB));
9672 SCM_DEFINE(module, "u8vector-mul!", SCM_OBJ(&uvlib_u8vector_mulX__STUB));
9673 SCM_DEFINE(module, "u8vector-mul", SCM_OBJ(&uvlib_u8vector_mul__STUB));
9674 SCM_DEFINE(module, "s8vector-mul!", SCM_OBJ(&uvlib_s8vector_mulX__STUB));
9675 SCM_DEFINE(module, "s8vector-mul", SCM_OBJ(&uvlib_s8vector_mul__STUB));
9676 SCM_DEFINE(module, "f64vector-sub!", SCM_OBJ(&uvlib_f64vector_subX__STUB));
9677 SCM_DEFINE(module, "f64vector-sub", SCM_OBJ(&uvlib_f64vector_sub__STUB));
9678 SCM_DEFINE(module, "f32vector-sub!", SCM_OBJ(&uvlib_f32vector_subX__STUB));
9679 SCM_DEFINE(module, "f32vector-sub", SCM_OBJ(&uvlib_f32vector_sub__STUB));
9680 SCM_DEFINE(module, "u64vector-sub!", SCM_OBJ(&uvlib_u64vector_subX__STUB));
9681 SCM_DEFINE(module, "u64vector-sub", SCM_OBJ(&uvlib_u64vector_sub__STUB));
9682 SCM_DEFINE(module, "s64vector-sub!", SCM_OBJ(&uvlib_s64vector_subX__STUB));
9683 SCM_DEFINE(module, "s64vector-sub", SCM_OBJ(&uvlib_s64vector_sub__STUB));
9684 SCM_DEFINE(module, "u32vector-sub!", SCM_OBJ(&uvlib_u32vector_subX__STUB));
9685 SCM_DEFINE(module, "u32vector-sub", SCM_OBJ(&uvlib_u32vector_sub__STUB));
9686 SCM_DEFINE(module, "s32vector-sub!", SCM_OBJ(&uvlib_s32vector_subX__STUB));
9687 SCM_DEFINE(module, "s32vector-sub", SCM_OBJ(&uvlib_s32vector_sub__STUB));
9688 SCM_DEFINE(module, "u16vector-sub!", SCM_OBJ(&uvlib_u16vector_subX__STUB));
9689 SCM_DEFINE(module, "u16vector-sub", SCM_OBJ(&uvlib_u16vector_sub__STUB));
9690 SCM_DEFINE(module, "s16vector-sub!", SCM_OBJ(&uvlib_s16vector_subX__STUB));
9691 SCM_DEFINE(module, "s16vector-sub", SCM_OBJ(&uvlib_s16vector_sub__STUB));
9692 SCM_DEFINE(module, "u8vector-sub!", SCM_OBJ(&uvlib_u8vector_subX__STUB));
9693 SCM_DEFINE(module, "u8vector-sub", SCM_OBJ(&uvlib_u8vector_sub__STUB));
9694 SCM_DEFINE(module, "s8vector-sub!", SCM_OBJ(&uvlib_s8vector_subX__STUB));
9695 SCM_DEFINE(module, "s8vector-sub", SCM_OBJ(&uvlib_s8vector_sub__STUB));
9696 SCM_DEFINE(module, "f64vector-add!", SCM_OBJ(&uvlib_f64vector_addX__STUB));
9697 SCM_DEFINE(module, "f64vector-add", SCM_OBJ(&uvlib_f64vector_add__STUB));
9698 SCM_DEFINE(module, "f32vector-add!", SCM_OBJ(&uvlib_f32vector_addX__STUB));
9699 SCM_DEFINE(module, "f32vector-add", SCM_OBJ(&uvlib_f32vector_add__STUB));
9700 SCM_DEFINE(module, "u64vector-add!", SCM_OBJ(&uvlib_u64vector_addX__STUB));
9701 SCM_DEFINE(module, "u64vector-add", SCM_OBJ(&uvlib_u64vector_add__STUB));
9702 SCM_DEFINE(module, "s64vector-add!", SCM_OBJ(&uvlib_s64vector_addX__STUB));
9703 SCM_DEFINE(module, "s64vector-add", SCM_OBJ(&uvlib_s64vector_add__STUB));
9704 SCM_DEFINE(module, "u32vector-add!", SCM_OBJ(&uvlib_u32vector_addX__STUB));
9705 SCM_DEFINE(module, "u32vector-add", SCM_OBJ(&uvlib_u32vector_add__STUB));
9706 SCM_DEFINE(module, "s32vector-add!", SCM_OBJ(&uvlib_s32vector_addX__STUB));
9707 SCM_DEFINE(module, "s32vector-add", SCM_OBJ(&uvlib_s32vector_add__STUB));
9708 SCM_DEFINE(module, "u16vector-add!", SCM_OBJ(&uvlib_u16vector_addX__STUB));
9709 SCM_DEFINE(module, "u16vector-add", SCM_OBJ(&uvlib_u16vector_add__STUB));
9710 SCM_DEFINE(module, "s16vector-add!", SCM_OBJ(&uvlib_s16vector_addX__STUB));
9711 SCM_DEFINE(module, "s16vector-add", SCM_OBJ(&uvlib_s16vector_add__STUB));
9712 SCM_DEFINE(module, "u8vector-add!", SCM_OBJ(&uvlib_u8vector_addX__STUB));
9713 SCM_DEFINE(module, "u8vector-add", SCM_OBJ(&uvlib_u8vector_add__STUB));
9714 SCM_DEFINE(module, "s8vector-add!", SCM_OBJ(&uvlib_s8vector_addX__STUB));
9715 SCM_DEFINE(module, "s8vector-add", SCM_OBJ(&uvlib_s8vector_add__STUB));
9716 SCM_DEFINE(module, "vector->f64vector", SCM_OBJ(&uvlib_vector_TOf64vector__STUB));
9717 SCM_DEFINE(module, "f64vector->vector", SCM_OBJ(&uvlib_f64vector_TOvector__STUB));
9718 SCM_DEFINE(module, "f64vector-fill!", SCM_OBJ(&uvlib_f64vector_fillX__STUB));
9719 SCM_DEFINE(module, "list->f64vector", SCM_OBJ(&uvlib_list_TOf64vector__STUB));
9720 SCM_DEFINE(module, "f64vector->list", SCM_OBJ(&uvlib_f64vector_TOlist__STUB));
9721 SCM_DEFINE(module, "f64vector-copy!", SCM_OBJ(&uvlib_f64vector_copyX__STUB));
9722 SCM_DEFINE(module, "f64vector-copy", SCM_OBJ(&uvlib_f64vector_copy__STUB));
9723 SCM_DEFINE(module, "f64vector-set!", SCM_OBJ(&uvlib_f64vector_setX__STUB));
9724 SCM_DEFINE(module, "f64vector-ref", SCM_OBJ(&uvlib_f64vector_ref__STUB));
9725 Scm_SetterSet(SCM_PROCEDURE(&uvlib_f64vector_ref__STUB), SCM_PROCEDURE(&uvlib_f64vector_setX__STUB), TRUE);
9726 SCM_DEFINE(module, "f64vector-length", SCM_OBJ(&uvlib_f64vector_length__STUB));
9727 SCM_DEFINE(module, "f64vector", SCM_OBJ(&uvlib_f64vector__STUB));
9728 SCM_DEFINE(module, "make-f64vector", SCM_OBJ(&uvlib_make_f64vector__STUB));
9729 SCM_DEFINE(module, "f64vector?", SCM_OBJ(&uvlib_f64vectorP__STUB));
9730 SCM_DEFINE(module, "vector->f32vector", SCM_OBJ(&uvlib_vector_TOf32vector__STUB));
9731 SCM_DEFINE(module, "f32vector->vector", SCM_OBJ(&uvlib_f32vector_TOvector__STUB));
9732 SCM_DEFINE(module, "f32vector-fill!", SCM_OBJ(&uvlib_f32vector_fillX__STUB));
9733 SCM_DEFINE(module, "list->f32vector", SCM_OBJ(&uvlib_list_TOf32vector__STUB));
9734 SCM_DEFINE(module, "f32vector->list", SCM_OBJ(&uvlib_f32vector_TOlist__STUB));
9735 SCM_DEFINE(module, "f32vector-copy!", SCM_OBJ(&uvlib_f32vector_copyX__STUB));
9736 SCM_DEFINE(module, "f32vector-copy", SCM_OBJ(&uvlib_f32vector_copy__STUB));
9737 SCM_DEFINE(module, "f32vector-set!", SCM_OBJ(&uvlib_f32vector_setX__STUB));
9738 SCM_DEFINE(module, "f32vector-ref", SCM_OBJ(&uvlib_f32vector_ref__STUB));
9739 Scm_SetterSet(SCM_PROCEDURE(&uvlib_f32vector_ref__STUB), SCM_PROCEDURE(&uvlib_f32vector_setX__STUB), TRUE);
9740 SCM_DEFINE(module, "f32vector-length", SCM_OBJ(&uvlib_f32vector_length__STUB));
9741 SCM_DEFINE(module, "f32vector", SCM_OBJ(&uvlib_f32vector__STUB));
9742 SCM_DEFINE(module, "make-f32vector", SCM_OBJ(&uvlib_make_f32vector__STUB));
9743 SCM_DEFINE(module, "f32vector?", SCM_OBJ(&uvlib_f32vectorP__STUB));
9744 SCM_DEFINE(module, "vector->u64vector", SCM_OBJ(&uvlib_vector_TOu64vector__STUB));
9745 SCM_DEFINE(module, "u64vector->vector", SCM_OBJ(&uvlib_u64vector_TOvector__STUB));
9746 SCM_DEFINE(module, "u64vector-fill!", SCM_OBJ(&uvlib_u64vector_fillX__STUB));
9747 SCM_DEFINE(module, "list->u64vector", SCM_OBJ(&uvlib_list_TOu64vector__STUB));
9748 SCM_DEFINE(module, "u64vector->list", SCM_OBJ(&uvlib_u64vector_TOlist__STUB));
9749 SCM_DEFINE(module, "u64vector-copy!", SCM_OBJ(&uvlib_u64vector_copyX__STUB));
9750 SCM_DEFINE(module, "u64vector-copy", SCM_OBJ(&uvlib_u64vector_copy__STUB));
9751 SCM_DEFINE(module, "u64vector-set!", SCM_OBJ(&uvlib_u64vector_setX__STUB));
9752 SCM_DEFINE(module, "u64vector-ref", SCM_OBJ(&uvlib_u64vector_ref__STUB));
9753 Scm_SetterSet(SCM_PROCEDURE(&uvlib_u64vector_ref__STUB), SCM_PROCEDURE(&uvlib_u64vector_setX__STUB), TRUE);
9754 SCM_DEFINE(module, "u64vector-length", SCM_OBJ(&uvlib_u64vector_length__STUB));
9755 SCM_DEFINE(module, "u64vector", SCM_OBJ(&uvlib_u64vector__STUB));
9756 SCM_DEFINE(module, "make-u64vector", SCM_OBJ(&uvlib_make_u64vector__STUB));
9757 SCM_DEFINE(module, "u64vector?", SCM_OBJ(&uvlib_u64vectorP__STUB));
9758 SCM_DEFINE(module, "vector->s64vector", SCM_OBJ(&uvlib_vector_TOs64vector__STUB));
9759 SCM_DEFINE(module, "s64vector->vector", SCM_OBJ(&uvlib_s64vector_TOvector__STUB));
9760 SCM_DEFINE(module, "s64vector-fill!", SCM_OBJ(&uvlib_s64vector_fillX__STUB));
9761 SCM_DEFINE(module, "list->s64vector", SCM_OBJ(&uvlib_list_TOs64vector__STUB));
9762 SCM_DEFINE(module, "s64vector->list", SCM_OBJ(&uvlib_s64vector_TOlist__STUB));
9763 SCM_DEFINE(module, "s64vector-copy!", SCM_OBJ(&uvlib_s64vector_copyX__STUB));
9764 SCM_DEFINE(module, "s64vector-copy", SCM_OBJ(&uvlib_s64vector_copy__STUB));
9765 SCM_DEFINE(module, "s64vector-set!", SCM_OBJ(&uvlib_s64vector_setX__STUB));
9766 SCM_DEFINE(module, "s64vector-ref", SCM_OBJ(&uvlib_s64vector_ref__STUB));
9767 Scm_SetterSet(SCM_PROCEDURE(&uvlib_s64vector_ref__STUB), SCM_PROCEDURE(&uvlib_s64vector_setX__STUB), TRUE);
9768 SCM_DEFINE(module, "s64vector-length", SCM_OBJ(&uvlib_s64vector_length__STUB));
9769 SCM_DEFINE(module, "s64vector", SCM_OBJ(&uvlib_s64vector__STUB));
9770 SCM_DEFINE(module, "make-s64vector", SCM_OBJ(&uvlib_make_s64vector__STUB));
9771 SCM_DEFINE(module, "s64vector?", SCM_OBJ(&uvlib_s64vectorP__STUB));
9772 SCM_DEFINE(module, "vector->u32vector", SCM_OBJ(&uvlib_vector_TOu32vector__STUB));
9773 SCM_DEFINE(module, "u32vector->vector", SCM_OBJ(&uvlib_u32vector_TOvector__STUB));
9774 SCM_DEFINE(module, "u32vector-fill!", SCM_OBJ(&uvlib_u32vector_fillX__STUB));
9775 SCM_DEFINE(module, "list->u32vector", SCM_OBJ(&uvlib_list_TOu32vector__STUB));
9776 SCM_DEFINE(module, "u32vector->list", SCM_OBJ(&uvlib_u32vector_TOlist__STUB));
9777 SCM_DEFINE(module, "u32vector-copy!", SCM_OBJ(&uvlib_u32vector_copyX__STUB));
9778 SCM_DEFINE(module, "u32vector-copy", SCM_OBJ(&uvlib_u32vector_copy__STUB));
9779 SCM_DEFINE(module, "u32vector-set!", SCM_OBJ(&uvlib_u32vector_setX__STUB));
9780 SCM_DEFINE(module, "u32vector-ref", SCM_OBJ(&uvlib_u32vector_ref__STUB));
9781 Scm_SetterSet(SCM_PROCEDURE(&uvlib_u32vector_ref__STUB), SCM_PROCEDURE(&uvlib_u32vector_setX__STUB), TRUE);
9782 SCM_DEFINE(module, "u32vector-length", SCM_OBJ(&uvlib_u32vector_length__STUB));
9783 SCM_DEFINE(module, "u32vector", SCM_OBJ(&uvlib_u32vector__STUB));
9784 SCM_DEFINE(module, "make-u32vector", SCM_OBJ(&uvlib_make_u32vector__STUB));
9785 SCM_DEFINE(module, "u32vector?", SCM_OBJ(&uvlib_u32vectorP__STUB));
9786 SCM_DEFINE(module, "vector->s32vector", SCM_OBJ(&uvlib_vector_TOs32vector__STUB));
9787 SCM_DEFINE(module, "s32vector->vector", SCM_OBJ(&uvlib_s32vector_TOvector__STUB));
9788 SCM_DEFINE(module, "s32vector-fill!", SCM_OBJ(&uvlib_s32vector_fillX__STUB));
9789 SCM_DEFINE(module, "list->s32vector", SCM_OBJ(&uvlib_list_TOs32vector__STUB));
9790 SCM_DEFINE(module, "s32vector->list", SCM_OBJ(&uvlib_s32vector_TOlist__STUB));
9791 SCM_DEFINE(module, "s32vector-copy!", SCM_OBJ(&uvlib_s32vector_copyX__STUB));
9792 SCM_DEFINE(module, "s32vector-copy", SCM_OBJ(&uvlib_s32vector_copy__STUB));
9793 SCM_DEFINE(module, "s32vector-set!", SCM_OBJ(&uvlib_s32vector_setX__STUB));
9794 SCM_DEFINE(module, "s32vector-ref", SCM_OBJ(&uvlib_s32vector_ref__STUB));
9795 Scm_SetterSet(SCM_PROCEDURE(&uvlib_s32vector_ref__STUB), SCM_PROCEDURE(&uvlib_s32vector_setX__STUB), TRUE);
9796 SCM_DEFINE(module, "s32vector-length", SCM_OBJ(&uvlib_s32vector_length__STUB));
9797 SCM_DEFINE(module, "s32vector", SCM_OBJ(&uvlib_s32vector__STUB));
9798 SCM_DEFINE(module, "make-s32vector", SCM_OBJ(&uvlib_make_s32vector__STUB));
9799 SCM_DEFINE(module, "s32vector?", SCM_OBJ(&uvlib_s32vectorP__STUB));
9800 SCM_DEFINE(module, "vector->u16vector", SCM_OBJ(&uvlib_vector_TOu16vector__STUB));
9801 SCM_DEFINE(module, "u16vector->vector", SCM_OBJ(&uvlib_u16vector_TOvector__STUB));
9802 SCM_DEFINE(module, "u16vector-fill!", SCM_OBJ(&uvlib_u16vector_fillX__STUB));
9803 SCM_DEFINE(module, "list->u16vector", SCM_OBJ(&uvlib_list_TOu16vector__STUB));
9804 SCM_DEFINE(module, "u16vector->list", SCM_OBJ(&uvlib_u16vector_TOlist__STUB));
9805 SCM_DEFINE(module, "u16vector-copy!", SCM_OBJ(&uvlib_u16vector_copyX__STUB));
9806 SCM_DEFINE(module, "u16vector-copy", SCM_OBJ(&uvlib_u16vector_copy__STUB));
9807 SCM_DEFINE(module, "u16vector-set!", SCM_OBJ(&uvlib_u16vector_setX__STUB));
9808 SCM_DEFINE(module, "u16vector-ref", SCM_OBJ(&uvlib_u16vector_ref__STUB));
9809 Scm_SetterSet(SCM_PROCEDURE(&uvlib_u16vector_ref__STUB), SCM_PROCEDURE(&uvlib_u16vector_setX__STUB), TRUE);
9810 SCM_DEFINE(module, "u16vector-length", SCM_OBJ(&uvlib_u16vector_length__STUB));
9811 SCM_DEFINE(module, "u16vector", SCM_OBJ(&uvlib_u16vector__STUB));
9812 SCM_DEFINE(module, "make-u16vector", SCM_OBJ(&uvlib_make_u16vector__STUB));
9813 SCM_DEFINE(module, "u16vector?", SCM_OBJ(&uvlib_u16vectorP__STUB));
9814 SCM_DEFINE(module, "vector->s16vector", SCM_OBJ(&uvlib_vector_TOs16vector__STUB));
9815 SCM_DEFINE(module, "s16vector->vector", SCM_OBJ(&uvlib_s16vector_TOvector__STUB));
9816 SCM_DEFINE(module, "s16vector-fill!", SCM_OBJ(&uvlib_s16vector_fillX__STUB));
9817 SCM_DEFINE(module, "list->s16vector", SCM_OBJ(&uvlib_list_TOs16vector__STUB));
9818 SCM_DEFINE(module, "s16vector->list", SCM_OBJ(&uvlib_s16vector_TOlist__STUB));
9819 SCM_DEFINE(module, "s16vector-copy!", SCM_OBJ(&uvlib_s16vector_copyX__STUB));
9820 SCM_DEFINE(module, "s16vector-copy", SCM_OBJ(&uvlib_s16vector_copy__STUB));
9821 SCM_DEFINE(module, "s16vector-set!", SCM_OBJ(&uvlib_s16vector_setX__STUB));
9822 SCM_DEFINE(module, "s16vector-ref", SCM_OBJ(&uvlib_s16vector_ref__STUB));
9823 Scm_SetterSet(SCM_PROCEDURE(&uvlib_s16vector_ref__STUB), SCM_PROCEDURE(&uvlib_s16vector_setX__STUB), TRUE);
9824 SCM_DEFINE(module, "s16vector-length", SCM_OBJ(&uvlib_s16vector_length__STUB));
9825 SCM_DEFINE(module, "s16vector", SCM_OBJ(&uvlib_s16vector__STUB));
9826 SCM_DEFINE(module, "make-s16vector", SCM_OBJ(&uvlib_make_s16vector__STUB));
9827 SCM_DEFINE(module, "s16vector?", SCM_OBJ(&uvlib_s16vectorP__STUB));
9828 SCM_DEFINE(module, "vector->u8vector", SCM_OBJ(&uvlib_vector_TOu8vector__STUB));
9829 SCM_DEFINE(module, "u8vector->vector", SCM_OBJ(&uvlib_u8vector_TOvector__STUB));
9830 SCM_DEFINE(module, "u8vector-fill!", SCM_OBJ(&uvlib_u8vector_fillX__STUB));
9831 SCM_DEFINE(module, "list->u8vector", SCM_OBJ(&uvlib_list_TOu8vector__STUB));
9832 SCM_DEFINE(module, "u8vector->list", SCM_OBJ(&uvlib_u8vector_TOlist__STUB));
9833 SCM_DEFINE(module, "u8vector-copy!", SCM_OBJ(&uvlib_u8vector_copyX__STUB));
9834 SCM_DEFINE(module, "u8vector-copy", SCM_OBJ(&uvlib_u8vector_copy__STUB));
9835 SCM_DEFINE(module, "u8vector-set!", SCM_OBJ(&uvlib_u8vector_setX__STUB));
9836 SCM_DEFINE(module, "u8vector-ref", SCM_OBJ(&uvlib_u8vector_ref__STUB));
9837 Scm_SetterSet(SCM_PROCEDURE(&uvlib_u8vector_ref__STUB), SCM_PROCEDURE(&uvlib_u8vector_setX__STUB), TRUE);
9838 SCM_DEFINE(module, "u8vector-length", SCM_OBJ(&uvlib_u8vector_length__STUB));
9839 SCM_DEFINE(module, "u8vector", SCM_OBJ(&uvlib_u8vector__STUB));
9840 SCM_DEFINE(module, "make-u8vector", SCM_OBJ(&uvlib_make_u8vector__STUB));
9841 SCM_DEFINE(module, "u8vector?", SCM_OBJ(&uvlib_u8vectorP__STUB));
9842 SCM_DEFINE(module, "vector->s8vector", SCM_OBJ(&uvlib_vector_TOs8vector__STUB));
9843 SCM_DEFINE(module, "s8vector->vector", SCM_OBJ(&uvlib_s8vector_TOvector__STUB));
9844 SCM_DEFINE(module, "s8vector-fill!", SCM_OBJ(&uvlib_s8vector_fillX__STUB));
9845 SCM_DEFINE(module, "list->s8vector", SCM_OBJ(&uvlib_list_TOs8vector__STUB));
9846 SCM_DEFINE(module, "s8vector->list", SCM_OBJ(&uvlib_s8vector_TOlist__STUB));
9847 SCM_DEFINE(module, "s8vector-copy!", SCM_OBJ(&uvlib_s8vector_copyX__STUB));
9848 SCM_DEFINE(module, "s8vector-copy", SCM_OBJ(&uvlib_s8vector_copy__STUB));
9849 SCM_DEFINE(module, "s8vector-set!", SCM_OBJ(&uvlib_s8vector_setX__STUB));
9850 SCM_DEFINE(module, "s8vector-ref", SCM_OBJ(&uvlib_s8vector_ref__STUB));
9851 Scm_SetterSet(SCM_PROCEDURE(&uvlib_s8vector_ref__STUB), SCM_PROCEDURE(&uvlib_s8vector_setX__STUB), TRUE);
9852 SCM_DEFINE(module, "s8vector-length", SCM_OBJ(&uvlib_s8vector_length__STUB));
9853 SCM_DEFINE(module, "s8vector", SCM_OBJ(&uvlib_s8vector__STUB));
9854 SCM_DEFINE(module, "make-s8vector", SCM_OBJ(&uvlib_make_s8vector__STUB));
9855 SCM_DEFINE(module, "s8vector?", SCM_OBJ(&uvlib_s8vectorP__STUB));
9856 sym_low = Scm_Intern(&sym_low__NAME);
9857 sym_high = Scm_Intern(&sym_high__NAME);
9858 sym_both = Scm_Intern(&sym_both__NAME);
9859 }