examples/PIPS/antiword/src/word2text.c

/*
 * word2text.c
 * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
 *
 * Description:
 * MS Word to "text" functions
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#if defined(__riscos)
#include "DeskLib:Hourglass.h"
#include "drawfile.h"
#endif /* __riscos */
#include "antiword.h"


#define INITIAL_SIZE            40
#define EXTENTION_SIZE          20


/* Macros to make sure all such statements will be identical */
#define OUTPUT_LINE()           \
        do {\
                vAlign2Window(pDiag, pAnchor, lWidthMax, ucAlignment);\
                TRACE_MSG("after vAlign2Window");\
                pAnchor = pStartNewOutput(pAnchor, NULL);\
                pOutput = pAnchor;\
        } while(0)

#define RESET_LINE()            \
        do {\
                pAnchor = pStartNewOutput(pAnchor, NULL);\
                pOutput = pAnchor;\
        } while(0)

#if defined(__riscos)
/* Length of the document in characters */
static ULONG    ulDocumentLength;
/* Number of characters processed so far */
static ULONG    ulCharCounter;
static int      iCurrPct, iPrevPct;
#endif /* __riscos */
/* The document is in the format belonging to this version of Word */
static int      iWordVersion = -1;
/* Special treatment for files from Word 4/5/6 on an Apple Macintosh */
static BOOL     bOldMacFile = FALSE;
/* Section Information */
static const section_block_type *pSection = NULL;
static const section_block_type *pSectionNext = NULL;
/* All the (command line) options */
static options_type     tOptions;
/* Needed for reading a complete table row */
static const row_block_type     *pRowInfo = NULL;
static BOOL     bStartRow = FALSE;
static BOOL     bEndRowNorm = FALSE;
static BOOL     bEndRowFast = FALSE;
static BOOL     bIsTableRow = FALSE;
/* Index of the next style and font information */
static USHORT   usIstdNext = ISTD_NORMAL;
/* Needed for finding the start of a style */
static const style_block_type   *pStyleInfo = NULL;
static style_block_type         tStyleNext;
static BOOL     bStartStyle = FALSE;
static BOOL     bStartStyleNext = FALSE;
/* Needed for finding the start of a font */
static const font_block_type    *pFontInfo = NULL;
static font_block_type          tFontNext;
static BOOL     bStartFont = FALSE;
static BOOL     bStartFontNext = FALSE;
/* Needed for finding an image */
static ULONG    ulFileOffsetImage = FC_INVALID;


/*
 * vUpdateCounters - Update the counters for the hourglass
 */
static void
vUpdateCounters(void)
{
#if defined(__riscos)
        ulCharCounter++;
        iCurrPct = (int)((ulCharCounter * 100) / ulDocumentLength);
        if (iCurrPct != iPrevPct) {
                Hourglass_Percentage(iCurrPct);
                iPrevPct = iCurrPct;
        }
#endif /* __riscos */
} /* end of vUpdateCounters */

/*
 * bOutputContainsText - see if the output contains more than white space
 */
BOOL
bOutputContainsText(const output_type *pAnchor)
{
        const output_type       *pCurr;
        size_t  tIndex;

        fail(pAnchor == NULL);

        for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
                fail(pCurr->lStringWidth < 0);
                for (tIndex = 0; tIndex < pCurr->tNextFree; tIndex++) {
                        if (isspace((int)(UCHAR)pCurr->szStorage[tIndex])) {
                                continue;
                        }
#if defined(DEBUG)
                        if (pCurr->szStorage[tIndex] == FILLER_CHAR) {
                                continue;
                        }
#endif /* DEBUG */
                        return TRUE;
                }
        }
        return FALSE;
} /* end of bOutputContainsText */

/*
 * lTotalStringWidth - compute the total width of the output string
 */
static long
lTotalStringWidth(const output_type *pAnchor)
{
        const output_type       *pCurr;
        long            lTotal;

        lTotal = 0;
        for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
                DBG_DEC_C(pCurr->lStringWidth < 0, pCurr->lStringWidth);
                fail(pCurr->lStringWidth < 0);
                lTotal += pCurr->lStringWidth;
        }
        return lTotal;
} /* end of lTotalStringWidth */

/*
 * vStoreByte - store one byte
 */
static void
vStoreByte(UCHAR ucChar, output_type *pOutput)
{
        fail(pOutput == NULL);

        if (ucChar == 0) {
                pOutput->szStorage[pOutput->tNextFree] = '\0';
                return;
        }

        while (pOutput->tNextFree + 2 > pOutput->tStorageSize) {
                pOutput->tStorageSize += EXTENTION_SIZE;
                pOutput->szStorage = xrealloc(pOutput->szStorage,
                                        pOutput->tStorageSize);
        }
        pOutput->szStorage[pOutput->tNextFree] = (char)ucChar;
        pOutput->szStorage[pOutput->tNextFree + 1] = '\0';
        pOutput->tNextFree++;
} /* end of vStoreByte */

/*
 * vStoreChar - store a character as one or more bytes
 */
static void
vStoreChar(ULONG ulChar, BOOL bChangeAllowed, output_type *pOutput)
{
        char    szResult[4];
        size_t  tIndex, tLen;

        fail(pOutput == NULL);

        if (tOptions.eEncoding == encoding_utf_8 && bChangeAllowed) {
                DBG_HEX_C(ulChar > 0xffff, ulChar);
                fail(ulChar > 0xffff);
                tLen = tUcs2Utf8(ulChar, szResult, sizeof(szResult));
                for (tIndex = 0; tIndex < tLen; tIndex++) {
                        vStoreByte((UCHAR)szResult[tIndex], pOutput);
                }
        } else {
                DBG_HEX_C(ulChar > 0xff, ulChar);
                fail(ulChar > 0xff);
                vStoreByte((UCHAR)ulChar, pOutput);
                tLen = 1;
        }
        pOutput->lStringWidth += lComputeStringWidth(
                                pOutput->szStorage + pOutput->tNextFree - tLen,
                                tLen,
                                pOutput->tFontRef,
                                pOutput->usFontSize);
} /* end of vStoreChar */

/*
 * vStoreCharacter - store one character
 */
static void
vStoreCharacter(ULONG ulChar, output_type *pOutput)
{
        vStoreChar(ulChar, TRUE, pOutput);
} /* end of vStoreCharacter */

/*
 * vStoreString - store a string
 */
static void
vStoreString(const char *szString, size_t tStringLength, output_type *pOutput)
{
        size_t  tIndex;

        fail(szString == NULL || pOutput == NULL);

        for (tIndex = 0; tIndex < tStringLength; tIndex++) {
                vStoreCharacter((ULONG)(UCHAR)szString[tIndex], pOutput);
        }
} /* end of vStoreString */

/*
 * vStoreNumberAsDecimal - store a number as a decimal number
 */
