compiler/arossupport/freestruct.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Free a structure returned by ReadStruct()
   6     Lang: english
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <proto/dos.h>
  11 #include <proto/exec.h>
  12 #include <aros/debug.h>
  13 #include <utility/hooks.h>
  14
  15 struct FreeLevel
  16 {
  17     struct MinNode   node;
  18     const IPTR     * sd;
  19     UBYTE          * s;
  20     ULONG            size;
  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         void FreeStruct (
  32
  33 /*  SYNOPSIS */
  34         APTR         data,
  35         const IPTR * sd)
  36
  37 /*  FUNCTION
  38         Free a structure which was created by ReadStruct().
  39
  40     INPUTS
  41         data - This was returned by ReadStruct() in the dataptr parameter.
  42                 Must be non-NULL.
  43         sd - Description of the structure to be read. The first element
  44                 is the size of the structure.
  45
  46     RESULT
  47         None.
  48
  49     NOTES
  50
  51     EXAMPLE
  52         See ReadStruct()
  53
  54     BUGS
  55
  56     SEE ALSO
  57         dos.library/Open(), dos.library/Close(), ReadByte(), ReadWord(),
  58         ReadLong(), ReadFloat(),
  59         ReadString(), ReadStruct(), WriteByte(), WriteWord(), WriteLong(),
  60         WriteFloat(), WriteDouble(), WriteString(), WriteStruct()
  61
  62 ******************************************************************************/
  63 {
  64     struct MinList     _list;
  65     struct FreeLevel * curr;
  66
  67 #   define list     ((struct List *)&_list)
  68
  69     NEWLIST(list);
  70
  71     if (!(curr = AllocMem (sizeof (struct FreeLevel), MEMF_ANY)) )
  72         return;
  73
  74     AddTail (list, (struct Node *)curr);
  75
  76     curr->sd  = sd;
  77     curr->pos = 0;
  78     curr->s   = data;
  79
  80 #   define DESC     curr->sd[curr->pos]
  81 #   define IDESC    curr->sd[curr->pos ++]
  82
  83     for (;;)
  84     {
  85         if (!curr->pos)
  86         {
  87             curr->size = IDESC;
  88         }
  89
  90         if (DESC == SDT_END)
  91             break;
  92
  93         switch (IDESC)
  94         {
  95         case SDT_UBYTE:      /* Read one  8bit byte */
  96         case SDT_UWORD:      /* Read one 16bit word */
  97         case SDT_ULONG:      /* Read one 32bit long */
  98         case SDT_FLOAT:      /* Read one 32bit IEEE */
  99         case SDT_DOUBLE:     /* Read one 64bit IEEE */
 100         case SDT_IGNORE:     /* Ignore x bytes */
 101             /* Ignore these */
 102             curr->pos ++;
 103             break;
 104
 105         case SDT_STRING: {   /* Read a string */
 106             STRPTR sptr;
 107
 108             sptr = *(STRPTR *)(curr->s + IDESC);
 109
 110         FreeVec (sptr);
 111
 112             break; }
 113
 114         case SDT_STRUCT: {    /* Read a structure */
 115             /* Ignore two parameters */
 116             curr->pos += 2;
 117
 118             break; }
 119
 120         case SDT_PTR: {    /* Follow a pointer */
 121             struct FreeLevel * next;
 122
 123             IPTR * desc;
 124             APTR * aptr;
 125
 126             aptr = ((APTR *)(curr->s + IDESC));
 127             desc = (IPTR *)IDESC;
 128
 129             if (*aptr)
 130             {
 131                 if (!(next = AllocMem (sizeof (struct FreeLevel), MEMF_ANY)) )
 132                     goto error;
 133
 134                 AddTail (list, (struct Node *)next);
 135                 next->sd  = desc;
 136                 next->pos = 0;
 137                 next->s   = *aptr;
 138
 139                 curr = next;
 140             }
 141
 142             break; }
 143
 144         case SDT_FILL_BYTE:   /* Fill x bytes */
 145         case SDT_FILL_LONG:   /* Fill x longs */
 146         case SDT_IFILL_BYTE:  /* Fill x bytes */
 147         case SDT_IFILL_LONG:  /* Fill x longs */
 148             curr->pos += 3; /* Ignore three parameters */
 149             break;
 150
 151         case SDT_SPECIAL: {   /* Call user hook */
 152             struct Hook * hook;
 153             struct SDData data;
 154
 155             data.sdd_Dest = ((APTR)(curr->s + IDESC));
 156             data.sdd_Mode = SDV_SPECIALMODE_FREE;
 157
 158             hook = (struct Hook *)IDESC;
 159
 160             CallHookA (hook, NULL, &data);
 161
 162             break; }
 163
 164         } /* switch */
 165
 166         /* End of the description list ? */
 167         if (DESC == SDT_END)
 168         {
 169             struct FreeLevel * last;
 170
 171             /* Remove the current level */
 172             last = curr;
 173             Remove ((struct Node *)last);
 174
 175             /* Get the last level */
 176             if ((curr = (struct FreeLevel *)GetTail (list)))
 177             {
 178                 FreeMem (last->s, last->size);
 179                 FreeMem (last, sizeof (struct FreeLevel));
 180             }
 181             else
 182             {
 183                 curr = last;
 184             }
 185         }
 186     } /* while */
 187
 188     FreeMem (curr->s, curr->size);
 189     FreeMem (curr, sizeof (struct FreeLevel));
 190
 191     return;
 192
 193 error:
 194     while ((curr = (struct FreeLevel *)RemTail (list)))
 195         FreeMem (curr, sizeof (struct FreeLevel));
 196 } /* FreeStruct */
 197