workbench/libs/iffparse/pushchunk.c

   1 /*
   2     Copyright © 1995-2004, 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     AROS_LIBBASE_EXT_DECL(struct Library *,IFFParseBase)
  83
  84     LONG err;
  85
  86     LONG byteswritten;
  87
  88     LONG scan = 0;
  89
  90     DEBUG_PUSHCHUNK(dprintf("PushChunk: iff 0x%lx type 0x%08lx (%c%c%c%c) id 0x%08lx (%c%c%c%c) size %d\n",
  91                             iff, type, dmkid(type), id, dmkid(id), size));
  92
  93     if (iff->iff_Flags & IFFF_WRITE)
  94     {
  95       struct ContextNode *pcn;
  96       LONG   ptype=0;
  97       BOOL   newfile=FALSE;
  98
  99       if((pcn = (struct ContextNode *)CurrentChunk(iff)) != NULL)
 100       {
 101         ptype = pcn->cn_Type;
 102       }
 103       else
 104       {
 105         if(iff->iff_Flags & IFFF_NEWFILE)
 106         {
 107           newfile = TRUE;
 108           iff->iff_Flags &= ~IFFF_NEWFILE;
 109         }
 110         else
 111         {
 112           return(IFFERR_EOF);
 113         }
 114       }
 115
 116       /* do some syntax checks (cyfm: added 2003/03/01 to "fix"/handle some broken apps) */
 117
 118       if(!GoodID(id))
 119       {
 120         DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid id -> IFFERR_SYNTAX\n"
 121                                  ));
 122
 123         return(IFFERR_SYNTAX);
 124
 125       }
 126       else if(newfile == TRUE)
 127       {
 128         /* check if first chunk is either FORM, LIST or CAT */
 129
 130         if( id != ID_FORM && id != ID_LIST && id != ID_CAT)
 131         {
 132          DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid first chunk (neither FORM, nor LIST, nor CAT -> IFFERR_NOTIFF\n"
 133                                  ));
 134
 135           return(IFFERR_NOTIFF);
 136         }
 137       }
 138       else if(id == ID_PROP)
 139       {
 140         /* make sure PROP containing context is a LIST */
 141
 142         if(pcn->cn_ID != ID_LIST)
 143         {
 144           DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid ID in PROP context -> IFFERR_SYNTAX\n"
 145                                  ));
 146
 147           return(IFFERR_SYNTAX);
 148         }
 149       }
 150       else if(id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP )
 151       {
 152         /* check for valid subtype if we found a generic id */
 153
 154         if(!GoodType(type))
 155         {
 156           DEBUG_PUSHCHUNK(dprintf("PushChunk: invalid type for generic id -> IFFERR_NOTIFF\n"
 157                                  ));
 158
 159           return(IFFERR_NOTIFF);
 160         }
 161       }
 162       else
 163       {
 164         /* if we found a non generic id, make sure the containing context is at
 165            least PROP or FORM */
 166
 167         if((pcn->cn_ID != ID_FORM) && (pcn->cn_ID != ID_PROP))
 168         {
 169           DEBUG_PUSHCHUNK(dprintf("PushChunk: containing context id 0x%08lx (%c%c%c%c) for generic id is neither PROP nor FORM -> IFFERR_SYNTAX\n"
 170                                  ,pcn->cn_ID,dmkid(pcn->cn_ID)));
 171
 172           return(IFFERR_SYNTAX);
 173         }
 174       }
 175
 176       /* we passed the syntax test ! */
 177
 178       /* Do we have a problem - situation ? */
 179         if ( (size == IFFSIZE_UNKNOWN)
 180             && (!(iff->iff_Flags & IFFF_RSEEK))
 181         )
 182         {
 183
 184             /* Initialize the buffering streamhandler */
 185             err = InitBufferedStream(iff, IPB(IFFParseBase));
 186             if (err) return (err);
 187         }
 188
 189         byteswritten = WriteStreamLong
 190         (
 191             iff,
 192             &id,
 193             IPB(IFFParseBase)
 194         );
 195
 196         /* IFFFERR_ ..  ? */
 197             if (byteswritten < 0) return (byteswritten);
 198
 199         /* The chunk size will be written during PopChunk too, but we write
 200          here to seek past it */
 201
 202         byteswritten = WriteStreamLong
 203         (
 204             iff,
 205             &size,
 206             IPB(IFFParseBase)
 207         );
 208         /* IFFERR_... ? */
 209         if (byteswritten < 0) return (byteswritten);
 210
 211         /* If a composite type, then write whole type */
 212         if
 213         ( id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP )
 214         {
 215             byteswritten = WriteStreamLong
 216             (
 217                 iff,
 218                 &type,
 219                 IPB(IFFParseBase)
 220             );
 221
 222             if (byteswritten < 0) return (byteswritten);
 223
 224             scan = sizeof(ULONG);
 225
 226         } /* End of composite */
 227
 228         err = PushContextNode
 229         (
 230             iff,
 231             type,
 232             id,
 233             size,
 234             scan,
 235             IPB(IFFParseBase)
 236         );
 237     }
 238     else  /* Read or write mode */
 239     {
 240         /* Read mode. Read the chunk header from stream and put a new contextnode into the stack */
 241         err = GetChunkHeader(iff, IPB(IFFParseBase));
 242     }  /* End of Write or Read */
 243
 244     return (err);
 245
 246     AROS_LIBFUNC_EXIT
 247 } /* PushChunk */