workbench/libs/iffparse/collectionhooks.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Hook functions neede for ColectionChunk() entry handlers.
   6 */
   7
   8 #include "iffparse_intern.h"
   9
  10
  11
  12 /****************************/
  13 /* CollectionLCI Purge func  */
  14 /****************************/
  15
  16 #define IFFParseBase    IPB(hook->h_Data)
  17
  18 ULONG CollectionPurgeFunc
  19 (
  20     struct Hook             * hook,
  21     struct LocalContextItem * lci,
  22     ULONG                     p
  23 )
  24 {
  25     struct CIPtr           *ciptr;
  26
  27     struct CollectionItem  *node,
  28                           *nextnode;
  29
  30     /* Read the LCI's userdata
  31     */
  32     ciptr = (struct CIPtr*)LocalItemData(lci);
  33
  34     /* Free all collectionitems in the linked list */
  35     node = ciptr->FirstCI;
  36
  37     while (node)
  38     {
  39         nextnode = node->ci_Next;
  40         if (node->ci_Data) FreeMem(node->ci_Data, node->ci_Size);
  41
  42         FreeMem(node,sizeof (struct CollectionItem));
  43
  44         node = nextnode;
  45     }
  46
  47     /* Free the local item itself */
  48     FreeLocalItem(lci);
  49
  50     return 0;
  51 }
  52
  53
  54
  55 /**********************************/
  56 /* CollectionChunk entry-handler  */
  57 /**********************************/
  58
  59 struct CF_ResourceInfo
  60 {
  61     struct LocalContextItem *LCI;
  62     APTR                    Buffer;
  63     LONG                    BufferSize;
  64     BOOL                    LCIStored;
  65     struct CollectionItem    *CollItem;
  66 };
  67
  68 #undef IFFParseBase
  69
  70 VOID CF_FreeResources (struct CF_ResourceInfo * ri,
  71         struct IFFParseBase_intern * IFFParseBase)
  72 {
  73     if (ri->LCIStored)  Remove((struct Node*)ri->LCI);
  74     if (ri->LCI)        FreeLocalItem(ri->LCI);
  75     if (ri->Buffer)     FreeMem(ri->Buffer,   ri->BufferSize);
  76     if (ri->CollItem)   FreeMem(ri->CollItem,  sizeof (struct CollectionItem));
  77
  78     return;
  79 }
  80
  81 #define IFFParseBase    IPB(hook->h_Data)
  82
  83 LONG CollectionFunc
  84 (
  85     struct Hook         * hook,
  86     struct IFFHandle    * iff,
  87     APTR                  p
  88 )
  89 {
  90     struct LocalContextItem *lci;
  91
  92     struct ContextNode      *cn;
  93     struct CIPtr            *ciptr;
  94     struct CollectionItem    *collitem;
  95
  96     struct CF_ResourceInfo resinfo = {0}; /* = {0} is important */
  97
  98
  99
 100     LONG   type,
 101           id,
 102           size;
 103
 104     LONG  bytesread,
 105           err;
 106
 107     APTR buf;
 108
 109     /* The Chunk that caused us to be invoked is always the top chunk */
 110     cn = TopChunk(iff);
 111
 112     type   = cn->cn_Type;
 113     id    = cn->cn_ID;
 114
 115     /* IMPORTANT !! For collectionchunks we MUST check if a collection is allready present,
 116     if so there is no clever to add a new one */
 117
 118     lci = FindLocalItem
 119     (
 120         iff,
 121         type,
 122         id,
 123         IFFLCI_COLLECTION
 124     );
 125
 126     if (!lci)
 127     {
 128
 129         /* Allocate new LCI for containing the property */
 130
 131         lci = AllocLocalItem
 132         (
 133             type,
 134             id,
 135             IFFLCI_COLLECTION,
 136             sizeof (struct CIPtr)
 137         );
 138         if (!lci) return (IFFERR_NOMEM);
 139
 140         resinfo.LCI = lci;
 141
 142         /* Store the new LCI into top of stack */
 143
 144         err = StoreLocalItem(iff,lci,IFFSLI_PROP);
 145
 146         if (err)
 147         {
 148             CF_FreeResources(&resinfo, IFFParseBase);
 149             return (err);
 150         }
 151         resinfo.LCIStored = TRUE;
 152
 153         SetLocalItemPurge(lci,&IFFParseBase->collectionpurgehook);
 154
 155     }
 156
 157     /* Allocate a new CollectionItem */
 158
 159     collitem = (struct CollectionItem*)AllocMem
 160     (
 161         sizeof (struct CollectionItem),
 162         MEMF_ANY|MEMF_CLEAR
 163     );
 164
 165     if (!collitem)
 166     {
 167         CF_FreeResources(&resinfo, IFFParseBase);
 168         return (IFFERR_NOMEM);
 169     }
 170
 171     resinfo.CollItem = collitem;
 172
 173
 174
 175     /* Allocate buffer to read chunk into */
 176     if ((size = cn->cn_Size))
 177     {
 178         buf = AllocMem
 179         (
 180             size,
 181             MEMF_ANY
 182         );
 183
 184         if (!buf)
 185         {
 186             CF_FreeResources(&resinfo, IFFParseBase);
 187             return (IFFERR_NOMEM);
 188         }
 189     }
 190     else buf = NULL;
 191
 192     resinfo.Buffer = buf;
 193     resinfo.BufferSize = size;
 194
 195     if (buf)
 196     {
 197         /* Read chunk into the buffer */
 198
 199         bytesread = ReadChunkBytes
 200         (
 201             iff,
 202             buf,
 203             size
 204         );
 205
 206         /* Sucess ? */
 207         if (bytesread != size)
 208         {
 209             CF_FreeResources(&resinfo, IFFParseBase);
 210
 211             /* IFFERR_.. ? */
 212             if (bytesread >= 0)
 213                 err = IFFERR_MANGLED;
 214         }
 215
 216     }
 217
 218     /* Get pointer to first ContextItem from LCIs userdata */
 219     ciptr = (struct CIPtr*)LocalItemData(lci);
 220
 221     /* Update pointers in linked list of collectionitems */
 222     collitem->ci_Next = ciptr->FirstCI;
 223     ciptr->FirstCI = collitem;
 224
 225     collitem->ci_Data = buf;
 226     collitem->ci_Size = size;
 227
 228
 229     return 0;
 230 }