xref: /plan9/sys/src/cmd/aux/antiword/blocklist.c (revision 25b329d522281a8cdd35da0dcc08c3fc621059a9)

/*
 * blocklist.c
 * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
 *
 * Description:
 * Build, read and destroy the lists of Word "text" blocks
 */

#include <stdlib.h>
#include "antiword.h"


/*
 * Private structure to hide the way the information
 * is stored from the rest of the program
 */
typedef struct list_mem_tag {
	text_block_type		tInfo;
	struct list_mem_tag	*pNext;
} list_mem_type;

typedef struct readinfo_tag {
	list_mem_type		*pBlockCurrent;
	ULONG			ulBlockOffset;
	size_t			tByteNext;
	UCHAR			aucBlock[BIG_BLOCK_SIZE];
} readinfo_type;

/* Variables to describe the start of the block lists */
static list_mem_type	*pTextAnchor = NULL;
static list_mem_type	*pFootnoteAnchor = NULL;
static list_mem_type	*pHdrFtrAnchor = NULL;
static list_mem_type	*pMacroAnchor = NULL;
static list_mem_type	*pAnnotationAnchor = NULL;
static list_mem_type	*pEndnoteAnchor = NULL;
static list_mem_type	*pTextBoxAnchor = NULL;
static list_mem_type	*pHdrTextBoxAnchor = NULL;
/* Variable needed to build the block list */
static list_mem_type	*pBlockLast = NULL;
/* Variable needed to read the block lists */
static readinfo_type	tOthers = { NULL, 0, 0, };
static readinfo_type	tHdrFtr = { NULL, 0, 0, };
static readinfo_type	tFootnote = { NULL, 0, 0, };


/*
 * pFreeOneList - free a text block list
 *
 * Will always return NULL
 */
static list_mem_type *
pFreeOneList(list_mem_type *pAnchor)
{
	list_mem_type	*pCurr, *pNext;

	pCurr = pAnchor;
	while (pCurr != NULL) {
		pNext = pCurr->pNext;
		pCurr = xfree(pCurr);
		pCurr = pNext;
	}
	return NULL;
} /* end of pFreeOneList */

/*
 * vDestroyTextBlockList - destroy the text block lists
 */
void
vDestroyTextBlockList(void)
{
	DBG_MSG("vDestroyTextBlockList");

	/* Free the lists one by one */
	pTextAnchor = pFreeOneList(pTextAnchor);
	pFootnoteAnchor = pFreeOneList(pFootnoteAnchor);
	pHdrFtrAnchor = pFreeOneList(pHdrFtrAnchor);
	pMacroAnchor = pFreeOneList(pMacroAnchor);
	pAnnotationAnchor = pFreeOneList(pAnnotationAnchor);
	pEndnoteAnchor = pFreeOneList(pEndnoteAnchor);
	pTextBoxAnchor = pFreeOneList(pTextBoxAnchor);
	pHdrTextBoxAnchor = pFreeOneList(pHdrTextBoxAnchor);
	/* Reset all the controle variables */
	pBlockLast = NULL;
	tOthers.pBlockCurrent = NULL;
	tHdrFtr.pBlockCurrent = NULL;
	tFootnote.pBlockCurrent = NULL;
} /* end of vDestroyTextBlockList */

/*
 * bAdd2TextBlockList - add an element to the text block list
 *
 * returns: TRUE when successful, otherwise FALSE
 */
