Debian Codegraph @

ext/binary/binary.c

raw
1 /*
2 * binary.c - Binary I/O routines
3 *
4 * Copyright (c) 2004-2024 Shiro Kawai <[email protected]>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the authors nor the names of its contributors
18 * may be used to endorse or promote products derived from this
19 * software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <gauche.h>
35 #include <gauche/priv/configP.h>
36 #include <gauche/extend.h>
37 #include <gauche/priv/bytesP.h>
38 #include "binary.h"
39
40 #define ENSURE_IPORT(var) if (!var) var = SCM_CURIN
41 #define ENSURE_OPORT(var) if (!var) var = SCM_CUROUT
42
43 #define SWAP_16(e, v) do { if (SWAP_REQUIRED(e)) SWAP_2(v); } while (0)
44 #define SWAP_32(e, v) do { if (SWAP_REQUIRED(e)) SWAP_4(v); } while (0)
45 #define SWAP_64(e, v) do { if (SWAP_REQUIRED(e)) SWAP_8(v); } while (0)
46
47 #ifdef DOUBLE_ARMENDIAN
48 #define SWAP_D(e, v) \
49 do { \
50 if (SCM_IS_ARM_LE(Scm_NativeEndian())) { \
51 if (SCM_IS_BE(e)) SWAP_ARM2BE(v); \
52 else if (SCM_IS_LE(e)) SWAP_ARM2LE(v); \
53 } else { \
54 if (SCM_IS_ARM_LE(e)) SWAP_ARM2LE(v); \
55 else if (SCM_IS_BE(e)) SWAP_8(v); \
56 } \
57 } while (0)
58 #elif WORDS_BIGENDIAN
59 #define SWAP_D(e, v) \
60 do { \
61 if (SCM_IS_LE(e)) SWAP_8(v); \
62 else if (SCM_IS_ARM_LE(e)) SWAP_ARM2BE(v); \
63 } while (0)
64 #else /*!WORDS_BIGENDIAN*/
65 #define SWAP_D(e, v) \
66 do { \
67 if (SCM_IS_BE(e)) SWAP_8(v); \
68 else if (SCM_IS_ARM_LE(e)) SWAP_ARM2LE(v); \
69 } while (0)
70 #endif /*!WORDS_BIGENDIAN*/
71
72
73 /*===========================================================
74 * Readers
75 */
76
77 /* generic routine to handle byte-stream */
78 static inline int getbytes(char *buf, int len, ScmPort *iport)
79 {
80 int nread = 0;
81 ENSURE_IPORT(iport);
82 while (nread < len) {
83 int r = Scm_Getz(buf, len-nread, iport);
84 if (r <= 0) return EOF;
85 nread += r;
86 buf += r;
87 }
88 return nread;
89 }
90
91 ScmObj Scm_ReadBinaryU8(ScmPort *iport, ScmSymbol *endian)
92 {
93 int b;
94 ENSURE_IPORT(iport);
95 SCM_CHECK_ENDIAN(endian);
96 if ((b = Scm_Getb(iport)) == EOF) return SCM_EOF;
97 else return SCM_MAKE_INT(b);
98 }
99
100 ScmObj Scm_ReadBinaryS8(ScmPort *iport, ScmSymbol *endian)
101 {
102 int b;
103 ENSURE_IPORT(iport);
104 SCM_CHECK_ENDIAN(endian);
105 if ((b = Scm_Getb(iport)) == EOF) return SCM_EOF;
106 if (b >= 128) b -= 256;
107 return SCM_MAKE_INT(b);
108 }
109
110 ScmObj Scm_ReadBinaryU16(ScmPort *iport, ScmSymbol *endian)
111 {
112 swap_u16_t v;
113 SCM_CHECK_ENDIAN(endian);
114 if (getbytes(v.buf, 2, iport) == EOF) return SCM_EOF;
115 SWAP_16(endian, v);
116 return SCM_MAKE_INT(v.val);
117 }
118
119 ScmObj Scm_ReadBinaryS16(ScmPort *iport, ScmSymbol *endian)
120 {
121 swap_s16_t v;
122 SCM_CHECK_ENDIAN(endian);
123 if (getbytes(v.buf, 2, iport) == EOF) return SCM_EOF;
124 SWAP_16(endian, v);
125 return SCM_MAKE_INT(v.val);
126 }
127
128 ScmObj Scm_ReadBinaryU32(ScmPort *iport, ScmSymbol *endian)
129 {
130 swap_u32_t v;
131 SCM_CHECK_ENDIAN(endian);
132 if (getbytes(v.buf, 4, iport) == EOF) return SCM_EOF;
133 SWAP_32(endian, v);
134 return Scm_MakeIntegerFromUI(v.val);
135 }
136
137 ScmObj Scm_ReadBinaryS32(ScmPort *iport, ScmSymbol *endian)
138 {
139 swap_s32_t v;
140 SCM_CHECK_ENDIAN(endian);
141 if (getbytes(v.buf, 4, iport) == EOF) return SCM_EOF;
142 SWAP_32(endian, v);
143 return Scm_MakeInteger(v.val);
144 }
145
146 ScmObj Scm_ReadBinaryU64(ScmPort *iport, ScmSymbol *endian)
147 {
148 swap_u64_t v;
149 SCM_CHECK_ENDIAN(endian);
150 if (getbytes(v.buf, 8, iport) == EOF) return SCM_EOF;
151 SWAP_64(endian, v);
152 return Scm_MakeIntegerU64(v.val);
153 }
154
155 ScmObj Scm_ReadBinaryS64(ScmPort *iport, ScmSymbol *endian)
156 {
157 swap_s64_t v;
158 SCM_CHECK_ENDIAN(endian);
159 if (getbytes(v.buf, 8, iport) == EOF) return SCM_EOF;
160 SWAP_64(endian, v);
161 return Scm_MakeInteger64(v.val);
162 }
163
164 ScmObj Scm_ReadBinaryF16(ScmPort *iport, ScmSymbol *endian)
165 {
166 swap_f16_t v;
167 SCM_CHECK_ENDIAN(endian);
168 if (getbytes(v.buf, 2, iport) == EOF) return SCM_EOF;
169 SWAP_16(endian, v);
170 return Scm_MakeFlonum(Scm_HalfToDouble(v.val));
171 }
172
173 ScmObj Scm_ReadBinaryF32(ScmPort *iport, ScmSymbol *endian)
174 {
175 swap_f32_t v;
176 SCM_CHECK_ENDIAN(endian);
177 if (getbytes(v.buf, 4, iport) == EOF) return SCM_EOF;
178 SWAP_32(endian, v);
179 return Scm_MakeFlonum((double)v.val);
180 }
181
182 ScmObj Scm_ReadBinaryF64(ScmPort *iport, ScmSymbol *endian)
183 {
184 swap_f64_t v;
185 SCM_CHECK_ENDIAN(endian);
186 if (getbytes(v.buf, 8, iport) == EOF) return SCM_EOF;
187 SWAP_D(endian, v);
188 return Scm_MakeFlonum(v.val);
189 }
190
191 /*===========================================================
192 * Writers
193 */
194
195 void Scm_WriteBinaryU8(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
196 {
197 int val = Scm_GetIntegerU8Clamp(sval, SCM_CLAMP_NONE, NULL);
198 SCM_CHECK_ENDIAN(endian);
199 ENSURE_OPORT(oport);
200 Scm_Putb(val, oport);
201 }
202
203 void Scm_WriteBinaryS8(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
204 {
205 int val = Scm_GetInteger8Clamp(sval, SCM_CLAMP_NONE, NULL);
206 SCM_CHECK_ENDIAN(endian);
207 ENSURE_OPORT(oport);
208 Scm_Putb(val, oport);
209 }
210
211 void Scm_WriteBinaryU16(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
212 {
213 swap_u16_t v;
214 ENSURE_OPORT(oport);
215 SCM_CHECK_ENDIAN(endian);
216 v.val = Scm_GetIntegerU16Clamp(sval, SCM_CLAMP_NONE, NULL);
217 SWAP_16(endian, v);
218 Scm_Putz(v.buf, 2, oport);
219 }
220
221 void Scm_WriteBinaryS16(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
222 {
223 swap_s16_t v;
224 ENSURE_OPORT(oport);
225 SCM_CHECK_ENDIAN(endian);
226 v.val = Scm_GetInteger16Clamp(sval, SCM_CLAMP_NONE, NULL);
227 SWAP_16(endian, v);
228 Scm_Putz(v.buf, 2, oport);
229 }
230
231 void Scm_WriteBinaryU32(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
232 {
233 swap_u32_t v;
234 ENSURE_OPORT(oport);
235 SCM_CHECK_ENDIAN(endian);
236 v.val = Scm_GetIntegerU32Clamp(sval, FALSE, FALSE);
237 SWAP_32(endian, v);
238 Scm_Putz(v.buf, 4, oport);
239 }
240
241 void Scm_WriteBinaryS32(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
242 {
243 swap_s32_t v;
244 ENSURE_OPORT(oport);
245 SCM_CHECK_ENDIAN(endian);
246 v.val = Scm_GetInteger32Clamp(sval, FALSE, FALSE);
247 SWAP_32(endian, v);
248 Scm_Putz(v.buf, 4, oport);
249 }
250
251 void Scm_WriteBinaryU64(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
252 {
253 swap_u64_t v;
254 ENSURE_OPORT(oport);
255 SCM_CHECK_ENDIAN(endian);
256 v.val = Scm_GetIntegerU64Clamp(sval, FALSE, FALSE);
257 SWAP_64(endian, v);
258 Scm_Putz(v.buf, 8, oport);
259 }
260
261 void Scm_WriteBinaryS64(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
262 {
263 swap_s64_t v;
264 ENSURE_OPORT(oport);
265 SCM_CHECK_ENDIAN(endian);
266 v.val = Scm_GetInteger64Clamp(sval, FALSE, FALSE);
267 SWAP_64(endian, v);
268 Scm_Putz(v.buf, 8, oport);
269 }
270
271 void Scm_WriteBinaryF16(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
272 {
273 swap_f16_t v;
274 ENSURE_OPORT(oport);
275 SCM_CHECK_ENDIAN(endian);
276 v.val = Scm_DoubleToHalf(Scm_GetDouble(sval));
277 SWAP_16(endian, v);
278 Scm_Putz(v.buf, 2, oport);
279 }
280
281 void Scm_WriteBinaryF32(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
282 {
283 swap_f32_t v;
284 ENSURE_OPORT(oport);
285 SCM_CHECK_ENDIAN(endian);
286 v.val = (float)Scm_GetDouble(sval);
287 SWAP_32(endian, v);
288 Scm_Putz(v.buf, 4, oport);
289 }
290
291 void Scm_WriteBinaryF64(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
292 {
293 swap_f64_t v;
294 ENSURE_OPORT(oport);
295 SCM_CHECK_ENDIAN(endian);
296 v.val = Scm_GetDouble(sval);
297 SWAP_D(endian, v);
298 Scm_Putz(v.buf, 8, oport);
299 }
300
301 /*===========================================================
302 * Getters
303 */
304
305 static void extract(ScmUVector *uv, char *buf, int off, int eltsize)
306 {
307 int size = Scm_UVectorSizeInBytes(uv);
308 unsigned char *b = (unsigned char*)SCM_UVECTOR_ELEMENTS(uv) + off;
309
310 if (off < 0 || off+eltsize > size) {
311 Scm_Error("offset %d is out of bound of the uvector.", off);
312 }
313 for (int i=0; i<eltsize; i++) {
314 *buf++ = *b++;
315 }
316 }
317
318
319 ScmObj Scm_GetBinaryU8(ScmUVector *uv, int off, ScmSymbol *endian)
320 {
321 unsigned char b;
322 SCM_CHECK_ENDIAN(endian);
323 extract(uv, (char *)&b, off, 1);
324 return SCM_MAKE_INT(b);
325 }
326
327 ScmObj Scm_GetBinaryS8(ScmUVector *uv, int off, ScmSymbol *endian)
328 {
329 unsigned char b;
330 SCM_CHECK_ENDIAN(endian);
331 extract(uv, (char *)&b, off, 1);
332 int r = b;
333 if (r >= 128) r -= 256;
334 return SCM_MAKE_INT(r);
335 }
336
337 ScmObj Scm_GetBinaryU16(ScmUVector *uv, int off, ScmSymbol *endian)
338 {
339 swap_u16_t v;
340 SCM_CHECK_ENDIAN(endian);
341 extract(uv, v.buf, off, 2);
342 SWAP_16(endian, v);
343 return SCM_MAKE_INT(v.val);
344 }
345
346 ScmObj Scm_GetBinaryS16(ScmUVector *uv, int off, ScmSymbol *endian)
347 {
348 swap_s16_t v;
349 SCM_CHECK_ENDIAN(endian);
350 extract(uv, v.buf, off, 2);
351 SWAP_16(endian, v);
352 return SCM_MAKE_INT(v.val);
353 }
354
355 ScmObj Scm_GetBinaryU32(ScmUVector *uv, int off, ScmSymbol *endian)
356 {
357 swap_u32_t v;
358 SCM_CHECK_ENDIAN(endian);
359 extract(uv, v.buf, off, 4);
360 SWAP_32(endian, v);
361 return Scm_MakeIntegerFromUI(v.val);
362 }
363
364 ScmObj Scm_GetBinaryS32(ScmUVector *uv, int off, ScmSymbol *endian)
365 {
366 swap_s32_t v;
367 SCM_CHECK_ENDIAN(endian);
368 extract(uv, v.buf, off, 4);
369 SWAP_32(endian, v);
370 return Scm_MakeInteger(v.val);
371 }
372
373 ScmObj Scm_GetBinaryU64(ScmUVector *uv, int off, ScmSymbol *endian)
374 {
375 swap_u64_t v;
376 SCM_CHECK_ENDIAN(endian);
377 extract(uv, v.buf, off, 8);
378 SWAP_64(endian, v);
379 return Scm_MakeIntegerU64(v.val);
380 }
381
382 ScmObj Scm_GetBinaryS64(ScmUVector *uv, int off, ScmSymbol *endian)
383 {
384 swap_s64_t v;
385 SCM_CHECK_ENDIAN(endian);
386 extract(uv, v.buf, off, 8);
387 SWAP_64(endian, v);
388 return Scm_MakeInteger64(v.val);
389 }
390
391 ScmObj Scm_GetBinaryF16(ScmUVector *uv, int off, ScmSymbol *endian)
392 {
393 swap_f16_t v;
394 SCM_CHECK_ENDIAN(endian);
395 extract(uv, v.buf, off, 2);
396 SWAP_16(endian, v);
397 return Scm_MakeFlonum(Scm_HalfToDouble(v.val));
398 }
399
400 ScmObj Scm_GetBinaryF32(ScmUVector *uv, int off, ScmSymbol *endian)
401 {
402 swap_f32_t v;
403 SCM_CHECK_ENDIAN(endian);
404 extract(uv, v.buf, off, 4);
405 SWAP_32(endian, v);
406 return Scm_MakeFlonum((double)v.val);
407 }
408
409 ScmObj Scm_GetBinaryF64(ScmUVector *uv, int off, ScmSymbol *endian)
410 {
411 swap_f64_t v;
412 SCM_CHECK_ENDIAN(endian);
413 extract(uv, v.buf, off, 8);
414 SWAP_D(endian, v);
415 return Scm_MakeFlonum(v.val);
416 }
417
418 /*===========================================================
419 * Putters
420 */
421
422 static void inject(ScmUVector *uv, char *buf, int off, int eltsize)
423 {
424 int size = Scm_UVectorSizeInBytes(uv);
425 unsigned char *b = (unsigned char*)SCM_UVECTOR_ELEMENTS(uv) + off;
426
427 SCM_UVECTOR_CHECK_MUTABLE(SCM_OBJ(uv));
428
429 if (off < 0 || off+eltsize > size) {
430 Scm_Error("offset %d is out of bound of the uvector.", off);
431 }
432 for (int i=0; i<eltsize; i++) {
433 *b++ = *buf++;
434 }
435 }
436
437 void Scm_PutBinaryU8(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
438 {
439 u_char v = (u_char)Scm_GetIntegerU8Clamp(val, SCM_CLAMP_NONE, NULL);
440 SCM_CHECK_ENDIAN(e);
441 inject(uv, (char *)&v, off, 1);
442 }
443
444 void Scm_PutBinaryS8(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
445 {
446 u_char v = (u_char)Scm_GetInteger8Clamp(val, SCM_CLAMP_NONE, NULL);
447 SCM_CHECK_ENDIAN(e);
448 inject(uv, (char *)&v, off, 1);
449 }
450
451 void Scm_PutBinaryU16(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
452 {
453 swap_u16_t v;
454 SCM_CHECK_ENDIAN(e);
455 v.val = Scm_GetIntegerU16Clamp(val, SCM_CLAMP_NONE, NULL);
456 SWAP_16(e, v);
457 inject(uv, v.buf, off, 2);
458 }
459
460 void Scm_PutBinaryS16(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
461 {
462 swap_s16_t v;
463 SCM_CHECK_ENDIAN(e);
464 v.val = Scm_GetInteger16Clamp(val, SCM_CLAMP_NONE, NULL);
465 SWAP_16(e, v);
466 inject(uv, v.buf, off, 2);
467 }
468
469 void Scm_PutBinaryU32(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
470 {
471 swap_u32_t v;
472 SCM_CHECK_ENDIAN(e);
473 v.val = Scm_GetIntegerU32Clamp(val, FALSE, FALSE);
474 SWAP_32(e, v);
475 inject(uv, v.buf, off, 4);
476 }
477
478 void Scm_PutBinaryS32(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
479 {
480 swap_s32_t v;
481 SCM_CHECK_ENDIAN(e);
482 v.val = Scm_GetInteger32Clamp(val, FALSE, FALSE);
483 SWAP_32(e, v);
484 inject(uv, v.buf, off, 4);
485 }
486
487 void Scm_PutBinaryU64(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
488 {
489 swap_u64_t v;
490 SCM_CHECK_ENDIAN(e);
491 v.val = Scm_GetIntegerU64Clamp(val, FALSE, FALSE);
492 SWAP_64(e, v);
493 inject(uv, v.buf, off, 8);
494 }
495
496 void Scm_PutBinaryS64(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
497 {
498 swap_s64_t v;
499 SCM_CHECK_ENDIAN(e);
500 v.val = Scm_GetInteger64Clamp(val, FALSE, FALSE);
501 SWAP_64(e, v);
502 inject(uv, v.buf, off, 8);
503 }
504
505 void Scm_PutBinaryF16(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
506 {
507 swap_f16_t v;
508 SCM_CHECK_ENDIAN(e);
509 v.val = Scm_DoubleToHalf(Scm_GetDouble(val));
510 SWAP_16(e, v);
511 inject(uv, v.buf, off, 2);
512 }
513
514 void Scm_PutBinaryF32(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
515 {
516 swap_f32_t v;
517 SCM_CHECK_ENDIAN(e);
518 v.val = (float)Scm_GetDouble(val);
519 SWAP_32(e, v);
520 inject(uv, v.buf, off, 4);
521 }
522
523 void Scm_PutBinaryF64(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
524 {
525 swap_f64_t v;
526 SCM_CHECK_ENDIAN(e);
527 v.val = Scm_GetDouble(val);
528 SWAP_D(e, v);
529 inject(uv, v.buf, off, 8);
530 }