workbench/libs/iffparse/pushchunk.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "iffparse_intern.h"
   7
   8 /*****************************************************************************
   9
  10     NAME */
  11 #include <proto/iffparse.h>
  12
  13         AROS_LH4(LONG, PushChunk,
  14
  15 /*  SYNOPSIS */
  16         AROS_LHA(struct IFFHandle *, iff, A0),
  17         AROS_LHA(LONG              , type, D0),
  18         AROS_LHA(LONG              , id, D1),
  19         AROS_LHA(LONG              , size, D2),
  20
  21 /*  LOCATION */
  22         struct Library *, IFFParseBase, 14, IFFParse)
  23
  24 /*  FUNCTION
  25         Pushes a new context node onto the context stack. Usually used in write mode.
  26         In write mode the contextnode will be pushed with the given parameters.
  27         In Read mode the type, id and size will be read from the installed stream.
  28         Note that IFFSIZE_UNKNOW can be given for size in write mode. In that case,
  29         the size of will not be known until you do a PopChunk(). PopChunk()
  30         will then seek back in the stream and write the correct size.
  31
  32
  33     INPUTS
  34         iff    - pointer to IFFHandle struct.
  35         type  -  chunk type specifier.
  36         id    -  chunk identifier.
  37         size  -  size of the new chunk. May be IFFSIZE_UNKNOWN.
  38
  39     RESULT
  40         error  -  0 if successfull, IFFERR_#? otherwize.
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46     BUGS
  47
  48     SEE ALSO
  49         PopChunk()
  50
  51     INTERNALS
  52         We do different things for Read and Write streams (obviosly enough ;->)
  53
  54         Write: Write the supplied id, size and evt type into the stream.
  55
  56         Read: Get a chunk from disk
  57
  58
  59         For Write mode there are som problems with unknown chunk size and
  60         non-random-seekable streams:
  61         4. situations:
  62
  63         SIZE KNOWN && RSEEK     - Just write the whole header.
  64         SIZE KNOWN && !RSEEK     - Write whole header. No RSEEK does not matter, since
  65                                   we don't have to seek back to write size in PopChunk
  66
  67         SIZE UNKNOWN && RSEEK   - Write whole header. Write size too, just to seek pass it,
  68                                   even if the size value might be meaningless. We will
  69                                   seek back and insert the correct size later.
  70
  71         SIZE UNKNOWN && !RSEEK  - Here is where the trouble starts. We can not seek back
  72                                   and insert the correct size later, which means that we MUST
  73                                   buffer the contents of the chunk, and don't write ANYTHING to
  74                                   the stream until we know its size.
  75
  76                                   We preserve the old StreamHandler, and inserts a new one
  77                                   that buffers all writes into memory.
  78
  79 *****************************************************************************/
  80 {
  81     AROS_LIBFUNC_INIT
  82
  83     LONG err;
  84
  85     LONG byteswritten;
  86
  87     LONG scan = 0;
  88
  89     DEBUG_PUSHCHUNK(dprintf("PushChunk: iff 0x%lx type 0x%08lx (%c%c%c%c) id 0x%08lx (%c%c%c%c) size %d\n",
  90                             iff, type, dmkid(type), id, dmkid(id), size));
  91
  92     if (iff->iff_Flags & IFFF_WRITE)
  93     {
  94       struct ContextNode *pcn;
  95
  96       if((pcn = (struct ContextNode *)CurrentChunk(iff)) == NULL)
  97       {
  98         if(iff->iff_Flags & IFFF_NEWFILE)
  99         {
 100           iff->iff_Flags &= ~IFFF_NEWFILE;
 101         }
 102         else
 103         {
 104           return(IFFERR_EOF);
 105         }
 106       }
 107
 108       /* do some syntax checks (cyfm: added 2003/03/01 to "fix"/handle some broken apps) */
 109
 110       if(!GoodID(id))
 111       {
 112         DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid id -> IFFERR_SYNTAX\n"
 113                                  ));
 114
 115         return(IFFERR_SYNTAX);
 116
 117       }
 118       else if(pcn == NULL)
 119       {
 120         /* check if first chunk is either FORM, LIST or CAT */
 121
 122         if( id != ID_FORM && id != ID_LIST && id != ID_CAT)
 123         {
 124          DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid first chunk (neither FORM, nor LIST, nor CAT -> IFFERR_NOTIFF\n"
 125                                  ));
 126
 127           return(IFFERR_NOTIFF);
 128         }
 129       }
 130       else if(id == ID_PROP)
 131       {
 132         /* make sure PROP containing context is a LIST */
 133
 134         if(pcn->cn_ID != ID_LIST)
 135         {
 136           DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid ID in PROP context -> IFFERR_SYNTAX\n"
 137                                  ));
 138
 139           return(IFFERR_SYNTAX);
 140         }
 141       }
 142       else if(id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP )
 143       {
 144         /* check for valid subtype if we found a generic id */
 145
 146         if(!GoodType(type))
 147         {
 148           DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid type for generic id -> IFFERR_NOTIFF\n"
 149                                  ));
 150
 151           return(IFFERR_NOTIFF);
 152         }
 153       }
 154       else
 155       {
 156         /* if we found a non generic id, make sure the containing context is at
 157            least PROP or FORM */
 158
 159         if((pcn->cn_ID != ID_FORM) && (pcn->cn_ID != ID_PROP))
 160         {
 161           DEBUG_PUSHCHUNK(dprintf("PushChunk: containing context id 0x%08lx (%c%c%c%c) for generic id is neither PROP nor FORM -> IFFERR_SYNTAX\n"
 162                                  ,pcn->cn_ID,dmkid(pcn->cn_ID)));
 163
 164           return(IFFERR_SYNTAX);
 165         }
 166       }
 167
 168       /* we passed the syntax test ! */
 169
 170       /* Do we have a problem - situation ? */
 171         if ( (size == IFFSIZE_UNKNOWN)
 172             && (!(iff->iff_Flags & IFFF_RSEEK))
 173         )
 174         {
 175
 176             /* Initialize the buffering streamhandler */
 177             err = InitBufferedStream(iff, IPB(IFFParseBase));
 178             if (err) return (err);
 179         }
 180
 181         byteswritten = WriteStreamLong
 182         (
 183             iff,
 184             &id,
 185             IPB(IFFParseBase)
 186         );
 187
 188         /* IFFFERR_ ..  ? */
 189             if (byteswritten < 0) return (byteswritten);
 190
 191         /* The chunk size will be written during PopChunk too, but we write
 192          here to seek past it */
 193
 194         byteswritten = WriteStreamLong
 195         (
 196             iff,
 197             &size,
 198             IPB(IFFParseBase)
 199         );
 200         /* IFFERR_... ? */
 201         if (byteswritten < 0) return (byteswritten);
 202
 203         /* If a composite type, then write whole type */
 204         if
 205         ( id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP )
 206         {
 207             byteswritten = WriteStreamLong
 208             (
 209                 iff,
 210                 &type,
 211                 IPB(IFFParseBase)
 212             );
 213
 214             if (byteswritten < 0) return (byteswritten);
 215
 216             scan = sizeof(ULONG);
 217
 218         } /* End of composite */
 219
 220         err = PushContextNode
 221         (
 222             iff,
 223             type,
 224             id,
 225             size,
 226             scan,
 227             IPB(IFFParseBase)
 228         );
 229     }
 230     else  /* Read or write mode */
 231     {
 232         /* Read mode. Read the chunk header from stream and put a new contextnode into the stack */
 233         err = GetChunkHeader(iff, IPB(IFFParseBase));
 234     }  /* End of Write or Read */
 235
 236     return (err);
 237
 238     AROS_LIBFUNC_EXIT
 239 } /* PushChunk */