sys/src/cmd/aux/antiword/stylelist.c

   1 /*
   2  * stylelist.c
   3  * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
   4  *
   5  * Description:
   6  * Build, read and destroy a list of Word style information
   7  */
   8
   9 #include <stdlib.h>
  10 #include <stddef.h>
  11 #include <ctype.h>
  12 #include "antiword.h"
  13
  14
  15 /*
  16  * Private structure to hide the way the information
  17  * is stored from the rest of the program
  18  */
  19 typedef struct style_mem_tag {
  20         style_block_type        tInfo;
  21         ULONG                   ulSequenceNumber;
  22         struct style_mem_tag    *pNext;
  23 } style_mem_type;
  24
  25 /* Variables needed to write the Style Information List */
  26 static style_mem_type   *pAnchor = NULL;
  27 static style_mem_type   *pStyleLast = NULL;
  28 /* The type of conversion */
  29 static conversion_type  eConversionType = conversion_unknown;
  30 /* The character set encoding */
  31 static encoding_type    eEncoding = encoding_neutral;
  32 /* Values for efficiency reasons */
  33 static const style_mem_type     *pMidPtr = NULL;
  34 static BOOL             bMoveMidPtr = FALSE;
  35 static BOOL             bInSequence = TRUE;
  36
  37
  38 /*
  39  * vDestroyStyleInfoList - destroy the Style Information List
  40  */
  41 void
  42 vDestroyStyleInfoList(void)
  43 {
  44         style_mem_type  *pCurr, *pNext;
  45
  46         DBG_MSG("vDestroyStyleInfoList");
  47
  48         /* Free the Style Information List */
  49         pCurr = pAnchor;
  50         while (pCurr != NULL) {
  51                 pNext = pCurr->pNext;
  52                 pCurr = xfree(pCurr);
  53                 pCurr = pNext;
  54         }
  55         pAnchor = NULL;
  56         /* Reset all control variables */
  57         pStyleLast = NULL;
  58         pMidPtr = NULL;
  59         bMoveMidPtr = FALSE;
  60         bInSequence = TRUE;
  61 } /* end of vDestroyStyleInfoList */
  62
  63 /*
  64  * vConvertListCharacter - convert the list character
  65  */
  66 static void
  67 vConvertListCharacter(UCHAR ucNFC, USHORT usListChar, char *szListChar)
  68 {
  69         options_type    tOptions;
  70         size_t  tLen;
  71
  72         fail(szListChar == NULL);
  73         fail(szListChar[0] != '\0');
  74
  75         if (usListChar < 0x80 && isprint((int)usListChar)) {
  76                 DBG_CHR_C(isalnum((int)usListChar), usListChar);
  77                 szListChar[0] = (char)usListChar;
  78                 szListChar[1] = '\0';
  79                 return;
  80         }
  81
  82         if (ucNFC != LIST_SPECIAL &&
  83             ucNFC != LIST_SPECIAL2 &&
  84             ucNFC != LIST_BULLETS) {
  85                 szListChar[0] = '.';
  86                 szListChar[1] = '\0';
  87                 return;
  88         }
  89
  90         if (eConversionType == conversion_unknown ||
  91             eEncoding == encoding_neutral) {
  92                 vGetOptions(&tOptions);
  93                 eConversionType = tOptions.eConversionType;
  94                 eEncoding = tOptions.eEncoding;
  95         }
  96
  97         switch (usListChar) {
  98         case 0x0000: case 0x00b7: case 0x00fe: case  0xf021: case 0xf043:
  99         case 0xf06c: case 0xf093: case 0xf0b7:
 100                 usListChar = 0x2022;    /* BULLET */
 101                 break;
 102         case 0x0096: case 0xf02d:
 103                 usListChar = 0x2013;    /* EN DASH */
 104                 break;
 105         case 0x00a8:
 106                 usListChar = 0x2666;    /* BLACK DIAMOND SUIT */
 107                 break;
 108         case 0x00de:
 109                 usListChar = 0x21d2;    /* RIGHTWARDS DOUBLE ARROW */
 110                 break;
 111         case 0x00e0: case 0xf074:
 112                 usListChar = 0x25ca;    /* LOZENGE */
 113                 break;
 114         case 0x00e1:
 115                 usListChar = 0x2329;    /* LEFT ANGLE BRACKET */
 116                 break;
 117         case 0xf020:
 118                 usListChar = 0x0020;    /* SPACE */
 119                 break;
 120         case 0xf041:
 121                 usListChar = 0x270c;    /* VICTORY HAND */
 122                 break;
 123         case 0xf066:
 124                 usListChar = 0x03d5;    /* GREEK PHI SYMBOL */
 125                 break;
 126         case 0xf06e:
 127                 usListChar = 0x25a0;    /* BLACK SQUARE */
 128                 break;
 129         case 0xf06f: case 0xf070: case 0xf0a8:
 130                 usListChar = 0x25a1;    /* WHITE SQUARE */
 131                 break;
 132         case 0xf071:
 133                 usListChar = 0x2751;    /* LOWER RIGHT SHADOWED WHITE SQUARE */
 134                 break;
 135         case 0xf075: case 0xf077:
 136                 usListChar = 0x25c6;    /* BLACK DIAMOND */
 137                 break;
 138         case 0xf076:
 139                 usListChar = 0x2756;    /* BLACK DIAMOND MINUS WHITE X */
 140                 break;
 141         case 0xf0a7:
 142                 usListChar = 0x25aa;    /* BLACK SMALL SQUARE */
 143                 break;
 144         case 0xf0d8:
 145                 usListChar = 0x27a2;    /* RIGHTWARDS ARROWHEAD */
 146                 break;
 147         case 0xf0e5:
 148                 usListChar = 0x2199;    /* SOUTH WEST ARROW */
 149                 break;
 150         case 0xf0f0:
 151                 usListChar = 0x21e8;    /* RIGHTWARDS WHITE ARROW */
 152                 break;
 153         case 0xf0fc:
 154                 usListChar = 0x2713;    /* CHECK MARK */
 155                 break;
 156         default:
 157                 if ((usListChar >= 0xe000 && usListChar < 0xf900) ||
 158                     (usListChar < 0x80 && !isprint((int)usListChar))) {
 159                         /*
 160                          * All remaining private area characters and all
 161                          * remaining non-printable ASCII characters to their
 162                          * default bullet character
 163                          */
 164                         DBG_HEX(usListChar);
 165                         DBG_FIXME();
 166                         if (ucNFC == LIST_SPECIAL || ucNFC == LIST_SPECIAL2) {
 167                                 usListChar = 0x2190;    /* LEFTWARDS ARROW */
 168                         } else {
 169                                 usListChar = 0x2022;    /* BULLET */
 170                         }
 171                 }
 172                 break;
 173         }
 174
 175         if (eEncoding == encoding_utf_8) {
 176                 tLen = tUcs2Utf8(usListChar, szListChar, 4);
 177                 szListChar[tLen] = '\0';
 178         } else {
 179                 switch (usListChar) {
 180                 case 0x03d5: case 0x25a1: case 0x25c6: case 0x25ca:
 181                 case 0x2751:
 182                         szListChar[0] = 'o';
 183                         break;
 184                 case 0x2013: case 0x2500:
 185                         szListChar[0] = '-';
 186                         break;
 187                 case 0x2190: case 0x2199: case 0x2329:
 188                         szListChar[0] = '<';
 189                         break;
 190                 case 0x21d2:
 191                         szListChar[0] = '=';
 192                         break;
 193                 case 0x21e8: case 0x27a2:
 194                         szListChar[0] = '>';
 195                         break;
 196                 case 0x25a0: case 0x25aa:
 197                         szListChar[0] = '.';
 198                         break;
 199                 case 0x2666:
 200                         szListChar[0] = OUR_DIAMOND;
 201                         break;
 202                 case 0x270c:
 203                         szListChar[0] = 'x';
 204                         break;
 205                 case 0x2713:
 206                         szListChar[0] = 'V';
 207                         break;
 208                 case 0x2756:
 209                         szListChar[0] = '*';
 210                         break;
 211                 case 0x2022:
 212                 default:
 213                         vGetBulletValue(eConversionType, eEncoding,
 214                                         szListChar, 2);
 215                         break;
 216                 }
 217                 tLen = 1;
 218         }
 219         szListChar[tLen] = '\0';
 220 } /* end of vConvertListCharacter */
 221
 222 /*
 223  * eGetNumType - get the level type from the given level number
 224  *
 225  * Returns the level type
 226  */
 227 level_type_enum
 228 eGetNumType(UCHAR ucNumLevel)
 229 {
 230         switch (ucNumLevel) {
 231         case  1: case  2: case  3: case  4: case  5:
 232         case  6: case  7: case  8: case  9:
 233                 return level_type_outline;
 234         case 10:
 235                 return level_type_numbering;
 236         case 11:
 237                 return level_type_sequence;
 238         case 12:
 239                 return level_type_pause;
 240         default:
 241                 return level_type_none;
 242         }
 243 } /* end of eGetNumType */
 244
 245 /*
 246  * vCorrectStyleValues - correct style values that Antiword can't use
 247  */
 248 void
 249 vCorrectStyleValues(style_block_type *pStyleBlock)
 250 {
 251         if (pStyleBlock->usBeforeIndent > 0x7fff) {
 252                 pStyleBlock->usBeforeIndent = 0;
 253         } else if (pStyleBlock->usBeforeIndent > 2160) {
 254                 /* 2160 twips = 1.5 inches or 38.1 mm */
 255                 DBG_DEC(pStyleBlock->usBeforeIndent);
 256                 pStyleBlock->usBeforeIndent = 2160;
 257         }
 258         if (pStyleBlock->usIstd >= 1 &&
 259             pStyleBlock->usIstd <= 9 &&
 260             pStyleBlock->usBeforeIndent < HEADING_GAP) {
 261                 NO_DBG_DEC(pStyleBlock->usBeforeIndent);
 262                 pStyleBlock->usBeforeIndent = HEADING_GAP;
 263         }
 264
 265         if (pStyleBlock->usAfterIndent > 0x7fff) {
 266                 pStyleBlock->usAfterIndent = 0;
 267         } else if (pStyleBlock->usAfterIndent > 2160) {
 268                 /* 2160 twips = 1.5 inches or 38.1 mm */
 269                 DBG_DEC(pStyleBlock->usAfterIndent);
 270                 pStyleBlock->usAfterIndent = 2160;
 271         }
 272         if (pStyleBlock->usIstd >= 1 &&
 273             pStyleBlock->usIstd <= 9 &&
 274             pStyleBlock->usAfterIndent < HEADING_GAP) {
 275                 NO_DBG_DEC(pStyleBlock->usAfterIndent);
 276                 pStyleBlock->usAfterIndent = HEADING_GAP;
 277         }
 278
 279         if (pStyleBlock->sLeftIndent < 0) {
 280                 pStyleBlock->sLeftIndent = 0;
 281         }
 282         if (pStyleBlock->sRightIndent > 0) {
 283                 pStyleBlock->sRightIndent = 0;
 284         }
 285         vConvertListCharacter(pStyleBlock->ucNFC,
 286                         pStyleBlock->usListChar,
 287                         pStyleBlock->szListChar);
 288 } /* end of vCorrectStyleValues */
 289
 290 /*
 291  * vAdd2StyleInfoList - Add an element to the Style Information List
 292  */
 293 void
 294 vAdd2StyleInfoList(const style_block_type *pStyleBlock)
 295 {
 296         style_mem_type  *pListMember;
 297
 298         fail(pStyleBlock == NULL);
 299
 300         NO_DBG_MSG("bAdd2StyleInfoList");
 301
 302         if (pStyleBlock->ulFileOffset == FC_INVALID) {
 303                 NO_DBG_DEC(pStyleBlock->usIstd);
 304                 return;
 305         }
 306
 307         NO_DBG_HEX(pStyleBlock->ulFileOffset);
 308         NO_DBG_DEC_C(pStyleBlock->sLeftIndent != 0,
 309                                         pStyleBlock->sLeftIndent);
 310         NO_DBG_DEC_C(pStyleBlock->sRightIndent != 0,
 311                                         pStyleBlock->sRightIndent);
 312         NO_DBG_DEC_C(pStyleBlock->bNumPause, pStyleBlock->bNumPause);
 313         NO_DBG_DEC_C(pStyleBlock->usIstd != 0, pStyleBlock->usIstd);
 314         NO_DBG_DEC_C(pStyleBlock->usStartAt != 1, pStyleBlock->usStartAt);
 315         NO_DBG_DEC_C(pStyleBlock->usAfterIndent != 0,
 316                                         pStyleBlock->usAfterIndent);
 317         NO_DBG_DEC_C(pStyleBlock->ucAlignment != 0, pStyleBlock->ucAlignment);
 318         NO_DBG_DEC(pStyleBlock->ucNFC);
 319         NO_DBG_HEX(pStyleBlock->usListChar);
 320
 321         if (pStyleLast != NULL &&
 322             pStyleLast->tInfo.ulFileOffset == pStyleBlock->ulFileOffset) {
 323                 /*
 324                  * If two consecutive styles share the same
 325                  * offset, remember only the last style
 326                  */
 327                 fail(pStyleLast->pNext != NULL);
 328                 pStyleLast->tInfo = *pStyleBlock;
 329                 /* Correct the values where needed */
 330                 vCorrectStyleValues(&pStyleLast->tInfo);
 331                 return;
 332         }
 333
 334         /* Create list member */
 335         pListMember = xmalloc(sizeof(style_mem_type));
 336         /* Fill the list member */
 337         pListMember->tInfo = *pStyleBlock;
 338         pListMember->pNext = NULL;
 339         /* Add the sequence number */
 340         pListMember->ulSequenceNumber =
 341                         ulGetSeqNumber(pListMember->tInfo.ulFileOffset);
 342         /* Correct the values where needed */
 343         vCorrectStyleValues(&pListMember->tInfo);
 344         /* Add the new member to the list */
 345         if (pAnchor == NULL) {
 346                 pAnchor = pListMember;
 347                 /* For efficiency */
 348                 pMidPtr = pAnchor;
 349                 bMoveMidPtr = FALSE;
 350                 bInSequence = TRUE;
 351         } else {
 352                 fail(pStyleLast == NULL);
 353                 pStyleLast->pNext = pListMember;
 354                 /* For efficiency */
 355                 if (bMoveMidPtr) {
 356                         pMidPtr = pMidPtr->pNext;
 357                         bMoveMidPtr = FALSE;
 358                 } else {
 359                         bMoveMidPtr = TRUE;
 360                 }
 361                 if (bInSequence) {
 362                         bInSequence = pListMember->ulSequenceNumber >
 363                                         pStyleLast->ulSequenceNumber;
 364                 }
 365         }
 366         pStyleLast = pListMember;
 367 } /* end of vAdd2StyleInfoList */
 368
 369 /*
 370  * Get the record that follows the given recored in the Style Information List
 371  */
 372 const style_block_type *
 373 pGetNextStyleInfoListItem(const style_block_type *pCurr)
 374 {
 375         const style_mem_type    *pRecord;
 376         size_t  tOffset;
 377
 378         if (pCurr == NULL) {
 379                 if (pAnchor == NULL) {
 380                         /* There are no records */
 381                         return NULL;
 382                 }
 383                 /* The first record is the only one without a predecessor */
 384                 return &pAnchor->tInfo;
 385         }
 386         tOffset = offsetof(style_mem_type, tInfo);
 387         /* Many casts to prevent alignment warnings */
 388         pRecord = (style_mem_type *)(void *)((char *)pCurr - tOffset);
 389         fail(pCurr != &pRecord->tInfo);
 390         if (pRecord->pNext == NULL) {
 391                 /* The last record has no successor */
 392                 return NULL;
 393         }
 394         return &pRecord->pNext->tInfo;
 395 } /* end of pGetNextStyleInfoListItem */
 396
 397 /*
 398  * Get the next text style
 399  */
 400 const style_block_type *
 401 pGetNextTextStyle(const style_block_type *pCurr)
 402 {
 403         const style_block_type  *pRecord;
 404
 405         pRecord = pCurr;
 406         do {
 407                 pRecord = pGetNextStyleInfoListItem(pRecord);
 408         } while (pRecord != NULL &&
 409                  (pRecord->eListID == hdrftr_list ||
 410                   pRecord->eListID == macro_list ||
 411                   pRecord->eListID == annotation_list));
 412         return pRecord;
 413 } /* end of pGetNextTextStyle */
 414
 415 /*
 416  * usGetIstd - get the istd that belongs to the given file offset
 417  */
 418 USHORT
 419 usGetIstd(ULONG ulFileOffset)
 420 {
 421         const style_mem_type    *pCurr, *pBest, *pStart;
 422         ULONG   ulSeq, ulBest;
 423
 424         ulSeq = ulGetSeqNumber(ulFileOffset);
 425         if (ulSeq == FC_INVALID) {
 426                 return ISTD_NORMAL;
 427         }
 428         NO_DBG_HEX(ulFileOffset);
 429         NO_DBG_DEC(ulSeq);
 430
 431         if (bInSequence &&
 432             pMidPtr != NULL &&
 433             ulSeq > pMidPtr->ulSequenceNumber) {
 434                 /* The istd is in the second half of the chained list */
 435                 pStart = pMidPtr;
 436         } else {
 437                 pStart = pAnchor;
 438         }
 439
 440         pBest = NULL;
 441         ulBest = 0;
 442         for (pCurr = pStart; pCurr != NULL; pCurr = pCurr->pNext) {
 443                 if (pCurr->ulSequenceNumber != FC_INVALID &&
 444                     (pBest == NULL || pCurr->ulSequenceNumber > ulBest) &&
 445                     pCurr->ulSequenceNumber <= ulSeq) {
 446                         pBest = pCurr;
 447                         ulBest = pCurr->ulSequenceNumber;
 448                 }
 449                 if (bInSequence && pCurr->ulSequenceNumber > ulSeq) {
 450                         break;
 451                 }
 452         }
 453         NO_DBG_DEC(ulBest);
 454
 455         if (pBest == NULL) {
 456                 return ISTD_NORMAL;
 457         }
 458
 459         NO_DBG_DEC(pBest->tInfo.usIstd);
 460         return pBest->tInfo.usIstd;
 461 } /* end of usGetIstd */
 462
 463 /*
 464  * bStyleImpliesList - does style info implies being part of a list
 465  *
 466  * Decide whether the style information implies that the given paragraph is
 467  * part of a list
 468  *
 469  * Returns TRUE when the paragraph is part of a list, otherwise FALSE
 470  */
 471 BOOL
 472 bStyleImpliesList(const style_block_type *pStyle, int iWordVersion)
 473 {
 474         fail(pStyle == NULL);
 475         fail(iWordVersion < 0);
 476
 477         if (pStyle->usIstd >= 1 && pStyle->usIstd <= 9) {
 478                 /* These are heading levels */
 479                 return FALSE;
 480         }
 481         if (iWordVersion < 8) {
 482                 /* Check for old style lists */
 483                 return pStyle->ucNumLevel != 0;
 484         }
 485         /* Check for new style lists */
 486         return pStyle->usListIndex != 0;
 487 } /* end of bStyleImpliesList */