workbench/libs/iffparse/parseiff.c

   1 /*
   2     Copyright © 1995-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8 #include "iffparse_intern.h"
   9
  10 #define SWAP_SCANEXIT 1
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/iffparse.h>
  16
  17         AROS_LH2(LONG, ParseIFF,
  18
  19 /*  SYNOPSIS */
  20         AROS_LHA(struct IFFHandle *, iff, A0),
  21         AROS_LHA(LONG              , mode, D0),
  22
  23 /*  LOCATION */
  24         struct Library *, IFFParseBase, 7, IFFParse)
  25
  26 /*  FUNCTION
  27         This function is the parser itself. It has three control modes.
  28             IFFPARSE_SCAN - the parser will go through the file invoking
  29                 entry and exit handlers on its way.
  30                 When it returns it might be for 3 different reasons:
  31
  32                 - It invoked a Stop entry/exit handler ( Installed by StopChunk[s] or
  33                   StopOnExit )
  34
  35                 - An error occured.
  36                   (return value will be negative.)
  37
  38                 - The parser reached EOF and returns IFFERR_EOF.
  39
  40             IFFPARSE_STEP  -  The parser steps through the file, returning to the
  41                 user each time it enters (returns NULL) and each time it exits
  42                 (return (IFFERR_EOC) a chunk.
  43                 It will also invoke entry/exit - handlers.
  44
  45             IFFPARSE_RAWSTEP - same as IFFPARSE_STEP except that in this mode
  46                 the parse won't invoke any handlers.
  47
  48
  49     INPUTS
  50         iff - pointer to IFFHandle struct.
  51         mode - IFFPARSE_SCAN, IFFPARSE_STEP or IFFPARSE_RAWSTEP.
  52
  53     RESULT
  54         0 if successful or IFFERR_#?
  55
  56     NOTES
  57
  58
  59     EXAMPLE
  60
  61     BUGS
  62
  63     SEE ALSO
  64         PushChunk(), PopChunk(), EntryHandler(), ExitHandler(), PropChunk[s](),
  65         CollectionChunk[s](), StopChunk[s](), StopOnExit()
  66
  67
  68     INTERNALS
  69
  70 *****************************************************************************/
  71 {
  72     AROS_LIBFUNC_INIT
  73     struct ContextNode *cn;
  74
  75     LONG size;
  76     LONG err = 0;
  77     LONG toseek; /* To hold number of bytes left to seek in a chunk */
  78     BOOL done = FALSE;
  79
  80     D(bug("ParseIFF (iff=%p, mode=%d)\n", iff, mode));
  81
  82     /* Cannot parse iff when it is not opened yet */
  83     if (!(iff->iff_Flags & IFFF_OPEN))
  84     {
  85         D(bug("ParseIFF: syntax error (open)\n"));
  86         ReturnInt ("ParseIFF",LONG,IFFERR_NOTIFF);
  87     }
  88
  89     /* Cannot parse iff file, when it is opened in write-mode */
  90     if (iff->iff_Flags & IFFF_WRITE)
  91     {
  92         /* Some applications accidently pass IFFF_WRITE to OpenIFF()
  93          * when IFFF_READ should be used. While this is certainly
  94          * wrong, these apps still work with 68k iffparse.library.
  95          *
  96          * So just warn, don't fail. - Piru
  97          */
  98 #if 1
  99         D(bug("ParseIFF: warning, IFFF_WRITE iffhandle parsed\n"));
 100 #else
 101         D(bug("ParseIFF: syntax error (write)\n"));
 102         ReturnInt ("ParseIFF",LONG,IFFERR_SYNTAX);
 103 #endif
 104     }
 105
 106     /* Main loop for reading the iff file
 107
 108     This works as a Finite State Automaton  where we between the states might return to the
 109     user, and get called by the user again. InternalIFFHandle->CurrentState holds
 110     the current state */
 111
 112     while (!done)
 113     {
 114         D(bug("ParseIFF: state %d\n", GetIntIH(iff)->iff_CurrentState));
 115         switch ( GetIntIH(iff)->iff_CurrentState )
 116         {
 117         case IFFSTATE_COMPOSITE:
 118
 119             /* We are inside a FORM, LIST, CAT or PROP
 120                 and expect a new chunk header to be found,
 121                 but first we must invoke the handlers on the current one */
 122
 123             /* Where to go next */
 124             GetIntIH(iff)->iff_CurrentState = IFFSTATE_PUSHCHUNK;
 125
 126             /* Invoke the handlers */
 127             err = InvokeHandlers(iff, mode, IFFLCI_ENTRYHANDLER, IPB(IFFParseBase));
 128
 129             if (err)
 130             {
 131                 if (err == IFF_RETURN2CLIENT)
 132                     err = 0;
 133                 done = TRUE;
 134             }
 135
 136
 137
 138             break;
 139
 140         case IFFSTATE_PUSHCHUNK:
 141
 142             /*  What we want to do now is to get the next chunk, make a context-node of it,
 143                 and put it in top of the stack */
 144
 145             err = GetChunkHeader(iff, IPB(IFFParseBase));
 146             if (err)
 147             {
 148                 done = TRUE;
 149                 break;
 150             }
 151
 152
 153             /* Determine if top chunk is composite or atomic */
 154             cn = TopChunk(iff);
 155
 156             if ( GetIntCN(cn)->cn_Composite)
 157                 GetIntIH(iff)->iff_CurrentState = IFFSTATE_COMPOSITE;
 158             else
 159                 GetIntIH(iff)->iff_CurrentState = IFFSTATE_ATOMIC;
 160
 161
 162             break;
 163
 164
 165         case IFFSTATE_ATOMIC:
 166
 167             /* We have entried an atomic chunk. Its contextnode has
 168             allready been laid onto the stack */
 169
 170             GetIntIH(iff)->iff_CurrentState = IFFSTATE_SCANEXIT;
 171
 172             err = InvokeHandlers(iff, mode, IFFLCI_ENTRYHANDLER, IPB(IFFParseBase));
 173             if (err)
 174             {
 175                 if (err == IFF_RETURN2CLIENT)
 176                     err = 0L;
 177
 178                 done = TRUE;
 179             }
 180             break;
 181
 182         case IFFSTATE_SCANEXIT:
 183
 184             /* We have done the needed entry stuff inside the ATOMIC chunk scan towards
 185             the end of it */
 186
 187             GetIntIH(iff)->iff_CurrentState = IFFSTATE_EXIT;
 188
 189 #if SWAP_SCANEXIT
 190           if (mode == IFFPARSE_SCAN)
 191           {
 192 #endif
 193             cn = TopChunk(iff);
 194
 195             toseek = cn->cn_Size - cn->cn_Scan;
 196
 197             /* If cn_Size is not wordaligned we must seek one more byte */
 198             if (cn->cn_Size & 1)
 199                 toseek ++;
 200
 201             if (toseek)
 202             {
 203                 err = SeekStream(iff, toseek, IPB(IFFParseBase));
 204                 if (err)
 205                 {
 206                     done = TRUE;
 207                 }
 208                 else
 209                 {
 210                     cn->cn_Scan += toseek;
 211                 }
 212             }
 213 #if SWAP_SCANEXIT
 214           }
 215 #endif
 216             break;
 217
 218         case IFFSTATE_EXIT:
 219
 220             /* We are at the end of the chunk, should scan for exithandlers */
 221             GetIntIH(iff)->iff_CurrentState = IFFSTATE_POPCHUNK;
 222
 223             err = InvokeHandlers(iff, mode, IFFLCI_EXITHANDLER, IPB(IFFParseBase));
 224             if (err)
 225             {
 226                 if (err == IFF_RETURN2CLIENT)
 227                     err = 0;
 228
 229
 230                 done = TRUE;
 231
 232             }
 233             break;
 234
 235         case IFFSTATE_POPCHUNK:
 236             /* Before we pop the top node, get its size */
 237             cn     = TopChunk(iff);
 238             size  = cn->cn_Size;
 239
 240             /* Align the size */
 241             if (size % 2)
 242                 size +=1;
 243
 244 #if SWAP_SCANEXIT
 245             if (!(GetIntCN(cn)->cn_Composite) && (toseek = size - cn->cn_Scan))
 246             {
 247                 err = SeekStream(iff, toseek, IPB(IFFParseBase));
 248                 if (err)
 249                 {
 250                     done = TRUE;
 251                     break;
 252                 } else {
 253                     cn->cn_Scan = size;
 254                 }
 255             }
 256 #endif
 257
 258
 259             /* Add size of chunk header */
 260             if ( GetIntCN(cn)->cn_Composite )
 261                 size += 12;
 262             else
 263                 size += 8;
 264
 265             /* Pop the top node */
 266             PopContextNode(iff, IPB(IFFParseBase));
 267
 268             /* The underlying node must get updated its scancount */
 269             cn  = TopChunk(iff);
 270             cn->cn_Scan += size;
 271
 272             /* The outer node is ALWAYS a composite one
 273             Now we might have 3 different situations :
 274
 275             1. There are more chunks inside this composite chunk, and we should
 276                 enter the PUSHCHUNK state to get them.
 277
 278             2. There are no more chunks in this composite, but we are not in the outer-most
 279                 composite, so we just want to enter the EXIT state.
 280
 281             3. We are at the end of and about to leave the outermost composite chunk,
 282                 and should therefore return IFFERR_EOF.
 283
 284                 */
 285
 286             /* Nr. 1 */
 287             if (cn->cn_Scan < cn->cn_Size)
 288                 GetIntIH(iff)->iff_CurrentState = IFFSTATE_PUSHCHUNK;
 289
 290             else
 291             {
 292                 /* Nr. 3 */
 293                 if (!iff->iff_Depth )
 294                 {
 295                     err = IFFERR_EOF;
 296                     done = TRUE;
 297                 }
 298                 else
 299                     /* Nr. 2 */
 300                     GetIntIH(iff)->iff_CurrentState = IFFSTATE_EXIT;
 301
 302             }
 303             break;
 304
 305
 306         }  /* End of switch */
 307
 308
 309     }  /* End of while */
 310
 311     D(bug("ParseIFF: return %ld\n", err));
 312
 313     ReturnInt ("ParseIFF",LONG,err);
 314     AROS_LIBFUNC_EXIT
 315 } /* ParseIFF */