Plan 9 from Bell Labs’s /usr/web/sources/plan9/sys/src/cmd/aux/antiword/listlist.c

Copyright © 2021 Plan 9 Foundation.
Distributed under the MIT License.
Download the Plan 9 distribution.


/*
 * listlist.c
 * Copyright (C) 2002,2003 A.J. van Os; Released under GPL
 *
 * Description:
 * Build, read and destroy a list of Word list information
 *
 * Note:
 * This list only exists when the Word document is saved by Word 8 or later
 */

#include "antiword.h"

/*
 * Private structure to hide the way the information
 * is stored from the rest of the program
 */
typedef struct list_desc_tag {
	list_block_type		tInfo;
	ULONG			ulListID;
	USHORT			usIstd;
	UCHAR			ucListLevel;
	struct list_desc_tag	*pNext;
} list_desc_type;

typedef struct list_value_tag {
	USHORT			usValue;
	USHORT			usListIndex;
	UCHAR			ucListLevel;
	struct list_value_tag	*pNext;
} list_value_type;

/* Variables needed to describe the LFO list (pllfo) */
static ULONG		*aulLfoList = NULL;
static USHORT		usLfoLen = 0;
/* Variables needed to write the List Information List */
static list_desc_type	*pAnchor = NULL;
static list_desc_type	*pBlockLast = NULL;
/* Variable needed for numbering new lists */
static list_value_type	*pValues = NULL;
/* Variables needed for numbering old lists */
static int	iOldListSeqNumber = 0;
static USHORT	usOldListValue = 0;


/*
 * vDestroyListInfoList - destroy the List Information List
 */
void
vDestroyListInfoList(void)
{
	list_desc_type	*pCurr, *pNext;
	list_value_type	*pValueCurr, *pValueNext;

	DBG_MSG("vDestroyListInfoList");

	/* Free the LFO list */
	usLfoLen = 0;
	aulLfoList = xfree(aulLfoList);

	/* Free the List Information List */
	pCurr = pAnchor;
	while (pCurr != NULL) {
		pNext = pCurr->pNext;
		pCurr = xfree(pCurr);
		pCurr = pNext;
	}
	pAnchor = NULL;
	/* Reset all control variables */
	pBlockLast = NULL;

	/* Free the values list */
	pValueCurr = pValues;
	while (pValueCurr != NULL) {
		pValueNext = pValueCurr->pNext;
		pValueCurr = xfree(pValueCurr);
		pValueCurr = pValueNext;
	}
	pValues = NULL;
	/* Reset the values for the old lists */
	iOldListSeqNumber = 0;
	usOldListValue = 0;
} /* end of vDestroyListInfoList */

/*
 * vBuildLfoList - build the LFO list (pllfo)
 */
void
vBuildLfoList(const UCHAR *aucBuffer, size_t tBufLen)
{
	size_t	tRecords;
	int	iIndex;

	fail(aucBuffer == NULL);

	if (tBufLen < 4) {
		return;
	}
	tRecords = (size_t)ulGetLong(0, aucBuffer);
	NO_DBG_DEC(tRecords);
	if (4 + 16 * tRecords > tBufLen || tRecords >= 0x7fff) {
		/* Just a sanity check */
		DBG_DEC(tRecords);
		DBG_DEC(4 + 16 * tRecords);
		DBG_DEC(tBufLen);
		return;
	}
	aulLfoList = xcalloc(tRecords, sizeof(ULONG));
	for (iIndex = 0; iIndex < (int)tRecords; iIndex++) {
		aulLfoList[iIndex] = ulGetLong(4 + 16 * iIndex, aucBuffer);
		NO_DBG_HEX(aulLfoList[iIndex]);
	}
	usLfoLen = (USHORT)tRecords;
} /* end of vBuildLfoList */

/*
 * vAdd2ListInfoList - add an element to the List Information list
 */
void
vAdd2ListInfoList(ULONG ulListID, USHORT usIstd, UCHAR ucListLevel,
	const list_block_type *pListBlock)
{
	list_desc_type	*pListMember;

	fail(pListBlock == NULL);

	NO_DBG_HEX(ulListID);
	NO_DBG_DEC(usIstd);
	NO_DBG_DEC(ucListLevel);
	NO_DBG_DEC(pListBlock->ulStartAt);
	NO_DBG_DEC(pListBlock->bNoRestart);
	NO_DBG_DEC(pListBlock->sLeftIndent);
	NO_DBG_HEX(pListBlock->ucNFC);
	NO_DBG_HEX(pListBlock->usListChar);

	/* Create list member */
	pListMember = xmalloc(sizeof(list_desc_type));
	/* Fill the list member */
	pListMember->tInfo = *pListBlock;
	pListMember->ulListID = ulListID;
	pListMember->usIstd = usIstd;
	pListMember->ucListLevel = ucListLevel;
	pListMember->pNext = NULL;
	/* Correct the values where needed */
	if (pListMember->tInfo.ulStartAt > 0xffff) {
		DBG_DEC(pListMember->tInfo.ulStartAt);
		pListMember->tInfo.ulStartAt = 1;
	}
	/* Add the new member to the list */
	if (pAnchor == NULL) {
		pAnchor = pListMember;
	} else {
		fail(pBlockLast == NULL);
		pBlockLast->pNext = pListMember;
	}
	pBlockLast = pListMember;
} /* end of vAdd2ListInfoList */

