/* copychunks
 *
 * For Read/Modify/Write programs and other programs that need
 *   to close the IFF file but still reference gathered chunks.
 * Copies your gathered property and collection chunks
 *   from an iff context so that IFF handle may be
 *   closed right after parsing (allowing file or clipboard to
 *   to be reopened for read or write by self or other programs)
 *
 * The created list of chunks can be modified and written
 *   back out to a new handle with writechunklist().
 *
 * If you have used copychunks(), remember to free the copied
 *   chunks with freechunklist(), when ready, to deallocate them.
 *
 * Note that this implementation is flat and is suitable only
 *   for simple FORMs.
 */

#include "iffp/iff.h"

/* copychunks()
 *
 * Copies chunks specified in propchks and collectchks
 *   FROM an already-parsed IFFHandle
 *   TO a singly linked list of Chunk structures,
 * and returns a pointer to the start of the list.
 *
 * Generally you would store this pointer in parseInfo.copiedchunks.
 *
 * You must later free the list of copied chunks by calling
 *   FreeChunkList().
 *
 * Reorders collection chunks so they appear in SAME ORDER
 * in chunk list as they did in the file.
 *
 * Returns 0 for failure
 */
struct Chunk *copychunks(struct IFFHandle *iff,
			LONG *propchks, LONG *collectchks,
			ULONG memtype)
    {
    struct Chunk *chunk, *first=NULL, *prevchunk = NULL;
    struct StoredProperty *sp;
    struct CollectionItem *ci, *cii;
    long error;
    int k, kk, bk;

    if(!iff)	return(NULL);

    /* Copy gathered property chunks */
    error = 0;
    for(k=0; (!error) && (propchks) && (propchks[k] != TAG_DONE); k+=2)
	{
	if(sp=FindProp(iff,propchks[k],propchks[k+1]))
	    {
	    D(bug("copying %.4s.%.4s chunk\n",&propchks[k],&propchks[k+1]));

	    if(chunk=(struct Chunk *)
			AllocMem(sizeof(struct Chunk),memtype|MEMF_CLEAR))
		{
		chunk->ch_Type = propchks[k];
		chunk->ch_ID   = propchks[k+1];
		if(chunk->ch_Data = AllocMem(sp->sp_Size,memtype))
		    {
		    chunk->ch_Size = sp->sp_Size;
		    CopyMem(sp->sp_Data,chunk->ch_Data,sp->sp_Size);
		    if(prevchunk)	prevchunk->ch_Next = chunk;
		    else 		first = chunk;
		    prevchunk = chunk;
		    }
		else
		    {
		    FreeMem(chunk,sizeof(struct Chunk));
		    chunk=NULL;
		    error = 1;
		    }
		}
	    else error = 1;
	    }
	}

    /* Copy gathered collection chunks in reverse order */
    for(k=0; (!error) && (collectchks) && (collectchks[k] != TAG_DONE); k+=2)
	{
	if(ci=FindCollection(iff,collectchks[k],collectchks[k+1]))
	    {
	    D(bug("copying %.4s.%.4s collection\n",&collectchks[k],&collectchks[k+1]));
	    for(cii=ci, bk=0; cii; cii=cii->ci_Next)	bk++;

	    D(bug(" There are %ld of these, first is at $%lx\n",bk,ci));

	    for( bk; bk; bk--)
		{
 		for(kk=1, cii=ci; kk<bk; kk++) cii=cii->ci_Next;

		D(bug("  copying number %ld\n",kk));

	    	if(chunk=(struct Chunk *)
		    AllocMem(sizeof(struct Chunk),memtype|MEMF_CLEAR))
		    {
		    chunk->ch_Type = collectchks[k];
		    chunk->ch_ID   = collectchks[k+1];
		    if(chunk->ch_Data = AllocMem(cii->ci_Size,memtype))
		    	{
		    	chunk->ch_Size = cii->ci_Size;
		    	CopyMem(cii->ci_Data,chunk->ch_Data,cii->ci_Size);
		    	if(prevchunk)	prevchunk->ch_Next = chunk;
		    	else 		first = chunk;
		    	prevchunk = chunk;
		    	}
		    else
		    	{
		    	FreeMem(chunk,sizeof(struct Chunk));
		    	chunk=NULL;
		    	error = 1;
		    	}
		    }
	    	else error = 1;
		}
	    }
	}

    if(error)
	{
	if(first) freechunklist(first);
	first = NULL;
	}

    return(first);
    }

/* freechunklist - Free a dynamically allocated Chunk list and
 *   all of its ch_Data.
 *
 * Note - if a chunk's ch_Size is IFFSIZE_UNKNOWN, its ch_Data
 *   will not be deallocated.
 */
void freechunklist(struct Chunk *first)
    {
    struct Chunk *chunk, *next;

    chunk = first;
    while(chunk)
	{
	next = chunk->ch_Next;
	if((chunk->ch_Data)&&(chunk->ch_Size != IFFSIZE_UNKNOWN))
		FreeMem(chunk->ch_Data,chunk->ch_Size);
	FreeMem(chunk, sizeof(struct Chunk));
	chunk = next;
	}
    }


/* findchunk - find first matching chunk in list of struct Chunks
 *    example  finchunk(pi->copiedchunks,ID_ILBM,ID_CRNG);
 *
 * returns struct Chunk *, or NULL if none found
 */
struct Chunk *findchunk(struct Chunk *first, long type, long id)
    {
    struct Chunk *chunk;

    for(chunk=first; chunk; chunk=chunk->ch_Next)
	{
	if((chunk->ch_Type == type)&&(chunk->ch_ID == id)) return(chunk);
	}
    return(NULL);
    }


/* writechunklist - write out list of struct Chunk's
 * If data is a null terminated string, you may use
 * IFFSIZE_UNKNOWN as the ch_Szie and strlen(chunk->ch_Data)
 * will be used here as size.
 *
 * Returns 0 for success or an IFFERR
 */
long writechunklist(struct IFFHandle *iff, struct Chunk *first)
    {
    struct Chunk *chunk;
    long size, error = 0;

    D(bug("writechunklist: first chunk pointer = $%lx\n",first));

    for(chunk=first; chunk && (!error); chunk=chunk->ch_Next)
	{
	size  = (chunk->ch_Size == IFFSIZE_UNKNOWN) ?
			strlen(chunk->ch_Data) :  chunk->ch_Size;
	error = PutCk(iff, chunk->ch_ID, size, chunk->ch_Data);
	D(bug("writechunklist: put %.4s size=%ld, error=%ld\n",
				&chunk->ch_ID,size, error));
	}
    return(error);
    }

[Back to Amiga Developer Docs]