static void
vStoreNumberAsDecimal(UINT uiNumber, output_type *pOutput)
{
        size_t  tLen;
        char    szString[3 * sizeof(UINT) + 1];

        fail(uiNumber == 0);
        fail(pOutput == NULL);

        tLen = (size_t)sprintf(szString, "%u", uiNumber);
        vStoreString(szString, tLen, pOutput);
} /* end of vStoreNumberAsDecimal */

/*
 * vStoreNumberAsRoman - store a number as a roman numerical
 */
static void
vStoreNumberAsRoman(UINT uiNumber, output_type *pOutput)
{
        size_t  tLen;
        char    szString[15];

        fail(uiNumber == 0);
        fail(pOutput == NULL);

        tLen = tNumber2Roman(uiNumber, FALSE, szString);
        vStoreString(szString, tLen, pOutput);
} /* end of vStoreNumberAsRoman */

/*
 * vStoreStyle - store a style
 */
static void
vStoreStyle(diagram_type *pDiag, output_type *pOutput,
        const style_block_type *pStyle)
{
        size_t  tLen;
        char    szString[120];

        fail(pDiag == NULL);
        fail(pOutput == NULL);
        fail(pStyle == NULL);

        if (tOptions.eConversionType == conversion_xml) {
                vSetHeaders(pDiag, pStyle->usIstd);
        } else {
                tLen = tStyle2Window(szString, sizeof(szString),
                                        pStyle, pSection);
                vStoreString(szString, tLen, pOutput);
        }
} /* end of vStoreStyle */

/*
 * vPutIndentation - output the specified amount of indentation
 */
static void
vPutIndentation(diagram_type *pDiag, output_type *pOutput,
        BOOL bNoMarks, BOOL bFirstLine,
        UINT uiListNumber, UCHAR ucNFC, const char *szListChar,
        long lLeftIndentation, long lLeftIndentation1)
{
        long    lWidth;
        size_t  tIndex, tNextFree;
        char    szLine[30];

        fail(pDiag == NULL);
        fail(pOutput == NULL);
        fail(szListChar == NULL);
        fail(lLeftIndentation < 0);

        if (tOptions.eConversionType == conversion_xml) {
                /* XML does its own indentation at rendering time */
                return;
        }

        if (bNoMarks) {
                if (bFirstLine) {
                        lLeftIndentation += lLeftIndentation1;
                }
                if (lLeftIndentation < 0) {
                        lLeftIndentation = 0;
                }
                vSetLeftIndentation(pDiag, lLeftIndentation);
                return;
        }
        if (lLeftIndentation <= 0) {
                DBG_HEX_C(ucNFC != 0x00, ucNFC);
                vSetLeftIndentation(pDiag, 0);
                return;
        }

#if defined(DEBUG)
        if (tOptions.eEncoding == encoding_utf_8) {
                fail(strlen(szListChar) > 3);
        } else {
                DBG_HEX_C(iscntrl((int)szListChar[0]), szListChar[0]);
                fail(iscntrl((int)szListChar[0]));
                fail(szListChar[1] != '\0');
        }
#endif /* DEBUG */

        switch (ucNFC) {
        case LIST_ARABIC_NUM:
        case LIST_NUMBER_TXT:
                tNextFree = (size_t)sprintf(szLine, "%u", uiListNumber);
                break;
        case LIST_UPPER_ROMAN:
        case LIST_LOWER_ROMAN:
                tNextFree = tNumber2Roman(uiListNumber,
                                ucNFC == LIST_UPPER_ROMAN, szLine);
                break;
        case LIST_UPPER_ALPHA:
        case LIST_LOWER_ALPHA:
                tNextFree = tNumber2Alpha(uiListNumber,
                                ucNFC == LIST_UPPER_ALPHA, szLine);
                break;
        case LIST_ORDINAL_NUM:
        case LIST_ORDINAL_TXT:
                if (uiListNumber % 10 == 1 && uiListNumber != 11) {
                        tNextFree =
                                (size_t)sprintf(szLine, "%ust", uiListNumber);
                } else if (uiListNumber % 10 == 2 && uiListNumber != 12) {
                        tNextFree =
                                (size_t)sprintf(szLine, "%und", uiListNumber);
                } else if (uiListNumber % 10 == 3 && uiListNumber != 13) {
                        tNextFree =
                                (size_t)sprintf(szLine, "%urd", uiListNumber);
                } else {
                        tNextFree =
                                (size_t)sprintf(szLine, "%uth", uiListNumber);
                }
                break;
        case LIST_OUTLINE_NUM:
                tNextFree = (size_t)sprintf(szLine, "%02u", uiListNumber);
                break;
        case LIST_SPECIAL:
        case LIST_SPECIAL2:
        case LIST_BULLETS:
                tNextFree = 0;
                break;
        default:
                DBG_HEX(ucNFC);
                DBG_FIXME();
                tNextFree = (size_t)sprintf(szLine, "%u", uiListNumber);
                break;
        }
        tNextFree += (size_t)sprintf(szLine + tNextFree, "%.3s", szListChar);
        szLine[tNextFree++] = ' ';
        szLine[tNextFree] = '\0';
        lWidth = lComputeStringWidth(szLine, tNextFree,
                                pOutput->tFontRef, pOutput->usFontSize);
        lLeftIndentation -= lWidth;
        if (lLeftIndentation < 0) {
                lLeftIndentation = 0;
        }
        vSetLeftIndentation(pDiag, lLeftIndentation);
        for (tIndex = 0; tIndex < tNextFree; tIndex++) {
                vStoreChar((ULONG)(UCHAR)szLine[tIndex], FALSE, pOutput);
        }
} /* end of vPutIndentation */

/*
 * vPutSeparatorLine - output a separator line
 *
 * A separator line is a horizontal line two inches long.
 * Two inches equals 144000 millipoints.
 */
static void
vPutSeparatorLine(output_type *pOutput)
{
        long    lCharWidth;
        int     iCounter, iChars;
        char    szOne[2];

        fail(pOutput == NULL);

        szOne[0] = OUR_EM_DASH;
        szOne[1] = '\0';
        lCharWidth = lComputeStringWidth(szOne, 1,
                                pOutput->tFontRef, pOutput->usFontSize);
        NO_DBG_DEC(lCharWidth);
        iChars = (int)((144000 + lCharWidth / 2) / lCharWidth);
        NO_DBG_DEC(iChars);
        for (iCounter = 0; iCounter < iChars; iCounter++) {
                vStoreCharacter((ULONG)(UCHAR)OUR_EM_DASH, pOutput);
        }
} /* end of vPutSeparatorLine */

/*
 * pStartNextOutput - start the next output record
 *
 * returns a pointer to the next record
 */
