compiler/arossupport/readstruct.c

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