compiler/arossupport/readstruct.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Read a big endian structure from a streamhook
   6     Lang: english
   7 */
   8
   9 #include <string.h>
  10 #include <exec/memory.h>
  11 #include <proto/dos.h>
  12 #include <proto/exec.h>
  13 #include <aros/debug.h>
  14 #include <utility/hooks.h>
  15
  16 struct ReadLevel
  17 {
  18     struct MinNode   node;
  19     const IPTR     * sd;
  20     UBYTE          * s;
  21     int              pos;
  22 };
  23
  24 /******************************************************************************
  25
  26     NAME */
  27 #include <stdio.h>
  28 #include <aros/bigendianio.h>
  29 #include <proto/alib.h>
  30
  31         BOOL ReadStruct (
  32
  33 /*  SYNOPSIS */
  34         struct Hook * hook,
  35         APTR        * dataptr,
  36         void        * stream,
  37         const IPTR  * sd)
  38
  39 /*  FUNCTION
  40         Reads one big endian structure from a streamhook.
  41
  42     INPUTS
  43         hook - Streamhook
  44         dataptr - Put the data here
  45         stream - Read from this stream
  46         sd - Description of the structure to be read. The first element
  47                 is the size of the structure.
  48
  49     RESULT
  50         The function returns TRUE on success. On success, the value
  51         read is written into dataptr. On failure, FALSE is returned and the
  52         contents of dataptr are not changed.
  53
  54     NOTES
  55         This function reads big endian values from a streamhook even on
  56         little endian machines.
  57
  58     EXAMPLE
  59         See below.
  60
  61     BUGS
  62
  63     SEE ALSO
  64         ReadByte(), ReadWord(), ReadLong(), ReadFloat(), ReadDouble(),
  65         ReadString(), ReadStruct(), WriteByte(), WriteWord(), WriteLong(),
  66         WriteFloat(), WriteDouble(), WriteString(), WriteStruct()
  67
  68     HISTORY
  69
  70 ******************************************************************************/
  71 {
  72     struct MinList     _list;
  73     struct ReadLevel * curr;
  74
  75 #   define list     ((struct List *)&_list)
  76
  77     NEWLIST(list);
  78
  79     if (!(curr = AllocMem (sizeof (struct ReadLevel), MEMF_ANY)) )
  80         return FALSE;
  81
  82     AddTail (list, (struct Node *)curr);
  83
  84     curr->sd  = sd;
  85     curr->pos = 0;
  86     curr->s   = NULL;
  87
  88 #   define DESC     curr->sd[curr->pos]
  89 #   define IDESC    curr->sd[curr->pos ++]
  90
  91     for (;;)
  92     {
  93         if (!curr->pos)
  94         {
  95             if (!(curr->s = AllocMem (IDESC, MEMF_CLEAR)) )
  96                 goto error;
  97         }
  98
  99         if (DESC == SDT_END)
 100             break;
 101
 102         switch (IDESC)
 103         {
 104         case SDT_UBYTE:      /* Read one  8bit byte */
 105             if (!ReadByte (hook, (UBYTE *)(curr->s + IDESC), stream))
 106                 goto error;
 107
 108             break;
 109
 110         case SDT_UWORD:      /* Read one 16bit word */
 111             if (!ReadWord (hook, (UWORD *)(curr->s + IDESC), stream))
 112                 goto error;
 113
 114             break;
 115
 116         case SDT_ULONG:      /* Read one 32bit long */
 117             if (!ReadLong (hook, (ULONG *)(curr->s + IDESC), stream))
 118                 goto error;
 119
 120             break;
 121
 122         case SDT_FLOAT:      /* Read one 32bit IEEE */
 123             if (!ReadFloat (hook, (FLOAT *)(curr->s + IDESC), stream))
 124                 goto error;
 125
 126             break;
 127
 128         case SDT_DOUBLE:     /* Read one 64bit IEEE */
 129             if (!ReadDouble (hook, (DOUBLE *)(curr->s + IDESC), stream))
 130                 goto error;
 131
 132             break;
 133
 134         case SDT_STRING: {   /* Read a string */
 135             UBYTE    valid_ptr;
 136             STRPTR * sptr;
 137
 138             sptr = (STRPTR *)(curr->s + IDESC);
 139
 140             if (!ReadByte (hook, &valid_ptr, stream))
 141                 goto error;
 142
 143             if (valid_ptr)
 144             {
 145                 if (!ReadString (hook, sptr, stream))
 146                     goto error;
 147             }
 148             else
 149             {
 150                 *sptr = NULL;
 151             }
 152
 153             break; }
 154
 155         case SDT_STRUCT: {    /* Read a structure */
 156             struct ReadLevel * next;
 157             IPTR * desc;
 158             APTR   aptr;
 159
 160             aptr = (APTR)(curr->s + IDESC);
 161             desc = (IPTR *)IDESC;
 162
 163             curr->pos -= 3; /* Go back to type */
 164
 165             if (!(next = AllocMem (sizeof (struct ReadLevel), MEMF_ANY)) )
 166                 goto error;
 167
 168             AddTail (list, (struct Node *)next);
 169             next->sd  = desc;
 170             next->pos = 1;
 171             next->s   = aptr;
 172
 173             curr = next;
 174
 175             break; }
 176
 177         case SDT_PTR: {    /* Follow a pointer */
 178             struct ReadLevel * next;
 179
 180             UBYTE  valid_ptr;
 181             IPTR * desc;
 182             APTR * aptr;
 183
 184             aptr = ((APTR *)(curr->s + IDESC));
 185             desc = (IPTR *)IDESC;
 186
 187             if (!ReadByte (hook, &valid_ptr, stream))
 188                 goto error;
 189
 190             if (valid_ptr)
 191             {
 192                 curr->pos -= 3;
 193
 194                 if (!(next = AllocMem (sizeof (struct ReadLevel), MEMF_ANY)) )
 195                     goto error;
 196
 197                 AddTail (list, (struct Node *)next);
 198                 next->sd  = desc;
 199                 next->pos = 0;
 200
 201                 curr = next;
 202             }
 203             else
 204             {
 205                 *aptr = NULL;
 206             }
 207
 208             break; }
 209
 210         case SDT_IGNORE: {   /* Ignore x bytes */
 211         struct BEIOM_Ignore ig = {BEIO_IGNORE, IDESC};
 212             if (CallHookA (hook, stream, &ig) == EOF)
 213                 goto error;
 214
 215             break; }
 216
 217         case SDT_FILL_BYTE: { /* Fill x bytes */
 218             IPTR  offset;
 219             UBYTE value;
 220             IPTR  count;
 221
 222             offset = IDESC;
 223             value  = IDESC;
 224             count  = IDESC;
 225
 226             memset (curr->s + offset, value, count);
 227
 228             break; }
 229
 230         case SDT_FILL_LONG: { /* Fill x longs */
 231             ULONG * ulptr;
 232             ULONG   value;
 233             IPTR    count;
 234
 235             ulptr = (ULONG *)(curr->s + IDESC);
 236             value = IDESC;
 237             count = IDESC;
 238
 239             while (count --)
 240                 *ulptr ++ = value;
 241
 242             break; }
 243
 244         case SDT_IFILL_BYTE: { /* Fill x bytes */
 245             IPTR  offset;
 246             UBYTE value;
 247             IPTR  count;
 248
 249             offset = IDESC;
 250             value  = IDESC;
 251             count  = IDESC;
 252
 253         struct BEIOM_Ignore ig = {BEIO_IGNORE, count};
 254
 255             if (CallHookA (hook, stream, &ig) == EOF)
 256                 goto error;
 257
 258             memset (curr->s + offset, value, count);
 259
 260             break; }
 261
 262         case SDT_IFILL_LONG: { /* Fill x longs */
 263             ULONG * ulptr;
 264             ULONG   value;
 265             IPTR    count;
 266
 267             ulptr = (ULONG *)(curr->s + IDESC);
 268             value = IDESC;
 269             count = IDESC;
 270
 271         struct BEIOM_Ignore ig = {BEIO_IGNORE, count << 2};
 272
 273             if (CallHookA (hook, stream, &ig) == EOF)
 274                 goto error;
 275
 276             while (count --)
 277                 *ulptr ++ = value;
 278
 279             break; }
 280
 281         case SDT_SPECIAL: {   /* Call user hook */
 282             struct Hook * uhook;
 283             struct SDData data;
 284
 285             data.sdd_Dest   = ((APTR)(curr->s + IDESC));
 286             data.sdd_Mode   = SDV_SPECIALMODE_READ;
 287             data.sdd_Stream = stream;
 288
 289             uhook = (struct Hook *)IDESC;
 290
 291             if (!CallHookA (uhook, hook, &data))
 292                 goto error;
 293
 294             break; }
 295
 296         default:
 297             goto error;
 298
 299         } /* switch */
 300
 301         /* End of the description list ? */
 302         if (DESC == SDT_END)
 303         {
 304             struct ReadLevel * last;
 305
 306             /* Remove the current level */
 307             last = curr;
 308             Remove ((struct Node *)last);
 309
 310             /* Get the last level */
 311             if ((curr = (struct ReadLevel *)GetTail (list)))
 312             {
 313                 switch (IDESC)
 314                 {
 315                 case SDT_STRUCT:
 316                     curr->pos += 2; /* Skip 2 parameters */
 317                     break;
 318
 319                 case SDT_PTR: {
 320                     APTR * aptr;
 321
 322                     aptr  = ((APTR *)(curr->s + IDESC));
 323                     curr->pos ++; /* Skip description parameter */
 324
 325                     /*
 326                         Now put the result of the current level in the
 327                         struct of the previous level.
 328                     */
 329                     *aptr = last->s;
 330
 331                     break; }
 332
 333                 }
 334
 335                 FreeMem (last, sizeof (struct ReadLevel));
 336             }
 337             else
 338             {
 339                 curr = last;
 340             }
 341         }
 342     } /* while */
 343
 344     *dataptr = curr->s;
 345
 346     FreeMem (curr, sizeof (struct ReadLevel));
 347
 348     return TRUE;
 349
 350 error:
 351     curr = (struct ReadLevel *)GetHead (list);
 352
 353     if (curr && curr->s)
 354         FreeStruct (curr->s, curr->sd);
 355
 356     while ((curr = (struct ReadLevel *)RemTail (list)))
 357         FreeMem (curr, sizeof (struct ReadLevel));
 358
 359     return FALSE;
 360 } /* ReadStruct */
 361
 362 #ifdef TEST
 363 #include <stdio.h>
 364 #include <dos/dos.h>
 365 #include <aros/structdesc.h>
 366 #include <proto/alib.h>
 367
 368 struct Level1
 369 {
 370     BYTE l1_Byte;
 371     LONG l1_Long;
 372 };
 373
 374 struct MainLevel
 375 {
 376     BYTE   ml_Byte;
 377     UBYTE  ml_UByte;
 378     WORD   ml_Word;
 379     UWORD  ml_UWord;
 380     LONG   ml_Long;
 381     ULONG  ml_ULong;
 382     FLOAT  ml_Float;
 383     DOUBLE ml_Double;
 384     STRPTR ml_String;
 385     struct Level1 ml_Level1;
 386
 387     BYTE   * ml_BytePtr;
 388     WORD   * ml_WordPtr;
 389     LONG   * ml_LongPtr;
 390     FLOAT  * ml_FloatPtr;
 391     DOUBLE * ml_DoublePtr;
 392     STRPTR * ml_StringPtr;
 393     struct Level1 * ml_Level1Ptr;
 394 };
 395
 396 IPTR ByteDesc[]   = { sizeof(UBYTE),  SDM_UBYTE(0),  SDM_END };
 397 IPTR WordDesc[]   = { sizeof(UWORD),  SDM_UWORD(0),  SDM_END };
 398 IPTR LongDesc[]   = { sizeof(ULONG),  SDM_ULONG(0),  SDM_END };
 399 IPTR FloatDesc[]  = { sizeof(FLOAT),  SDM_FLOAT(0),  SDM_END };
 400 IPTR DoubleDesc[] = { sizeof(DOUBLE), SDM_DOUBLE(0), SDM_END };
 401 IPTR StringDesc[] = { sizeof(STRPTR), SDM_STRING(0), SDM_END };
 402
 403 #define O(x)        offsetof(struct Level1,x)
 404 IPTR Level1Desc[] =
 405 {
 406     sizeof (struct Level1),
 407     SDM_UBYTE(O(l1_Byte)),
 408     SDM_ULONG(O(l1_Long)),
 409     SDM_END
 410 };
 411
 412 #undef O
 413 #define O(x)        offsetof(struct MainLevel,x)
 414 IPTR MainDesc[] =
 415 {
 416     sizeof (struct MainLevel),
 417     SDM_UBYTE(O(ml_Byte)),
 418     SDM_UBYTE(O(ml_UByte)),
 419     SDM_UWORD(O(ml_Word)),
 420     SDM_UWORD(O(ml_UWord)),
 421     SDM_ULONG(O(ml_Long)),
 422     SDM_ULONG(O(ml_ULong)),
 423     SDM_FLOAT(O(ml_Float)),
 424     SDM_DOUBLE(O(ml_Double)),
 425     SDM_STRING(O(ml_String)),
 426     SDM_STRUCT(O(ml_Level1),Level1Desc),
 427
 428     SDM_PTR(O(ml_BytePtr),ByteDesc),
 429     SDM_PTR(O(ml_WordPtr),WordDesc),
 430     SDM_PTR(O(ml_LongPtr),LongDesc),
 431     SDM_PTR(O(ml_FloatPtr),FloatDesc),
 432     SDM_PTR(O(ml_DoublePtr),DoubleDesc),
 433     SDM_PTR(O(ml_StringPtr),StringDesc),
 434     SDM_PTR(O(ml_Level1Ptr),Level1Desc),
 435
 436     SDM_END
 437 };
 438
 439 LONG dosstreamhook (struct Hook * hook, BPTR fh, ULONG * msg);
 440
 441 struct Hook dsh =
 442 {
 443     { NULL, NULL }, HookEntry, (void *)dosstreamhook, NULL
 444 };
 445
 446 LONG dosstreamhook (struct Hook * hook, BPTR fh, ULONG * msg)
 447 {
 448     LONG rc;
 449
 450     switch (*msg)
 451     {
 452     case BEIO_READ:
 453         rc = FGetC (fh);
 454         break;
 455
 456     case BEIO_WRITE:
 457         rc = FPutC (fh, ((struct BEIOM_Write *)msg)->Data);
 458         break;
 459
 460     case BEIO_IGNORE:
 461         Flush (fh);
 462
 463         rc = Seek (fh, ((struct BEIOM_Ignore *)msg)->Count, OFFSET_CURRENT);
 464         break;
 465
 466     }
 467
 468     return rc;
 469 } /* dosstreamhook */
 470
 471 int main (int argc, char ** argv)
 472 {
 473     struct MainLevel demo =
 474     {
 475         (BYTE)0x88,       0xFF,
 476         (WORD)0x8844,     0xFF77,
 477         (LONG)0x88442211, 0xFF773311,
 478         1.5, 1.75,
 479         "Hallo",
 480         { (BYTE)0x88, (LONG)0x88442211 },
 481         /* ... */
 482     };
 483     BYTE b = (BYTE)0x88;
 484     WORD w = (WORD)0x8844;
 485     LONG l = (LONG)0x88442211;
 486     FLOAT f = 1.5;
 487     DOUBLE d = 1.75;
 488     STRPTR s = "Hallo";
 489     struct Level1 l1 =
 490     {
 491         (BYTE)0x88, (LONG)0x88442211
 492     };
 493     BPTR fh;
 494     struct MainLevel * readback;
 495
 496     demo.ml_BytePtr = &b;
 497     demo.ml_WordPtr = &w;
 498     demo.ml_LongPtr = &l;
 499     demo.ml_FloatPtr = &f;
 500     demo.ml_DoublePtr = &d;
 501     demo.ml_StringPtr = &s;
 502     demo.ml_Level1Ptr = &l1;
 503
 504     fh = Open ("writestruct.dat", MODE_NEWFILE);
 505
 506     if (!fh)
 507     {
 508         PrintFault (IoErr(), "Can't open file\n");
 509         return 10;
 510     }
 511
 512     /*
 513         This writes the following data stream:
 514
 515             0000 88                         ml_Byte
 516             0001 ff                         ml_Ubyte
 517             0002 88 44                      ml_Word
 518             0004 ff 77                      ml_UWord
 519             0006 88 44 22 11                ml_Long
 520             000a ff 77 33 11                ml_ULong
 521             000e 3f c0 00 00                ml_Float
 522             0012 3f fc 00 00 00 00 00 00    ml_Double
 523             001a 01:48 61 6c 6c 6f 00       ml_String
 524             0021 88                         ml_Level1.l1_Byte
 525             0022 88 44 22 11                ml_Level1.l1_Long
 526             0026 01:88                      ml_BytePtr
 527             0028 01:88 44                   ml_WordPtr
 528             002b 01:88 44 22 11             ml_LongPtr
 529             0030 01:3f c0 00 00             ml_FloatPtr
 530             0035 01:3f fc 00 00 00 00 00 00 ml_DoublePtr
 531             003e 01:01:48 61 6c 6c 6f 00    ml_StringPtr - Note two 01 !
 532             0046 01:88 88 44 22 11          ml_Level1Ptr
 533     */
 534
 535     if (!WriteStruct (&dsh, &demo, fh, MainDesc))
 536     {
 537         PrintFault (IoErr(), "Failed to write to file\n");
 538     }
 539
 540     if (!Close (fh))
 541     {
 542         PrintFault (IoErr(), "Failed to close file\n");
 543     }
 544
 545     /* Read the structure back */
 546     fh = Open ("writestruct.dat", MODE_OLDFILE);
 547
 548     if (!fh)
 549     {
 550         PrintFault (IoErr(), "Can't open file for reading\n");
 551         return 10;
 552     }
 553
 554     if (!ReadStruct (&dsh, (APTR *)&readback, fh, MainDesc))
 555     {
 556         PrintFault (IoErr(), "Failed to read from file\n");
 557     }
 558     else
 559     {
 560         UBYTE * ptr;
 561         int t;
 562
 563         ptr = (UBYTE *)readback;
 564         t = 0;
 565
 566         kprintf ("readback = %p\n", readback);
 567
 568         kprintf ("%02X (88) %02X (FF)\n"
 569             , (UBYTE)readback->ml_Byte
 570             , readback->ml_UByte
 571         );
 572         kprintf ("%04X (8844) %04X (FF77)\n"
 573             , (UWORD)readback->ml_Word
 574             , readback->ml_UWord
 575         );
 576         kprintf ("%08lX (88442211) %08lX (FF773311)\n"
 577             , readback->ml_Long
 578             , readback->ml_ULong
 579         );
 580         kprintf ("%08lX (3FC00000) %08lX:%08lX (3FFC0000:00000000)\n"
 581             , *(ULONG *)&readback->ml_Float
 582             , ((ULONG *)&readback->ml_Double)[1]
 583             , ((ULONG *)&readback->ml_Double)[0]
 584         );
 585         kprintf ("%s (Hallo)\n"
 586             , readback->ml_String
 587         );
 588         kprintf ("{ %02X %08X } ({ 88 88442211 })\n"
 589             , (UBYTE)readback->ml_Level1.l1_Byte
 590             , readback->ml_Level1.l1_Long
 591         );
 592         kprintf ("%02X (88)\n"
 593             , (UBYTE)*readback->ml_BytePtr
 594         );
 595         kprintf ("%04X (8844)\n"
 596             , (UWORD)*readback->ml_WordPtr
 597         );
 598         kprintf ("%08lX (88442211)\n"
 599             , *readback->ml_LongPtr
 600         );
 601         kprintf ("%08lX (3FC00000) %08lX:%08lX (3FFC0000:00000000)\n"
 602             , *(ULONG *)readback->ml_FloatPtr
 603             , ((ULONG *)readback->ml_DoublePtr)[1]
 604             , ((ULONG *)readback->ml_DoublePtr)[0]
 605         );
 606         kprintf ("%s (Hallo)\n"
 607             , *readback->ml_StringPtr
 608         );
 609         kprintf ("{ %02X %08X } ({ 88 88442211 })\n"
 610             , (UBYTE)readback->ml_Level1Ptr->l1_Byte
 611             , readback->ml_Level1Ptr->l1_Long
 612         );
 613
 614         FreeStruct (readback, MainDesc);
 615     }
 616
 617     if (!Close (fh))
 618     {
 619         PrintFault (IoErr(), "Failed to close file after reading\n");
 620     }
 621
 622     return 0;
 623 } /* main */
 624
 625 #endif /* TEST */
 626