static output_type *
pStartNextOutput(output_type *pCurrent)
{
        output_type     *pNew;

        TRACE_MSG("pStartNextOutput");

        if (pCurrent->tNextFree == 0) {
                /* The current record is empty, re-use */
                fail(pCurrent->szStorage[0] != '\0');
                fail(pCurrent->lStringWidth != 0);
                return pCurrent;
        }
        /* The current record is in use, make a new one */
        pNew = xmalloc(sizeof(*pNew));
        pCurrent->pNext = pNew;
        pNew->tStorageSize = INITIAL_SIZE;
        pNew->szStorage = xmalloc(pNew->tStorageSize);
        pNew->szStorage[0] = '\0';
        pNew->tNextFree = 0;
        pNew->lStringWidth = 0;
        pNew->ucFontColor = FONT_COLOR_DEFAULT;
        pNew->usFontStyle = FONT_REGULAR;
        pNew->tFontRef = (drawfile_fontref)0;
        pNew->usFontSize = DEFAULT_FONT_SIZE;
        pNew->pPrev = pCurrent;
        pNew->pNext = NULL;
        return pNew;
} /* end of pStartNextOutput */

/*
 * pStartNewOutput
 */
static output_type *
pStartNewOutput(output_type *pAnchor, output_type *pLeftOver)
{
        output_type     *pCurr, *pNext;
        USHORT          usFontStyle, usFontSize;
        drawfile_fontref        tFontRef;
        UCHAR           ucFontColor;

        TRACE_MSG("pStartNewOutput");

        ucFontColor = FONT_COLOR_DEFAULT;
        usFontStyle = FONT_REGULAR;
        tFontRef = (drawfile_fontref)0;
        usFontSize = DEFAULT_FONT_SIZE;
        /* Free the old output space */
        pCurr = pAnchor;
        while (pCurr != NULL) {
                TRACE_MSG("Free the old output space");
                pNext = pCurr->pNext;
                pCurr->szStorage = xfree(pCurr->szStorage);
                if (pCurr->pNext == NULL) {
                        ucFontColor = pCurr->ucFontColor;
                        usFontStyle = pCurr->usFontStyle;
                        tFontRef = pCurr->tFontRef;
                        usFontSize = pCurr->usFontSize;
                }
                pCurr = xfree(pCurr);
                pCurr = pNext;
        }
        if (pLeftOver == NULL) {
                /* Create new output space */
                TRACE_MSG("Create new output space");
                pLeftOver = xmalloc(sizeof(*pLeftOver));
                pLeftOver->tStorageSize = INITIAL_SIZE;
                NO_DBG_DEC(pLeftOver->tStorageSize);
                TRACE_MSG("before 2nd xmalloc");
                pLeftOver->szStorage = xmalloc(pLeftOver->tStorageSize);
                TRACE_MSG("after 2nd xmalloc");
                pLeftOver->szStorage[0] = '\0';
                pLeftOver->tNextFree = 0;
                pLeftOver->lStringWidth = 0;
                pLeftOver->ucFontColor = ucFontColor;
                pLeftOver->usFontStyle = usFontStyle;
                pLeftOver->tFontRef = tFontRef;
                pLeftOver->usFontSize = usFontSize;
                pLeftOver->pPrev = NULL;
                pLeftOver->pNext = NULL;
        }
        fail(!bCheckDoubleLinkedList(pLeftOver));
        return pLeftOver;
} /* end of pStartNewOutput */

/*
 * ulGetChar - get the next character from the specified list
 *
 * returns the next character of EOF
 */
static ULONG
ulGetChar(FILE *pFile, list_id_enum eListID)
{
        const font_block_type   *pCurr;
        ULONG           ulChar, ulFileOffset, ulCharPos;
        row_info_enum   eRowInfo;
        USHORT          usChar, usPropMod;
        BOOL            bSkip;

        fail(pFile == NULL);

        pCurr = pFontInfo;
        bSkip = FALSE;
        for (;;) {
                usChar = usNextChar(pFile, eListID,
                                &ulFileOffset, &ulCharPos, &usPropMod);
                if (usChar == (USHORT)EOF) {
                        return (ULONG)EOF;
                }

                vUpdateCounters();

                eRowInfo = ePropMod2RowInfo(usPropMod, iWordVersion);
                if (!bStartRow) {
#if 0
                        bStartRow = eRowInfo == found_a_cell ||
                                (pRowInfo != NULL &&
                                 ulFileOffset == pRowInfo->ulFileOffsetStart &&
                                 eRowInfo != found_not_a_cell);
#else
                        bStartRow = pRowInfo != NULL &&
                                ulFileOffset == pRowInfo->ulFileOffsetStart;
#endif
                        NO_DBG_HEX_C(bStartRow, pRowInfo->ulFileOffsetStart);
                }
                if (!bEndRowNorm) {
#if 0
                        bEndRow = eRowInfo == found_end_of_row ||
                                (pRowInfo != NULL &&
                                 ulFileOffset == pRowInfo->ulFileOffsetEnd &&
                                 eRowInfo != found_not_end_of_row);
#else
                        bEndRowNorm = pRowInfo != NULL &&
                                ulFileOffset == pRowInfo->ulFileOffsetEnd;
#endif
                        NO_DBG_HEX_C(bEndRowNorm, pRowInfo->ulFileOffsetEnd);
                }
                if (!bEndRowFast) {
                        bEndRowFast = eRowInfo == found_end_of_row;
                        NO_DBG_HEX_C(bEndRowFast, pRowInfo->ulFileOffsetEnd);
                }

                if (!bStartStyle) {
                        bStartStyle = pStyleInfo != NULL &&
                                ulFileOffset == pStyleInfo->ulFileOffset;
                        NO_DBG_HEX_C(bStartStyle, ulFileOffset);
                }
                if (pCurr != NULL && ulFileOffset == pCurr->ulFileOffset) {
                        bStartFont = TRUE;
                        NO_DBG_HEX(ulFileOffset);
                        pFontInfo = pCurr;
                        pCurr = pGetNextFontInfoListItem(pCurr);
                }

                /* Skip embedded characters */
                if (usChar == START_EMBEDDED) {
                        bSkip = TRUE;
                        continue;
                }
                if (usChar == END_IGNORE || usChar == END_EMBEDDED) {
                        bSkip = FALSE;
                        continue;
                }
                if (bSkip) {
                        continue;
                }
                ulChar = ulTranslateCharacters(usChar,
                                        ulFileOffset,
                                        iWordVersion,
                                        tOptions.eConversionType,
                                        tOptions.eEncoding,
                                        bOldMacFile);
                if (ulChar == IGNORE_CHARACTER) {
                        continue;
                }
                if (ulChar == PICTURE) {
                        ulFileOffsetImage = ulGetPictInfoListItem(ulFileOffset);
                } else {
                        ulFileOffsetImage = FC_INVALID;
                }
                if (ulChar == PAR_END) {
                        /* End of paragraph seen, prepare for the next */
                        vFillStyleFromStylesheet(usIstdNext, &tStyleNext);
                        vCorrectStyleValues(&tStyleNext);
                        bStartStyleNext = TRUE;
                        vFillFontFromStylesheet(usIstdNext, &tFontNext);
                        vCorrectFontValues(&tFontNext);
                        bStartFontNext = TRUE;
                }
                if (ulChar == PAGE_BREAK) {
                        /* Might be the start of a new section */
                        pSectionNext = pGetSectionInfo(pSection, ulCharPos);
                }
                return ulChar;
        }
} /* end of ulGetChar */

