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

00001 /*
+00002  * stylesheet.c
+00003  * Copyright (C) 2001-2004 A.J. van Os; Released under GNU GPL
+00004  *
+00005  * Description:
+00006  * Build, read and destroy a list of stylesheet information
+00007  *
+00008  */
+00009 
+00010 #include <string.h>
+00011 #include "antiword.h"
+00012 
+00013 
+00014 #define SGC_PAP         1
+00015 #define SGC_CHP         2
+00016 
+00017 /* Variables needed to describe the stylesheet list */
+00018 static style_block_type *atStyleInfo = NULL;
+00019 static font_block_type  *atFontInfo = NULL;
+00020 static BOOL             *abFilled = NULL;
+00021 static size_t           tStdCount = 0;
+00022 
+00023 
+00024 /*
+00025  * vDestroyStylesheetList - destroy the stylesheet list
+00026  */
+00027 void
+00028 vDestroyStylesheetList(void)
+00029 {
+00030         DBG_MSG("vDestroyStylesheetList");
+00031 
+00032         tStdCount = 0;
+00033         atStyleInfo = xfree(atStyleInfo);
+00034         atFontInfo = xfree(atFontInfo);
+00035         abFilled = xfree(abFilled);
+00036 } /* end of vDestroyStylesheetList */
+00037 
+00038 /*
+00039  * vGetDefaultStyle - fill the style struct with default values
+00040  */
+00041 static void
+00042 vGetDefaultStyle(style_block_type *pStyle)
+00043 {
+00044         (void)memset(pStyle, 0, sizeof(*pStyle));
+00045         pStyle->usIstd = ISTD_INVALID;
+00046         pStyle->usIstdNext = ISTD_INVALID;
+00047         pStyle->usStartAt = 1;
+00048         pStyle->ucListLevel = 9;
+00049 } /* end of vGetDefaultStyle */
+00050 
+00051 /*
+00052  * vGetDefaultFont - fill the font struct with default values
+00053  */
+00054 static void
+00055 vGetDefaultFont(font_block_type *pFont, USHORT usDefaultFontNumber)
+00056 {
+00057         (void)memset(pFont, 0, sizeof(*pFont));
+00058         pFont->usFontSize = DEFAULT_FONT_SIZE;
+00059         if (usDefaultFontNumber <= (USHORT)UCHAR_MAX) {
+00060                 pFont->ucFontNumber = (UCHAR)usDefaultFontNumber;
+00061         } else {
+00062                 DBG_DEC(usDefaultFontNumber);
+00063                 DBG_FIXME();
+00064                 pFont->ucFontNumber = 0;
+00065         }
+00066 } /* end of vGetDefaultFont */
+00067 
+00068 /*
+00069  * iGetStyleIndex - get the index of the record with the specified istd
+00070  *
+00071  * returns the index when found, otherwise -1
+00072  */
+00073 static int
+00074 iGetStyleIndex(USHORT usIstd)
+00075 {
+00076         int     iIndex;
+00077 
+00078         fail(abFilled == NULL);
+00079 
+00080         if (usIstd == ISTD_INVALID || abFilled == NULL) {
+00081                 return -1;
+00082         }
+00083 
+00084         for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00085                 if (abFilled[iIndex] && atStyleInfo[iIndex].usIstd == usIstd) {
+00086                         /* The record is filled and the istd matches */
+00087                         return iIndex;
+00088                 }
+00089         }
+00090         return -1;
+00091 } /* end of iGetStyleIndex */
+00092 
+00093 /*
+00094  * Get a build-in style for Winword 1/2
+00095  */
+00096 static void
+00097 vGetBuildinStyle(UCHAR ucStc, style_block_type *pStyle)
+00098 {
+00099         fail(pStyle == NULL);
+00100 
+00101         /* Start with de defaults */
+00102         vGetDefaultStyle(pStyle);
+00103 
+00104         /* Add the build-in style info */
+00105         switch (ucStc) {
+00106         case 246:
+00107         case 247:
+00108         case 248:
+00109         case 249:
+00110         case 250:
+00111         case 255:
+00112                 pStyle->sLeftIndent = 720;
+00113                 break;
+00114         case 251:
+00115         case 252:
+00116                 pStyle->sLeftIndent = 360;
+00117                 break;
+00118         case 253:
+00119                 pStyle->usBeforeIndent = 120;
+00120                 break;
+00121         case 254:
+00122                 pStyle->usBeforeIndent = 240;
+00123                 break;
+00124         default:
+00125                 if (ucStc >= 233 && ucStc <= 239) {
+00126                         pStyle->sLeftIndent = (239 - (short)ucStc) * 360;
+00127                 }
+00128                 if (ucStc >= 225 && ucStc <= 232) {
+00129                         pStyle->sLeftIndent = (232 - (short)ucStc) * 720;
+00130                         pStyle->sRightIndent = 720;
+00131                 }
+00132                 break;
+00133         }
+00134 } /* end of vGetBuildinStyle */
+00135 
+00136 /*
+00137  * Get a build-in fontstyle for Winword 1/2
+00138  */
+00139 static void
+00140 vGetBuildinFont(UCHAR ucStc, font_block_type *pFont)
+00141 {
+00142         fail(pFont == NULL);
+00143 
+00144         /* Start with de defaults */
+00145         vGetDefaultFont(pFont, 0);
+00146 
+00147         /* Add the build-in fontstyle info */
+00148         switch (ucStc) {
+00149         case 223:
+00150         case 244:
+00151                 pFont->usFontSize = 16;
+00152                 break;
+00153         case 246:
+00154         case 247:
+00155         case 248:
+00156                 pFont->usFontStyle |= FONT_ITALIC;
+00157                 break;
+00158         case 249:
+00159                 pFont->usFontStyle |= FONT_UNDERLINE;
+00160                 break;
+00161         case 250:
+00162                 pFont->usFontStyle |= FONT_BOLD;
+00163                 break;
+00164         case 251:
+00165                 pFont->usFontStyle |= FONT_UNDERLINE;
+00166                 pFont->usFontSize = 24;
+00167                 break;
+00168         case 252:
+00169                 pFont->usFontStyle |= FONT_BOLD;
+00170                 pFont->usFontSize = 24;
+00171                 break;
+00172         case 253:
+00173                 pFont->ucFontNumber = 2;
+00174                 pFont->usFontStyle |= FONT_BOLD;
+00175                 pFont->usFontSize = 24;
+00176                 break;
+00177         case 254:
+00178                 pFont->ucFontNumber = 2;
+00179                 pFont->usFontStyle |= (FONT_BOLD|FONT_UNDERLINE);
+00180                 pFont->usFontSize = 24;
+00181                 break;
+00182         default:
+00183                 break;
+00184         }
+00185 } /* end of vGetBuildinFont */
+00186 
+00187 /*
+00188  * Convert a stylecode (stc) as used by WinWord 1/2 into a styleindex (istd)
+00189  * as used by Word 6 and up
+00190  */
+00191 USHORT
+00192 usStc2istd(UCHAR ucStc)
+00193 {
+00194         /* Old nil style to new nil style */
+00195         if (ucStc == 222) {
+00196                 return STI_NIL;
+00197         }
+00198 
+00199         /* Heading 1 through 9 must become istd 1 through 9 */
+00200         /* so 254 through 246 must become 1 through 9 and vice versa */
+00201         if ((ucStc >= 1 && ucStc <= 9) ||
+00202             (ucStc >= 246 && ucStc <= 254)) {
+00203                 return 255 - (USHORT)ucStc;
+00204         }
+00205         return (USHORT)ucStc;
+00206 } /* end of usStd2istd */
+00207 
+00208 /*
+00209  * Build the lists with Stylesheet Information for WinWord 1/2 files
+00210  */
+00211 void
+00212 vGet2Stylesheet(FILE *pFile, int iWordVersion, const UCHAR *aucHeader)
+00213 {
+00214         style_block_type        *pStyle;
+00215         font_block_type         *pFont;
+00216         UCHAR   *aucBuffer;
+00217         ULONG   ulBeginStshInfo;
+00218         size_t  tStshInfoLen, tName, tChpx, tPapx, tMaxIndex;
+00219         int     iStIndex, iChpxIndex, iPapxIndex, iSt, iChpx, iPapx;
+00220         int     iStd, iIndex, iBaseStyleIndex, iCounter;
+00221         USHORT  usBaseStyle;
+00222         UCHAR   ucStc, ucStcNext, ucStcBase;
+00223 
+00224         fail(pFile == NULL || aucHeader == NULL);
+00225         fail(iWordVersion != 1 && iWordVersion != 2);
+00226 
+00227         ulBeginStshInfo = ulGetLong(0x5e, aucHeader); /* fcStshf */
+00228         NO_DBG_HEX(ulBeginStshInfo);
+00229         tStshInfoLen = (size_t)usGetWord(0x62, aucHeader); /* cbStshf */
+00230         NO_DBG_DEC(tStshInfoLen);
+00231 
+00232         aucBuffer = xmalloc(tStshInfoLen);
+00233         if (!bReadBytes(aucBuffer, tStshInfoLen, ulBeginStshInfo, pFile)) {
+00234                 aucBuffer = xfree(aucBuffer);
+00235                 return;
+00236         }
+00237         NO_DBG_PRINT_BLOCK(aucBuffer, tStshInfoLen);
+00238 
+00239         fail(2 > tStshInfoLen);
+00240         iStd = (int)usGetWord(0, aucBuffer);
+00241 
+00242         fail(2 + 2 > tStshInfoLen);
+00243         tName = (size_t)usGetWord(2, aucBuffer);
+00244 
+00245         fail(2 + tName + 2 > tStshInfoLen);
+00246         tChpx = (size_t)usGetWord(2 + tName, aucBuffer);
+00247 
+00248         fail(2 + tName + tChpx + 2 > tStshInfoLen);
+00249         tPapx = (size_t)usGetWord(2 + tName + tChpx, aucBuffer);
+00250 
+00251         fail(2 + tName + tChpx + tPapx + 2 > tStshInfoLen);
+00252         tStdCount = (size_t)usGetWord(2 + tName + tChpx + tPapx, aucBuffer);
+00253 
+00254         NO_DBG_HEX(tStdCount);
+00255 
+00256         atStyleInfo = xcalloc(tStdCount, sizeof(style_block_type));
+00257         atFontInfo = xcalloc(tStdCount, sizeof(font_block_type));
+00258         abFilled = xcalloc(tStdCount, sizeof(BOOL));
+00259 
+00260         do {
+00261                 iCounter = 0;
+00262                 iStIndex = 2 + 2;
+00263                 iChpxIndex = 2 + (int)tName + 2;
+00264                 iPapxIndex = 2 + (int)tName + (int)tChpx + 2;
+00265                 tMaxIndex = 2 + tName + tChpx + tPapx + 2;
+00266                 /* Read the styles one-by-one */
+00267                 for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00268                         pStyle = &atStyleInfo[iIndex];
+00269                         pFont = &atFontInfo[iIndex];
+00270                         iSt = (int)ucGetByte(iStIndex, aucBuffer);
+00271                         iChpx = (int)ucGetByte(iChpxIndex, aucBuffer);
+00272                         iPapx = (int)ucGetByte(iPapxIndex, aucBuffer);
+00273                         NO_DBG_HEX(iSt);
+00274                         NO_DBG_HEX(iChpx);
+00275                         NO_DBG_HEX(iPapx);
+00276                         if (iSt == 0xff || tMaxIndex + 1 >= tStshInfoLen) {
+00277                                 /* Undefined style or no information */
+00278                                 iStIndex++;
+00279                                 iChpxIndex++;
+00280                                 iPapxIndex++;
+00281                                 tMaxIndex += 2;
+00282                                 if (!abFilled[iIndex]) {
+00283                                         DBG_HEX_C(iChpx != 0xff, iChpx);
+00284                                         DBG_HEX_C(iPapx != 0xff, iPapx);
+00285                                         vGetDefaultStyle(pStyle);
+00286                                         vGetDefaultFont(pFont, 0);
+00287                                         abFilled[iIndex] = TRUE;
+00288                                 }
+00289                                 continue;
+00290                         }
+00291 
+00292                         NO_DBG_STRN(aucBuffer + iStIndex + 1, iSt);
+00293                         iStIndex += iSt + 1;
+00294 
+00295                         ucStcNext = ucGetByte(tMaxIndex, aucBuffer);
+00296                         ucStcBase = ucGetByte(tMaxIndex + 1, aucBuffer);
+00297                         ucStc = (UCHAR)((iIndex - iStd) & 0xff);
+00298                         NO_DBG_DEC(ucStc);
+00299 
+00300                         if (iChpx == 0xff || iPapx == 0xff) {
+00301                                 /* Use a build-in style */
+00302                                 iChpxIndex++;
+00303                                 iPapxIndex++;
+00304                                 tMaxIndex += 2;
+00305                                 if (!abFilled[iIndex]) {
+00306                                         DBG_HEX_C(iChpx != 0xff, iChpx);
+00307                                         DBG_HEX_C(iPapx != 0xff, iPapx);
+00308                                         vGetBuildinStyle(ucStc, pStyle);
+00309                                         pStyle->usIstd = usStc2istd(ucStc);
+00310                                         pStyle->usIstdNext =
+00311                                                         usStc2istd(ucStcNext);
+00312                                         vGetBuildinFont(ucStc, pFont);
+00313                                         abFilled[iIndex] = TRUE;
+00314                                 }
+00315                                 continue;
+00316                         }
+00317 
+00318                         if (abFilled[iIndex]) {
+00319                                 /* This record has already been filled */
+00320                                 iChpxIndex += iChpx + 1;
+00321                                 iPapxIndex += iPapx + 1;
+00322                                 tMaxIndex += 2;
+00323                                 continue;
+00324                         }
+00325 
+00326                         usBaseStyle = usStc2istd(ucStcBase);
+00327 
+00328                         if (usBaseStyle == STI_NIL) {
+00329                                 /* Based on the Nil style */
+00330                                 vGetDefaultStyle(pStyle);
+00331                                 vGetDefaultFont(pFont, 0);
+00332                         } else {
+00333                                 iBaseStyleIndex = iGetStyleIndex(usBaseStyle);
+00334                                 NO_DBG_DEC(iBaseStyleIndex);
+00335                                 if (iBaseStyleIndex < 0) {
+00336                                         /* This style is not known yet */
+00337                                         iChpxIndex += iChpx + 1;
+00338                                         iPapxIndex += iPapx + 1;
+00339                                         tMaxIndex += 2;
+00340                                         continue;
+00341                                 }
+00342                                 fail(iBaseStyleIndex >= (int)tStdCount);
+00343                                 fail(!abFilled[iBaseStyleIndex]);
+00344                                 /* Based on the specified base style */
+00345                                 *pStyle = atStyleInfo[iBaseStyleIndex];
+00346                                 *pFont = atFontInfo[iBaseStyleIndex];
+00347                         }
+00348                         pStyle->usIstd = usStc2istd(ucStc);
+00349                         pStyle->usIstdNext = usStc2istd(ucStcNext);
+00350 
+00351                         abFilled[iIndex] = TRUE;
+00352                         iCounter++;
+00353 
+00354                         /* Add the changes if any */
+00355                         switch (iChpx) {
+00356                         case 0x00:
+00357                         case 0xff:
+00358                                 iChpxIndex++;
+00359                                 break;
+00360                         default:
+00361                                 NO_DBG_PRINT_BLOCK(aucBuffer + iChpxIndex + 1,
+00362                                                 iChpx);
+00363                                 if (iWordVersion == 1) {
+00364                                         vGet1FontInfo(0,
+00365                                                 aucBuffer + iChpxIndex + 1,
+00366                                                 (size_t)iChpx, pFont);
+00367                                 } else {
+00368                                         vGet2FontInfo(0,
+00369                                                 aucBuffer + iChpxIndex + 1,
+00370                                                 (size_t)iChpx, pFont);
+00371                                 }
+00372                                 iChpxIndex += iChpx + 1;
+00373                                 break;
+00374                         }
+00375 
+00376                         switch (iPapx) {
+00377                         case 0x00:
+00378                         case 0xff:
+00379                                 iPapxIndex++;
+00380                                 break;
+00381                         default:
+00382                                 NO_DBG_PRINT_BLOCK(aucBuffer + iPapxIndex + 8,
+00383                                                 iPapx - 7);
+00384                                 vGet2StyleInfo(0, aucBuffer + iPapxIndex + 8,
+00385                                                 iPapx - 7, pStyle);
+00386                                 iPapxIndex += iPapx + 1;
+00387                                 break;
+00388                         }
+00389                         tMaxIndex += 2;
+00390 
+00391                 }
+00392                 NO_DBG_DEC(iCounter);
+00393         } while (iCounter > 0);
+00394 
+00395         /* Fill records that are still empty */
+00396         for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00397                 if (!abFilled[iIndex]) {
+00398                         NO_DBG_DEC(iIndex);
+00399                         vGetDefaultStyle(&atStyleInfo[iIndex]);
+00400                         vGetDefaultFont(&atFontInfo[iIndex], 0);
+00401                 }
+00402         }
+00403 
+00404         /* Clean up before you leave */
+00405         abFilled = xfree(abFilled);
+00406         aucBuffer = xfree(aucBuffer);
+00407 } /* end of vGet2Stylesheet */
+00408 
+00409 /*
+00410  * Build the lists with Stylesheet Information for Word 6/7 files
+00411  */
+00412 void
+00413 vGet6Stylesheet(FILE *pFile, ULONG ulStartBlock,
+00414         const ULONG *aulBBD, size_t tBBDLen, const UCHAR *aucHeader)
+00415 {
+00416         style_block_type        *pStyle;
+00417         font_block_type         *pFont;
+00418         UCHAR   *aucBuffer;
+00419         ULONG   ulBeginStshInfo;
+00420         size_t  tStshInfoLen, tOffset, tStdLen, tStdBaseInFile;
+00421         size_t  tPos, tNameLen, tUpxLen;
+00422         int     iIndex, iBaseStyleIndex, iCounter;
+00423         USHORT  usTmp, usUpxCount, usStyleType, usBaseStyle;
+00424         USHORT  usFtcStandardChpStsh;
+00425 
+00426         fail(pFile == NULL || aucHeader == NULL);
+00427         fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
+00428         fail(aulBBD == NULL);
+00429 
+00430         ulBeginStshInfo = ulGetLong(0x60, aucHeader); /* fcStshf */
+00431         NO_DBG_HEX(ulBeginStshInfo);
+00432         tStshInfoLen = (size_t)ulGetLong(0x64, aucHeader); /* lcbStshf */
+00433         NO_DBG_DEC(tStshInfoLen);
+00434 
+00435         aucBuffer = xmalloc(tStshInfoLen);
+00436         if (!bReadBuffer(pFile, ulStartBlock,
+00437                         aulBBD, tBBDLen, BIG_BLOCK_SIZE,
+00438                         aucBuffer, ulBeginStshInfo, tStshInfoLen)) {
+00439                 aucBuffer = xfree(aucBuffer);
+00440                 return;
+00441         }
+00442         NO_DBG_PRINT_BLOCK(aucBuffer, tStshInfoLen);
+00443 
+00444         tStdCount = (size_t)usGetWord(2, aucBuffer);
+00445         NO_DBG_DEC(tStdCount);
+00446         tStdBaseInFile = (size_t)usGetWord(4, aucBuffer);
+00447         usFtcStandardChpStsh = usGetWord(14, aucBuffer);
+00448         NO_DBG_DEC(usFtcStandardChpStsh);
+00449 
+00450         atStyleInfo = xcalloc(tStdCount, sizeof(style_block_type));
+00451         atFontInfo = xcalloc(tStdCount, sizeof(font_block_type));
+00452         abFilled = xcalloc(tStdCount, sizeof(BOOL));
+00453 
+00454         do {
+00455                 iCounter = 0;
+00456                 /* Read the styles one-by-one */
+00457                 for (iIndex = 0, tOffset = 2 + (size_t)usGetWord(0, aucBuffer);
+00458                      iIndex < (int)tStdCount;
+00459                      iIndex++, tOffset += 2 + tStdLen) {
+00460                         NO_DBG_DEC(tOffset);
+00461                         tStdLen = (size_t)usGetWord(tOffset, aucBuffer);
+00462                         NO_DBG_DEC(tStdLen);
+00463                         if (abFilled[iIndex]) {
+00464                                 /* This record has already been filled */
+00465                                 continue;
+00466                         }
+00467                         pStyle = &atStyleInfo[iIndex];
+00468                         pFont = &atFontInfo[iIndex];
+00469                         if (tStdLen == 0) {
+00470                                 /* Empty record */
+00471                                 vGetDefaultStyle(pStyle);
+00472                                 vGetDefaultFont(pFont, usFtcStandardChpStsh);
+00473                                 abFilled[iIndex] = TRUE;
+00474                                 continue;
+00475                         }
+00476                         usTmp = usGetWord(tOffset + 4, aucBuffer);
+00477                         usStyleType = usTmp % 16;
+00478                         usBaseStyle = usTmp / 16;
+00479                         NO_DBG_DEC(usStyleType);
+00480                         NO_DBG_DEC(usBaseStyle);
+00481                         if (usBaseStyle == STI_NIL || usBaseStyle == STI_USER) {
+00482                                 /* Based on the Nil style */
+00483                                 vGetDefaultStyle(pStyle);
+00484                                 vGetDefaultFont(pFont, usFtcStandardChpStsh);
+00485                         } else {
+00486                                 iBaseStyleIndex = iGetStyleIndex(usBaseStyle);
+00487                                 NO_DBG_DEC(iBaseStyleIndex);
+00488                                 if (iBaseStyleIndex < 0) {
+00489                                         /* This base style is not known yet */
+00490                                         continue;
+00491                                 }
+00492                                 fail(iBaseStyleIndex >= (int)tStdCount);
+00493                                 fail(!abFilled[iBaseStyleIndex]);
+00494                                 /* Based on the specified base style */
+00495                                 *pStyle = atStyleInfo[iBaseStyleIndex];
+00496                                 pStyle->usIstd = ISTD_INVALID;
+00497                                 *pFont = atFontInfo[iBaseStyleIndex];
+00498                         }
+00499                         abFilled[iIndex] = TRUE;
+00500                         iCounter++;
+00501                         /* STD */
+00502                         usTmp = usGetWord(tOffset + 6, aucBuffer);
+00503                         usUpxCount = usTmp % 16;
+00504                         pStyle->usIstdNext = usTmp / 16;;
+00505                         NO_DBG_DEC(usUpxCount);
+00506                         tPos = 2 + tStdBaseInFile;
+00507                         NO_DBG_DEC(tPos);
+00508                         tNameLen = (size_t)ucGetByte(tOffset + tPos, aucBuffer);
+00509                         NO_DBG_DEC(tNameLen);
+00510                         NO_DBG_STRN(aucBuffer + tOffset + tPos + 1, tNameLen);
+00511                         tNameLen++;     /* Include the ASCII NULL character */
+00512                         tPos += 1 + tNameLen;
+00513                         if (odd(tPos)) {
+00514                                 tPos++;
+00515                         }
+00516                         NO_DBG_DEC(tPos);
+00517                         if (tPos >= tStdLen) {
+00518                                 continue;
+00519                         }
+00520                         tUpxLen = (size_t)usGetWord(tOffset + tPos, aucBuffer);
+00521                         NO_DBG_DEC(tUpxLen);
+00522                         if (tPos + tUpxLen > tStdLen) {
+00523                                 /* UPX length too large to be a record */
+00524                                 DBG_DEC_C(tPos + tUpxLen > tStdLen,
+00525                                                 tPos + tUpxLen);
+00526                                 continue;
+00527                         }
+00528                         if (usStyleType == SGC_PAP && usUpxCount >= 1) {
+00529                                 if (tUpxLen >= 2) {
+00530                                         NO_DBG_PRINT_BLOCK(
+00531                                                 aucBuffer + tOffset + tPos + 2,
+00532                                                 tUpxLen);
+00533                                         pStyle->usIstd = usGetWord(
+00534                                                 tOffset + tPos + 2, aucBuffer);
+00535                                         NO_DBG_DEC(pStyle->usIstd);
+00536                                         NO_DBG_DEC(pStyle->usIstdNext);
+00537                                         vGet6StyleInfo(0,
+00538                                                 aucBuffer + tOffset + tPos + 4,
+00539                                                 tUpxLen - 2, pStyle);
+00540                                         NO_DBG_DEC(pStyle->sLeftIndent);
+00541                                         NO_DBG_DEC(pStyle->sRightIndent);
+00542                                         NO_DBG_HEX(pStyle->ucAlignment);
+00543                                 }
+00544                                 tPos += 2 + tUpxLen;
+00545                                 if (odd(tPos)) {
+00546                                         tPos++;
+00547                                 }
+00548                                 NO_DBG_DEC(tPos);
+00549                                 tUpxLen = (size_t)usGetWord(
+00550                                                 tOffset + tPos, aucBuffer);
+00551                                 NO_DBG_DEC(tUpxLen);
+00552                         }
+00553                         if (tUpxLen == 0 || tPos + tUpxLen > tStdLen) {
+00554                                 /* Too small or too large to be a record */
+00555                                 DBG_DEC_C(tPos + tUpxLen > tStdLen,
+00556                                                         tPos + tUpxLen);
+00557                                 continue;
+00558                         }
+00559                         if ((usStyleType == SGC_PAP && usUpxCount >= 2) ||
+00560                             (usStyleType == SGC_CHP && usUpxCount >= 1)) {
+00561                                 NO_DBG_PRINT_BLOCK(
+00562                                                 aucBuffer + tOffset + tPos + 2,
+00563                                                 tUpxLen);
+00564                                 vGet6FontInfo(0, ISTD_INVALID,
+00565                                                 aucBuffer + tOffset + tPos + 2,
+00566                                                 (int)tUpxLen, pFont);
+00567                                 NO_DBG_DEC(pFont->usFontSize);
+00568                                 NO_DBG_DEC(pFont->ucFontcolor);
+00569                                 NO_DBG_HEX(pFont->usFontStyle);
+00570                         }
+00571                 }
+00572                 NO_DBG_DEC(iCounter);
+00573         } while (iCounter > 0);
+00574 
+00575         /* Fill records that are still empty */
+00576         for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00577                 if (!abFilled[iIndex]) {
+00578                         NO_DBG_DEC(iIndex);
+00579                         vGetDefaultStyle(&atStyleInfo[iIndex]);
+00580                         vGetDefaultFont(&atFontInfo[iIndex],
+00581                                         usFtcStandardChpStsh);
+00582                 }
+00583         }
+00584 
+00585         /* Clean up before you leave */
+00586         abFilled = xfree(abFilled);
+00587         aucBuffer = xfree(aucBuffer);
+00588 } /* end of vGet6Stylesheet */
+00589 
+00590 /*
+00591  * Build the lists with Stylesheet Information for Word 8/9/10 files
+00592  */
+00593 void
+00594 vGet8Stylesheet(FILE *pFile, const pps_info_type *pPPS,
+00595         const ULONG *aulBBD, size_t tBBDLen,
+00596         const ULONG *aulSBD, size_t tSBDLen,
+00597         const UCHAR *aucHeader)
+00598 {
+00599         style_block_type        *pStyle;
+00600         font_block_type         *pFont;
+00601         const ULONG     *aulBlockDepot;
+00602         UCHAR   *aucBuffer;
+00603         ULONG   ulBeginStshInfo;
+00604         size_t  tStshInfoLen, tBlockDepotLen, tOffset, tStdLen, tStdBaseInFile;
+00605         size_t  tBlockSize, tPos, tNameLen, tUpxLen;
+00606         int     iIndex, iBaseStyleIndex, iCounter;
+00607         USHORT  usTmp, usUpxCount, usStyleType, usBaseStyle;
+00608         USHORT  usFtcStandardChpStsh;
+00609 
+00610         fail(pFile == NULL || pPPS == NULL || aucHeader == NULL);
+00611         fail(aulBBD == NULL || aulSBD == NULL);
+00612 
+00613         ulBeginStshInfo = ulGetLong(0xa2, aucHeader); /* fcStshf */
+00614         NO_DBG_HEX(ulBeginStshInfo);
+00615         tStshInfoLen = (size_t)ulGetLong(0xa6, aucHeader); /* lcbStshf */
+00616         NO_DBG_DEC(tStshInfoLen);
+00617 
+00618         NO_DBG_DEC(pPPS->tTable.ulSB);
+00619         NO_DBG_HEX(pPPS->tTable.ulSize);
+00620         if (pPPS->tTable.ulSize == 0) {
+00621                 DBG_MSG("No stylesheet information");
+00622                 return;
+00623         }
+00624 
+00625         if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
+00626                 /* Use the Small Block Depot */
+00627                 aulBlockDepot = aulSBD;
+00628                 tBlockDepotLen = tSBDLen;
+00629                 tBlockSize = SMALL_BLOCK_SIZE;
+00630         } else {
+00631                 /* Use the Big Block Depot */
+00632                 aulBlockDepot = aulBBD;
+00633                 tBlockDepotLen = tBBDLen;
+00634                 tBlockSize = BIG_BLOCK_SIZE;
+00635         }
+00636         aucBuffer = xmalloc(tStshInfoLen);
+00637         if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
+00638                         aulBlockDepot, tBlockDepotLen, tBlockSize,
+00639                         aucBuffer, ulBeginStshInfo, tStshInfoLen)) {
+00640                 aucBuffer = xfree(aucBuffer);
+00641                 return;
+00642         }
+00643         NO_DBG_PRINT_BLOCK(aucBuffer, tStshInfoLen);
+00644 
+00645         tStdCount = (size_t)usGetWord(2, aucBuffer);
+00646         NO_DBG_DEC(tStdCount);
+00647         tStdBaseInFile = (size_t)usGetWord(4, aucBuffer);
+00648         usFtcStandardChpStsh = usGetWord(14, aucBuffer);
+00649         NO_DBG_DEC(usFtcStandardChpStsh);
+00650 
+00651         atStyleInfo = xcalloc(tStdCount, sizeof(style_block_type));
+00652         atFontInfo = xcalloc(tStdCount, sizeof(font_block_type));
+00653         abFilled = xcalloc(tStdCount, sizeof(BOOL));
+00654 
+00655         do {
+00656                 iCounter = 0;
+00657                 /* Read the styles one-by-one */
+00658                 for (iIndex = 0, tOffset = 2 + (size_t)usGetWord(0, aucBuffer);
+00659                      iIndex < (int)tStdCount;
+00660                      iIndex++, tOffset += 2 + tStdLen) {
+00661                         NO_DBG_DEC(tOffset);
+00662                         tStdLen = (size_t)usGetWord(tOffset, aucBuffer);
+00663                         NO_DBG_DEC(tStdLen);
+00664                         if (abFilled[iIndex]) {
+00665                                 /* This record has already been filled */
+00666                                 continue;
+00667                         }
+00668                         pStyle = &atStyleInfo[iIndex];
+00669                         pFont = &atFontInfo[iIndex];
+00670                         if (tStdLen == 0) {
+00671                                 /* Empty record */
+00672                                 vGetDefaultStyle(pStyle);
+00673                                 vGetDefaultFont(pFont, usFtcStandardChpStsh);
+00674                                 abFilled[iIndex] = TRUE;
+00675                                 continue;
+00676                         }
+00677                         usTmp = usGetWord(tOffset + 4, aucBuffer);
+00678                         usStyleType = usTmp % 16;
+00679                         usBaseStyle = usTmp / 16;
+00680                         NO_DBG_DEC(usStyleType);
+00681                         NO_DBG_DEC(usBaseStyle);
+00682                         if (usBaseStyle == STI_NIL || usBaseStyle == STI_USER) {
+00683                                 /* Based on the Nil style */
+00684                                 vGetDefaultStyle(pStyle);
+00685                                 vGetDefaultFont(pFont, usFtcStandardChpStsh);
+00686                         } else {
+00687                                 iBaseStyleIndex = iGetStyleIndex(usBaseStyle);
+00688                                 NO_DBG_DEC(iBaseStyleIndex);
+00689                                 if (iBaseStyleIndex < 0) {
+00690                                         /* This base style is not known yet */
+00691                                         continue;
+00692                                 }
+00693                                 fail(iBaseStyleIndex >= (int)tStdCount);
+00694                                 fail(!abFilled[iBaseStyleIndex]);
+00695                                 /* Based on the specified base style */
+00696                                 *pStyle = atStyleInfo[iBaseStyleIndex];
+00697                                 pStyle->usIstd = ISTD_INVALID;
+00698                                 *pFont = atFontInfo[iBaseStyleIndex];
+00699                         }
+00700                         abFilled[iIndex] = TRUE;
+00701                         iCounter++;
+00702                         /* STD */
+00703                         usTmp = usGetWord(tOffset + 6, aucBuffer);
+00704                         usUpxCount = usTmp % 16;
+00705                         pStyle->usIstdNext = usTmp / 16;
+00706                         NO_DBG_DEC(usUpxCount);
+00707                         tPos = 2 + tStdBaseInFile;
+00708                         NO_DBG_DEC(tPos);
+00709                         tNameLen = (size_t)usGetWord(tOffset + tPos, aucBuffer);
+00710                         NO_DBG_DEC(tNameLen);
+00711                         tNameLen *= 2;  /* From Unicode characters to bytes */
+00712                         NO_DBG_UNICODE_N(aucBuffer + tOffset + tPos + 2,
+00713                                         tNameLen);
+00714                         tNameLen += 2;  /* Include the Unicode NULL character */
+00715                         tPos += 2 + tNameLen;
+00716                         if (odd(tPos)) {
+00717                                 tPos++;
+00718                         }
+00719                         NO_DBG_DEC(tPos);
+00720                         if (tPos >= tStdLen) {
+00721                                 continue;
+00722                         }
+00723                         tUpxLen = (size_t)usGetWord(tOffset + tPos, aucBuffer);
+00724                         NO_DBG_DEC(tUpxLen);
+00725                         if (tPos + tUpxLen > tStdLen) {
+00726                                 /* UPX length too large to be a record */
+00727                                 DBG_DEC_C(tPos + tUpxLen > tStdLen,
+00728                                                 tPos + tUpxLen);
+00729                                 continue;
+00730                         }
+00731                         if (usStyleType == SGC_PAP && usUpxCount >= 1) {
+00732                                 if (tUpxLen >= 2) {
+00733                                         NO_DBG_PRINT_BLOCK(
+00734                                                 aucBuffer + tOffset + tPos + 2,
+00735                                                 tUpxLen);
+00736                                         pStyle->usIstd = usGetWord(
+00737                                                 tOffset + tPos + 2, aucBuffer);
+00738                                         NO_DBG_DEC(pStyle->usIstd);
+00739                                         NO_DBG_DEC(pStyle->usIstdNext);
+00740                                         vGet8StyleInfo(0,
+00741                                                 aucBuffer + tOffset + tPos + 4,
+00742                                                 tUpxLen - 2, pStyle);
+00743                                         NO_DBG_DEC(pStyle->sLeftIndent);
+00744                                         NO_DBG_DEC(pStyle->sRightIndent);
+00745                                         NO_DBG_HEX(pStyle->ucAlignment);
+00746                                 }
+00747                                 tPos += 2 + tUpxLen;
+00748                                 if (odd(tPos)) {
+00749                                         tPos++;
+00750                                 }
+00751                                 NO_DBG_DEC(tPos);
+00752                                 tUpxLen = (size_t)usGetWord(
+00753                                                 tOffset + tPos, aucBuffer);
+00754                                 NO_DBG_DEC(tUpxLen);
+00755                         }
+00756                         if (tUpxLen == 0 || tPos + tUpxLen > tStdLen) {
+00757                                 /* Too small or too large to be a record */
+00758                                 DBG_DEC_C(tPos + tUpxLen > tStdLen,
+00759                                                         tPos + tUpxLen);
+00760                                 continue;
+00761                         }
+00762                         if ((usStyleType == SGC_PAP && usUpxCount >= 2) ||
+00763                             (usStyleType == SGC_CHP && usUpxCount >= 1)) {
+00764                                 NO_DBG_PRINT_BLOCK(
+00765                                                 aucBuffer + tOffset + tPos + 2,
+00766                                                 tUpxLen);
+00767                                 vGet8FontInfo(0, ISTD_INVALID,
+00768                                                 aucBuffer + tOffset + tPos + 2,
+00769                                                 (int)tUpxLen, pFont);
+00770                                 NO_DBG_DEC(pFont->usFontSize);
+00771                                 NO_DBG_DEC(pFont->ucFontcolor);
+00772                                 NO_DBG_HEX(pFont->usFontStyle);
+00773                         }
+00774                 }
+00775                 NO_DBG_DEC(iCounter);
+00776         } while (iCounter > 0);
+00777 
+00778         /* Fill records that are still empty */
+00779         for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00780                 if (!abFilled[iIndex]) {
+00781                         NO_DBG_DEC(iIndex);
+00782                         vGetDefaultStyle(&atStyleInfo[iIndex]);
+00783                         vGetDefaultFont(&atFontInfo[iIndex],
+00784                                         usFtcStandardChpStsh);
+00785                 }
+00786         }
+00787 
+00788         /* Clean up before you leave */
+00789         abFilled = xfree(abFilled);
+00790         aucBuffer = xfree(aucBuffer);
+00791 } /* end of vGet8Stylesheet */
+00792 
+00793 /*
+00794  * vFillStyleFromStylesheet - fill a style struct with stylesheet info
+00795  */
+00796 void
+00797 vFillStyleFromStylesheet(USHORT usIstd, style_block_type *pStyle)
+00798 {
+00799         int     iIndex;
+00800 
+00801         fail(pStyle == NULL);
+00802 
+00803         if (usIstd != ISTD_INVALID && usIstd != STI_NIL && usIstd != STI_USER) {
+00804                 for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00805                         if (atStyleInfo[iIndex].usIstd == usIstd) {
+00806                                 /* Right index found; return style */
+00807                                 *pStyle = atStyleInfo[iIndex];
+00808                                 return;
+00809                         }
+00810                 }
+00811         }
+00812 
+00813         vGetDefaultStyle(pStyle);
+00814         pStyle->usIstd = usIstd;
+00815 } /* end of vFillStyleFromStylesheet */
+00816 
+00817 /*
+00818  * vFillFontFromStylesheet - fill a font struct with stylesheet info
+00819  */
+00820 void
+00821 vFillFontFromStylesheet(USHORT usIstd, font_block_type *pFont)
+00822 {
+00823         int     iIndex;
+00824 
+00825         fail(pFont == NULL);
+00826 
+00827         if (usIstd != ISTD_INVALID && usIstd != STI_NIL && usIstd != STI_USER) {
+00828                 for (iIndex = 0; iIndex < (int)tStdCount; iIndex++) {
+00829                         if (atStyleInfo[iIndex].usIstd == usIstd) {
+00830                                 /* Right index found; return font */
+00831                                 *pFont = atFontInfo[iIndex];
+00832                                 return;
+00833                         }
+00834                 }
+00835         }
+00836 
+00837         vGetDefaultFont(pFont, 0);
+00838 } /* end of vFillFontFromStylesheet */
+