/*
* stylelist.c
* Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
*
* Description:
* Build, read and destroy a list of Word style information
*/

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


/*
* Private structure to hide the way the information
* is stored from the rest of the program
*/
typedef struct style_mem_tag {
       style_block_type        tInfo;
       ULONG                   ulSequenceNumber;
       struct style_mem_tag    *pNext;
} style_mem_type;

/* Variables needed to write the Style Information List */
static style_mem_type   *pAnchor = NULL;
static style_mem_type   *pStyleLast = NULL;
/* The type of conversion */
static conversion_type  eConversionType = conversion_unknown;
/* The character set encoding */
static encoding_type    eEncoding = encoding_neutral;
/* Values for efficiency reasons */
static const style_mem_type     *pMidPtr = NULL;
static BOOL             bMoveMidPtr = FALSE;
static BOOL             bInSequence = TRUE;


/*
* vDestroyStyleInfoList - destroy the Style Information List
*/
void
vDestroyStyleInfoList(void)
{
       style_mem_type  *pCurr, *pNext;

       DBG_MSG("vDestroyStyleInfoList");

       /* Free the Style Information List */
       pCurr = pAnchor;
       while (pCurr != NULL) {
               pNext = pCurr->pNext;
               pCurr = xfree(pCurr);
               pCurr = pNext;
       }
       pAnchor = NULL;
       /* Reset all control variables */
       pStyleLast = NULL;
       pMidPtr = NULL;
       bMoveMidPtr = FALSE;
       bInSequence = TRUE;
} /* end of vDestroyStyleInfoList */

