Subversion Repositories planix.SVN

/*

 * datalist.c

 * Copyright (C) 2000-2002 A.J. van Os; Released under GPL

 *

 * Description:

 * Build, read and destroy a list of Word data blocks

 */

#include <stdlib.h>

#include <errno.h>

#include "antiword.h"

#if defined(__riscos)

#define EIO		42

#endif /* __riscos */

/*

 * Private structure to hide the way the information

 * is stored from the rest of the program

 */

typedef struct data_mem_tag {

	data_block_type		tInfo;

	struct data_mem_tag	*pNext;

} data_mem_type;

/* Variable to describe the start of the data block list */

static data_mem_type	*pAnchor = NULL;

/* Variable needed to read the data block list */

static data_mem_type	*pBlockLast = NULL;

/* Variable needed to read the data block list */

static data_mem_type	*pBlockCurrent = NULL;

static ULONG	ulBlockOffset = 0;

static size_t	tByteNext = 0;

/* Last block read */

static UCHAR	aucBlock[BIG_BLOCK_SIZE];

/*

 * vDestroyDataBlockList - destroy the data block list

 */

void

vDestroyDataBlockList(void)

{

	data_mem_type	*pCurr, *pNext;

	DBG_MSG("vDestroyDataBlockList");

	pCurr = pAnchor;

	while (pCurr != NULL) {

		pNext = pCurr->pNext;

		pCurr = xfree(pCurr);

		pCurr = pNext;

	}

	pAnchor = NULL;

	/* Reset all the control variables */

	pBlockLast = NULL;

	pBlockCurrent = NULL;

	ulBlockOffset = 0;

	tByteNext = 0;

} /* end of vDestroyDataBlockList */

/*

 * bAdd2DataBlockList - add an element to the data block list

 *

 * Returns TRUE when successful, otherwise FALSE

 */

BOOL

bAdd2DataBlockList(const data_block_type *pDataBlock)

{

	data_mem_type	*pListMember;

	fail(pDataBlock == NULL);

	fail(pDataBlock->ulFileOffset == FC_INVALID);

	fail(pDataBlock->ulDataPos == CP_INVALID);

	fail(pDataBlock->ulLength == 0);

	NO_DBG_MSG("bAdd2DataBlockList");

	NO_DBG_HEX(pDataBlock->ulFileOffset);

	NO_DBG_HEX(pDataBlock->ulDataPos);

	NO_DBG_HEX(pDataBlock->ulLength);

	if (pDataBlock->ulFileOffset == FC_INVALID ||

	    pDataBlock->ulDataPos == CP_INVALID ||

	    pDataBlock->ulLength == 0) {

		werr(0, "Software (datablock) error");

		return FALSE;

	}

	/* Check for continuous blocks */

	if (pBlockLast != NULL &&

	    pBlockLast->tInfo.ulFileOffset +

	     pBlockLast->tInfo.ulLength == pDataBlock->ulFileOffset &&

	    pBlockLast->tInfo.ulDataPos +

	     pBlockLast->tInfo.ulLength == pDataBlock->ulDataPos) {

		/* These are continous blocks */

		pBlockLast->tInfo.ulLength += pDataBlock->ulLength;

		return TRUE;

	}

	/* Make a new block */

	pListMember = xmalloc(sizeof(data_mem_type));

	/* Add the block to the data list */

	pListMember->tInfo = *pDataBlock;

	pListMember->pNext = NULL;

	if (pAnchor == NULL) {

		pAnchor = pListMember;

	} else {

		fail(pBlockLast == NULL);

		pBlockLast->pNext = pListMember;

	}

	pBlockLast = pListMember;

	return TRUE;

} /* end of bAdd2DataBlockList */

/*

 * ulGetDataOffset - get the offset in the data block list

 *

 * Get the fileoffset the current position in the data block list

 */

ULONG

ulGetDataOffset(FILE *pFile)

{

	return pBlockCurrent->tInfo.ulFileOffset + ulBlockOffset + tByteNext;

} /* end of ulGetDataOffset */

