ref: d1cebf608b05e45b148108ac6c16ae94f6862097
dir: /sys/src/cmd/aux/antiword/datalist.c/
/*
* 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 */