BOOL
bAdd2TextBlockList(const text_block_type *pTextBlock)
{
	list_mem_type	*pListMember;

	fail(pTextBlock == NULL);
	fail(pTextBlock->ulFileOffset == FC_INVALID);
	fail(pTextBlock->ulCharPos == CP_INVALID);
	fail(pTextBlock->ulLength == 0);
	fail(pTextBlock->bUsesUnicode && odd(pTextBlock->ulLength));

	NO_DBG_MSG("bAdd2TextBlockList");
	NO_DBG_HEX(pTextBlock->ulFileOffset);
	NO_DBG_HEX(pTextBlock->ulCharPos);
	NO_DBG_HEX(pTextBlock->ulLength);
	NO_DBG_DEC(pTextBlock->bUsesUnicode);
	NO_DBG_DEC(pTextBlock->usPropMod);

	if (pTextBlock->ulFileOffset == FC_INVALID ||
	    pTextBlock->ulCharPos == CP_INVALID ||
	    pTextBlock->ulLength == 0 ||
	    (pTextBlock->bUsesUnicode && odd(pTextBlock->ulLength))) {
		werr(0, "Software (textblock) error");
		return FALSE;
	}
	/*
	 * Check for continuous blocks of the same character size and
	 * the same properties modifier
	 */
	if (pBlockLast != NULL &&
	    pBlockLast->tInfo.ulFileOffset +
	     pBlockLast->tInfo.ulLength == pTextBlock->ulFileOffset &&
	    pBlockLast->tInfo.ulCharPos +
	     pBlockLast->tInfo.ulLength == pTextBlock->ulCharPos &&
	    pBlockLast->tInfo.bUsesUnicode == pTextBlock->bUsesUnicode &&
	    pBlockLast->tInfo.usPropMod == pTextBlock->usPropMod) {
		/* These are continous blocks */
		pBlockLast->tInfo.ulLength += pTextBlock->ulLength;
		return TRUE;
	}
	/* Make a new block */
	pListMember = xmalloc(sizeof(list_mem_type));
	/* Add the block to the list */
	pListMember->tInfo = *pTextBlock;
	pListMember->pNext = NULL;
	if (pTextAnchor == NULL) {
		pTextAnchor = pListMember;
	} else {
		fail(pBlockLast == NULL);
		pBlockLast->pNext = pListMember;
	}
	pBlockLast = pListMember;
	return TRUE;
} /* end of bAdd2TextBlockList */

/*
 * vSpitList - Split the list in two
 */
static void
vSpitList(list_mem_type **ppAnchorCurr, list_mem_type **ppAnchorNext,
	ULONG ulListLen)
{
	list_mem_type	*pCurr;
	long		lCharsToGo, lBytesTooFar;

	fail(ppAnchorCurr == NULL);
	fail(ppAnchorNext == NULL);
	fail(ulListLen > (ULONG)LONG_MAX);

	pCurr = NULL;
	lCharsToGo = (long)ulListLen;
	lBytesTooFar = -1;
	if (ulListLen != 0) {
		DBG_DEC(ulListLen);
		for (pCurr = *ppAnchorCurr;
		     pCurr != NULL;
		     pCurr = pCurr->pNext) {
			NO_DBG_DEC(pCurr->tInfo.ulLength);
			fail(pCurr->tInfo.ulLength == 0);
			fail(pCurr->tInfo.ulLength > (ULONG)LONG_MAX);
			if (pCurr->tInfo.bUsesUnicode) {
				fail(odd(pCurr->tInfo.ulLength));
				lCharsToGo -= (long)(pCurr->tInfo.ulLength / 2);
				if (lCharsToGo < 0) {
					lBytesTooFar = -2 * lCharsToGo;
				}
			} else {
				lCharsToGo -= (long)pCurr->tInfo.ulLength;
				if (lCharsToGo < 0) {
					lBytesTooFar = -lCharsToGo;
				}
			}
			if (lCharsToGo <= 0) {
				break;
			}
		}
	}
/* Split the list */
	if (ulListLen == 0) {
		/* Current blocklist is empty */
		*ppAnchorNext = *ppAnchorCurr;
		*ppAnchorCurr = NULL;
	} else if (pCurr == NULL) {
		/* No blocks for the next list */
		*ppAnchorNext = NULL;
	} else if (lCharsToGo == 0) {
		/* Move the integral number of blocks to the next list */
		*ppAnchorNext = pCurr->pNext;
		pCurr->pNext = NULL;
	} else {
		/* Split the part current block list, part next block list */
		DBG_DEC(lBytesTooFar);
		fail(lBytesTooFar <= 0);
		*ppAnchorNext = xmalloc(sizeof(list_mem_type));
		DBG_HEX(pCurr->tInfo.ulFileOffset);
		(*ppAnchorNext)->tInfo.ulFileOffset =
				pCurr->tInfo.ulFileOffset +
				pCurr->tInfo.ulLength -
				lBytesTooFar;
		DBG_HEX((*ppAnchorNext)->tInfo.ulFileOffset);
		DBG_HEX(pCurr->tInfo.ulCharPos);
		(*ppAnchorNext)->tInfo.ulCharPos =
				pCurr->tInfo.ulCharPos +
				pCurr->tInfo.ulLength -
				lBytesTooFar;
		DBG_HEX((*ppAnchorNext)->tInfo.ulCharPos);
		(*ppAnchorNext)->tInfo.ulLength = (ULONG)lBytesTooFar;
		pCurr->tInfo.ulLength -= (ULONG)lBytesTooFar;
		(*ppAnchorNext)->tInfo.bUsesUnicode = pCurr->tInfo.bUsesUnicode;
		(*ppAnchorNext)->tInfo.usPropMod = pCurr->tInfo.usPropMod;
		/* Move the integral number of blocks to the next list */
		(*ppAnchorNext)->pNext = pCurr->pNext;
		pCurr->pNext = NULL;
	}
} /* end of vSpitList */