/*
* vConvertListCharacter - convert the list character
*/
static void
vConvertListCharacter(UCHAR ucNFC, USHORT usListChar, char *szListChar)
{
       options_type    tOptions;
       size_t  tLen;

       fail(szListChar == NULL);
       fail(szListChar[0] != '\0');

       if (usListChar < 0x80 && isprint((int)usListChar)) {
               DBG_CHR_C(isalnum((int)usListChar), usListChar);
               szListChar[0] = (char)usListChar;
               szListChar[1] = '\0';
               return;
       }

       if (ucNFC != LIST_SPECIAL &&
           ucNFC != LIST_SPECIAL2 &&
           ucNFC != LIST_BULLETS) {
               szListChar[0] = '.';
               szListChar[1] = '\0';
               return;
       }

       if (eConversionType == conversion_unknown ||
           eEncoding == encoding_neutral) {
               vGetOptions(&tOptions);
               eConversionType = tOptions.eConversionType;
               eEncoding = tOptions.eEncoding;
       }

       switch (usListChar) {
       case 0x0000: case 0x00b7: case 0x00fe: case  0xf021: case 0xf043:
       case 0xf06c: case 0xf093: case 0xf0b7:
               usListChar = 0x2022;    /* BULLET */
               break;
       case 0x0096: case 0xf02d:
               usListChar = 0x2013;    /* EN DASH */
               break;
       case 0x00a8:
               usListChar = 0x2666;    /* BLACK DIAMOND SUIT */
               break;
       case 0x00de:
               usListChar = 0x21d2;    /* RIGHTWARDS DOUBLE ARROW */
               break;
       case 0x00e0: case 0xf074:
               usListChar = 0x25ca;    /* LOZENGE */
               break;
       case 0x00e1:
               usListChar = 0x2329;    /* LEFT ANGLE BRACKET */
               break;
       case 0xf020:
               usListChar = 0x0020;    /* SPACE */
               break;
       case 0xf041:
               usListChar = 0x270c;    /* VICTORY HAND */
               break;
       case 0xf066:
               usListChar = 0x03d5;    /* GREEK PHI SYMBOL */
               break;
       case 0xf06e:
               usListChar = 0x25a0;    /* BLACK SQUARE */
               break;
       case 0xf06f: case 0xf070: case 0xf0a8:
               usListChar = 0x25a1;    /* WHITE SQUARE */
               break;
       case 0xf071:
               usListChar = 0x2751;    /* LOWER RIGHT SHADOWED WHITE SQUARE */
               break;
       case 0xf075: case 0xf077:
               usListChar = 0x25c6;    /* BLACK DIAMOND */
               break;
       case 0xf076:
               usListChar = 0x2756;    /* BLACK DIAMOND MINUS WHITE X */
               break;
       case 0xf0a7:
               usListChar = 0x25aa;    /* BLACK SMALL SQUARE */
               break;
       case 0xf0d8:
               usListChar = 0x27a2;    /* RIGHTWARDS ARROWHEAD */
               break;
       case 0xf0e5:
               usListChar = 0x2199;    /* SOUTH WEST ARROW */
               break;
       case 0xf0f0:
               usListChar = 0x21e8;    /* RIGHTWARDS WHITE ARROW */
               break;
       case 0xf0fc:
               usListChar = 0x2713;    /* CHECK MARK */
               break;
       default:
               if ((usListChar >= 0xe000 && usListChar < 0xf900) ||
                   (usListChar < 0x80 && !isprint((int)usListChar))) {
                       /*
                        * All remaining private area characters and all
                        * remaining non-printable ASCII characters to their
                        * default bullet character
                        */
                       DBG_HEX(usListChar);
                       DBG_FIXME();
                       if (ucNFC == LIST_SPECIAL || ucNFC == LIST_SPECIAL2) {
                               usListChar = 0x2190;    /* LEFTWARDS ARROW */
                       } else {
                               usListChar = 0x2022;    /* BULLET */
                       }
               }
               break;
       }

       if (eEncoding == encoding_utf_8) {
               tLen = tUcs2Utf8(usListChar, szListChar, 4);
               szListChar[tLen] = '\0';
       } else {
               switch (usListChar) {
               case 0x03d5: case 0x25a1: case 0x25c6: case 0x25ca:
               case 0x2751:
                       szListChar[0] = 'o';
                       break;
               case 0x2013: case 0x2500:
                       szListChar[0] = '-';
                       break;
               case 0x2190: case 0x2199: case 0x2329:
                       szListChar[0] = '<';
                       break;
               case 0x21d2:
                       szListChar[0] = '=';
                       break;
               case 0x21e8: case 0x27a2:
                       szListChar[0] = '>';
                       break;
               case 0x25a0: case 0x25aa:
                       szListChar[0] = '.';
                       break;
               case 0x2666:
                       szListChar[0] = OUR_DIAMOND;
                       break;
               case 0x270c:
                       szListChar[0] = 'x';
                       break;
               case 0x2713:
                       szListChar[0] = 'V';
                       break;
               case 0x2756:
                       szListChar[0] = '*';
                       break;
               case 0x2022:
               default:
                       vGetBulletValue(eConversionType, eEncoding,
                                       szListChar, 2);
                       break;
               }
               tLen = 1;
       }
       szListChar[tLen] = '\0';
} /* end of vConvertListCharacter */

/*
* eGetNumType - get the level type from the given level number
*
* Returns the level type
*/
level_type_enum
eGetNumType(UCHAR ucNumLevel)
{
       switch (ucNumLevel) {
       case  1: case  2: case  3: case  4: case  5:
       case  6: case  7: case  8: case  9:
               return level_type_outline;
       case 10:
               return level_type_numbering;
       case 11:
               return level_type_sequence;
       case 12:
               return level_type_pause;
       default:
               return level_type_none;
       }
} /* end of eGetNumType */

