?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sample: cleaning up Inheritance
[io/quag.git] / libs / basekit / source / BStream.c
blobfb9939ce64e5d0e3e72e9b13b800b2b14823be3b
1 /*
2 docCopyright("Steve Dekorte", 2004)
3 docLicense("BSD revised")
4 */
5
6 #include "Base.h"
7
8 //#define BStream_C
9 #include "BStream.h"
10 //#undef BStream_C
11
12 #include <string.h>
13 #include <ctype.h>
14 #include <stdlib.h>
15 #include <math.h>
16 #include <limits.h>
17
18 #define BSTREAM_IS_BIG_ENDIAN 1
19
20 BStream *BStream_new(void)
21 {
22 int flipEndian;
23 BStream *self = (BStream *)io_calloc(1, sizeof(BStream));
24 self->ba = UArray_new();
25 self->index = 0;
26 self->ownsUArray = 1;
27 self->tmp = UArray_new();
28 self->errorBa = UArray_new();
29 flipEndian = 0;
30 self->typeBuf = (unsigned char *)io_calloc(1, 512);
31 return self;
32 }
33
34 BStream *BStream_clone(BStream *self)
35 {
36 BStream *child = BStream_new();
37 UArray_copy_(child->ba, self->ba);
38 child->index = self->index;
39 return child;
40 }
41
42 void BStream_free(BStream *self)
43 {
44 if (self->ownsUArray) UArray_free(self->ba);
45 UArray_free(self->tmp);
46 UArray_free(self->errorBa);
47 io_free(self->typeBuf);
48 io_free(self);
49 }
50
51 void BStream_error_(BStream *self, const char *s)
52 {
53 UArray_setCString_(self->errorBa, s);
54 }
55
56 char *BStream_error(BStream *self)
57 {
58 return (char *)UArray_bytes(self->errorBa);
59 }
60
61 void BStream_setUArray_(BStream *self, UArray *ba)
62 {
63 if (self->ownsUArray)
64 {
65 UArray_free(ba);
66 self->ownsUArray = 0;
67 }
68 self->ba = ba;
69 self->index = 0;
70 }
71
72 void BStream_setData_length_(BStream *self, unsigned char *data, size_t length)
73 {
74 UArray_setData_type_size_copy_(self->ba, data, CTYPE_uint8_t, length, 1);
75 self->index = 0;
76 }
77
78 UArray *BStream_byteArray(BStream *self)
79 {
80 return self->ba;
81 }
82
83 void BStream_empty(BStream *self)
84 {
85 self->index = 0;
86 UArray_setSize_(self->ba, 0);
87 }
88
89 int BStream_isEmpty(BStream *self)
90 {
91 return UArray_size(self->ba) == 0;
92 }
93
94 // writing --------------------------------------
95
96 void BStream_writeByte_(BStream *self, unsigned char v)
97 {
98 BStream_writeUint8_(self, v);
99 }
100
101 void BStream_writeUint8_(BStream *self, uint8_t v)
102 {
103 UArray_appendLong_(self->ba, v);
104 self->index ++;
105 }
106
107 static void reverseBytes(unsigned char *d, size_t length)
108 {
109 size_t a = 0;
110 size_t b = length - 1;
111
112 while ( a < b)
113 {
114 unsigned char c = d[a];
115
116 d[a] = d[b];
117 d[b] = c;
118 a ++;
119 b --;
120 }
121 }
122
123 void BStream_writeNumber_size_(BStream *self, unsigned char *v, size_t length)
124 {
125 memcpy(self->typeBuf, v, length);
126
127 if (self->flipEndian)
128 {
129 reverseBytes(self->typeBuf, length);
130 }
131
132 UArray_appendBytes_size_(self->ba, (unsigned char *)self->typeBuf, length);
133 self->index += length;
134 }
135
136 void BStream_writeData_length_(BStream *self, const unsigned char *data, size_t length)
137 {
138 UArray_appendBytes_size_(self->ba, (unsigned char *)data, length);
139 self->index += length;
140 }
141
142 void BStream_writeInt32_(BStream *self, int32_t v)
143 {
144 BStream_writeNumber_size_(self, (unsigned char *)(&v), sizeof(int32_t));
145 }
146
147 void BStream_writeUint32_(BStream *self, uint32_t v)
148 {
149 BStream_writeNumber_size_(self, (unsigned char *)(&v), sizeof(uint32_t));
150 }
151
152 #if !defined(__SYMBIAN32__)
153 void BStream_writeInt64_(BStream *self, int64_t v)
154 {
155 BStream_writeNumber_size_(self, (unsigned char *)(&v), sizeof(int64_t));
156 }
157 #endif
158
159 void BStream_writeDouble_(BStream *self, double v)
160 {
161 BStream_writeNumber_size_(self, (unsigned char *)(&v), sizeof(double));
162 }
163
164 void BStream_writeCString_(BStream *self, const char *s)
165 {
166 int length = strlen(s);
167 BStream_writeInt32_(self, length);
168 BStream_writeData_length_(self, (unsigned char *)s, length);
169 }
170
171 void BStream_writeUArray_(BStream *self, UArray *ba)
172 {
173 BStream_writeInt32_(self, UArray_size(ba));
174 UArray_append_(self->ba, ba);
175 self->index += UArray_size(ba);
176 }
177
178 // reading --------------------------------------
179
180 unsigned char BStream_readByte(BStream *self)
181 {
182 return BStream_readUint8(self);
183 }
184
185 uint8_t BStream_readUint8(BStream *self)
186 {
187 if (self->index < UArray_size(self->ba))
188 {
189 unsigned char b = UArray_bytes(self->ba)[self->index];
190 self->index ++;
191 return b;
192 }
193
194 return 0;
195 }
196
197 void BStream_readNumber_size_(BStream *self, unsigned char *v, int size)
198 {
199 if (self->index + size <= UArray_size(self->ba))
200 {
201 const uint8_t *b = UArray_bytes(self->ba);
202 memcpy(v, b + self->index, size);
203
204 if (self->flipEndian)
205 {
206 reverseBytes(v, size);
207 }
208
209 self->index += size;
210 return;
211 }
212
213 while (size--)
214 {
215 *v = 0;
216 v ++;
217 }
218 }
219
220 uint32_t BStream_readUint32(BStream *self)
221 {
222 uint32_t v;
223 BStream_readNumber_size_(self, (unsigned char *)(&v), sizeof(uint32_t));
224 return v;
225 }
226
227 int32_t BStream_readInt32(BStream *self)
228 {
229 int32_t v;
230 BStream_readNumber_size_(self, (unsigned char *)(&v), sizeof(int32_t));
231 return v;
232 }
233
234 #if !defined(__SYMBIAN32__)
235 int64_t BStream_readInt64(BStream *self)
236 {
237 int64_t v;
238 BStream_readNumber_size_(self, (unsigned char *)(&v), sizeof(int64_t));
239 return v;
240 }
241 #endif
242
243 double BStream_readDouble(BStream *self)
244 {
245 double v;
246 BStream_readNumber_size_(self, (unsigned char *)(&v), sizeof(double));
247 return v;
248 }
249
250 unsigned char *BStream_readDataOfLength_(BStream *self, size_t length)
251 {
252 if (self->index + length <= UArray_size(self->ba))
253 {
254 unsigned char *b = (unsigned char *)UArray_bytes(self->ba) + self->index;
255 self->index += length;
256 return b;
257 }
258
259 return NULL;
260 }
261
262 void BStream_readUArray_(BStream *self, UArray *b)
263 {
264 size_t size = BStream_readInt32(self);
265 unsigned char *data = BStream_readDataOfLength_(self, size);
266 UArray_setData_type_size_copy_(b, data, CTYPE_uint8_t, size, 1);
267 }
268
269 UArray *BStream_readUArray(BStream *self)
270 {
271 BStream_readUArray_(self, self->tmp);
272 return self->tmp;
273 }
274
275 const char *BStream_readCString(BStream *self)
276 {
277 BStream_readUArray_(self, self->tmp);
278 return (const char *)UArray_bytes(self->tmp);
279 }
280
281 // tagged writing --------------------------------------
282
283 void BStream_writeTag(BStream *self, unsigned int t, unsigned int b, unsigned int a)
284 {
285 BStreamTag tag;
286 tag.isArray = a;
287 tag.type = t;
288 tag.byteCount = b;
289
290 {
291 unsigned char c = BStreamTag_asUnsignedChar(&tag);
292 BStreamTag tag2 = BStreamTag_FromUnsignedChar(c);
293
294 if (tag2.isArray != tag.isArray ||
295 tag2.type != tag.type ||
296 tag2.byteCount != tag.byteCount)
297 {
298 printf("tags don't match\n");
299 exit(-1);
300 }
301
302 BStream_writeUint8_(self, c);
303 }
304 }
305
306 void BStream_writeTaggedUint8_(BStream *self, uint8_t v)
307 {
308 BStream_writeTag(self, BSTREAM_UNSIGNED_INT, 1, 0);
309 BStream_writeUint8_(self, v);
310 }
311
312 void BStream_writeTaggedUint32_(BStream *self, uint32_t v)
313 {
314 BStream_writeTag(self, BSTREAM_UNSIGNED_INT, 4, 0);
315 BStream_writeUint32_(self, v);
316 }
317
318 void BStream_writeTaggedInt32_(BStream *self, int32_t v)
319 {
320 /*
321 if (v =< MAX_INT && v -128)
322 {
323 BStream_writeTag(self, BSTREAM_SIGNED_INT, 1, 0);
324 BStream_writeInt8_(self, (int8_t)v);
325 }
326 else
327 */
328 {
329 BStream_writeTag(self, BSTREAM_SIGNED_INT, 4, 0);
330 BStream_writeInt32_(self, v);
331 }
332 }
333 #if !defined(__SYMBIAN32__)
334 void BStream_writeTaggedInt64_(BStream *self, int64_t v)
335 {
336 BStream_writeTag(self, BSTREAM_SIGNED_INT, 8, 0);
337 BStream_writeInt64_(self, v);
338 }
339 #endif
340
341 /*
342 #if sizeof(double) != 8
343 #error BStream expects doubles to be 64bit
344 #endif
345 */
346
347 void BStream_writeTaggedDouble_(BStream *self, double v)
348 {
349 BStream_writeTag(self, BSTREAM_FLOAT, 8, 0);
350 BStream_writeDouble_(self, v);
351 }
352
353 void BStream_writeTaggedData_length_(BStream *self, const unsigned char *data, size_t length)
354 {
355 BStream_writeTag(self, BSTREAM_UNSIGNED_INT, 1, 1);
356 BStream_writeTaggedInt32_(self, length);
357 UArray_appendBytes_size_(self->ba, (unsigned char *)data, length);
358 self->index += length;
359 }
360
361 void BStream_writeTaggedCString_(BStream *self, const char *s)
362 {
363 BStream_writeTaggedData_length_(self, (unsigned char *)s, strlen(s));
364 }
365
366 void BStream_writeTaggedUArray_(BStream *self, UArray *ba)
367 {
368 BStream_writeTaggedData_length_(self, UArray_bytes(ba), UArray_size(ba));
369 }
370
371 // reading --------------------------------------
372
373 int BStream_readTag(BStream *self, unsigned int t, unsigned int b, unsigned int a)
374 {
375 unsigned char c = BStream_readUint8(self);
376 BStreamTag readTag = BStreamTag_FromUnsignedChar(c);
377 BStreamTag expectedTag = BStreamTag_TagArray_type_byteCount_(a, t, b);
378
379 if (!BStreamTag_isEqual_(&readTag, &expectedTag))
380 {
381 printf("BStream error: read:\n ");
382 BStreamTag_print(&readTag);
383 printf(" but expected:\n ");
384 BStreamTag_print(&expectedTag);
385 printf("\n");
386 BStream_show(self);
387 printf("\n");
388 return -1;
389 }
390
391 return 0;
392 }
393
394 /*
395 unsigned char BStream_readTaggedByte(BStream *self)
396 {
397 BStream_readTag(self, BSTREAM_UNSIGNED_INT, 1, 0);
398 return BStream_readByte(self);
399 }
400
401 int BStream_readTaggedInt(BStream *self)
402 {
403 BStream_readTag(self, BSTREAM_SIGNED_INT, 4, 0);
404 return BStream_readInt32(self);
405 }
406 */
407
408 uint8_t BStream_readTaggedUint8(BStream *self)
409 {
410 return BStream_readTaggedInt32(self);
411 }
412
413 uint32_t BStream_readTaggedUint32(BStream *self)
414 {
415 unsigned char c = BStream_readByte(self);
416 BStreamTag t = BStreamTag_FromUnsignedChar(c);
417
418 if (t.type == BSTREAM_UNSIGNED_INT && t.byteCount == 1)
419 { return (uint32_t)BStream_readUint8(self); }
420
421 if (t.type == BSTREAM_UNSIGNED_INT && t.byteCount == 4)
422 { return (uint32_t)BStream_readUint32(self); }
423
424 BStream_error_(self, "unhandled int type/size combination");
425 return 0;
426 }
427
428 int32_t BStream_readTaggedInt32(BStream *self)
429 {
430 unsigned char c = BStream_readByte(self);
431 BStreamTag t = BStreamTag_FromUnsignedChar(c);
432
433 if (t.type == BSTREAM_UNSIGNED_INT && t.byteCount == 1)
434 {
435 return (int32_t)BStream_readUint8(self);
436 }
437
438 if (t.type == BSTREAM_SIGNED_INT && t.byteCount == 4)
439 {
440 return (int32_t)BStream_readInt32(self);
441 }
442 /*
443 if (t.type == BSTREAM_SIGNED_INT && t.byteCount == 8)
444 {
445 return (int32_t)BStream_readInt64(self);
446 }
447 */
448
449 BStream_error_(self, "unhandled int type/size combination");
450
451 return 0;
452 }
453
454 intptr_t BStream_readTaggedPointer(BStream *self)
455 {
456 unsigned char c = BStream_readByte(self);
457 BStreamTag t = BStreamTag_FromUnsignedChar(c);
458
459 if (t.type == BSTREAM_POINTER)
460 {
461 BStream_error_(self, "expected pointer");
462 return 0;
463 }
464
465 if (t.byteCount == 1)
466 {
467 return (intptr_t)BStream_readUint8(self);
468 }
469
470 if (t.byteCount == 4)
471 {
472 return (intptr_t)BStream_readInt32(self);
473 }
474
475 #if !defined(__SYMBIAN32__)
476 if (t.byteCount == 8)
477 {
478 return (intptr_t)BStream_readInt64(self);
479 }
480 #endif
481
482 BStream_error_(self, "unhandled pointer size");
483 return 0;
484 }
485
486 double BStream_readTaggedDouble(BStream *self)
487 {
488 unsigned char c = BStream_readByte(self);
489 BStreamTag t = BStreamTag_FromUnsignedChar(c);
490 /*
491 if (t.type == BSTREAM_FLOAT && t.byteCount == 4)
492 {
493 return BStream_readFloat(self);
494 }
495 */
496 if (t.type == BSTREAM_FLOAT && t.byteCount == 8)
497 {
498 return BStream_readDouble(self);
499 }
500
501 BStream_error_(self, "unhandled float type/size combination");
502 return 0;
503 }
504
505 void BStream_readTaggedUArray_(BStream *self, UArray *b)
506 {
507 BStream_readTag(self, BSTREAM_UNSIGNED_INT, 1, 1);
508 {
509 size_t size = BStream_readTaggedInt32(self);
510 unsigned char *data = BStream_readDataOfLength_(self, size);
511 UArray_setData_type_size_copy_(b, data, CTYPE_uint8_t, size, 1);
512 }
513 }
514
515 UArray *BStream_readTaggedUArray(BStream *self)
516 {
517 BStream_readTaggedUArray_(self, self->tmp);
518 return self->tmp;
519 }
520
521 const char *BStream_readTaggedCString(BStream *self)
522 {
523 BStream_readTag(self, BSTREAM_UNSIGNED_INT, 1, 1);
524
525 {
526 size_t size = BStream_readTaggedInt32(self);
527 return (char *)BStream_readDataOfLength_(self, size);
528 }
529 }
530
531 int BStream_atEnd(BStream *self)
532 {
533 return self->index >= UArray_size(self->ba);
534 }
535
536 int BStream_showInt(BStream *self)
537 {
538 unsigned char c = BStream_readUint8(self);
539 BStreamTag t = BStreamTag_FromUnsignedChar(c);
540 int v = 0;
541
542 printf("%s%i ", BStreamTag_typeName(&t), t.byteCount * 8);
543
544 if (t.byteCount < 5)
545 {
546 BStream_readNumber_size_(self, (unsigned char *)(&v), t.byteCount);
547 }
548 else
549 {
550 printf("ERROR: byteCount out of range\n");
551 exit(-1);
552 }
553
554 printf("%i", v);
555 return v;
556 }
557
558 void BStream_show(BStream *self)
559 {
560 int pos = self->index;
561 int v = 0;
562
563 self->index = 0;
564
565 while (!BStream_atEnd(self))
566 {
567 unsigned char c = BStream_readUint8(self);
568 BStreamTag t = BStreamTag_FromUnsignedChar(c);
569
570 /*printf("isArray:%i type:%s byteCount:%i value:", t.isArray, BStreamTag_typeName(t), t.byteCount);*/
571 printf(" %s%i %s", BStreamTag_typeName(&t), t.byteCount * 8, t.isArray ? "array " : "");
572 fflush(stdout);
573
574 if (t.isArray)
575 {
576 printf("[");
577
578 if (t.byteCount == 1)
579 {
580 int size = BStream_showInt(self);
581 if (size == 0)
582 {
583 printf(" '']\n");
584 }
585 else
586 {
587 unsigned char *data = BStream_readDataOfLength_(self, size);
588 printf(" '%s']\n", data);
589 }
590 }
591 else
592 {
593 printf("ERROR: array element byteCount not 1\n");
594 exit(-1);
595 }
596 }
597 else
598 {
599 if (t.byteCount > 0 && t.byteCount < 5)
600 {
601 BStream_readNumber_size_(self, (unsigned char *)(&v), t.byteCount);
602 }
603 else
604 {
605 printf("ERROR: byteCount out of range\n");
606 exit(1);
607 }
608
609 /*
610 if (t.byteCount == 1)
611 {
612 printf("%c\n", v);
613 }
614 else
615 {
616 */
617 printf("%i\n", v);
618 /*}*/
619 }
620 }
621 self->index = pos;
622 }
quag's Io