#if defined(DEBUG) || defined(__riscos)
/*
 * ulComputeListLength - compute the length of a list
 *
 * returns the list length in characters
 */
static ULONG
ulComputeListLength(const list_mem_type *pAnchor)
{
	const list_mem_type	*pCurr;
	ULONG		ulTotal;

	ulTotal = 0;
	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		fail(pCurr->tInfo.ulLength == 0);
		if (pCurr->tInfo.bUsesUnicode) {
			fail(odd(pCurr->tInfo.ulLength));
			ulTotal += pCurr->tInfo.ulLength / 2;
		} else {
			ulTotal += pCurr->tInfo.ulLength;
		}
	}
	return ulTotal;
} /* end of ulComputeListLength */
#endif /* DEBUG || __riscos */

#if defined(DEBUG)
/*
 * vCheckList - check the number of bytes in a block list
 */
static void
vCheckList(const list_mem_type *pAnchor, ULONG ulListLen, char *szMsg)
{
	ULONG		ulTotal;

	ulTotal = ulComputeListLength(pAnchor);
	DBG_DEC(ulTotal);
	if (ulTotal != ulListLen) {
		DBG_DEC(ulListLen);
		werr(1, szMsg);
	}
} /* end of vCheckList */
#endif /* DEBUG */

/*
 * bIsEmptyBox - check to see if the given text box is empty
 */
static BOOL
bIsEmptyBox(FILE *pFile, const list_mem_type *pAnchor)
{
	const list_mem_type	*pCurr;
	size_t	tIndex, tSize;
	UCHAR	*aucBuffer;
	char	cChar;

	fail(pFile == NULL);

	if (pAnchor == NULL) {
		return TRUE;
	}

	aucBuffer = NULL;
	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		fail(pCurr->tInfo.ulLength == 0);
		tSize = (size_t)pCurr->tInfo.ulLength;
#if defined(__dos) && !defined(__DJGPP__)
		if (pCurr->tInfo.ulLength > 0xffffUL) {
			tSize = 0xffff;
		}
#endif /* __dos && !__DJGPP__ */
		fail(aucBuffer != NULL);
		aucBuffer = xmalloc(tSize);
		if (!bReadBytes(aucBuffer, tSize,
				pCurr->tInfo.ulFileOffset, pFile)) {
			aucBuffer = xfree(aucBuffer);
			return FALSE;
		}
		for (tIndex = 0; tIndex < tSize; tIndex++) {
			cChar = (char)aucBuffer[tIndex];
			switch (cChar) {
			case '\0': case '\r': case '\n':
			case '\f': case '\t': case '\v':
			case ' ':
				break;
			default:
				aucBuffer = xfree(aucBuffer);
				return FALSE;
			}
		}
		aucBuffer = xfree(aucBuffer);
	}
	fail(aucBuffer != NULL);
	return TRUE;
} /* end of bIsEmptyBox */