/*
 * lGetWidthMax - get the maximum line width from the paragraph break value
 *
 * Returns the maximum line width in millipoints
 */
static long
lGetWidthMax(int iParagraphBreak)
{
        fail(iParagraphBreak < 0);

        if (iParagraphBreak == 0) {
                return LONG_MAX;
        }
        if (iParagraphBreak < MIN_SCREEN_WIDTH) {
                return lChar2MilliPoints(MIN_SCREEN_WIDTH);
        }
        if (iParagraphBreak > MAX_SCREEN_WIDTH) {
                return lChar2MilliPoints(MAX_SCREEN_WIDTH);
        }
        return lChar2MilliPoints(iParagraphBreak);
} /* end of lGetWidthMax */

/*
 * bWordDecryptor - turn Word to something more useful
 *
 * returns TRUE when succesful, otherwise FALSE
 */
BOOL
bWordDecryptor(FILE *pFile, long lFilesize, diagram_type *pDiag)
{
        imagedata_type  tImage;
        const style_block_type  *pStyleTmp;
        const font_block_type   *pFontTmp;
        const char      *szListChar;
        output_type     *pAnchor, *pOutput, *pLeftOver;
        ULONG   ulChar;
        long    lBeforeIndentation, lAfterIndentation;
        long    lLeftIndentation, lLeftIndentation1, lRightIndentation;
        long    lWidthCurr, lWidthMax, lDefaultTabWidth, lHalfSpaceWidth, lTmp;
        list_id_enum    eListID;
        image_info_enum eRes;
        UINT    uiFootnoteNumber, uiEndnoteNumber, uiTmp;
        int     iListSeqNumber;
        BOOL    bWasTableRow, bTableFontClosed, bWasEndOfParagraph;
        BOOL    bInList, bWasInList, bNoMarks, bFirstLine;
        BOOL    bAllCapitals, bHiddenText, bMarkDelText, bSuccess;
        USHORT  usListNumber;
        USHORT  usFontStyle, usFontStyleMinimal, usFontSize, usTmp;
        UCHAR   ucFontNumber, ucFontColor;
        UCHAR   ucNFC, ucAlignment;

        fail(pFile == NULL || lFilesize <= 0 || pDiag == NULL);

        TRACE_MSG("bWordDecryptor");

        iWordVersion = iInitDocument(pFile, lFilesize);
        if (iWordVersion < 0) {
                DBG_DEC(iWordVersion);
                return FALSE;
        }

        vGetOptions(&tOptions);
        bOldMacFile = bIsOldMacFile();
        vPrepareHdrFtrText(pFile);
        vPrepareFootnoteText(pFile);

        vPrologue2(pDiag, iWordVersion);

        /* Initialisation */
#if defined(__riscos)
        ulCharCounter = 0;
        iCurrPct = 0;
        iPrevPct = -1;
        ulDocumentLength = ulGetDocumentLength();
#endif /* __riscos */
        pSection = pGetSectionInfo(NULL, 0);
        pSectionNext = pSection;
        lDefaultTabWidth = lGetDefaultTabWidth();
        DBG_DEC_C(lDefaultTabWidth != 36000, lDefaultTabWidth);
        pRowInfo = pGetNextRowInfoListItem();
        DBG_HEX_C(pRowInfo != NULL, pRowInfo->ulFileOffsetStart);
        DBG_HEX_C(pRowInfo != NULL, pRowInfo->ulFileOffsetEnd);
        DBG_MSG_C(pRowInfo == NULL, "No rows at all");
        bStartRow = FALSE;
        bEndRowNorm = FALSE;
        bEndRowFast = FALSE;
        bIsTableRow = FALSE;
        bWasTableRow = FALSE;
        vResetStyles();
        pStyleInfo = pGetNextTextStyle(NULL);
        bStartStyle = FALSE;
        bInList = FALSE;
        bWasInList = FALSE;
        iListSeqNumber = 0;
        usIstdNext = ISTD_NORMAL;
        pAnchor = NULL;
        pFontInfo = pGetNextFontInfoListItem(NULL);
        DBG_HEX_C(pFontInfo != NULL, pFontInfo->ulFileOffset);
        DBG_MSG_C(pFontInfo == NULL, "No fonts at all");
        bStartFont = FALSE;
        ucFontNumber = 0;
        usFontStyleMinimal = FONT_REGULAR;
        usFontStyle = FONT_REGULAR;
        usFontSize = DEFAULT_FONT_SIZE;
        ucFontColor = FONT_COLOR_DEFAULT;
        pAnchor = pStartNewOutput(pAnchor, NULL);
        pOutput = pAnchor;
        pOutput->ucFontColor = ucFontColor;
        pOutput->usFontStyle = usFontStyle;
        pOutput->tFontRef = tOpenFont(ucFontNumber, usFontStyle, usFontSize);
        pOutput->usFontSize = usFontSize;
        bTableFontClosed = TRUE;
        lBeforeIndentation = 0;
        lAfterIndentation = 0;
        lLeftIndentation = 0;
        lLeftIndentation1 = 0;
        lRightIndentation = 0;
        bWasEndOfParagraph = TRUE;
        bNoMarks = TRUE;
        bFirstLine = TRUE;
        ucNFC = LIST_BULLETS;
        if (pStyleInfo != NULL) {
                szListChar = pStyleInfo->szListChar;
                pStyleTmp = pStyleInfo;
        } else {
                if (tStyleNext.szListChar[0] == '\0') {
                        vGetBulletValue(tOptions.eConversionType,
                                tOptions.eEncoding, tStyleNext.szListChar, 4);
                }
                szListChar = tStyleNext.szListChar;
                pStyleTmp = &tStyleNext;
        }
        usListNumber = 0;
        ucAlignment = ALIGNMENT_LEFT;
        bAllCapitals = FALSE;
        bHiddenText = FALSE;
        bMarkDelText = FALSE;
        lWidthMax = lGetWidthMax(tOptions.iParagraphBreak);
        NO_DBG_DEC(lWidthMax);

        Hourglass_On();

        uiFootnoteNumber = 0;
        uiEndnoteNumber = 0;
        eListID = text_list;
        for(;;) {
                ulChar = ulGetChar(pFile, eListID);
                if (ulChar == (ULONG)EOF) {
                        if (bOutputContainsText(pAnchor)) {
                                OUTPUT_LINE();
                        } else {
                                RESET_LINE();
                        }
                        switch (eListID) {
                        case text_list:
                                if (tOptions.eConversionType !=
                                                        conversion_xml) {
                                        eListID = footnote_list;
                                        if (uiFootnoteNumber != 0) {
                                                vPutSeparatorLine(pAnchor);
                                                OUTPUT_LINE();
                                                uiFootnoteNumber = 0;
                                        }
                                        break;
                                }
                                /* No break or return */
                        case footnote_list:
                                eListID = endnote_list;
                                if (uiEndnoteNumber != 0) {
                                        vPutSeparatorLine(pAnchor);
                                        OUTPUT_LINE();
                                        uiEndnoteNumber = 0;
                                }
                                break;
                        case endnote_list:
                                eListID = textbox_list;
                                if (bExistsTextBox()) {
                                        vPutSeparatorLine(pAnchor);
                                        OUTPUT_LINE();
                                }
                                break;
                        case textbox_list:
                                eListID = hdrtextbox_list;
                                if (bExistsHdrTextBox()) {
                                        vPutSeparatorLine(pAnchor);
                                        OUTPUT_LINE();
                                }
                                break;
                        case hdrtextbox_list:
                        default:
                                eListID = end_of_lists;
                                break;
                        }
                        if (eListID == end_of_lists) {
                                break;
                        }
                        continue;
                }

                if (ulChar == UNKNOWN_NOTE_CHAR) {
                        switch (eListID) {
                        case footnote_list:
                                ulChar = FOOTNOTE_CHAR;
                                break;
                        case endnote_list:
                                ulChar = ENDNOTE_CHAR;
                                break;
                        default:
                                break;
                        }
                }

                if (bStartRow) {
                        /* Begin of a tablerow found */
                        if (bOutputContainsText(pAnchor)) {
                                OUTPUT_LINE();
                        } else {
                                RESET_LINE();
                        }
                        fail(pAnchor != pOutput);
                        if (bTableFontClosed) {
                                /* Start special table font */
                                vCloseFont();
                                /*
                                 * Compensate for the fact that Word uses
                                 * proportional fonts for its tables and we
                                 * only one fixed-width font
                                 */
                                uiTmp = ((UINT)usFontSize * 5 + 3) / 6;
                                if (uiTmp < MIN_TABLEFONT_SIZE) {
                                        uiTmp = MIN_TABLEFONT_SIZE;
                                } else if (uiTmp > MAX_TABLEFONT_SIZE) {
                                        uiTmp = MAX_TABLEFONT_SIZE;
                                }
                                pOutput->usFontSize = (USHORT)uiTmp;
                                pOutput->tFontRef =
                                        tOpenTableFont(pOutput->usFontSize);
                                pOutput->usFontStyle = FONT_REGULAR;
                                pOutput->ucFontColor = FONT_COLOR_BLACK;
                                bTableFontClosed = FALSE;
                        }
                        bIsTableRow = TRUE;
                        bStartRow = FALSE;
                }

                if (bWasTableRow &&
                    !bIsTableRow &&
                    ulChar != PAR_END &&
                    ulChar != HARD_RETURN &&
                    ulChar != PAGE_BREAK &&
                    ulChar != COLUMN_FEED) {
                        /*
                         * The end of a table should be followed by an
                         * empty line, like the end of a paragraph
                         */
                        OUTPUT_LINE();
                        vEndOfParagraph(pDiag,
                                        pOutput->tFontRef,
                                        pOutput->usFontSize,
                                        (long)pOutput->usFontSize * 600);
                }

                switch (ulChar) {
                case PAGE_BREAK:
                case COLUMN_FEED:
                        if (bIsTableRow) {
                                /* Ignore when in a table */
                                break;
                        }
                        if (bOutputContainsText(pAnchor)) {
                                OUTPUT_LINE();
                        } else {
                                RESET_LINE();
                        }
                        if (ulChar == PAGE_BREAK) {
                                vEndOfPage(pDiag, lAfterIndentation,
                                                pSection != pSectionNext);
                        } else {
                                vEndOfParagraph(pDiag,
                                        pOutput->tFontRef,
                                        pOutput->usFontSize,
                                        lAfterIndentation);
                        }
                        break;
                default:
                        break;
                }

                if (bStartFont || (bStartFontNext && ulChar != PAR_END)) {
                        /* Begin of a font found */
                        if (bStartFont) {
                                /* bStartFont takes priority */
                                fail(pFontInfo == NULL);
                                pFontTmp = pFontInfo;
                        } else {
                                pFontTmp = &tFontNext;
                        }
                        bAllCapitals = bIsCapitals(pFontTmp->usFontStyle);
                        bHiddenText = bIsHidden(pFontTmp->usFontStyle);
                        bMarkDelText = bIsMarkDel(pFontTmp->usFontStyle);
                        usTmp = pFontTmp->usFontStyle &
                                (FONT_BOLD|FONT_ITALIC|FONT_UNDERLINE|
                                 FONT_STRIKE|FONT_MARKDEL|
                                 FONT_SUPERSCRIPT|FONT_SUBSCRIPT);
                        if (!bIsTableRow &&
                            (usFontSize != pFontTmp->usFontSize ||
                             ucFontNumber != pFontTmp->ucFontNumber ||
                             usFontStyleMinimal != usTmp ||
                             ucFontColor != pFontTmp->ucFontColor)) {
                                pOutput = pStartNextOutput(pOutput);
                                vCloseFont();
                                pOutput->ucFontColor = pFontTmp->ucFontColor;
                                pOutput->usFontStyle = pFontTmp->usFontStyle;
                                pOutput->usFontSize = pFontTmp->usFontSize;
                                pOutput->tFontRef = tOpenFont(
                                                pFontTmp->ucFontNumber,
                                                pFontTmp->usFontStyle,
                                                pFontTmp->usFontSize);
                                fail(!bCheckDoubleLinkedList(pAnchor));
                        }
                        ucFontNumber = pFontTmp->ucFontNumber;
                        usFontSize = pFontTmp->usFontSize;
                        ucFontColor = pFontTmp->ucFontColor;
                        usFontStyle = pFontTmp->usFontStyle;
                        usFontStyleMinimal = usTmp;
                        if (bStartFont) {
                                /* Get the next font info */
                                pFontInfo = pGetNextFontInfoListItem(pFontInfo);
                                NO_DBG_HEX_C(pFontInfo != NULL,
                                                pFontInfo->ulFileOffset);
                                DBG_MSG_C(pFontInfo == NULL, "No more fonts");
                        }
                        bStartFont = FALSE;
                        bStartFontNext = FALSE;
                }

                if (bStartStyle || (bStartStyleNext && ulChar != PAR_END)) {
                        bFirstLine = TRUE;
                        /* Begin of a style found */
                        if (bStartStyle) {
                                /* bStartStyle takes priority */
                                fail(pStyleInfo == NULL);
                                pStyleTmp = pStyleInfo;
                        } else {
                                pStyleTmp = &tStyleNext;
                        }
                        if (!bIsTableRow) {
                                vStoreStyle(pDiag, pOutput, pStyleTmp);
                        }
                        usIstdNext = pStyleTmp->usIstdNext;
                        lBeforeIndentation =
                                lTwips2MilliPoints(pStyleTmp->usBeforeIndent);
                        lAfterIndentation =
                                lTwips2MilliPoints(pStyleTmp->usAfterIndent);
                        lLeftIndentation =
                                lTwips2MilliPoints(pStyleTmp->sLeftIndent);
                        lLeftIndentation1 =
                                lTwips2MilliPoints(pStyleTmp->sLeftIndent1);
                        lRightIndentation =
                                lTwips2MilliPoints(pStyleTmp->sRightIndent);
                        bInList = bStyleImpliesList(pStyleTmp, iWordVersion);
                        bNoMarks = !bInList || pStyleTmp->bNumPause;
                        ucNFC = pStyleTmp->ucNFC;
                        szListChar = pStyleTmp->szListChar;
                        ucAlignment = pStyleTmp->ucAlignment;
                        if (bInList && !bWasInList) {
                                /* Start of a list */
                                iListSeqNumber++;
                                vStartOfList(pDiag, ucNFC,
                                                bWasTableRow && !bIsTableRow);
                        }
                        if (!bInList && bWasInList) {
                                /* End of a list */
                                vEndOfList(pDiag);
                        }
                        bWasInList = bInList;
                        if (bStartStyle) {
                                pStyleInfo = pGetNextTextStyle(pStyleInfo);
                                NO_DBG_HEX_C(pStyleInfo != NULL,
                                                pStyleInfo->ulFileOffset);
                                DBG_MSG_C(pStyleInfo == NULL,
                                                "No more styles");
                        }
                        bStartStyle = FALSE;
                        bStartStyleNext = FALSE;
                }

                if (bWasEndOfParagraph) {
                        vStartOfParagraph1(pDiag, lBeforeIndentation);
                }

                if (!bIsTableRow &&
                    lTotalStringWidth(pAnchor) == 0) {
                        if (!bNoMarks) {
                                usListNumber = usGetListValue(iListSeqNumber,
                                                        iWordVersion,
                                                        pStyleTmp);
                        }
                        if (bInList && bFirstLine) {
                                vStartOfListItem(pDiag, bNoMarks);
                        }
                        vPutIndentation(pDiag, pAnchor, bNoMarks, bFirstLine,
                                        usListNumber, ucNFC, szListChar,
                                        lLeftIndentation, lLeftIndentation1);
                        bFirstLine = FALSE;
                        /* One number or mark per paragraph will do */
                        bNoMarks = TRUE;
                }

                if (bWasEndOfParagraph) {
                        vStartOfParagraph2(pDiag);
                        bWasEndOfParagraph = FALSE;
                }

                switch (ulChar) {
                case PICTURE:
                        (void)memset(&tImage, 0, sizeof(tImage));
                        eRes = eExamineImage(pFile, ulFileOffsetImage, &tImage);
                        switch (eRes) {
                        case image_no_information:
                                bSuccess = FALSE;
                                break;
                        case image_minimal_information:
                        case image_full_information:
#if 0
                                if (bOutputContainsText(pAnchor)) {
                                        OUTPUT_LINE();
                                } else {
                                        RESET_LINE();
                                }
#endif
                                bSuccess = bTranslateImage(pDiag, pFile,
                                        eRes == image_minimal_information,
                                        ulFileOffsetImage, &tImage);
                                break;
                        default:
                                DBG_DEC(eRes);
                                bSuccess = FALSE;
                                break;
                        }
                        if (!bSuccess) {
                                vStoreString("[pic]", 5, pOutput);
                        }
                        break;
                case FOOTNOTE_CHAR:
                        uiFootnoteNumber++;
                        if (tOptions.eConversionType == conversion_xml) {
                                vStoreCharacter((ULONG)FOOTNOTE_OR_ENDNOTE,
                                                                pOutput);
                                break;
                        }
                        vStoreCharacter((ULONG)'[', pOutput);
                        vStoreNumberAsDecimal(uiFootnoteNumber, pOutput);
                        vStoreCharacter((ULONG)']', pOutput);
                        break;
                case ENDNOTE_CHAR:
                        uiEndnoteNumber++;
                        vStoreCharacter((ULONG)'[', pOutput);
                        vStoreNumberAsRoman(uiEndnoteNumber, pOutput);
                        vStoreCharacter((ULONG)']', pOutput);
                        break;
                case UNKNOWN_NOTE_CHAR:
                        vStoreString("[?]", 3, pOutput);
                        break;
                case PAR_END:
                        if (bIsTableRow) {
                                vStoreCharacter((ULONG)'\n', pOutput);
                                break;
                        }
                        if (bOutputContainsText(pAnchor)) {
                                OUTPUT_LINE();
                        } else {
                                vMove2NextLine(pDiag,
                                        pOutput->tFontRef, pOutput->usFontSize);
                                RESET_LINE();
                        }
                        vEndOfParagraph(pDiag,
                                        pOutput->tFontRef,
                                        pOutput->usFontSize,
                                        lAfterIndentation);
                        bWasEndOfParagraph = TRUE;
                        break;
                case HARD_RETURN:
                        if (bIsTableRow) {
                                vStoreCharacter((ULONG)'\n', pOutput);
                                break;
                        }
                        if (bOutputContainsText(pAnchor)) {
                                OUTPUT_LINE();
                        } else {
                                vMove2NextLine(pDiag,
                                        pOutput->tFontRef, pOutput->usFontSize);
                                RESET_LINE();
                        }
                        break;
                case PAGE_BREAK:
                case COLUMN_FEED:
                        pSection = pSectionNext;
                        break;
                case TABLE_SEPARATOR:
                        if (bIsTableRow) {
                                vStoreCharacter(ulChar, pOutput);
                                break;
                        }
                        vStoreCharacter((ULONG)' ', pOutput);
                        vStoreCharacter((ULONG)TABLE_SEPARATOR_CHAR, pOutput);
                        break;
                case TAB:
                        if (bIsTableRow ||
                            tOptions.eConversionType == conversion_xml) {
                                vStoreCharacter((ULONG)' ', pOutput);
                                break;
                        }
                        if (tOptions.iParagraphBreak == 0 &&
                            (tOptions.eConversionType == conversion_text ||
                             tOptions.eConversionType == conversion_fmt_text)) {
                                /* No logical lines, so no tab expansion */
                                vStoreCharacter(TAB, pOutput);
                                break;
                        }
                        lHalfSpaceWidth = (lComputeSpaceWidth(
                                        pOutput->tFontRef,
                                        pOutput->usFontSize) + 1) / 2;
                        lTmp = lTotalStringWidth(pAnchor);
                        lTmp += lDrawUnits2MilliPoints(pDiag->lXleft);
                        lTmp /= lDefaultTabWidth;
                        do {
                                vStoreCharacter((ULONG)FILLER_CHAR, pOutput);
                                lWidthCurr = lTotalStringWidth(pAnchor);
                                lWidthCurr +=
                                        lDrawUnits2MilliPoints(pDiag->lXleft);
                        } while (lTmp == lWidthCurr / lDefaultTabWidth &&
                                 lWidthCurr < lWidthMax + lRightIndentation);
                        break;
                default:
                        if (bHiddenText && tOptions.bHideHiddenText) {
                                continue;
                        }
                        if (bMarkDelText && tOptions.bRemoveRemovedText) {
                                continue;
                        }
                        if (ulChar == UNICODE_ELLIPSIS &&
                            tOptions.eEncoding != encoding_utf_8) {
                                vStoreString("...", 3, pOutput);
                        } else {
                                if (bAllCapitals) {
                                        ulChar = ulToUpper(ulChar);
                                }
                                vStoreCharacter(ulChar, pOutput);
                        }
                        break;
                }

                if (bWasTableRow && !bIsTableRow) {
                        /* End of a table */
                        vEndOfTable(pDiag);
                        /* Resume normal font */
                        NO_DBG_MSG("End of table font");
                        vCloseFont();
                        bTableFontClosed = TRUE;
                        pOutput->ucFontColor = ucFontColor;
                        pOutput->usFontStyle = usFontStyle;
                        pOutput->usFontSize = usFontSize;
                        pOutput->tFontRef = tOpenFont(
                                        ucFontNumber, usFontStyle, usFontSize);
                }
                bWasTableRow = bIsTableRow;

                if (bIsTableRow) {
                        fail(pAnchor != pOutput);
                        if (!bEndRowNorm && !bEndRowFast) {
                                continue;
                        }
                        /* End of a table row */
                        if (bEndRowNorm) {
                                fail(pRowInfo == NULL);
                                vTableRow2Window(pDiag, pAnchor, pRowInfo,
                                                tOptions.eConversionType,
                                                tOptions.iParagraphBreak);
                        } else {
                                fail(!bEndRowFast);
                        }
                        /* Reset */
                        pAnchor = pStartNewOutput(pAnchor, NULL);
                        pOutput = pAnchor;
                        if (bEndRowNorm) {
                                pRowInfo = pGetNextRowInfoListItem();
                        }
                        bIsTableRow = FALSE;
                        bEndRowNorm = FALSE;
                        bEndRowFast = FALSE;
                        NO_DBG_HEX_C(pRowInfo != NULL,
                                                pRowInfo->ulFileOffsetStart);
                        NO_DBG_HEX_C(pRowInfo != NULL,
                                                pRowInfo->ulFileOffsetEnd);
                        continue;
                }
                lWidthCurr = lTotalStringWidth(pAnchor);
                lWidthCurr += lDrawUnits2MilliPoints(pDiag->lXleft);
                if (lWidthCurr < lWidthMax + lRightIndentation) {
                        continue;
                }
                pLeftOver = pSplitList(pAnchor);
                vJustify2Window(pDiag, pAnchor,
                                lWidthMax, lRightIndentation, ucAlignment);
                pAnchor = pStartNewOutput(pAnchor, pLeftOver);
                for (pOutput = pAnchor;
                     pOutput->pNext != NULL;
                     pOutput = pOutput->pNext)
                        ;       /* EMPTY */
                fail(pOutput == NULL);
                if (lTotalStringWidth(pAnchor) > 0) {
                        vSetLeftIndentation(pDiag, lLeftIndentation);
                }
        }

        pAnchor = pStartNewOutput(pAnchor, NULL);
        pAnchor->szStorage = xfree(pAnchor->szStorage);
        pAnchor = xfree(pAnchor);
        vCloseFont();
        vFreeDocument();
        Hourglass_Off();
        return TRUE;
} /* end of bWordDecryptor */

