TB9.2 Example Applications: examples/PIPS/antiword/src/stylelist.c Source File

00001 /*
00002  * stylelist.c
00003  * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
00004  *
00005  * Description:
00006  * Build, read and destroy a list of Word style information
00007  */
00008 
00009 #include <stdlib.h>
00010 #include <stddef.h>
00011 #include <ctype.h>
00012 #include "antiword.h"
00013 
00014 
00015 /*
00016  * Private structure to hide the way the information
00017  * is stored from the rest of the program
00018  */
00019 typedef struct style_mem_tag {
00020         style_block_type        tInfo;
00021         ULONG                   ulSequenceNumber;
00022         struct style_mem_tag    *pNext;
00023 } style_mem_type;
00024 
00025 /* Variables needed to write the Style Information List */
00026 static style_mem_type   *pAnchor = NULL;
00027 static style_mem_type   *pStyleLast = NULL;
00028 /* The type of conversion */
00029 static conversion_type  eConversionType = conversion_unknown;
00030 /* The character set encoding */
00031 static encoding_type    eEncoding = encoding_neutral;
00032 /* Values for efficiency reasons */
00033 static const style_mem_type     *pMidPtr = NULL;
00034 static BOOL             bMoveMidPtr = FALSE;
00035 static BOOL             bInSequence = TRUE;
00036 
00037 
00038 /*
00039  * vDestroyStyleInfoList - destroy the Style Information List
00040  */
00041 void
00042 vDestroyStyleInfoList(void)
00043 {
00044         style_mem_type  *pCurr, *pNext;
00045 
00046         DBG_MSG("vDestroyStyleInfoList");
00047 
00048         /* Free the Style Information List */
00049         pCurr = pAnchor;
00050         while (pCurr != NULL) {
00051                 pNext = pCurr->pNext;
00052                 pCurr = xfree(pCurr);
00053                 pCurr = pNext;
00054         }
00055         pAnchor = NULL;
00056         /* Reset all control variables */
00057         pStyleLast = NULL;
00058         pMidPtr = NULL;
00059         bMoveMidPtr = FALSE;
00060         bInSequence = TRUE;
00061 } /* end of vDestroyStyleInfoList */
00062 
00063 /*
00064  * vConvertListCharacter - convert the list character
00065  */
00066 static void
00067 vConvertListCharacter(UCHAR ucNFC, USHORT usListChar, char *szListChar)
00068 {
00069         options_type    tOptions;
00070         size_t  tLen;
00071 
00072         fail(szListChar == NULL);
00073         fail(szListChar[0] != '\0');
00074 
00075         if (usListChar < 0x80 && isprint((int)usListChar)) {
00076                 DBG_CHR_C(isalnum((int)usListChar), usListChar);
00077                 szListChar[0] = (char)usListChar;
00078                 szListChar[1] = '\0';
00079                 return;
00080         }
00081 
00082         if (ucNFC != LIST_SPECIAL &&
00083             ucNFC != LIST_SPECIAL2 &&
00084             ucNFC != LIST_BULLETS) {
00085                 szListChar[0] = '.';
00086                 szListChar[1] = '\0';
00087                 return;
00088         }
00089 
00090         if (eConversionType == conversion_unknown ||
00091             eEncoding == encoding_neutral) {
00092                 vGetOptions(&tOptions);
00093                 eConversionType = tOptions.eConversionType;
00094                 eEncoding = tOptions.eEncoding;
00095         }
00096 
00097         switch (usListChar) {
00098         case 0x0000: case 0x00b7: case 0x00fe: case  0xf021: case 0xf043:
00099         case 0xf06c: case 0xf093: case 0xf0b7:
00100                 usListChar = 0x2022;    /* BULLET */
00101                 break;
00102         case 0x0096: case 0xf02d:
00103                 usListChar = 0x2013;    /* EN DASH */
00104                 break;
00105         case 0x00a8:
00106                 usListChar = 0x2666;    /* BLACK DIAMOND SUIT */
00107                 break;
00108         case 0x00de:
00109                 usListChar = 0x21d2;    /* RIGHTWARDS DOUBLE ARROW */
00110                 break;
00111         case 0x00e0: case 0xf074:
00112                 usListChar = 0x25ca;    /* LOZENGE */
00113                 break;
00114         case 0x00e1:
00115                 usListChar = 0x2329;    /* LEFT ANGLE BRACKET */
00116                 break;
00117         case 0xf020:
00118                 usListChar = 0x0020;    /* SPACE */
00119                 break;
00120         case 0xf041:
00121                 usListChar = 0x270c;    /* VICTORY HAND */
00122                 break;
00123         case 0xf066:
00124                 usListChar = 0x03d5;    /* GREEK PHI SYMBOL */
00125                 break;
00126         case 0xf06e:
00127                 usListChar = 0x25a0;    /* BLACK SQUARE */
00128                 break;
00129         case 0xf06f: case 0xf070: case 0xf0a8:
00130                 usListChar = 0x25a1;    /* WHITE SQUARE */
00131                 break;
00132         case 0xf071:
00133                 usListChar = 0x2751;    /* LOWER RIGHT SHADOWED WHITE SQUARE */
00134                 break;
00135         case 0xf075: case 0xf077:
00136                 usListChar = 0x25c6;    /* BLACK DIAMOND */
00137                 break;
00138         case 0xf076:
00139                 usListChar = 0x2756;    /* BLACK DIAMOND MINUS WHITE X */
00140                 break;
00141         case 0xf0a7:
00142                 usListChar = 0x25aa;    /* BLACK SMALL SQUARE */
00143                 break;
00144         case 0xf0d8:
00145                 usListChar = 0x27a2;    /* RIGHTWARDS ARROWHEAD */
00146                 break;
00147         case 0xf0e5:
00148                 usListChar = 0x2199;    /* SOUTH WEST ARROW */
00149                 break;
00150         case 0xf0f0:
00151                 usListChar = 0x21e8;    /* RIGHTWARDS WHITE ARROW */
00152                 break;
00153         case 0xf0fc:
00154                 usListChar = 0x2713;    /* CHECK MARK */
00155                 break;
00156         default:
00157                 if ((usListChar >= 0xe000 && usListChar < 0xf900) ||
00158                     (usListChar < 0x80 && !isprint((int)usListChar))) {
00159                         /*
00160                          * All remaining private area characters and all
00161                          * remaining non-printable ASCII characters to their
00162                          * default bullet character
00163                          */
00164                         DBG_HEX(usListChar);
00165                         DBG_FIXME();
00166                         if (ucNFC == LIST_SPECIAL || ucNFC == LIST_SPECIAL2) {
00167                                 usListChar = 0x2190;    /* LEFTWARDS ARROW */
00168                         } else {
00169                                 usListChar = 0x2022;    /* BULLET */
00170                         }
00171                 }
00172                 break;
00173         }
00174 
00175         if (eEncoding == encoding_utf_8) {
00176                 tLen = tUcs2Utf8(usListChar, szListChar, 4);
00177                 szListChar[tLen] = '\0';
00178         } else {
00179                 switch (usListChar) {
00180                 case 0x03d5: case 0x25a1: case 0x25c6: case 0x25ca:
00181                 case 0x2751:
00182                         szListChar[0] = 'o';
00183                         break;
00184                 case 0x2013: case 0x2500:
00185                         szListChar[0] = '-';
00186                         break;
00187                 case 0x2190: case 0x2199: case 0x2329:
00188                         szListChar[0] = '<';
00189                         break;
00190                 case 0x21d2:
00191                         szListChar[0] = '=';
00192                         break;
00193                 case 0x21e8: case 0x27a2:
00194                         szListChar[0] = '>';
00195                         break;
00196                 case 0x25a0: case 0x25aa:
00197                         szListChar[0] = '.';
00198                         break;
00199                 case 0x2666:
00200                         szListChar[0] = OUR_DIAMOND;
00201                         break;
00202                 case 0x270c:
00203                         szListChar[0] = 'x';
00204                         break;
00205                 case 0x2713:
00206                         szListChar[0] = 'V';
00207                         break;
00208                 case 0x2756:
00209                         szListChar[0] = '*';
00210                         break;
00211                 case 0x2022:
00212                 default:
00213                         vGetBulletValue(eConversionType, eEncoding,
00214                                         szListChar, 2);
00215                         break;
00216                 }
00217                 tLen = 1;
00218         }
00219         szListChar[tLen] = '\0';
00220 } /* end of vConvertListCharacter */
00221 
00222 /*
00223  * eGetNumType - get the level type from the given level number
00224  *
00225  * Returns the level type
00226  */
00227 level_type_enum
00228 eGetNumType(UCHAR ucNumLevel)
00229 {
00230         switch (ucNumLevel) {
00231         case  1: case  2: case  3: case  4: case  5:
00232         case  6: case  7: case  8: case  9:
00233                 return level_type_outline;
00234         case 10:
00235                 return level_type_numbering;
00236         case 11:
00237                 return level_type_sequence;
00238         case 12:
00239                 return level_type_pause;
00240         default:
00241                 return level_type_none;
00242         }
00243 } /* end of eGetNumType */
00244 
00245 /*
00246  * vCorrectStyleValues - correct style values that Antiword can't use
00247  */
00248 void
00249 vCorrectStyleValues(style_block_type *pStyleBlock)
00250 {
00251         if (pStyleBlock->usBeforeIndent > 0x7fff) {
00252                 pStyleBlock->usBeforeIndent = 0;
00253         } else if (pStyleBlock->usBeforeIndent > 2160) {
00254                 /* 2160 twips = 1.5 inches or 38.1 mm */
00255                 DBG_DEC(pStyleBlock->usBeforeIndent);
00256                 pStyleBlock->usBeforeIndent = 2160;
00257         }
00258         if (pStyleBlock->usIstd >= 1 &&
00259             pStyleBlock->usIstd <= 9 &&
00260             pStyleBlock->usBeforeIndent < HEADING_GAP) {
00261                 NO_DBG_DEC(pStyleBlock->usBeforeIndent);
00262                 pStyleBlock->usBeforeIndent = HEADING_GAP;
00263         }
00264 
00265         if (pStyleBlock->usAfterIndent > 0x7fff) {
00266                 pStyleBlock->usAfterIndent = 0;
00267         } else if (pStyleBlock->usAfterIndent > 2160) {
00268                 /* 2160 twips = 1.5 inches or 38.1 mm */
00269                 DBG_DEC(pStyleBlock->usAfterIndent);
00270                 pStyleBlock->usAfterIndent = 2160;
00271         }
00272         if (pStyleBlock->usIstd >= 1 &&
00273             pStyleBlock->usIstd <= 9 &&
00274             pStyleBlock->usAfterIndent < HEADING_GAP) {
00275                 NO_DBG_DEC(pStyleBlock->usAfterIndent);
00276                 pStyleBlock->usAfterIndent = HEADING_GAP;
00277         }
00278 
00279         if (pStyleBlock->sLeftIndent < 0) {
00280                 pStyleBlock->sLeftIndent = 0;
00281         }
00282         if (pStyleBlock->sRightIndent > 0) {
00283                 pStyleBlock->sRightIndent = 0;
00284         }
00285         vConvertListCharacter(pStyleBlock->ucNFC,
00286                         pStyleBlock->usListChar,
00287                         pStyleBlock->szListChar);
00288 } /* end of vCorrectStyleValues */
00289 
00290 /*
00291  * vAdd2StyleInfoList - Add an element to the Style Information List
00292  */
00293 void
00294 vAdd2StyleInfoList(const style_block_type *pStyleBlock)
00295 {
00296         style_mem_type  *pListMember;
00297 
00298         fail(pStyleBlock == NULL);
00299 
00300         NO_DBG_MSG("bAdd2StyleInfoList");
00301 
00302         if (pStyleBlock->ulFileOffset == FC_INVALID) {
00303                 NO_DBG_DEC(pStyleBlock->usIstd);
00304                 return;
00305         }
00306 
00307         NO_DBG_HEX(pStyleBlock->ulFileOffset);
00308         NO_DBG_DEC_C(pStyleBlock->sLeftIndent != 0,
00309                                         pStyleBlock->sLeftIndent);
00310         NO_DBG_DEC_C(pStyleBlock->sRightIndent != 0,
00311                                         pStyleBlock->sRightIndent);
00312         NO_DBG_DEC_C(pStyleBlock->bNumPause, pStyleBlock->bNumPause);
00313         NO_DBG_DEC_C(pStyleBlock->usIstd != 0, pStyleBlock->usIstd);
00314         NO_DBG_DEC_C(pStyleBlock->usStartAt != 1, pStyleBlock->usStartAt);
00315         NO_DBG_DEC_C(pStyleBlock->usAfterIndent != 0,
00316                                         pStyleBlock->usAfterIndent);
00317         NO_DBG_DEC_C(pStyleBlock->ucAlignment != 0, pStyleBlock->ucAlignment);
00318         NO_DBG_DEC(pStyleBlock->ucNFC);
00319         NO_DBG_HEX(pStyleBlock->usListChar);
00320 
00321         if (pStyleLast != NULL &&
00322             pStyleLast->tInfo.ulFileOffset == pStyleBlock->ulFileOffset) {
00323                 /*
00324                  * If two consecutive styles share the same
00325                  * offset, remember only the last style
00326                  */
00327                 fail(pStyleLast->pNext != NULL);
00328                 pStyleLast->tInfo = *pStyleBlock;
00329                 /* Correct the values where needed */
00330                 vCorrectStyleValues(&pStyleLast->tInfo);
00331                 return;
00332         }
00333 
00334         /* Create list member */
00335         pListMember = xmalloc(sizeof(style_mem_type));
00336         /* Fill the list member */
00337         pListMember->tInfo = *pStyleBlock;
00338         pListMember->pNext = NULL;
00339         /* Add the sequence number */
00340         pListMember->ulSequenceNumber =
00341                         ulGetSeqNumber(pListMember->tInfo.ulFileOffset);
00342         /* Correct the values where needed */
00343         vCorrectStyleValues(&pListMember->tInfo);
00344         /* Add the new member to the list */
00345         if (pAnchor == NULL) {
00346                 pAnchor = pListMember;
00347                 /* For efficiency */
00348                 pMidPtr = pAnchor;
00349                 bMoveMidPtr = FALSE;
00350                 bInSequence = TRUE;
00351         } else {
00352                 fail(pStyleLast == NULL);
00353                 pStyleLast->pNext = pListMember;
00354                 /* For efficiency */
00355                 if (bMoveMidPtr) {
00356                         pMidPtr = pMidPtr->pNext;
00357                         bMoveMidPtr = FALSE;
00358                 } else {
00359                         bMoveMidPtr = TRUE;
00360                 }
00361                 if (bInSequence) {
00362                         bInSequence = pListMember->ulSequenceNumber >
00363                                         pStyleLast->ulSequenceNumber;
00364                 }
00365         }
00366         pStyleLast = pListMember;
00367 } /* end of vAdd2StyleInfoList */
00368 
00369 /*
00370  * Get the record that follows the given recored in the Style Information List
00371  */
00372 const style_block_type *
00373 pGetNextStyleInfoListItem(const style_block_type *pCurr)
00374 {
00375         const style_mem_type    *pRecord;
00376         size_t  tOffset;
00377 
00378         if (pCurr == NULL) {
00379                 if (pAnchor == NULL) {
00380                         /* There are no records */
00381                         return NULL;
00382                 }
00383                 /* The first record is the only one without a predecessor */
00384                 return &pAnchor->tInfo;
00385         }
00386         tOffset = offsetof(style_mem_type, tInfo);
00387         /* Many casts to prevent alignment warnings */
00388         pRecord = (style_mem_type *)(void *)((char *)pCurr - tOffset);
00389         fail(pCurr != &pRecord->tInfo);
00390         if (pRecord->pNext == NULL) {
00391                 /* The last record has no successor */
00392                 return NULL;
00393         }
00394         return &pRecord->pNext->tInfo;
00395 } /* end of pGetNextStyleInfoListItem */
00396 
00397 /*
00398  * Get the next text style
00399  */
00400 const style_block_type *
00401 pGetNextTextStyle(const style_block_type *pCurr)
00402 {
00403         const style_block_type  *pRecord;
00404 
00405         pRecord = pCurr;
00406         do {
00407                 pRecord = pGetNextStyleInfoListItem(pRecord);
00408         } while (pRecord != NULL &&
00409                  (pRecord->eListID == hdrftr_list ||
00410                   pRecord->eListID == macro_list ||
00411                   pRecord->eListID == annotation_list));
00412         return pRecord;
00413 } /* end of pGetNextTextStyle */
00414 
00415 /*
00416  * usGetIstd - get the istd that belongs to the given file offset
00417  */
00418 USHORT
00419 usGetIstd(ULONG ulFileOffset)
00420 {
00421         const style_mem_type    *pCurr, *pBest, *pStart;
00422         ULONG   ulSeq, ulBest;
00423 
00424         ulSeq = ulGetSeqNumber(ulFileOffset);
00425         if (ulSeq == FC_INVALID) {
00426                 return ISTD_NORMAL;
00427         }
00428         NO_DBG_HEX(ulFileOffset);
00429         NO_DBG_DEC(ulSeq);
00430 
00431         if (bInSequence &&
00432             pMidPtr != NULL &&
00433             ulSeq > pMidPtr->ulSequenceNumber) {
00434                 /* The istd is in the second half of the chained list */
00435                 pStart = pMidPtr;
00436         } else {
00437                 pStart = pAnchor;
00438         }
00439 
00440         pBest = NULL;
00441         ulBest = 0;
00442         for (pCurr = pStart; pCurr != NULL; pCurr = pCurr->pNext) {
00443                 if (pCurr->ulSequenceNumber != FC_INVALID &&
00444                     (pBest == NULL || pCurr->ulSequenceNumber > ulBest) &&
00445                     pCurr->ulSequenceNumber <= ulSeq) {
00446                         pBest = pCurr;
00447                         ulBest = pCurr->ulSequenceNumber;
00448                 }
00449                 if (bInSequence && pCurr->ulSequenceNumber > ulSeq) {
00450                         break;
00451                 }
00452         }
00453         NO_DBG_DEC(ulBest);
00454 
00455         if (pBest == NULL) {
00456                 return ISTD_NORMAL;
00457         }
00458 
00459         NO_DBG_DEC(pBest->tInfo.usIstd);
00460         return pBest->tInfo.usIstd;
00461 } /* end of usGetIstd */
00462 
00463 /*
00464  * bStyleImpliesList - does style info implies being part of a list
00465  *
00466  * Decide whether the style information implies that the given paragraph is
00467  * part of a list
00468  *
00469  * Returns TRUE when the paragraph is part of a list, otherwise FALSE
00470  */
00471 BOOL
00472 bStyleImpliesList(const style_block_type *pStyle, int iWordVersion)
00473 {
00474         fail(pStyle == NULL);
00475         fail(iWordVersion < 0);
00476 
00477         if (pStyle->usIstd >= 1 && pStyle->usIstd <= 9) {
00478                 /* These are heading levels */
00479                 return FALSE;
00480         }
00481         if (iWordVersion < 8) {
00482                 /* Check for old style lists */
00483                 return pStyle->ucNumLevel != 0;
00484         }
00485         /* Check for new style lists */
00486         return pStyle->usListIndex != 0;
00487 } /* end of bStyleImpliesList */