/*
 * vSplitBlockList - split the block list in the various parts
 *
 * Split the blocklist in a Text block list, a Footnote block list, a
 * HeaderFooter block list, a Macro block list, an Annotation block list,
 * an Endnote block list, a TextBox list and a HeaderTextBox list.
 *
 * NOTE:
 * The various ul*Len input parameters are given in characters, but the
 * length of the blocks are in bytes.
 */
void
vSplitBlockList(FILE *pFile, ULONG ulTextLen, ULONG ulFootnoteLen,
	ULONG ulHdrFtrLen, ULONG ulMacroLen, ULONG ulAnnotationLen,
	ULONG ulEndnoteLen, ULONG ulTextBoxLen, ULONG ulHdrTextBoxLen,
	BOOL bMustExtend)
{
	list_mem_type	*apAnchors[8];
	list_mem_type	*pGarbageAnchor, *pCurr;
	size_t		tIndex;

	DBG_MSG("vSplitBlockList");

	pGarbageAnchor = NULL;

	DBG_MSG_C(ulTextLen != 0, "Text block list");
	vSpitList(&pTextAnchor, &pFootnoteAnchor, ulTextLen);
	DBG_MSG_C(ulFootnoteLen != 0, "Footnote block list");
	vSpitList(&pFootnoteAnchor, &pHdrFtrAnchor, ulFootnoteLen);
	DBG_MSG_C(ulHdrFtrLen != 0, "Header/Footer block list");
	vSpitList(&pHdrFtrAnchor, &pMacroAnchor, ulHdrFtrLen);
	DBG_MSG_C(ulMacroLen != 0, "Macro block list");
	vSpitList(&pMacroAnchor, &pAnnotationAnchor, ulMacroLen);
	DBG_MSG_C(ulAnnotationLen != 0, "Annotation block list");
	vSpitList(&pAnnotationAnchor, &pEndnoteAnchor, ulAnnotationLen);
	DBG_MSG_C(ulEndnoteLen != 0, "Endnote block list");
	vSpitList(&pEndnoteAnchor, &pTextBoxAnchor, ulEndnoteLen);
	DBG_MSG_C(ulTextBoxLen != 0, "Textbox block list");
	vSpitList(&pTextBoxAnchor, &pHdrTextBoxAnchor, ulTextBoxLen);
	DBG_MSG_C(ulHdrTextBoxLen != 0, "HeaderTextbox block list");
	vSpitList(&pHdrTextBoxAnchor, &pGarbageAnchor, ulHdrTextBoxLen);

	/* Free the garbage block list, this should not be needed */
	DBG_DEC_C(pGarbageAnchor != NULL, pGarbageAnchor->tInfo.ulLength);
	pGarbageAnchor = pFreeOneList(pGarbageAnchor);

#if defined(DEBUG)
	vCheckList(pTextAnchor, ulTextLen, "Software error (Text)");
	vCheckList(pFootnoteAnchor, ulFootnoteLen, "Software error (Footnote)");
	vCheckList(pHdrFtrAnchor, ulHdrFtrLen, "Software error (Hdr/Ftr)");
	vCheckList(pMacroAnchor, ulMacroLen, "Software error (Macro)");
	vCheckList(pAnnotationAnchor, ulAnnotationLen,
						"Software error (Annotation)");
	vCheckList(pEndnoteAnchor, ulEndnoteLen, "Software error (Endnote)");
	vCheckList(pTextBoxAnchor, ulTextBoxLen, "Software error (TextBox)");
	vCheckList(pHdrTextBoxAnchor, ulHdrTextBoxLen,
						"Software error (HdrTextBox)");
#endif /* DEBUG */

	/* Remove the list if the text box is empty */
	if (bIsEmptyBox(pFile, pTextBoxAnchor)) {
		pTextBoxAnchor = pFreeOneList(pTextBoxAnchor);
	}
	if (bIsEmptyBox(pFile, pHdrTextBoxAnchor)) {
		pHdrTextBoxAnchor = pFreeOneList(pHdrTextBoxAnchor);
	}

	if (!bMustExtend) {
		return;
	}
	/*
	 * All blocks (except the last one) must have a length that
	 * is a multiple of the Big Block Size
	 */

	apAnchors[0] = pTextAnchor;
	apAnchors[1] = pFootnoteAnchor;
	apAnchors[2] = pHdrFtrAnchor;
	apAnchors[3] = pMacroAnchor;
	apAnchors[4] = pAnnotationAnchor;
	apAnchors[5] = pEndnoteAnchor;
	apAnchors[6] = pTextBoxAnchor;
	apAnchors[7] = pHdrTextBoxAnchor;

	for (tIndex = 0; tIndex < elementsof(apAnchors); tIndex++) {
		for (pCurr = apAnchors[tIndex];
		     pCurr != NULL;
		     pCurr = pCurr->pNext) {
			if (pCurr->pNext != NULL &&
			    pCurr->tInfo.ulLength % BIG_BLOCK_SIZE != 0) {
				DBG_DEC(tIndex);
				DBG_HEX(pCurr->tInfo.ulFileOffset);
				DBG_HEX(pCurr->tInfo.ulCharPos);
				DBG_DEC(pCurr->tInfo.ulLength);
				pCurr->tInfo.ulLength /= BIG_BLOCK_SIZE;
				pCurr->tInfo.ulLength++;
				pCurr->tInfo.ulLength *= BIG_BLOCK_SIZE;
				DBG_DEC(pCurr->tInfo.ulLength);
			}
		}
	}
} /* end of vSplitBlockList */