/*
 * lLastStringWidth - compute the width of the last part of the output string
 */
static long
lLastStringWidth(const output_type *pAnchor)
{
        const output_type       *pCurr, *pStart;

        pStart = NULL;
        for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
                if (pCurr->tNextFree == 1 &&
                    (pCurr->szStorage[0] == PAR_END ||
                     pCurr->szStorage[0] == HARD_RETURN)) {
                        /* Found a separator. Start after the separator */
                        pStart = pCurr->pNext;
                }
        }
        if (pStart == NULL) {
                /* No separators. Use the whole output string */
                pStart = pAnchor;
        }
        return lTotalStringWidth(pStart);
} /* end of lLastStringWidth */

/*
 * pHdrFtrDecryptor - turn a header/footer list element to something useful
 */
output_type *
pHdrFtrDecryptor(FILE *pFile, ULONG ulCharPosStart, ULONG ulCharPosNext)
{
        output_type     *pAnchor, *pOutput, *pLeftOver;
        ULONG   ulChar, ulFileOffset, ulCharPos;
        long    lWidthCurr, lWidthMax;
        long    lRightIndentation;
        USHORT  usChar;
        UCHAR   ucAlignment;
        BOOL    bSkip;

        fail(iWordVersion < 0);
        fail(tOptions.eConversionType == conversion_unknown);
        fail(tOptions.eEncoding == 0);

        if (ulCharPosStart == ulCharPosNext) {
                /* There are no bytes to decrypt */
                return NULL;
        }

        lRightIndentation = 0;
        ucAlignment = ALIGNMENT_LEFT;
        bSkip = FALSE;
        lWidthMax = lGetWidthMax(tOptions.iParagraphBreak);
        pAnchor = pStartNewOutput(NULL, NULL);
        pOutput = pAnchor;
        pOutput->tFontRef = tOpenFont(0, FONT_REGULAR, DEFAULT_FONT_SIZE);
        usChar = usToHdrFtrPosition(pFile, ulCharPosStart);
        ulCharPos = ulCharPosStart;
        ulFileOffset = ulCharPos2FileOffset(ulCharPos);
        while (usChar != (USHORT)EOF && ulCharPos != ulCharPosNext) {
                /* Skip embedded characters */
                if (usChar == START_EMBEDDED) {
                        bSkip = TRUE;
                } else if (usChar == END_IGNORE || usChar == END_EMBEDDED) {
                        bSkip = FALSE;
                }
                /* Translate character */
                if (bSkip || usChar == END_IGNORE || usChar == END_EMBEDDED) {
                        ulChar = IGNORE_CHARACTER;
                } else {
                        ulChar = ulTranslateCharacters(usChar,
                                        ulFileOffset,
                                        iWordVersion,
                                        tOptions.eConversionType,
                                        tOptions.eEncoding,
                                        bOldMacFile);
                }
                /* Process character */
                if (ulChar != IGNORE_CHARACTER) {
                        switch (ulChar) {
                        case PICTURE:
                                vStoreString("[pic]", 5, pOutput);
                                break;
                        case PAR_END:
                        case HARD_RETURN:
                        case PAGE_BREAK:
                        case COLUMN_FEED:
                                /* To the next substring */
                                pOutput = pStartNextOutput(pOutput);
                                vCloseFont();
                                pOutput->tFontRef = tOpenFont(0,
                                        FONT_REGULAR, DEFAULT_FONT_SIZE);
                                /* A substring with just one character */
                                if (ulChar == HARD_RETURN) {
                                        vStoreCharacter(HARD_RETURN, pOutput);
                                } else {
                                        vStoreCharacter(PAR_END, pOutput);
                                }
                                /* To the next substring */
                                pOutput = pStartNextOutput(pOutput);
                                vCloseFont();
                                pOutput->tFontRef = tOpenFont(0,
                                        FONT_REGULAR, DEFAULT_FONT_SIZE);
                                fail(!bCheckDoubleLinkedList(pAnchor));
                                break;
                        case TABLE_SEPARATOR:
                                vStoreCharacter((ULONG)' ', pOutput);
                                vStoreCharacter((ULONG)TABLE_SEPARATOR_CHAR,
                                                        pOutput);
                                break;
                        case TAB:
                                vStoreCharacter((ULONG)FILLER_CHAR, pOutput);
                                break;
                        default:
                                vStoreCharacter(ulChar, pOutput);
                                break;
                        }
                }
                lWidthCurr = lLastStringWidth(pAnchor);
                if (lWidthCurr >= lWidthMax + lRightIndentation) {
                        pLeftOver = pSplitList(pAnchor);
                        for (pOutput = pAnchor;
                             pOutput->pNext != NULL;
                             pOutput = pOutput->pNext)
                                ;       /* EMPTY */
                        fail(pOutput == NULL);
                        /* To the next substring */
                        pOutput = pStartNextOutput(pOutput);
                        /* A substring with just one HARD_RETURN */
                        vStoreCharacter(HARD_RETURN, pOutput);
                        /* Put the leftover piece(s) at the end */
                        pOutput->pNext = pLeftOver;
                        if (pLeftOver != NULL) {
                                pLeftOver->pPrev = pOutput;
                        }
                        fail(!bCheckDoubleLinkedList(pAnchor));
                        for (pOutput = pAnchor;
                             pOutput->pNext != NULL;
                             pOutput = pOutput->pNext)
                                ;       /* EMPTY */
                        fail(pOutput == NULL);
                }
                usChar = usNextChar(pFile, hdrftr_list,
                                        &ulFileOffset, &ulCharPos, NULL);
        }
        vCloseFont();
        if (bOutputContainsText(pAnchor)) {
                return pAnchor;
        }
        pAnchor = pStartNewOutput(pAnchor, NULL);
        pAnchor->szStorage = xfree(pAnchor->szStorage);
        pAnchor = xfree(pAnchor);
        return NULL;
} /* end of pHdrFtrDecryptor */

