workbench/libs/iffparse/popchunk.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_LH1(LONG, PopChunk,
  14
  15 /*  SYNOPSIS */
  16         AROS_LHA(struct IFFHandle *, iff, A0),
  17
  18 /*  LOCATION */
  19         struct Library *, IFFParseBase, 15, IFFParse)
  20
  21 /*  FUNCTION
  22         Pops a context node of the context stack. Usually called
  23         in write mode to signal the end of a chunk.
  24
  25
  26     INPUTS
  27         iff    - pointer to IFFHandle struct.
  28
  29     RESULT
  30         error  -  0 if successfull, IFFERR_#? otherwise.
  31
  32     NOTES
  33
  34     EXAMPLE
  35
  36     BUGS
  37
  38     SEE ALSO
  39         PushChunk()
  40
  41     INTERNALS
  42
  43     Frees a contextnode an all its related LCIs and removes it from the stack-list
  44     If we are in write mode, we will update the cn_Size in the chunk according
  45     t cn_Scan, and we will also insert an align byte if necessary
  46
  47
  48     If the stream was of PushChunked() as IFFSIZE_UNKNOWN, we have to seek backwards
  49     and write the correct size.
  50     Since non RSEEK streams are automagically buffered by
  51     WriteStream, we don't have to fiddle with it here.
  52     However if the stream is buffered, we MUST see if we are
  53     about to pop the chunk that started the Buffering (in PushChunk)
  54
  55 *****************************************************************************/
  56 {
  57     AROS_LIBFUNC_INIT
  58     AROS_LIBBASE_EXT_DECL(struct Library *,IFFParseBase)
  59
  60
  61     struct ContextNode  *cn;
  62
  63     LONG err;
  64
  65     LONG size;
  66
  67     UBYTE nullbyte = 0;
  68
  69     DEBUG_POPCHUNK(dprintf("PopChunk: iff 0x%lx\n", iff));
  70
  71     /* Get current chunk */
  72     cn = TopChunk(iff);
  73
  74     /* Is the IFFHandle opened in Read or Write mode ? */
  75     if (iff->iff_Flags & IFFF_WRITE)
  76     {
  77         /* Write mode. We should update cn_Size *INSIDE the stream,
  78         if the chunk was pushed with IFFSIZE_UNKNOWN */
  79
  80         if (cn->cn_Size == IFFSIZE_UNKNOWN)
  81         {
  82
  83             err = SeekStream
  84             (
  85                 iff,
  86                 /* minus is for seeking backwards. Remember: evt. chunk types
  87                 for composite chunks are allready in cn_Scan */
  88                 - ( cn->cn_Scan + sizeof(ULONG) ),
  89                 IPB(IFFParseBase)
  90             );
  91
  92             if (err) return (err);
  93
  94             size = cn->cn_Scan;
  95
  96             /* Write the chunk size */
  97             err = WriteStreamLong
  98             (
  99                 iff,
 100                 &size,
 101                 IPB(IFFParseBase)
 102             );
 103
 104             if (err < 0) return (err);
 105
 106             /* Seek towards end of chunk again */
 107             err = SeekStream
 108             (
 109                 iff,
 110                 size,
 111                 IPB(IFFParseBase)
 112             );
 113
 114             if (err) return (err);
 115
 116         }
 117         else  /* IFFSIZE known at PushChunk() time */
 118             size = cn->cn_Size;
 119
 120
 121         /* Write a pad byte if chunk is not word-aligned */
 122         if (size % 2)
 123         {
 124             err =  WriteStream
 125             (
 126                 iff,
 127                 &nullbyte,
 128                 1,
 129                 IPB(IFFParseBase)
 130             );
 131
 132             if (err < 0) return (err);
 133             size++;
 134         }
 135
 136         if
 137         (
 138             GetIntIH(iff)->iff_BufferStartDepth
 139         ==
 140             iff->iff_Depth
 141         )
 142         {
 143             /* a routine that writes the buffer to stream and reinstallss the old streamhandler */
 144
 145             err = ExitBufferedStream(iff, IPB(IFFParseBase));
 146             if (err) return (err);
 147
 148         }
 149     }
 150
 151     /* Actually pop the top context-node. (Done for both handles in Read & Write mode) */
 152
 153     PopContextNode(iff, IPB(IFFParseBase));
 154
 155     /* stegerg: is this okay!? */
 156
 157     if (iff->iff_Flags & IFFF_WRITE)
 158     {
 159         cn = TopChunk(iff);
 160
 161         /* Might work without this check, because there seems to be always at
 162            least one contextnode --> see AllocIFF) */
 163         if (cn->cn_Node.mln_Succ)
 164         {
 165             cn->cn_Scan += size + sizeof(ULONG) + sizeof(ULONG);
 166         }
 167     }
 168
 169     return 0;
 170
 171     AROS_LIBFUNC_EXIT
 172 } /* PopChunk */