workbench/libs/iffparse/basicfuncs.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Basic help functions needed by iffparse.
   6 */
   7
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10 #include "iffparse_intern.h"
  11
  12 LONG PushContextNode
  13 (
  14     struct IFFHandle   *iff,
  15     LONG               type,
  16     LONG               id,
  17     LONG               size,
  18     LONG               scan,
  19     struct IFFParseBase_intern *IFFParseBase
  20 )
  21 {
  22     /* Allocates and puts a new context-node into the top of the context-stack
  23      Also does GoodType and GoodID checking  */
  24     struct ContextNode   *cn;
  25     BOOL composite;
  26
  27     D(bug("PushContextNode(iff=%p, type=%c%c%c%c, id=%c%c%c%c, size=%d, scan=%d)\n",
  28         iff,
  29         dmkid(type),
  30         dmkid(id),
  31         size,
  32         scan
  33     ));
  34
  35     /* Set the composite flag if we have a composite contextnnode */
  36     if (id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP)
  37     {
  38         composite = TRUE;
  39         /* We have a new type, check it */
  40     }
  41     else
  42     {
  43         composite = FALSE;
  44         /* No composite type found.  Get old type from top contextnode */
  45         cn = TopChunk(iff);
  46         type = cn->cn_Type;
  47     }
  48
  49       /* Check if type and ids are valid */
  50     if (!(GoodType(type) && GoodID(id)) )
  51         ReturnInt ("PushContextNode",LONG,IFFERR_MANGLED);
  52
  53     /* Allocate a new context node */
  54     if ( !(cn = AllocMem ( sizeof (struct IntContextNode), MEMF_ANY ) ) )
  55         ReturnInt ("PushContextNode",LONG,IFFERR_NOMEM);
  56
  57     /* Put the context node at top of the stack */
  58     AddHead ( (struct List*)&( GetIntIH(iff)->iff_CNStack ), (struct Node*)cn );
  59
  60     /* Set the contextnode attrs */
  61     cn->cn_Type  =  type;
  62     cn->cn_ID   = id;
  63     cn->cn_Size  = size;
  64     cn->cn_Scan  =  scan;
  65
  66     GetIntCN(cn)->cn_Composite = composite;
  67     /* Initialize the LCI-list */
  68     NewList ((struct List*)&( GetIntCN(cn)->cn_LCIList ));
  69
  70     /* Deeper stack */
  71     iff->iff_Depth ++;
  72
  73     ReturnInt ("PushContextNode",LONG,0L);
  74 }
  75
  76 VOID PopContextNode(struct IFFHandle* iff,
  77     struct IFFParseBase_intern *IFFParseBase)
  78 {
  79     struct LocalContextItem *node,
  80                             *nextnode;
  81
  82     struct IntContextNode *cn;
  83
  84     D(bug("PopContextNode(iff=%p)\n", iff));
  85
  86     cn = GetIntCN( TopChunk( iff ) );
  87
  88     if (cn)
  89     {
  90         D(bug("(%c%c%c%c, %c%c%c%c)\n",
  91             dmkid(cn->CN.cn_Type),
  92             dmkid(cn->CN.cn_ID)
  93         ));
  94     }
  95     else
  96     {
  97         D(bug("\n"));
  98     }
  99
 100     /* Free all localcontextitems */
 101     node = (struct LocalContextItem*)cn->cn_LCIList.mlh_Head;
 102
 103     while ((nextnode = (struct LocalContextItem*)node->lci_Node.mln_Succ))
 104     {
 105         PurgeLCI((struct LocalContextItem*)node, IFFParseBase);
 106
 107         node = nextnode;
 108     }
 109
 110     /* Free the contextnode itself */
 111     Remove((struct Node*)cn);
 112     FreeMem(cn,sizeof (struct IntContextNode));
 113
 114     /*One less node on stack */
 115     iff->iff_Depth --;
 116 }
 117
 118 LONG ReadStreamLong (struct IFFHandle *iff,
 119     APTR valptr,
 120     struct IFFParseBase_intern *IFFParseBase)
 121 {
 122     LONG val;
 123 #if AROS_BIG_ENDIAN
 124 #   define bytes valptr
 125 #else
 126     UBYTE bytes[4];
 127 #endif
 128
 129     D(bug("ReadStreamLong(iff=%p valptr=%p)\n", iff, valptr));
 130
 131     val = ReadStream (iff, bytes, sizeof(LONG), IFFParseBase);
 132
 133     D(bug("ReadStreamLong: val %ld\n", val));
 134
 135     if (val < 0)
 136         return val;
 137     else if (val != sizeof(LONG))
 138         return IFFERR_EOF;
 139
 140 #if !AROS_BIG_ENDIAN
 141     *(LONG *)valptr = bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3];
 142 #endif
 143
 144     D(bug("ReadStreamLong: *valptr 0x%08lx '%c%c%c%c'\n", *(LONG *) valptr, dmkid(*(LONG *) valptr)));
 145
 146     return sizeof(LONG);
 147 } /* ReadStreamLong */
 148
 149
 150 LONG WriteStreamLong (struct IFFHandle *iff,
 151     APTR valptr,
 152     struct IFFParseBase_intern *IFFParseBase)
 153 {
 154     LONG val;
 155 #if AROS_BIG_ENDIAN
 156 #   define bytes valptr
 157 #else
 158     UBYTE bytes[4];
 159     val = *(LONG *)valptr;
 160
 161     bytes[0] = val >> 24;
 162     bytes[1] = val >> 16;
 163     bytes[2] = val >> 8;
 164     bytes[3] = val;
 165 #endif
 166
 167     D(bug("WriteStreamLong(iff=%p valptr=%p)\n", iff, valptr));
 168
 169     val = WriteStream (iff, bytes, sizeof(LONG), IFFParseBase);
 170
 171     D(bug("WriteStreamLong: val %ld\n", val));
 172
 173     if (val < 0)
 174         return val;
 175     else if (val != sizeof(LONG))
 176         return IFFERR_EOF;
 177
 178     return sizeof(LONG);
 179 } /* WriteStreamLong */
 180
 181 /********************/
 182 /* GetChunkHeader   */
 183 /********************/
 184
 185 LONG GetChunkHeader(struct IFFHandle *iff,
 186     struct IFFParseBase_intern *IFFParseBase)
 187 {
 188     LONG type,
 189          id,
 190          size;
 191     LONG scan = 0;
 192     LONG bytesread;
 193
 194     D(bug("GetChunkHeader (iff=%p)\n", iff));
 195
 196     /* Reads in the appropriate stuff from a chunk and makes a contextnode of it */
 197
 198     /* Read chunk ID */
 199     bytesread = ReadStreamLong ( iff, &id, IFFParseBase );
 200
 201     /* We may have an IFF Error */
 202     if (bytesread < 0)
 203         ReturnInt ("GetChunkHeader",LONG,bytesread);
 204
 205     /* Read chunk size */
 206     bytesread = ReadStreamLong ( iff, &size, IFFParseBase );
 207
 208     if (bytesread < 0)
 209         ReturnInt ("GetChunkHeader",LONG,bytesread);
 210
 211     /* We must see if we have a IFF header ("FORM", "CAT" or "LIST" */
 212     if ( id == ID_FORM || id == ID_CAT || id == ID_LIST || id == ID_PROP )
 213     {
 214         /* Read chunk size */
 215         bytesread = ReadStreamLong ( iff, &type, IFFParseBase );
 216
 217         if (bytesread < 0)
 218             ReturnInt ("GetChunkHeader",LONG,bytesread);
 219
 220         DB2(bug("  Found Chunk %c%c%c%c size=%d type %c%c%c%c\n",
 221             dmkid(id),
 222             size,
 223             dmkid(type)
 224         ));
 225
 226         /* Type is inside chunk so we had to add its size to the scancount. */
 227         scan = sizeof (LONG);
 228     }
 229     else
 230     {
 231         type = 0L;
 232         DB2(bug("  Found Chunk %c%c%c%c size=%d\n",
 233             dmkid(id),
 234             size
 235         ));
 236     }
 237
 238     ReturnInt
 239     (
 240         "GetChunkHeader",
 241         LONG,
 242         PushContextNode
 243         (
 244             iff,
 245             type,
 246             id,
 247             size,
 248             scan,
 249             IFFParseBase
 250         )
 251     );
 252 }
 253
 254 /********************/
 255 /* InvokeHandlers    */
 256 /********************/
 257
 258 LONG InvokeHandlers(struct IFFHandle *iff, LONG mode, LONG ident,
 259     struct IFFParseBase_intern *IFFParseBase)
 260 {
 261     struct ContextNode       *cn;
 262     struct HandlerInfo      *hi;
 263     struct LocalContextItem *lci;
 264
 265     LONG err;
 266     /* Either RETURN_2CLIENT or IFFERR_EOC */
 267     LONG stepping_retval;
 268     ULONG param;
 269
 270     D(bug("InvokeHandlers (Iff=%p, mode=%d, ident=0x%08lx\n",
 271         iff, mode, ident
 272     ));
 273
 274     if (ident == IFFLCI_ENTRYHANDLER)
 275         stepping_retval = IFF_RETURN2CLIENT;
 276     else
 277         stepping_retval = IFFERR_EOC;
 278
 279     /* Check for IFFPARSE_RAWSTEP *before* calling evt entryhandlers */
 280     if (mode == IFFPARSE_RAWSTEP)
 281         ReturnInt ("InvokeHandlers(1)",LONG,stepping_retval);
 282
 283     /* Get top of contextstack */
 284     cn = TopChunk(iff);
 285
 286     /* Scan downwards to find a contextnode with a matching LCI */
 287     lci = FindLocalItem ( iff, cn->cn_Type, cn->cn_ID, ident );
 288
 289     if (lci)
 290     {
 291         /* Get the HandlerInfo userdata */
 292         hi = LocalItemData(lci);
 293
 294
 295         /* First check if a hook really is present */
 296         if (! hi->hi_Hook)
 297             ReturnInt ("InvokeHandlers",LONG,IFFERR_NOHOOK);
 298
 299         /* What kind off command shall the hook receive */
 300
 301         if (ident == IFFLCI_ENTRYHANDLER)
 302             param = IFFCMD_ENTRY;
 303         else
 304             param = IFFCMD_EXIT;
 305
 306
 307         /* Call the handler */
 308         if ( (err = CallHookPkt (  hi->hi_Hook, hi->hi_Object, (APTR)param)) )
 309             ReturnInt ("InvokeHandlers(2)",LONG,err);
 310     }
 311
 312     /* Check for IFFPARSE_STEP. (stepping through file WITH handlers enabled */
 313     if (mode == IFFPARSE_STEP)
 314         ReturnInt ("InvokeHandlers(3)",LONG,stepping_retval);
 315
 316     ReturnInt ("InvokeHandlers",LONG,0L);
 317 }
 318
 319 /******************/
 320 /* PurgeLCI        */
 321 /******************/
 322
 323 VOID PurgeLCI(struct LocalContextItem *lci,
 324     struct IFFParseBase_intern *IFFParseBase)
 325 {
 326     /* Look in the RKM SetLocalItemPurge autodoc for explanation on that one below */
 327
 328     D(bug("PurgeLCI(lci=%p)\n", lci));
 329
 330     Remove((struct Node*)lci);
 331     /* Has the user specified a Purge hook ? */
 332
 333     if ( GetIntLCI(lci)->lci_PurgeHook)
 334         CallHookPkt
 335         (
 336             GetIntLCI(lci)->lci_PurgeHook,
 337             lci,
 338             (APTR)IFFCMD_PURGELCI
 339         );
 340
 341     else
 342         FreeLocalItem(lci);
 343 }
 344
 345
 346
 347 /******************/
 348 /* Readstream      */
 349 /******************/
 350
 351 /* Reads from the current StreamHandler */
 352
 353 /* returns one of the standard IFF errors */
 354 LONG ReadStream(struct IFFHandle *iff, APTR buf, LONG bytestoread,
 355     struct IFFParseBase_intern *IFFParseBase)
 356 {
 357     LONG   retval,
 358           err;
 359
 360     /* For use with custom streams */
 361     struct IFFStreamCmd cmd;
 362
 363     D(bug("ReadStream(iff=%p buf=%p bytestoread=%d)\n", iff, buf, bytestoread));
 364
 365     retval = bytestoread;
 366     if (bytestoread)
 367     {
 368         /* Now we can do the actual reading of the stream */
 369         cmd.sc_Command  = IFFCMD_READ;
 370         cmd.sc_Buf      = buf;
 371         cmd.sc_NBytes   = bytestoread;
 372
 373         err = CallHookPkt
 374         (
 375             GetIntIH(iff)->iff_StreamHandler,
 376             iff,
 377             &cmd
 378         );
 379
 380         if (err)
 381             retval = IFFERR_READ;
 382     }
 383
 384     D(bug("ReadStream: return %d\n", retval));
 385     return (retval);
 386 }
 387
 388
 389 /****************/
 390 /* WriteStream  */
 391 /****************/
 392
 393 LONG WriteStream(struct IFFHandle *iff, APTR buf, LONG bytestowrite,
 394     struct IFFParseBase_intern *IFFParseBase)
 395 {
 396     LONG   retval,
 397           err;
 398
 399     struct IFFStreamCmd cmd;
 400
 401     /* Call the custom hook with a write command */
 402
 403     D(bug("WriteStream(iff=%p buf=%p bytestowrite=%d)\n", iff, buf, bytestowrite));
 404
 405     retval = bytestowrite;
 406
 407     if (bytestowrite)
 408     {
 409         cmd.sc_Command   = IFFCMD_WRITE;
 410         cmd.sc_Buf       = buf;
 411         cmd.sc_NBytes    = bytestowrite;
 412
 413         err = CallHookPkt
 414         (
 415             GetIntIH(iff)->iff_StreamHandler,
 416             iff,
 417             &cmd
 418         );
 419
 420         if (err)
 421             retval = IFFERR_WRITE;
 422     }
 423
 424     D(bug("WriteStream: return %d\n", retval));
 425     return (retval);
 426 }
 427 /***************/
 428 /* SeekStream */
 429 /***************/
 430
 431 LONG SeekStream(struct IFFHandle *iff,LONG offset,
 432     struct IFFParseBase_intern *IFFParseBase)
 433 {
 434
 435     /* Some different problem - situations:
 436
 437         1. Backwards seek in non back seekable stream. In this case the stream is buffered,
 438           and we may seek in the buffer. This is done automagically, since PushChunk
 439           then has inserted a Buffering streamhandle.
 440
 441
 442         2. Forwards seek in a non - seekable stream. Simulate the seek with a bunch
 443           of ReadStream's
 444
 445     */
 446
 447     struct IFFStreamCmd cmd;
 448     ULONG flags;
 449     LONG retval = 0;
 450     LONG err;
 451     UBYTE *seekbuf;
 452
 453     D(bug("SeekStream(iff=%p offset=%d)\n", iff, offset));
 454
 455     flags = iff->iff_Flags;
 456
 457
 458     /* Problem 2. */
 459     if
 460     (
 461         (offset > 0)
 462     &&
 463         (
 464             !(
 465                 (flags & IFFF_RSEEK)
 466             ||
 467                 (flags & IFFF_FSEEK)
 468             )
 469         )
 470     )
 471     {
 472         /* We should use consecutive ReadStream()s to simulate a Seek */
 473
 474         /* Allocate a buffer to use with the read */
 475         seekbuf = AllocMem(SEEKBUFSIZE, MEMF_ANY);
 476
 477         if (!seekbuf)
 478             retval = IFFERR_NOMEM;
 479         else
 480         {
 481
 482             for (; offset > SEEKBUFSIZE; offset -= SEEKBUFSIZE)
 483             {
 484                 retval = ReadStream(iff, seekbuf, SEEKBUFSIZE, IFFParseBase);
 485
 486                 if (retval != SEEKBUFSIZE)
 487                     retval = IFFERR_SEEK;
 488             }
 489
 490             /* Seek what is left of offset  */
 491             retval = ReadStream(iff, seekbuf, SEEKBUFSIZE, IFFParseBase);
 492             if ( retval != SEEKBUFSIZE)
 493                 retval = IFFERR_SEEK;
 494
 495             FreeMem(seekbuf, SEEKBUFSIZE);
 496         }
 497
 498     }
 499     else if (offset == 0)
 500     {
 501         ; /* Do nothing */
 502     }
 503     else
 504     {
 505
 506         /* Everything is just fine... Seek in a normal manner */
 507
 508         cmd.sc_Command = IFFCMD_SEEK;
 509         cmd.sc_NBytes      = offset;
 510
 511         err = CallHookPkt
 512         (
 513             GetIntIH(iff)->iff_StreamHandler,
 514             iff,
 515             &cmd
 516         );
 517
 518         if (err)
 519               retval = IFFERR_SEEK;
 520     }
 521
 522     D(bug("SeekStream: return %d\n", retval));
 523     return (retval);
 524 }
 525
 526
 527 /********************/
 528 /* Buffering stuff  */
 529 /********************/