/*
 * pFootnoteDecryptor - turn a footnote text list element into text
 */
char *
szFootnoteDecryptor(FILE *pFile, ULONG ulCharPosStart, ULONG ulCharPosNext)
{
        char    *szText;
        ULONG   ulChar, ulFileOffset, ulCharPos;
        USHORT  usChar;
        size_t  tLen, tIndex, tNextFree, tStorageSize;
        char    szResult[6];
        BOOL    bSkip;

        fail(iWordVersion < 0);
        fail(tOptions.eConversionType == conversion_unknown);
        fail(tOptions.eEncoding == 0);

        if (ulCharPosStart == ulCharPosNext) {
                /* There are no bytes to decrypt */
                return NULL;
        }

        if (tOptions.eConversionType != conversion_xml) {
                /* Only implemented for XML output */
                return NULL;
        }

        bSkip = FALSE;

        /* Initialise the text buffer */
        tStorageSize = INITIAL_SIZE;
        szText = xmalloc(tStorageSize);
        tNextFree = 0;
        szText[tNextFree] = '\0';

        /* Goto the start */
        usChar = usToFootnotePosition(pFile, ulCharPosStart);
        ulCharPos = ulCharPosStart;
        ulFileOffset = ulCharPos2FileOffset(ulCharPos);
        /* Skip the unwanted starting characters */
        while (usChar != (USHORT)EOF && ulCharPos != ulCharPosNext &&
               (usChar == FOOTNOTE_OR_ENDNOTE ||
                usChar == PAR_END ||
                usChar == TAB ||
                usChar == (USHORT)' ')) {
                usChar = usNextChar(pFile, footnote_list,
                                        &ulFileOffset, &ulCharPos, NULL);
        }
        /* Process the footnote text */
        while (usChar != (USHORT)EOF && ulCharPos != ulCharPosNext) {
                /* Skip embedded characters */
                if (usChar == START_EMBEDDED) {
                        bSkip = TRUE;
                } else if (usChar == END_IGNORE || usChar == END_EMBEDDED) {
                        bSkip = FALSE;
                }
                /* Translate character */
                if (bSkip ||
                    usChar == END_IGNORE ||
                    usChar == END_EMBEDDED ||
                    usChar == FOOTNOTE_OR_ENDNOTE) {
                        ulChar = IGNORE_CHARACTER;
                } else {
                        ulChar = ulTranslateCharacters(usChar,
                                        ulFileOffset,
                                        iWordVersion,
                                        tOptions.eConversionType,
                                        tOptions.eEncoding,
                                        bOldMacFile);
                }
                /* Process character */
                if (ulChar == PICTURE) {
                        tLen = 5;
                        strcpy(szResult, "[pic]");
                } else if (ulChar == IGNORE_CHARACTER) {
                        tLen = 0;
                        szResult[0] = '\0';
                } else {
                        switch (ulChar) {
                        case PAR_END:
                        case HARD_RETURN:
                        case PAGE_BREAK:
                        case COLUMN_FEED:
                                ulChar = (ULONG)PAR_END;
                                break;
                        case TAB:
                                ulChar = (ULONG)' ';
                                break;
                        default:
                                break;
                        }
                        tLen = tUcs2Utf8(ulChar, szResult, sizeof(szResult));
                }
                /* Add the results to the text */
                if (tNextFree + tLen + 1 > tStorageSize) {
                        tStorageSize += EXTENTION_SIZE;
                        szText = xrealloc(szText, tStorageSize);
                }
                for (tIndex = 0; tIndex < tLen; tIndex++) {
                        szText[tNextFree++] = szResult[tIndex];
                }
                szText[tNextFree] = '\0';
                /* Next character */
                usChar = usNextChar(pFile, footnote_list,
                                        &ulFileOffset, &ulCharPos, NULL);
        }
        /* Remove redundant spaces */
        while (tNextFree != 0 && szText[tNextFree - 1] == ' ') {
                szText[tNextFree - 1] = '\0';
                tNextFree--;
        }
        if (tNextFree == 0) {
                /* No text */
                szText = xfree(szText);
                return NULL;
        }
        return szText;
} /* end of szFootnoteDecryptor */

---