examples/PIPS/antiword/src/listlist.c

/*
 * 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 */

---