#if defined(__riscos)
/*
 * ulGetDocumentLength - get the total character length of the printable lists
 *
 * returns: The total number of characters
 */
ULONG
ulGetDocumentLength(void)
{
	long		ulTotal;

	DBG_MSG("ulGetDocumentLength");

	ulTotal = ulComputeListLength(pTextAnchor);
	ulTotal += ulComputeListLength(pFootnoteAnchor);
	ulTotal += ulComputeListLength(pEndnoteAnchor);
	ulTotal += ulComputeListLength(pTextBoxAnchor);
	ulTotal += ulComputeListLength(pHdrTextBoxAnchor);
	DBG_DEC(ulTotal);
	return ulTotal;
} /* end of ulGetDocumentLength */
#endif /* __riscos */

#if 0
/*
 * bExistsHdrFtr - are there headers and/or footers?
 */
BOOL
bExistsHdrFtr(void)
{
	return pHdrFtrAnchor != NULL &&
		pHdrFtrAnchor->tInfo.ulLength != 0;
} /* end of bExistsHdrFtr */
#endif

/*
 * bExistsTextBox - is there a text box?
 */
BOOL
bExistsTextBox(void)
{
	return pTextBoxAnchor != NULL &&
		pTextBoxAnchor->tInfo.ulLength != 0;
} /* end of bExistsTextBox */

/*
 * bExistsHdrTextBox - is there a header text box?
 */
BOOL
bExistsHdrTextBox(void)
{
	return pHdrTextBoxAnchor != NULL &&
		pHdrTextBoxAnchor->tInfo.ulLength != 0;
} /* end of bExistsHdrTextBox */

/*
 * usGetNextByte - get the next byte from the specified block list
 */