/*
 * Get a matching record from the List Information List
 *
 * Returns NULL if no matching records is found
 */
const list_block_type *
pGetListInfo(USHORT usListIndex, UCHAR ucListLevel)
{
	list_desc_type	*pCurr;
	list_block_type	*pNearMatch;
	ULONG	ulListID;

	if (usListIndex == 0) {
		return NULL;
	}
	if (usListIndex - 1 >= usLfoLen || ucListLevel > 8) {
		DBG_DEC(usListIndex);
		DBG_DEC(ucListLevel);
		return NULL;
	}
	fail(aulLfoList == NULL);
	ulListID = aulLfoList[usListIndex - 1];
	NO_DBG_HEX(ulListID);

	pNearMatch = NULL;
	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		if (pCurr->ulListID != ulListID) {
			/* No match */
			continue;
		}
		if (pCurr->ucListLevel == ucListLevel) {
			/* Exact match */
			return &pCurr->tInfo;
		}
		if (pCurr->ucListLevel == 0) {
			/* Near match */
			pNearMatch = &pCurr->tInfo;
		}
	}
	/* No exact match, use a near match if any */
	return pNearMatch;
} /* end of pGetListInfo */

/*
 * Get a matching record from the List Information List
 *
 * Returns NULL if no matching records is found
 */
const list_block_type *
pGetListInfoByIstd(USHORT usIstd)
{
	list_desc_type	*pCurr;

	if (usIstd == ISTD_INVALID || usIstd == STI_NIL || usIstd == STI_USER) {
		return NULL;
	}

	for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
		if (pCurr->usIstd == usIstd) {
			return &pCurr->tInfo;
		}
	}
	return NULL;
} /* end of pGetListInfoByIstd */

/*
 * vRestartListValues - reset the less significant list levels
 */
static void
vRestartListValues(USHORT usListIndex, UCHAR ucListLevel)
{
	list_value_type	*pPrev, *pCurr, *pNext;
	int		iCounter;

	iCounter = 0;
	pPrev = NULL;
	pCurr = pValues;

	while (pCurr != NULL) {
		if (pCurr->usListIndex != usListIndex ||
		    pCurr->ucListLevel <= ucListLevel) {
			pPrev = pCurr;
			pCurr = pCurr->pNext;
			continue;
		}
		/* Reset the level by deleting the record */
		pNext = pCurr->pNext;
		if (pPrev == NULL) {
			pValues = pNext;
		} else {
			pPrev->pNext = pNext;
		}
		DBG_DEC(pCurr->usListIndex);
		DBG_DEC(pCurr->ucListLevel);
		pCurr = xfree(pCurr);
		pCurr = pNext;
		iCounter++;
	}
	DBG_DEC_C(iCounter > 0, iCounter);
} /* end of vRestartListValues */

/*
 * usGetListValue - Get the current value of the given list
 *
 * Returns the value of the given list
 */
USHORT
usGetListValue(int iListSeqNumber, int iWordVersion,
	const style_block_type *pStyle)
{
	list_value_type	*pCurr;
	USHORT		usValue;

	fail(iListSeqNumber < 0);
	fail(iListSeqNumber < iOldListSeqNumber);
	fail(iWordVersion < 0);
	fail(pStyle == NULL);

	if (iListSeqNumber <= 0) {
		return 0;
	}

	if (iWordVersion < 8) {
		/* Old style list */
		if (iListSeqNumber == iOldListSeqNumber ||
		    (iListSeqNumber == iOldListSeqNumber + 1 &&
		     eGetNumType(pStyle->ucNumLevel) == level_type_sequence)) {
			if (!pStyle->bNumPause) {
				usOldListValue++;
			}
		} else {
			usOldListValue = pStyle->usStartAt;
		}
		iOldListSeqNumber = iListSeqNumber;
		return usOldListValue;
	}

	/* New style list */
	if (pStyle->usListIndex == 0 ||
	    pStyle->usListIndex - 1 >= usLfoLen ||
	    pStyle->ucListLevel > 8) {
		/* Out of range; no need to search */
		return 0;
	}

	for (pCurr = pValues; pCurr != NULL; pCurr = pCurr->pNext) {
		if (pCurr->usListIndex == pStyle->usListIndex &&
		    pCurr->ucListLevel == pStyle->ucListLevel) {
			/* Record found; increment and return the value */
			pCurr->usValue++;
			usValue = pCurr->usValue;
			if (!pStyle->bNoRestart) {
				vRestartListValues(pStyle->usListIndex,
						pStyle->ucListLevel);
			}
			return usValue;
		}
	}

	/* Record not found; create it and add it to the front of the list */
	pCurr = xmalloc(sizeof(list_value_type));
	pCurr->usValue = pStyle->usStartAt;
	pCurr->usListIndex = pStyle->usListIndex;
	pCurr->ucListLevel = pStyle->ucListLevel;
	pCurr->pNext = pValues;
	pValues = pCurr;
	usValue = pCurr->usValue;
	if (!pStyle->bNoRestart) {
		vRestartListValues(pStyle->usListIndex, pStyle->ucListLevel);
	}
	return usValue;
} /* end of usGetListValue */

Bell Labs OSI certified Powered by Plan 9

(Return to Plan 9 Home Page)

Copyright © 2021 Plan 9 Foundation. All Rights Reserved.
Comments to [email protected].