/*

 * bSetDataOffset - set the offset in the data block list

 *

 * Make the given fileoffset the current position in the data block list

 */

BOOL

bSetDataOffset(FILE *pFile, ULONG ulFileOffset)

{

	data_mem_type	*pCurr;

	size_t	tReadLen;

	DBG_HEX(ulFileOffset);

	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {

		if (ulFileOffset < pCurr->tInfo.ulFileOffset ||

		    ulFileOffset >= pCurr->tInfo.ulFileOffset +

		     pCurr->tInfo.ulLength) {

			/* The file offset is not in this block */

			continue;

		}

		/* Compute the maximum number of bytes to read */

		tReadLen = (size_t)(pCurr->tInfo.ulFileOffset +

				pCurr->tInfo.ulLength -

				ulFileOffset);

		/* Compute the real number of bytes to read */

		if (tReadLen > sizeof(aucBlock)) {

			tReadLen = sizeof(aucBlock);

		}

		/* Read the bytes */

		if (!bReadBytes(aucBlock, tReadLen, ulFileOffset, pFile)) {

			return FALSE;

		}

		/* Set the control variables */

		pBlockCurrent = pCurr;

		ulBlockOffset = ulFileOffset - pCurr->tInfo.ulFileOffset;

		tByteNext = 0;

		return TRUE;

	}

	return FALSE;

} /* end of bSetDataOffset */

/*

 * iNextByte - get the next byte from the data block list

 */

int

iNextByte(FILE *pFile)

{

	ULONG	ulReadOff;

	size_t	tReadLen;

	fail(pBlockCurrent == NULL);

	if (tByteNext >= sizeof(aucBlock) ||

	    ulBlockOffset + tByteNext >= pBlockCurrent->tInfo.ulLength) {

		if (ulBlockOffset + sizeof(aucBlock) <

					pBlockCurrent->tInfo.ulLength) {

			/* Same block, next part */

			ulBlockOffset += sizeof(aucBlock);

		} else {

			/* Next block, first part */

			pBlockCurrent = pBlockCurrent->pNext;

			ulBlockOffset = 0;

		}

		if (pBlockCurrent == NULL) {

			/* Past the last part of the last block */

			errno = EIO;

			return EOF;

		}

		tReadLen = (size_t)

				(pBlockCurrent->tInfo.ulLength - ulBlockOffset);

		if (tReadLen > sizeof(aucBlock)) {

			tReadLen = sizeof(aucBlock);

		}

		ulReadOff = pBlockCurrent->tInfo.ulFileOffset + ulBlockOffset;

		if (!bReadBytes(aucBlock, tReadLen, ulReadOff, pFile)) {

			errno = EIO;

			return EOF;

		}

		tByteNext = 0;

	}

	return (int)aucBlock[tByteNext++];

} /* end of iNextByte */

/*

 * usNextWord - get the next word from the data block list

 *

 * Read a two byte value in Little Endian order, that means MSB last

 *

 * All return values can be valid so errno is set in case of error

 */

USHORT

usNextWord(FILE *pFile)

{

	USHORT	usLSB, usMSB;

	usLSB = (USHORT)iNextByte(pFile);

	if (usLSB == (USHORT)EOF) {

		errno = EIO;

		return (USHORT)EOF;

	}

	usMSB = (USHORT)iNextByte(pFile);

	if (usMSB == (USHORT)EOF) {

		DBG_MSG("usNextWord: Unexpected EOF");

		errno = EIO;

		return (USHORT)EOF;

	}

	return (usMSB << 8) | usLSB;

} /* end of usNextWord */

/*

 * ulNextLong - get the next long from the data block list

 *

 * Read a four byte value in Little Endian order, that means MSW last

 *

 * All return values can be valid so errno is set in case of error

 */

ULONG

ulNextLong(FILE *pFile)