/*
* vCorrectStyleValues - correct style values that Antiword can't use
*/
void
vCorrectStyleValues(style_block_type *pStyleBlock)
{
       if (pStyleBlock->usBeforeIndent > 0x7fff) {
               pStyleBlock->usBeforeIndent = 0;
       } else if (pStyleBlock->usBeforeIndent > 2160) {
               /* 2160 twips = 1.5 inches or 38.1 mm */
               DBG_DEC(pStyleBlock->usBeforeIndent);
               pStyleBlock->usBeforeIndent = 2160;
       }
       if (pStyleBlock->usIstd >= 1 &&
           pStyleBlock->usIstd <= 9 &&
           pStyleBlock->usBeforeIndent < HEADING_GAP) {
               NO_DBG_DEC(pStyleBlock->usBeforeIndent);
               pStyleBlock->usBeforeIndent = HEADING_GAP;
       }

       if (pStyleBlock->usAfterIndent > 0x7fff) {
               pStyleBlock->usAfterIndent = 0;
       } else if (pStyleBlock->usAfterIndent > 2160) {
               /* 2160 twips = 1.5 inches or 38.1 mm */
               DBG_DEC(pStyleBlock->usAfterIndent);
               pStyleBlock->usAfterIndent = 2160;
       }
       if (pStyleBlock->usIstd >= 1 &&
           pStyleBlock->usIstd <= 9 &&
           pStyleBlock->usAfterIndent < HEADING_GAP) {
               NO_DBG_DEC(pStyleBlock->usAfterIndent);
               pStyleBlock->usAfterIndent = HEADING_GAP;
       }

       if (pStyleBlock->sLeftIndent < 0) {
               pStyleBlock->sLeftIndent = 0;
       }
       if (pStyleBlock->sRightIndent > 0) {
               pStyleBlock->sRightIndent = 0;
       }
       vConvertListCharacter(pStyleBlock->ucNFC,
                       pStyleBlock->usListChar,
                       pStyleBlock->szListChar);
} /* end of vCorrectStyleValues */

/*
* vAdd2StyleInfoList - Add an element to the Style Information List
*/
void
vAdd2StyleInfoList(const style_block_type *pStyleBlock)
{
       style_mem_type  *pListMember;

       fail(pStyleBlock == NULL);

       NO_DBG_MSG("bAdd2StyleInfoList");

       if (pStyleBlock->ulFileOffset == FC_INVALID) {
               NO_DBG_DEC(pStyleBlock->usIstd);
               return;
       }

       NO_DBG_HEX(pStyleBlock->ulFileOffset);
       NO_DBG_DEC_C(pStyleBlock->sLeftIndent != 0,
                                       pStyleBlock->sLeftIndent);
       NO_DBG_DEC_C(pStyleBlock->sRightIndent != 0,
                                       pStyleBlock->sRightIndent);
       NO_DBG_DEC_C(pStyleBlock->bNumPause, pStyleBlock->bNumPause);
       NO_DBG_DEC_C(pStyleBlock->usIstd != 0, pStyleBlock->usIstd);
       NO_DBG_DEC_C(pStyleBlock->usStartAt != 1, pStyleBlock->usStartAt);
       NO_DBG_DEC_C(pStyleBlock->usAfterIndent != 0,
                                       pStyleBlock->usAfterIndent);
       NO_DBG_DEC_C(pStyleBlock->ucAlignment != 0, pStyleBlock->ucAlignment);
       NO_DBG_DEC(pStyleBlock->ucNFC);
       NO_DBG_HEX(pStyleBlock->usListChar);

       if (pStyleLast != NULL &&
           pStyleLast->tInfo.ulFileOffset == pStyleBlock->ulFileOffset) {
               /*
                * If two consecutive styles share the same
                * offset, remember only the last style
                */
               fail(pStyleLast->pNext != NULL);
               pStyleLast->tInfo = *pStyleBlock;
               /* Correct the values where needed */
               vCorrectStyleValues(&pStyleLast->tInfo);
               return;
       }

       /* Create list member */
       pListMember = xmalloc(sizeof(style_mem_type));
       /* Fill the list member */
       pListMember->tInfo = *pStyleBlock;
       pListMember->pNext = NULL;
       /* Add the sequence number */
       pListMember->ulSequenceNumber =
                       ulGetSeqNumber(pListMember->tInfo.ulFileOffset);
       /* Correct the values where needed */
       vCorrectStyleValues(&pListMember->tInfo);
       /* Add the new member to the list */
       if (pAnchor == NULL) {
               pAnchor = pListMember;
               /* For efficiency */
               pMidPtr = pAnchor;
               bMoveMidPtr = FALSE;
               bInSequence = TRUE;
       } else {
               fail(pStyleLast == NULL);
               pStyleLast->pNext = pListMember;
               /* For efficiency */
               if (bMoveMidPtr) {
                       pMidPtr = pMidPtr->pNext;
                       bMoveMidPtr = FALSE;
               } else {
                       bMoveMidPtr = TRUE;
               }
               if (bInSequence) {
                       bInSequence = pListMember->ulSequenceNumber >
                                       pStyleLast->ulSequenceNumber;
               }
       }
       pStyleLast = pListMember;
} /* end of vAdd2StyleInfoList */

