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  count;
 232
 233         struct BEIOM_Write wr = {BEIO_WRITE, 0};
 234
 235             count  = IDESC;
 236
 237             while (count --)
 238             {
 239                 if (CallHookA (hook, stream, &wr) == EOF)
 240                     goto error;
 241             }
 242
 243             break; }
 244
 245         case SDT_IFILL_LONG: { /* Fill x longs */
 246             IPTR  count;
 247         struct BEIOM_Write wr = {BEIO_WRITE, 0};
 248
 249             count  = IDESC;
 250
 251             count <<= 2;
 252
 253             while (count --)
 254             {
 255                 if (CallHookA (hook, stream, &wr) == EOF)
 256                     goto error;
 257             }
 258
 259             break; }
 260
 261         case SDT_SPECIAL: {   /* Call user hook */
 262             struct Hook * uhook;
 263             struct SDData data;
 264
 265             data.sdd_Dest   = ((APTR)(curr->s + IDESC));
 266             data.sdd_Mode   = SDV_SPECIALMODE_WRITE;
 267             data.sdd_Stream = stream;
 268
 269             uhook = (struct Hook *)IDESC;
 270
 271             if (!CallHookA (uhook, hook, &data))
 272                 goto error;
 273
 274             break; }
 275
 276         default:
 277             goto error;
 278
 279         } /* switch */
 280
 281         /* End of the description list ? */
 282         if (DESC == SDT_END)
 283         {
 284             struct WriteLevel * last;
 285
 286             /* Remove the current level */
 287             last = curr;
 288             Remove ((struct Node *)last);
 289
 290             /* Get the last level */
 291             if ((curr = (struct WriteLevel *)GetTail (list)))
 292             {
 293                 FreeMem (last, sizeof (struct WriteLevel));
 294             }
 295             else
 296             {
 297                 curr = last;
 298             }
 299         }
 300     } /* while */
 301
 302     FreeMem (curr, sizeof (struct WriteLevel));
 303
 304     return TRUE;
 305
 306 error:
 307
 308     while ((curr = (struct WriteLevel *)RemTail (list)))
 309         FreeMem (curr, sizeof (struct WriteLevel));
 310
 311     return FALSE;
 312 } /* WriteStruct */