compiler/arossupport/writestruct.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Write a big endian structure to 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 WriteLevel
  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 WriteStruct (
  32
  33 /*  SYNOPSIS */
  34         struct Hook * hook,
  35         void        * data,
  36         void        * stream,
  37         const IPTR  * sd)
  38
  39 /*  FUNCTION
  40         Writes one big endian structure to a streamhook.
  41
  42     INPUTS
  43         hook - Write to this streamhook
  44         data - Data to be written
  45         stream - Stream passed to streamhook
  46         sd - Description of the structure to be written. The first element
  47                 is the size of the structure.
  48
  49     RESULT
  50         The function returns TRUE on success and FALSE otherwise. In error,
  51         you can examine IoErr() to find out what was wrong.
  52
  53     NOTES
  54         This function writes big endian values to a file even on little
  55         endian machines.
  56
  57     EXAMPLE
  58         See ReadStruct().
  59
  60     BUGS
  61
  62     INTERNALS
  63         The function uses the Write*()-functions to write data into
  64         the file.
  65
  66         Pointers are written as <valid><data structure>, where valid is
  67         a byte with the values 1 (then the full data structure follows)
  68         or 0 (then nothing follows and the pointer will be intialized as
  69         NULL when the structure is read back).
  70
  71     SEE ALSO
  72         ReadByte(), ReadWord(), ReadLong(), ReadFloat(), ReadDouble(),
  73         ReadString(), ReadStruct(), WriteByte(), WriteWord(), WriteLong(),
  74         WriteFloat(), WriteDouble(), WriteString(), WriteStruct()
  75
  76     HISTORY
  77
  78 ******************************************************************************/
  79 {
  80     struct MinList      _list;
  81     struct WriteLevel * curr;
  82
  83 #   define list     ((struct List *)&_list)
  84
  85     NEWLIST(list);
  86
  87     if (!(curr = AllocMem (sizeof (struct WriteLevel), MEMF_ANY)) )
  88         return FALSE;
  89
  90     AddTail (list, (struct Node *)curr);
  91
  92     curr->sd  = sd;
  93     curr->pos = 1; /* Ignore size */
  94     curr->s   = data;
  95
  96 #   define DESC     (curr->sd[curr->pos])
  97 #   define IDESC    (curr->sd[curr->pos ++])
  98
  99     while (DESC != SDT_END)
 100     {
 101         switch (IDESC)
 102         {
 103         case SDT_UBYTE:      /* Write one  8bit byte */
 104             if (!WriteByte (hook, *((UBYTE *)(curr->s + IDESC)), stream))
 105                 goto error;
 106
 107             break;
 108
 109         case SDT_UWORD:      /* Write one 16bit word */
 110             if (!WriteWord (hook, *((UWORD *)(curr->s + IDESC)), stream))
 111                 goto error;
 112
 113             break;
 114
 115         case SDT_ULONG:      /* Write one 32bit long */
 116             if (!WriteLong (hook, *((ULONG *)(curr->s + IDESC)), stream))
 117                 goto error;
 118
 119             break;
 120
 121         case SDT_FLOAT:      /* Write one 32bit IEEE */
 122             if (!WriteFloat (hook, *((FLOAT *)(curr->s + IDESC)), stream))
 123                 goto error;
 124
 125             break;
 126
 127         case SDT_DOUBLE:     /* Write one 64bit IEEE */
 128             if (!WriteDouble (hook, *((DOUBLE *)(curr->s + IDESC)), stream))
 129                 goto error;
 130
 131             break;
 132
 133         case SDT_STRING: {   /* Write a string */
 134             STRPTR str;
 135
 136             str = *((STRPTR *)(curr->s + IDESC));
 137
 138             if (str)
 139             {
 140                 if (!WriteByte (hook, 1, stream))
 141                     goto error;
 142
 143                 if (!WriteString (hook, str, stream))
 144                     goto error;
 145             }
 146             else
 147             {
 148                 if (!WriteByte (hook, 0, stream))
 149                     goto error;
 150
 151                 curr->pos ++;
 152             }
 153
 154             break; }
 155
 156         case SDT_STRUCT: {    /* Write a structure */
 157             struct WriteLevel * next;
 158
 159             IPTR * desc;
 160             APTR   ptr;
 161
 162             ptr  = (APTR)(curr->s + IDESC);
 163             desc = (IPTR *)IDESC;
 164
 165             if (!(next = AllocMem (sizeof (struct WriteLevel), MEMF_ANY)) )
 166                 goto error;
 167
 168             AddTail (list, (struct Node *)next);
 169             next->sd  = desc;
 170             next->pos = 1; /* Ignore size */
 171             next->s   = ptr;
 172
 173             curr = next;
 174
 175             break; }
 176
 177         case SDT_PTR: {       /* Follow a pointer */
 178             struct WriteLevel * next;
 179
 180             IPTR * desc;
 181             APTR   ptr;
 182
 183             ptr  = *((APTR *)(curr->s + IDESC));
 184             desc = (IPTR *)IDESC;
 185
 186             if (ptr)
 187             {
 188                 if (!WriteByte (hook, 1, stream))
 189                     goto error;
 190
 191                 if (!(next = AllocMem (sizeof (struct WriteLevel), MEMF_ANY)) )
 192                     goto error;
 193
 194                 AddTail (list, (struct Node *)next);
 195                 next->sd  = desc;
 196                 next->pos = 1;
 197                 next->s   = ptr;
 198
 199                 curr = next;
 200             }
 201             else
 202             {
 203                 if (!WriteByte (hook, 0, stream))
 204                     goto error;
 205
 206                 curr->pos ++;
 207             }
 208
 209             break; }
 210
 211         case SDT_IGNORE: {   /* Ignore x bytes */
 212             ULONG count;
 213         struct BEIOM_Write wr = {BEIO_WRITE, 0};
 214
 215             count = IDESC;
 216
 217             while (count --)
 218             {
 219                 if (CallHookA (hook, stream, &wr) == EOF)
 220                     goto error;
 221             }
 222
 223             break; }
 224
 225         case SDT_FILL_BYTE:   /* Fill x bytes */
 226         case SDT_FILL_LONG:   /* Fill x longs */
 227             /* ignore */
 228             break;
 229
 230         case SDT_IFILL_BYTE: { /* Fill x bytes */
 231             IPTR  offset;
 232             UBYTE value;
 233             IPTR  count;
 234
 235         struct BEIOM_Write wr = {BEIO_WRITE, 0};
 236
 237             offset = IDESC;
 238             value  = IDESC;
 239             count  = IDESC;
 240
 241             while (count --)
 242             {
 243                 if (CallHookA (hook, stream, &wr) == EOF)
 244                     goto error;
 245             }
 246
 247             break; }
 248
 249         case SDT_IFILL_LONG: { /* Fill x longs */
 250             IPTR  offset;
 251             UBYTE value;
 252             IPTR  count;
 253         struct BEIOM_Write wr = {BEIO_WRITE, 0};
 254
 255             offset = IDESC;
 256             value  = IDESC;
 257             count  = IDESC;
 258
 259             count <<= 2;
 260
 261             while (count --)
 262             {
 263                 if (CallHookA (hook, stream, &wr) == EOF)
 264                     goto error;
 265             }
 266
 267             break; }
 268
 269         case SDT_SPECIAL: {   /* Call user hook */
 270             struct Hook * uhook;
 271             struct SDData data;
 272
 273             data.sdd_Dest   = ((APTR)(curr->s + IDESC));
 274             data.sdd_Mode   = SDV_SPECIALMODE_WRITE;
 275             data.sdd_Stream = stream;
 276
 277             uhook = (struct Hook *)IDESC;
 278
 279             CallHookA (uhook, hook, &data);
 280
 281             break; }
 282
 283         default:
 284             goto error;
 285
 286         } /* switch */
 287
 288         /* End of the description list ? */
 289         if (DESC == SDT_END)
 290         {
 291             struct WriteLevel * last;
 292
 293             /* Remove the current level */
 294             last = curr;
 295             Remove ((struct Node *)last);
 296
 297             /* Get the last level */
 298             if ((curr = (struct WriteLevel *)GetTail (list)))
 299             {
 300                 FreeMem (last, sizeof (struct WriteLevel));
 301             }
 302             else
 303             {
 304                 curr = last;
 305             }
 306         }
 307     } /* while */
 308
 309     FreeMem (curr, sizeof (struct WriteLevel));
 310
 311     return TRUE;
 312
 313 error:
 314
 315     while ((curr = (struct WriteLevel *)RemTail (list)))
 316         FreeMem (curr, sizeof (struct WriteLevel));
 317
 318     return FALSE;
 319 } /* WriteStruct */