/*
* Get the record that follows the given recored in the Style Information List
*/
const style_block_type *
pGetNextStyleInfoListItem(const style_block_type *pCurr)
{
       const style_mem_type    *pRecord;
       size_t  tOffset;

       if (pCurr == NULL) {
               if (pAnchor == NULL) {
                       /* There are no records */
                       return NULL;
               }
               /* The first record is the only one without a predecessor */
               return &pAnchor->tInfo;
       }
       tOffset = offsetof(style_mem_type, tInfo);
       /* Many casts to prevent alignment warnings */
       pRecord = (style_mem_type *)(void *)((char *)pCurr - tOffset);
       fail(pCurr != &pRecord->tInfo);
       if (pRecord->pNext == NULL) {
               /* The last record has no successor */
               return NULL;
       }
       return &pRecord->pNext->tInfo;
} /* end of pGetNextStyleInfoListItem */

/*
* Get the next text style
*/
const style_block_type *
pGetNextTextStyle(const style_block_type *pCurr)
{
       const style_block_type  *pRecord;

       pRecord = pCurr;
       do {
               pRecord = pGetNextStyleInfoListItem(pRecord);
       } while (pRecord != NULL &&
                (pRecord->eListID == hdrftr_list ||
                 pRecord->eListID == macro_list ||
                 pRecord->eListID == annotation_list));
       return pRecord;
} /* end of pGetNextTextStyle */

/*
* usGetIstd - get the istd that belongs to the given file offset
*/
USHORT
usGetIstd(ULONG ulFileOffset)
{
       const style_mem_type    *pCurr, *pBest, *pStart;
       ULONG   ulSeq, ulBest;

       ulSeq = ulGetSeqNumber(ulFileOffset);
       if (ulSeq == FC_INVALID) {
               return ISTD_NORMAL;
       }
       NO_DBG_HEX(ulFileOffset);
       NO_DBG_DEC(ulSeq);

       if (bInSequence &&
           pMidPtr != NULL &&
           ulSeq > pMidPtr->ulSequenceNumber) {
               /* The istd is in the second half of the chained list */
               pStart = pMidPtr;
       } else {
               pStart = pAnchor;
       }

       pBest = NULL;
       ulBest = 0;
       for (pCurr = pStart; pCurr != NULL; pCurr = pCurr->pNext) {
               if (pCurr->ulSequenceNumber != FC_INVALID &&
                   (pBest == NULL || pCurr->ulSequenceNumber > ulBest) &&
                   pCurr->ulSequenceNumber <= ulSeq) {
                       pBest = pCurr;
                       ulBest = pCurr->ulSequenceNumber;
               }
               if (bInSequence && pCurr->ulSequenceNumber > ulSeq) {
                       break;
               }
       }
       NO_DBG_DEC(ulBest);

       if (pBest == NULL) {
               return ISTD_NORMAL;
       }

       NO_DBG_DEC(pBest->tInfo.usIstd);
       return pBest->tInfo.usIstd;
} /* end of usGetIstd */

/*
* bStyleImpliesList - does style info implies being part of a list
*
* Decide whether the style information implies that the given paragraph is
* part of a list
*
* Returns TRUE when the paragraph is part of a list, otherwise FALSE
*/
BOOL
bStyleImpliesList(const style_block_type *pStyle, int iWordVersion)
{
       fail(pStyle == NULL);
       fail(iWordVersion < 0);

       if (pStyle->usIstd >= 1 && pStyle->usIstd <= 9) {
               /* These are heading levels */
               return FALSE;
       }
       if (iWordVersion < 8) {
               /* Check for old style lists */
               return pStyle->ucNumLevel != 0;
       }
       /* Check for new style lists */
       return pStyle->usListIndex != 0;
} /* end of bStyleImpliesList */

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.