static USHORT
usGetNextByte(FILE *pFile, readinfo_type *pInfoCurrent, list_mem_type *pAnchor,
	ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
{
	ULONG	ulReadOff;
	size_t	tReadLen;

	fail(pInfoCurrent == NULL);

	if (pInfoCurrent->pBlockCurrent == NULL ||
	    pInfoCurrent->tByteNext >= sizeof(pInfoCurrent->aucBlock) ||
	    pInfoCurrent->ulBlockOffset + pInfoCurrent->tByteNext >=
				pInfoCurrent->pBlockCurrent->tInfo.ulLength) {
		if (pInfoCurrent->pBlockCurrent == NULL) {
			/* First block, first part */
			pInfoCurrent->pBlockCurrent = pAnchor;
			pInfoCurrent->ulBlockOffset = 0;
		} else if (pInfoCurrent->ulBlockOffset +
				sizeof(pInfoCurrent->aucBlock) <
				pInfoCurrent->pBlockCurrent->tInfo.ulLength) {
			/* Same block, next part */
			pInfoCurrent->ulBlockOffset +=
					sizeof(pInfoCurrent->aucBlock);
		} else {
			/* Next block, first part */
			pInfoCurrent->pBlockCurrent =
					pInfoCurrent->pBlockCurrent->pNext;
			pInfoCurrent->ulBlockOffset = 0;
		}
		if (pInfoCurrent->pBlockCurrent == NULL) {
			/* Past the last part of the last block */
			return (USHORT)EOF;
		}
		tReadLen = (size_t)
			(pInfoCurrent->pBlockCurrent->tInfo.ulLength -
			 pInfoCurrent->ulBlockOffset);
		if (tReadLen > sizeof(pInfoCurrent->aucBlock)) {
			tReadLen = sizeof(pInfoCurrent->aucBlock);
		}
		ulReadOff = pInfoCurrent->pBlockCurrent->tInfo.ulFileOffset +
				pInfoCurrent->ulBlockOffset;
		if (!bReadBytes(pInfoCurrent->aucBlock,
						tReadLen, ulReadOff, pFile)) {
			/* Don't read from this list any longer */
			pInfoCurrent->pBlockCurrent = NULL;
			return (USHORT)EOF;
		}
		pInfoCurrent->tByteNext = 0;
	}
	if (pulFileOffset != NULL) {
		*pulFileOffset =
			pInfoCurrent->pBlockCurrent->tInfo.ulFileOffset +
			pInfoCurrent->ulBlockOffset +
			pInfoCurrent->tByteNext;
	}
	if (pulCharPos != NULL) {
		*pulCharPos =
			pInfoCurrent->pBlockCurrent->tInfo.ulCharPos +
			pInfoCurrent->ulBlockOffset +
			pInfoCurrent->tByteNext;
	}
	if (pusPropMod != NULL) {
		*pusPropMod = pInfoCurrent->pBlockCurrent->tInfo.usPropMod;
	}
	return (USHORT)pInfoCurrent->aucBlock[pInfoCurrent->tByteNext++];
} /* end of usGetNextByte */


/*
 * usGetNextChar - get the next character from the specified block list
 */
static USHORT
usGetNextChar(FILE *pFile, list_id_enum eListID,
	ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
{
	readinfo_type	*pReadinfo;
	list_mem_type	*pAnchor;
	USHORT	usLSB, usMSB;

	switch (eListID) {
	case text_list:
		pReadinfo = &tOthers;
		pAnchor = pTextAnchor;
		break;
	case footnote_list:
		pReadinfo = &tFootnote;
		pAnchor = pFootnoteAnchor;
		break;
	case hdrftr_list:
		pReadinfo = &tHdrFtr;
		pAnchor = pHdrFtrAnchor;
		break;
	case endnote_list:
		pReadinfo = &tOthers;
		pAnchor = pEndnoteAnchor;
		break;
	case textbox_list:
		pReadinfo = &tOthers;
		pAnchor = pTextBoxAnchor;
		break;
	case hdrtextbox_list:
		pReadinfo = &tOthers;
		pAnchor = pHdrTextBoxAnchor;
		break;
	default:
		DBG_DEC(eListID);
		return (USHORT)EOF;
	}

	usLSB = usGetNextByte(pFile, pReadinfo, pAnchor,
				pulFileOffset, pulCharPos, pusPropMod);
	if (usLSB == (USHORT)EOF) {
		return (USHORT)EOF;
	}
	fail(pReadinfo->pBlockCurrent == NULL);

	if (pReadinfo->pBlockCurrent->tInfo.bUsesUnicode) {
		usMSB = usGetNextByte(pFile,
				pReadinfo, pAnchor, NULL, NULL, NULL);
	} else {
		usMSB = 0x00;
	}
	if (usMSB == (USHORT)EOF) {
		DBG_MSG("usGetNextChar: Unexpected EOF");
		DBG_HEX_C(pulFileOffset != NULL, *pulFileOffset);
		DBG_HEX_C(pulCharPos != NULL, *pulCharPos);
		return (USHORT)EOF;
	}
	return (usMSB << 8) | usLSB;
} /* end of usGetNextChar */

/*
 * usNextChar - get the next character from the given block list
 */
USHORT
usNextChar(FILE *pFile, list_id_enum eListID,
	ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
{
	USHORT	usRetVal;

	fail(pFile == NULL);

	usRetVal = usGetNextChar(pFile, eListID,
				pulFileOffset, pulCharPos, pusPropMod);
	if (usRetVal == (USHORT)EOF) {
		if (pulFileOffset != NULL) {
			*pulFileOffset = FC_INVALID;
		}
		if (pulCharPos != NULL) {
			*pulCharPos = CP_INVALID;
		}
		if (pusPropMod != NULL) {
			*pusPropMod = IGNORE_PROPMOD;
		}
	}
	return usRetVal;
} /* end of usNextChar */

/*
 * usToHdrFtrPosition - Go to a character position in header/foorter list
 *
 * Returns the character found on the specified character position
 */
USHORT
usToHdrFtrPosition(FILE *pFile, ULONG ulCharPos)
{
	ULONG	ulCharPosCurr;
	USHORT	usChar;

	tHdrFtr.pBlockCurrent = NULL;	/* To reset the header/footer list */
	do {
		usChar = usNextChar(pFile,
				hdrftr_list, NULL, &ulCharPosCurr, NULL);
	} while (usChar != (USHORT)EOF && ulCharPosCurr != ulCharPos);
	return usChar;
} /* end of usToHdrFtrPosition */

/*
 * usToFootnotePosition - Go to a character position in footnote list
 *
 * Returns the character found on the specified character position
 */
USHORT
usToFootnotePosition(FILE *pFile, ULONG ulCharPos)
{
	ULONG	ulCharPosCurr;
	USHORT	usChar;

	tFootnote.pBlockCurrent = NULL;	/* To reset the footnote list */
	do {
		usChar = usNextChar(pFile,
				footnote_list, NULL, &ulCharPosCurr, NULL);
	} while (usChar != (USHORT)EOF && ulCharPosCurr != ulCharPos);
	return usChar;
} /* end of usToFootnotePosition */

/*
 * Convert a character position to an offset in the file.
 * Logical to physical offset.
 *
 * Returns:	FC_INVALID: in case of error
 *		otherwise: the computed file offset
 */
ULONG
ulCharPos2FileOffsetX(ULONG ulCharPos, list_id_enum *peListID)
{
	static list_id_enum	eListIDs[8] = {
		text_list,	footnote_list,		hdrftr_list,
		macro_list,	annotation_list,	endnote_list,
		textbox_list,	hdrtextbox_list,
	};
	list_mem_type	*apAnchors[8];
	list_mem_type	*pCurr;
	list_id_enum	eListGuess;
	ULONG		ulBestGuess;
	size_t		tIndex;

	fail(peListID == NULL);

	if (ulCharPos == CP_INVALID) {
		*peListID = no_list;
		return FC_INVALID;
	}

	apAnchors[0] = pTextAnchor;
	apAnchors[1] = pFootnoteAnchor;
	apAnchors[2] = pHdrFtrAnchor;
	apAnchors[3] = pMacroAnchor;
	apAnchors[4] = pAnnotationAnchor;
	apAnchors[5] = pEndnoteAnchor;
	apAnchors[6] = pTextBoxAnchor;
	apAnchors[7] = pHdrTextBoxAnchor;

	eListGuess = no_list;	  /* Best guess is no list */
	ulBestGuess = FC_INVALID; /* Best guess is "file offset not found" */

	for (tIndex = 0; tIndex < elementsof(apAnchors); tIndex++) {
		for (pCurr = apAnchors[tIndex];
		     pCurr != NULL;
		     pCurr = pCurr->pNext) {
			if (ulCharPos == pCurr->tInfo.ulCharPos +
			     pCurr->tInfo.ulLength &&
			    pCurr->pNext != NULL) {
				/*
				 * The character position is one beyond this
				 * block, so we guess it's the first byte of
				 * the next block (if there is a next block)
				 */
				eListGuess= eListIDs[tIndex];
				ulBestGuess = pCurr->pNext->tInfo.ulFileOffset;
			}

			if (ulCharPos < pCurr->tInfo.ulCharPos ||
			    ulCharPos >= pCurr->tInfo.ulCharPos +
			     pCurr->tInfo.ulLength) {
				/* Character position is not in this block */
				continue;
			}

			/* The character position is in the current block */
			*peListID = eListIDs[tIndex];
			return pCurr->tInfo.ulFileOffset +
				ulCharPos - pCurr->tInfo.ulCharPos;
		}
	}
	/* Passed beyond the end of the last list */
	NO_DBG_HEX(ulCharPos);
	NO_DBG_HEX(ulBestGuess);
	*peListID = eListGuess;
	return ulBestGuess;
} /* end of ulCharPos2FileOffsetX */

/*
 * Convert a character position to an offset in the file.
 * Logical to physical offset.
 *
 * Returns:	FC_INVALID: in case of error
 *		otherwise: the computed file offset
 */
ULONG
ulCharPos2FileOffset(ULONG ulCharPos)
{
	list_id_enum	eListID;

	return ulCharPos2FileOffsetX(ulCharPos, &eListID);
} /* end of ulCharPos2FileOffset */

/*
 * Convert an offset in the header/footer list to a character position.
 *
 * Returns:	CP_INVALID: in case of error
 *		otherwise: the computed character position
 */
ULONG
ulHdrFtrOffset2CharPos(ULONG ulHdrFtrOffset)
{
	list_mem_type	*pCurr;
	ULONG		ulOffset;

	ulOffset = ulHdrFtrOffset;
	for (pCurr = pHdrFtrAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		if (ulOffset >= pCurr->tInfo.ulLength) {
			/* The offset is not in this block */
			ulOffset -= pCurr->tInfo.ulLength;
			continue;
		}
		return pCurr->tInfo.ulCharPos + ulOffset;
	}
	return CP_INVALID;
} /* end of ulHdrFtrOffset2CharPos */

/*
 * Get the sequence number beloning to the given file offset
 *
 * Returns the sequence number
 */
ULONG
ulGetSeqNumber(ULONG ulFileOffset)
{
	list_mem_type	*pCurr;
	ULONG		ulSeq;

	if (ulFileOffset == FC_INVALID) {
		return FC_INVALID;
	}

	ulSeq = 0;
	for (pCurr = pTextAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		if (ulFileOffset >= pCurr->tInfo.ulFileOffset &&
		    ulFileOffset < pCurr->tInfo.ulFileOffset +
		     pCurr->tInfo.ulLength) {
			/* The file offset is within the current textblock */
			return ulSeq + ulFileOffset - pCurr->tInfo.ulFileOffset;
		}
		ulSeq += pCurr->tInfo.ulLength;
	}
	return FC_INVALID;
} /* end of ulGetSeqNumber */