{

	ULONG	ulLSW, ulMSW;

	ulLSW = (ULONG)usNextWord(pFile);

	if (ulLSW == (ULONG)EOF) {

		errno = EIO;

		return (ULONG)EOF;

	}

	ulMSW = (ULONG)usNextWord(pFile);

	if (ulMSW == (ULONG)EOF) {

		DBG_MSG("ulNextLong: Unexpected EOF");

		errno = EIO;

		return (ULONG)EOF;

	}

	return (ulMSW << 16) | ulLSW;

} /* end of ulNextLong */

/*

 * usNextWordBE - get the next two byte value

 *

 * Read a two byte value in Big Endian order, that means MSB first

 *

 * All return values can be valid so errno is set in case of error

 */

USHORT

usNextWordBE(FILE *pFile)

{

	USHORT usLSB, usMSB;

	usMSB = (USHORT)iNextByte(pFile);

	if (usMSB == (USHORT)EOF) {

		errno = EIO;

		return (USHORT)EOF;

	}

	usLSB = (USHORT)iNextByte(pFile);

	if (usLSB == (USHORT)EOF) {

		DBG_MSG("usNextWordBE: Unexpected EOF");

		errno = EIO;

		return (USHORT)EOF;

	}

	return (usMSB << 8) | usLSB;

} /* end of usNextWordBE */

/*

 * ulNextLongBE - get the next four byte value

 *

 * Read a four byte value in Big Endian order, that means MSW first

 *

 * All return values can be valid so errno is set in case of error

 */

ULONG

ulNextLongBE(FILE *pFile)

{

	ULONG	ulLSW, ulMSW;

	ulMSW = (ULONG)usNextWordBE(pFile);

	if (ulMSW == (ULONG)EOF) {

		errno = EIO;

		return (ULONG)EOF;

	}

	ulLSW = (ULONG)usNextWordBE(pFile);

	if (ulLSW == (ULONG)EOF) {

		DBG_MSG("ulNextLongBE: Unexpected EOF");

		errno = EIO;

		return (ULONG)EOF;

	}

	return (ulMSW << 16) | ulLSW;

} /* end of ulNextLongBE */

/*

 * tSkipBytes - skip over the given number of bytes

 *

 * Returns the number of skipped bytes

 */

size_t

tSkipBytes(FILE *pFile, size_t tToSkip)

{

	size_t	tToGo, tMaxMove, tMove;

	fail(pFile == NULL);

	fail(pBlockCurrent == NULL);

	tToGo = tToSkip;

	while (tToGo != 0) {

		/* Goto the end of the current block */

		tMaxMove = min(sizeof(aucBlock) - tByteNext,

				(size_t)(pBlockCurrent->tInfo.ulLength -

				ulBlockOffset - tByteNext));

		tMove = min(tMaxMove, tToGo);

		tByteNext += tMove;

		tToGo -= tMove;

		if (tToGo != 0) {

			/* Goto the next block */

			if (iNextByte(pFile) == EOF) {

				return tToSkip - tToGo;

			}

			tToGo--;

		}

	}

	return tToSkip;

} /* end of tSkipBytes */

/*

 * Translate  a data position to an offset in the file.

 * Logical to physical offset.

 *

 * Returns:	FC_INVALID: in case of error

 *		otherwise: the computed file offset

 */

ULONG

ulDataPos2FileOffset(ULONG ulDataPos)

{

	data_mem_type	*pCurr;

	fail(ulDataPos == CP_INVALID);

	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {

		if (ulDataPos < pCurr->tInfo.ulDataPos ||

		    ulDataPos >= pCurr->tInfo.ulDataPos +

		     pCurr->tInfo.ulLength) {

			/* The data offset is not in this block, try the next */

			continue;

		}

		/* The data offset is in the current block */

		return pCurr->tInfo.ulFileOffset +

				ulDataPos -

				pCurr->tInfo.ulDataPos;

	}

	/* Passed beyond the end of the list */

	DBG_HEX_C(ulDataPos != 0, ulDataPos);

	return FC_INVALID;

} /* end of ulDataPos2FileOffset */