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