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

00001 /*
00002  * prop2.c
00003  * Copyright (C) 2002-2005 A.J. van Os; Released under GPL
00004  *
00005  * Description:
00006  * Read the property information from a WinWord 1 or 2 file
00007  */
00008 
00009 #include <string.h>
00010 #include "antiword.h"
00011 
00012 
00013 #define MAX_FILESIZE            0x2000000UL     /* 32 Mb */
00014 
00015 /*
00016  * iGet2InfoLength - the length of the information for WinWord 1/2 files
00017  */
00018 static int
00019 iGet2InfoLength(int iByteNbr, const UCHAR *aucGrpprl)
00020 {
00021         int     iTmp, iDel, iAdd;
00022 
00023         switch (ucGetByte(iByteNbr, aucGrpprl)) {
00024         case   3: case  15: case  78: case 152: case 154: case 155:
00025                 return 2 + (int)ucGetByte(iByteNbr + 1, aucGrpprl);
00026         case  16: case  17: case  18: case  19: case  21: case  22: case  26:
00027         case  27: case  28: case  30: case  31: case  32: case  33: case  34:
00028         case  35: case  36: case  38: case  39: case  40: case  41: case  42:
00029         case  43: case  45: case  46: case  47: case  48: case  49: case  68:
00030         case  71: case  72: case  82: case  83: case  96: case  97: case  98:
00031         case  99: case 115: case 116: case 119: case 120: case 123: case 124:
00032         case 129: case 130: case 131: case 132: case 135: case 136: case 139:
00033         case 140: case 141: case 142: case 143: case 144: case 145: case 146:
00034         case 147: case 148: case 153: case 159: case 161: case 162:
00035                 return 1 + 2;
00036         case  23:
00037                 iTmp = (int)ucGetByte(iByteNbr + 1, aucGrpprl);
00038                 if (iTmp == 255) {
00039                         iDel = (int)ucGetByte(iByteNbr + 2, aucGrpprl);
00040                         iAdd = (int)ucGetByte(
00041                                         iByteNbr + 3 + iDel * 4, aucGrpprl);
00042                         iTmp = 2 + iDel * 4 + iAdd * 3;
00043                 }
00044                 return 2 + iTmp;
00045         case  70:
00046                 return 1 + 3;
00047         case  95:
00048                 return 1 + 13;
00049         case 157: case 163:
00050                 return 1 + 5;
00051         case 158: case 160: case 164:
00052                 return 1 + 4;
00053         default:
00054                 return 1 + 1;
00055         }
00056 } /* end of iGet2InfoLength */
00057 
00058 /*
00059  * Build the lists with Document Property Information for WinWord 1/2 files
00060  */
00061 void
00062 vGet2DopInfo(FILE *pFile, const UCHAR *aucHeader)
00063 {
00064         document_block_type     tDocument;
00065         UCHAR   *aucBuffer;
00066         ULONG   ulBeginDocpInfo, ulTmp;
00067         size_t  tDocpInfoLen;
00068         USHORT  usTmp;
00069 
00070         ulBeginDocpInfo = ulGetLong(0x112, aucHeader); /* fcDop */
00071         DBG_HEX(ulBeginDocpInfo);
00072         tDocpInfoLen = (size_t)usGetWord(0x116, aucHeader); /* cbDop */
00073         DBG_DEC(tDocpInfoLen);
00074         if (tDocpInfoLen < 28) {
00075                 DBG_MSG("No Document information");
00076                 return;
00077         }
00078 
00079         aucBuffer = xmalloc(tDocpInfoLen);
00080         if (!bReadBytes(aucBuffer, tDocpInfoLen, ulBeginDocpInfo, pFile)) {
00081                 aucBuffer = xfree(aucBuffer);
00082                 return;
00083         }
00084 
00085         usTmp = usGetWord(0x00, aucBuffer);
00086         tDocument.ucHdrFtrSpecification = (UCHAR)(usTmp >> 8); /* grpfIhdt */
00087         tDocument.usDefaultTabWidth = usGetWord(0x0a, aucBuffer); /* dxaTab */
00088         ulTmp = ulGetLong(0x14, aucBuffer); /* dttmCreated */
00089         tDocument.tCreateDate = tConvertDTTM(ulTmp);
00090         ulTmp = ulGetLong(0x18, aucBuffer); /* dttmRevised */
00091         tDocument.tRevisedDate = tConvertDTTM(ulTmp);
00092         vCreateDocumentInfoList(&tDocument);
00093 
00094         aucBuffer = xfree(aucBuffer);
00095 } /* end of vGet2DopInfo */
00096 
00097 /*
00098  * Fill the section information block with information
00099  * from a WinWord 1/2 file.
00100  */
00101 static void
00102 vGet2SectionInfo(const UCHAR *aucGrpprl, size_t tBytes,
00103                 section_block_type *pSection)
00104 {
00105         int     iFodoOff, iInfoLen;
00106         USHORT  usCcol;
00107         UCHAR   ucTmp;
00108 
00109         fail(aucGrpprl == NULL || pSection == NULL);
00110 
00111         iFodoOff = 0;
00112         while (tBytes >= (size_t)iFodoOff + 1) {
00113                 switch (ucGetByte(iFodoOff, aucGrpprl)) {
00114                 case 117:       /* bkc */
00115                         ucTmp = ucGetByte(iFodoOff + 1, aucGrpprl);
00116                         DBG_DEC(ucTmp);
00117                         pSection->bNewPage = ucTmp != 0 && ucTmp != 1;
00118                         break;
00119                 case 119:       /* ccolM1 */
00120                         usCcol = 1 + usGetWord(iFodoOff + 1, aucGrpprl);
00121                         DBG_DEC(usCcol);
00122                         break;
00123                 case 128:       /* grpfIhdt */
00124                         pSection->ucHdrFtrSpecification =
00125                                         ucGetByte(iFodoOff + 1, aucGrpprl);
00126                         break;
00127                 default:
00128                         break;
00129                 }
00130                 iInfoLen = iGet2InfoLength(iFodoOff, aucGrpprl);
00131                 fail(iInfoLen <= 0);
00132                 iFodoOff += iInfoLen;
00133         }
00134 } /* end of vGet2SectionInfo */
00135 
00136 /*
00137  * Build the lists with Section Property Information for WinWord 1/2 files
00138  */
00139 void
00140 vGet2SepInfo(FILE *pFile, const UCHAR *aucHeader)
00141 {
00142         section_block_type      tSection;
00143         ULONG   *aulSectPage, *aulCharPos;
00144         UCHAR   *aucBuffer, *aucFpage;
00145         ULONG   ulBeginOfText, ulTextOffset, ulBeginSectInfo;
00146         size_t  tSectInfoLen, tIndex, tOffset, tLen, tBytes;
00147         UCHAR   aucTmp[1];
00148 
00149         fail(pFile == NULL || aucHeader == NULL);
00150 
00151         ulBeginOfText = ulGetLong(0x18, aucHeader); /* fcMin */
00152         NO_DBG_HEX(ulBeginOfText);
00153         ulBeginSectInfo = ulGetLong(0x7c, aucHeader); /* fcPlcfsed */
00154         DBG_HEX(ulBeginSectInfo);
00155         tSectInfoLen = (size_t)usGetWord(0x80, aucHeader); /* cbPlcfsed */
00156         DBG_DEC(tSectInfoLen);
00157         if (tSectInfoLen < 4) {
00158                 DBG_DEC(tSectInfoLen);
00159                 return;
00160         }
00161 
00162         aucBuffer = xmalloc(tSectInfoLen);
00163         if (!bReadBytes(aucBuffer, tSectInfoLen, ulBeginSectInfo, pFile)) {
00164                 aucBuffer = xfree(aucBuffer);
00165                 return;
00166         }
00167         NO_DBG_PRINT_BLOCK(aucBuffer, tSectInfoLen);
00168 
00169         /* Read the Section Descriptors */
00170         tLen = (tSectInfoLen - 4) / 10;
00171         /* Save the section offsets */
00172         aulCharPos = xcalloc(tLen, sizeof(ULONG));
00173         for (tIndex = 0, tOffset = 0;
00174              tIndex < tLen;
00175              tIndex++, tOffset += 4) {
00176                 ulTextOffset = ulGetLong(tOffset, aucBuffer);
00177                 NO_DBG_HEX(ulTextOffset);
00178                 aulCharPos[tIndex] = ulBeginOfText + ulTextOffset;
00179                 NO_DBG_HEX(aulCharPos[tIndex]);
00180         }
00181         /* Save the Sepx offsets */
00182         aulSectPage = xcalloc(tLen, sizeof(ULONG));
00183         for (tIndex = 0, tOffset = (tLen + 1) * 4;
00184              tIndex < tLen;
00185              tIndex++, tOffset += 6) {
00186                 aulSectPage[tIndex] = ulGetLong(tOffset + 2, aucBuffer);
00187                 NO_DBG_HEX(aulSectPage[tIndex]); /* fcSepx */
00188         }
00189         aucBuffer = xfree(aucBuffer);
00190 
00191         /* Read the Section Properties */
00192         for (tIndex = 0; tIndex < tLen; tIndex++) {
00193                 if (aulSectPage[tIndex] == FC_INVALID) {
00194                         vDefault2SectionInfoList(aulCharPos[tIndex]);
00195                         continue;
00196                 }
00197                 /* Get the number of bytes to read */
00198                 if (!bReadBytes(aucTmp, 1, aulSectPage[tIndex], pFile)) {
00199                         continue;
00200                 }
00201                 tBytes = 1 + (size_t)ucGetByte(0, aucTmp);
00202                 NO_DBG_DEC(tBytes);
00203                 /* Read the bytes */
00204                 aucFpage = xmalloc(tBytes);
00205                 if (!bReadBytes(aucFpage, tBytes, aulSectPage[tIndex], pFile)) {
00206                         aucFpage = xfree(aucFpage);
00207                         continue;
00208                 }
00209                 NO_DBG_PRINT_BLOCK(aucFpage, tBytes);
00210                 /* Process the bytes */
00211                 vGetDefaultSection(&tSection);
00212                 vGet2SectionInfo(aucFpage + 1, tBytes - 1, &tSection);
00213                 vAdd2SectionInfoList(&tSection, aulCharPos[tIndex]);
00214                 aucFpage = xfree(aucFpage);
00215         }
00216         aulCharPos = xfree(aulCharPos);
00217         aulSectPage = xfree(aulSectPage);
00218 } /* end of vGet2SepInfo */
00219 
00220 /*
00221  * Build the list with Header/Footer Information for WinWord 1/2 files
00222  */
00223 void
00224 vGet2HdrFtrInfo(FILE *pFile, const UCHAR *aucHeader)
00225 {
00226         ULONG   *aulCharPos;
00227         UCHAR   *aucBuffer;
00228         ULONG   ulHdrFtrOffset, ulBeginHdrFtrInfo;
00229         size_t  tHdrFtrInfoLen, tIndex, tOffset, tLen;
00230 
00231         fail(pFile == NULL || aucHeader == NULL);
00232 
00233         ulBeginHdrFtrInfo = ulGetLong(0x9a, aucHeader); /* fcPlcfhdd */
00234         NO_DBG_HEX(ulBeginHdrFtrInfo);
00235         tHdrFtrInfoLen = (size_t)usGetWord(0x9e, aucHeader); /* cbPlcfhdd */
00236         NO_DBG_DEC(tHdrFtrInfoLen);
00237         if (tHdrFtrInfoLen < 8) {
00238                 DBG_DEC_C(tHdrFtrInfoLen != 0, tHdrFtrInfoLen);
00239                 return;
00240         }
00241 
00242         aucBuffer = xmalloc(tHdrFtrInfoLen);
00243         if (!bReadBytes(aucBuffer, tHdrFtrInfoLen, ulBeginHdrFtrInfo, pFile)) {
00244                 aucBuffer = xfree(aucBuffer);
00245                 return;
00246         }
00247         NO_DBG_PRINT_BLOCK(aucBuffer, tHdrFtrInfoLen);
00248 
00249         tLen = tHdrFtrInfoLen / 4 - 1;
00250         /* Save the header/footer offsets */
00251         aulCharPos = xcalloc(tLen, sizeof(ULONG));
00252         for (tIndex = 0, tOffset = 0;
00253              tIndex < tLen;
00254              tIndex++, tOffset += 4) {
00255                 ulHdrFtrOffset = ulGetLong(tOffset, aucBuffer);
00256                 NO_DBG_HEX(ulHdrFtrOffset);
00257                 aulCharPos[tIndex] = ulHdrFtrOffset2CharPos(ulHdrFtrOffset);
00258                 NO_DBG_HEX(aulCharPos[tIndex]);
00259         }
00260         vCreat2HdrFtrInfoList(aulCharPos, tLen);
00261         aulCharPos = xfree(aulCharPos);
00262         aucBuffer = xfree(aucBuffer);
00263 } /* end of vGet2HdrFtrInfo */
00264 
00265 /*
00266  * Translate the rowinfo to a member of the row_info enumeration
00267  */
00268 row_info_enum
00269 eGet2RowInfo(int iFodo,
00270         const UCHAR *aucGrpprl, int iBytes, row_block_type *pRow)
00271 {
00272         int     iFodoOff, iInfoLen;
00273         int     iIndex, iSize, iCol;
00274         int     iPosCurr, iPosPrev;
00275         USHORT  usTmp;
00276         BOOL    bFound24_0, bFound24_1, bFound25_0, bFound25_1, bFound154;
00277 
00278         fail(iFodo < 0 || aucGrpprl == NULL || pRow == NULL);
00279 
00280         iFodoOff = 0;
00281         bFound24_0 = FALSE;
00282         bFound24_1 = FALSE;
00283         bFound25_0 = FALSE;
00284         bFound25_1 = FALSE;
00285         bFound154 = FALSE;
00286         while (iBytes >= iFodoOff + 1) {
00287                 iInfoLen = 0;
00288                 switch (ucGetByte(iFodo + iFodoOff, aucGrpprl)) {
00289                 case  24:       /* fIntable */
00290                         if (odd(ucGetByte(iFodo + iFodoOff + 1, aucGrpprl))) {
00291                                 bFound24_1 = TRUE;
00292                         } else {
00293                                 bFound24_0 = TRUE;
00294                         }
00295                         break;
00296                 case  25:       /* fTtp */
00297                         if (odd(ucGetByte(iFodo + iFodoOff + 1, aucGrpprl))) {
00298                                 bFound25_1 = TRUE;
00299                         } else {
00300                                 bFound25_0 = TRUE;
00301                         }
00302                         break;
00303                 case 30:        /* brcTop10 */
00304                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00305                         usTmp &= 0x01ff;
00306                         NO_DBG_DEC(usTmp >> 6);
00307                         if (usTmp == 0) {
00308                                 pRow->ucBorderInfo &= ~TABLE_BORDER_TOP;
00309                         } else {
00310                                 pRow->ucBorderInfo |= TABLE_BORDER_TOP;
00311                         }
00312                         break;
00313                 case 31:        /* brcLeft10 */
00314                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00315                         usTmp &= 0x01ff;
00316                         NO_DBG_DEC(usTmp >> 6);
00317                         if (usTmp == 0) {
00318                                 pRow->ucBorderInfo &= ~TABLE_BORDER_LEFT;
00319                         } else {
00320                                 pRow->ucBorderInfo |= TABLE_BORDER_LEFT;
00321                         }
00322                         break;
00323                 case 32:        /* brcBottom10 */
00324                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00325                         usTmp &= 0x01ff;
00326                         NO_DBG_DEC(usTmp >> 6);
00327                         if (usTmp == 0) {
00328                                 pRow->ucBorderInfo &= ~TABLE_BORDER_BOTTOM;
00329                         } else {
00330                                 pRow->ucBorderInfo |= TABLE_BORDER_BOTTOM;
00331                         }
00332                         break;
00333                 case 33:        /* brcRight10 */
00334                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00335                         usTmp &= 0x01ff;
00336                         NO_DBG_DEC(usTmp >> 6);
00337                         if (usTmp == 0) {
00338                                 pRow->ucBorderInfo &= ~TABLE_BORDER_RIGHT;
00339                         } else {
00340                                 pRow->ucBorderInfo |= TABLE_BORDER_RIGHT;
00341                         }
00342                         break;
00343                 case 38:        /* brcTop */
00344                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00345                         usTmp &= 0x0018;
00346                         NO_DBG_DEC(usTmp >> 3);
00347                         if (usTmp == 0) {
00348                                 pRow->ucBorderInfo &= ~TABLE_BORDER_TOP;
00349                         } else {
00350                                 pRow->ucBorderInfo |= TABLE_BORDER_TOP;
00351                         }
00352                         break;
00353                 case 39:        /* brcLeft */
00354                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00355                         usTmp &= 0x0018;
00356                         NO_DBG_DEC(usTmp >> 3);
00357                         if (usTmp == 0) {
00358                                 pRow->ucBorderInfo &= ~TABLE_BORDER_LEFT;
00359                         } else {
00360                                 pRow->ucBorderInfo |= TABLE_BORDER_LEFT;
00361                         }
00362                         break;
00363                 case 40:        /* brcBottom */
00364                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00365                         usTmp &= 0x0018;
00366                         NO_DBG_DEC(usTmp >> 3);
00367                         if (usTmp == 0) {
00368                                 pRow->ucBorderInfo &= ~TABLE_BORDER_BOTTOM;
00369                         } else {
00370                                 pRow->ucBorderInfo |= TABLE_BORDER_BOTTOM;
00371                         }
00372                         break;
00373                 case 41:        /* brcRight */
00374                         usTmp = usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00375                         usTmp &= 0x0018;
00376                         NO_DBG_DEC(usTmp >> 3);
00377                         if (usTmp == 0) {
00378                                 pRow->ucBorderInfo &= ~TABLE_BORDER_RIGHT;
00379                         } else {
00380                                 pRow->ucBorderInfo |= TABLE_BORDER_RIGHT;
00381                         }
00382                         break;
00383                 case 152:       /* cDefTable10 */
00384                 case 154:       /* cDefTable */
00385                         iSize = (int)usGetWord(iFodo + iFodoOff + 1, aucGrpprl);
00386                         if (iSize < 6 || iBytes < iFodoOff + 7) {
00387                                 DBG_DEC(iSize);
00388                                 DBG_DEC(iBytes);
00389                                 DBG_DEC(iFodoOff);
00390                                 iInfoLen = 1;
00391                                 break;
00392                         }
00393                         iCol = (int)ucGetByte(iFodo + iFodoOff + 3, aucGrpprl);
00394                         if (iCol < 1 ||
00395                             iBytes < iFodoOff + 3 + (iCol + 1) * 2) {
00396                                 DBG_DEC(iCol);
00397                                 DBG_DEC(iBytes);
00398                                 DBG_DEC(iFodoOff);
00399                                 DBG_DEC(ucGetByte(iFodo + iFodoOff, aucGrpprl));
00400                                 iInfoLen = 1;
00401                                 break;
00402                         }
00403                         if (iCol >= (int)elementsof(pRow->asColumnWidth)) {
00404                                 DBG_DEC(iCol);
00405                                 werr(1, "The number of columns is corrupt");
00406                         }
00407                         pRow->ucNumberOfColumns = (UCHAR)iCol;
00408                         iPosPrev = (int)(short)usGetWord(
00409                                         iFodo + iFodoOff + 4,
00410                                         aucGrpprl);
00411                         for (iIndex = 0; iIndex < iCol; iIndex++) {
00412                                 iPosCurr = (int)(short)usGetWord(
00413                                         iFodo + iFodoOff + 6 + iIndex * 2,
00414                                         aucGrpprl);
00415                                 pRow->asColumnWidth[iIndex] =
00416                                                 (short)(iPosCurr - iPosPrev);
00417                                 iPosPrev = iPosCurr;
00418                         }
00419                         bFound154 = TRUE;
00420                         break;
00421                 default:
00422                         break;
00423                 }
00424                 if (iInfoLen <= 0) {
00425                         iInfoLen =
00426                                 iGet2InfoLength(iFodo + iFodoOff, aucGrpprl);
00427                         fail(iInfoLen <= 0);
00428                 }
00429                 iFodoOff += iInfoLen;
00430         }
00431         if (bFound24_1 && bFound25_1 && bFound154) {
00432                 return found_end_of_row;
00433         }
00434         if (bFound24_0 && bFound25_0 && !bFound154) {
00435                 return found_not_end_of_row;
00436         }
00437         if (bFound24_1) {
00438                 return found_a_cell;
00439         }
00440         if (bFound24_0) {
00441                 return found_not_a_cell;
00442         }
00443         return found_nothing;
00444 } /* end of eGet2RowInfo */
00445 
00446 /*
00447  * Fill the style information block with information
00448  * from a WinWord 1/2 file.
00449  */
00450 void
00451 vGet2StyleInfo(int iFodo,
00452         const UCHAR *aucGrpprl, int iBytes, style_block_type *pStyle)
00453 {
00454         int     iFodoOff, iInfoLen;
00455         int     iTmp, iDel, iAdd;
00456         short   sTmp;
00457         UCHAR   ucTmp;
00458 
00459         fail(iFodo < 0 || aucGrpprl == NULL || pStyle == NULL);
00460 
00461         NO_DBG_DEC(pStyle->usIstd);
00462 
00463         iFodoOff = 0;
00464         while (iBytes >= iFodoOff + 1) {
00465                 iInfoLen = 0;
00466                 switch (ucGetByte(iFodo + iFodoOff, aucGrpprl)) {
00467                 case   2:       /* istd */
00468                         sTmp = (short)ucGetByte(
00469                                         iFodo + iFodoOff + 1, aucGrpprl);
00470                         NO_DBG_DEC(sTmp);
00471                         break;
00472                 case   5:       /* jc */
00473                         pStyle->ucAlignment = ucGetByte(
00474                                         iFodo + iFodoOff + 1, aucGrpprl);
00475                         break;
00476                 case  12:       /* nfcSeqNumb */
00477                         pStyle->ucNFC = ucGetByte(
00478                                         iFodo + iFodoOff + 1, aucGrpprl);
00479                         break;
00480                 case  13:       /* nLvlAnm */
00481                         ucTmp = ucGetByte(iFodo + iFodoOff + 1, aucGrpprl);
00482                         pStyle->ucNumLevel = ucTmp;
00483                         pStyle->bNumPause =
00484                                 eGetNumType(ucTmp) == level_type_pause;
00485                         break;
00486                 case  15:       /* ChgTabsPapx */
00487                 case  23:       /* ChgTabs */
00488                         iTmp = (int)ucGetByte(iFodo + iFodoOff + 1, aucGrpprl);
00489                         if (iTmp < 2) {
00490                                 iInfoLen = 1;
00491                                 break;
00492                         }
00493                         NO_DBG_DEC(iTmp);
00494                         iDel = (int)ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
00495                         if (iTmp < 2 + 2 * iDel) {
00496                                 iInfoLen = 1;
00497                                 break;
00498                         }
00499                         NO_DBG_DEC(iDel);
00500                         iAdd = (int)ucGetByte(
00501                                 iFodo + iFodoOff + 3 + 2 * iDel, aucGrpprl);
00502                         if (iTmp < 2 + 2 * iDel + 2 * iAdd) {
00503                                 iInfoLen = 1;
00504                                 break;
00505                         }
00506                         NO_DBG_DEC(iAdd);
00507                         break;
00508                 case  16:       /* dxaRight */
00509                         pStyle->sRightIndent = (short)usGetWord(
00510                                         iFodo + iFodoOff + 1, aucGrpprl);
00511                         NO_DBG_DEC(pStyle->sRightIndent);
00512                         break;
00513                 case  17:       /* dxaLeft */
00514                         pStyle->sLeftIndent = (short)usGetWord(
00515                                         iFodo + iFodoOff + 1, aucGrpprl);
00516                         NO_DBG_DEC(pStyle->sLeftIndent);
00517                         break;
00518                 case  18:       /* Nest dxaLeft */
00519                         sTmp = (short)usGetWord(
00520                                         iFodo + iFodoOff + 1, aucGrpprl);
00521                         pStyle->sLeftIndent += sTmp;
00522                         if (pStyle->sLeftIndent < 0) {
00523                                 pStyle->sLeftIndent = 0;
00524                         }
00525                         NO_DBG_DEC(sTmp);
00526                         NO_DBG_DEC(pStyle->sLeftIndent);
00527                         break;
00528                 case  19:       /* dxaLeft1 */
00529                         pStyle->sLeftIndent1 = (short)usGetWord(
00530                                         iFodo + iFodoOff + 1, aucGrpprl);
00531                         NO_DBG_DEC(pStyle->sLeftIndent1);
00532                         break;
00533                 case  21:       /* dyaBefore */
00534                         pStyle->usBeforeIndent = usGetWord(
00535                                         iFodo + iFodoOff + 1, aucGrpprl);
00536                         NO_DBG_DEC(pStyle->usBeforeIndent);
00537                         break;
00538                 case  22:       /* dyaAfter */
00539                         pStyle->usAfterIndent = usGetWord(
00540                                         iFodo + iFodoOff + 1, aucGrpprl);
00541                         NO_DBG_DEC(pStyle->usAfterIndent);
00542                         break;
00543                 default:
00544                         break;
00545                 }
00546                 if (iInfoLen <= 0) {
00547                         iInfoLen =
00548                                 iGet2InfoLength(iFodo + iFodoOff, aucGrpprl);
00549                         fail(iInfoLen <= 0);
00550                 }
00551                 iFodoOff += iInfoLen;
00552         }
00553 } /* end of vGet2StyleInfo */
00554 
00555 /*
00556  * Build the lists with Paragraph Information for WinWord 1/2 files
00557  */
00558 void
00559 vGet2PapInfo(FILE *pFile, const UCHAR *aucHeader)
00560 {
00561         row_block_type          tRow;
00562         style_block_type        tStyle;
00563         USHORT  *ausParfPage;
00564         UCHAR   *aucBuffer;
00565         ULONG   ulCharPos, ulCharPosFirst, ulCharPosLast;
00566         ULONG   ulBeginParfInfo;
00567         size_t  tParfInfoLen, tParfPageNum, tOffset, tSize, tLenOld, tLen;
00568         int     iIndex, iIndex2, iRun, iFodo, iLen;
00569         row_info_enum   eRowInfo;
00570         USHORT  usParfFirstPage, usCount, usIstd;
00571         UCHAR   ucStc;
00572         UCHAR   aucFpage[BIG_BLOCK_SIZE];
00573 
00574         fail(pFile == NULL || aucHeader == NULL);
00575 
00576         ulBeginParfInfo = ulGetLong(0xa6, aucHeader); /* fcPlcfbtePapx */
00577         NO_DBG_HEX(ulBeginParfInfo);
00578         tParfInfoLen = (size_t)usGetWord(0xaa, aucHeader); /* cbPlcfbtePapx */
00579         NO_DBG_DEC(tParfInfoLen);
00580         if (tParfInfoLen < 4) {
00581                 DBG_DEC(tParfInfoLen);
00582                 return;
00583         }
00584 
00585         aucBuffer = xmalloc(tParfInfoLen);
00586         if (!bReadBytes(aucBuffer, tParfInfoLen, ulBeginParfInfo, pFile)) {
00587                 aucBuffer = xfree(aucBuffer);
00588                 return;
00589         }
00590         NO_DBG_PRINT_BLOCK(aucBuffer, tParfInfoLen);
00591 
00592         tLen = (tParfInfoLen - 4) / 6;
00593         ausParfPage = xcalloc(tLen, sizeof(USHORT));
00594         for (iIndex = 0, tOffset = (tLen + 1) * 4;
00595              iIndex < (int)tLen;
00596              iIndex++, tOffset += 2) {
00597                 ausParfPage[iIndex] = usGetWord(tOffset, aucBuffer);
00598                 NO_DBG_DEC(ausParfPage[iIndex]);
00599         }
00600         DBG_HEX(ulGetLong(0, aucBuffer));
00601         aucBuffer = xfree(aucBuffer);
00602         tParfPageNum = (size_t)usGetWord(0x144, aucHeader); /* cpnBtePap */
00603         DBG_DEC(tParfPageNum);
00604         if (tLen < tParfPageNum) {
00605                 /* Replace ParfPage by a longer version */
00606                 tLenOld = tLen;
00607                 usParfFirstPage = usGetWord(0x140, aucHeader); /* pnPapFirst */
00608                 DBG_DEC(usParfFirstPage);
00609                 tLen += tParfPageNum - 1;
00610                 tSize = tLen * sizeof(USHORT);
00611                 ausParfPage = xrealloc(ausParfPage, tSize);
00612                 /* Add new values */
00613                 usCount = usParfFirstPage + 1;
00614                 for (iIndex = (int)tLenOld; iIndex < (int)tLen; iIndex++) {
00615                         ausParfPage[iIndex] = usCount;
00616                         NO_DBG_DEC(ausParfPage[iIndex]);
00617                         usCount++;
00618                 }
00619         }
00620 
00621         (void)memset(&tRow, 0, sizeof(tRow));
00622         ulCharPosFirst = CP_INVALID;
00623         for (iIndex = 0; iIndex < (int)tLen; iIndex++) {
00624                 if (!bReadBytes(aucFpage, BIG_BLOCK_SIZE,
00625                                 (ULONG)ausParfPage[iIndex] * BIG_BLOCK_SIZE,
00626                                 pFile)) {
00627                         break;
00628                 }
00629                 NO_DBG_PRINT_BLOCK(aucFpage, BIG_BLOCK_SIZE);
00630                 iRun = (int)ucGetByte(0x1ff, aucFpage);
00631                 NO_DBG_DEC(iRun);
00632                 for (iIndex2 = 0; iIndex2 < iRun; iIndex2++) {
00633                         if ((iRun + 1) * 4 + iIndex2 * 1 >= BIG_BLOCK_SIZE) {
00634                                 break;
00635                         }
00636                         NO_DBG_HEX(ulGetLong(iIndex2 * 4, aucFpage));
00637                         iFodo = 2 * (int)ucGetByte(
00638                                 (iRun + 1) * 4 + iIndex2 * 1, aucFpage);
00639                         if (iFodo <= 0) {
00640                                 continue;
00641                         }
00642 
00643                         iLen = 2 * (int)ucGetByte(iFodo, aucFpage);
00644 
00645                         ucStc = ucGetByte(iFodo + 1, aucFpage);
00646                         usIstd = usStc2istd(ucStc);
00647 
00648                         vFillStyleFromStylesheet(usIstd, &tStyle);
00649                         vGet2StyleInfo(iFodo, aucFpage + 8, iLen - 8, &tStyle);
00650                         ulCharPos = ulGetLong(iIndex2 * 4, aucFpage);
00651                         NO_DBG_HEX(ulCharPos);
00652                         tStyle.ulFileOffset = ulCharPos;
00653                         vAdd2StyleInfoList(&tStyle);
00654 
00655                         eRowInfo = eGet2RowInfo(iFodo,
00656                                         aucFpage + 8, iLen - 8, &tRow);
00657 
00658                         switch(eRowInfo) {
00659                         case found_a_cell:
00660                                 if (ulCharPosFirst != CP_INVALID) {
00661                                         break;
00662                                 }
00663                                 ulCharPosFirst = ulGetLong(
00664                                                 iIndex2 * 4, aucFpage);
00665                                 NO_DBG_HEX(ulCharPosFirst);
00666                                 tRow.ulCharPosStart = ulCharPosFirst;
00667                                 tRow.ulFileOffsetStart = ulCharPosFirst;
00668                                 break;
00669                         case found_end_of_row:
00670                                 ulCharPosLast = ulGetLong(
00671                                                 iIndex2 * 4, aucFpage);
00672                                 NO_DBG_HEX(ulCharPosLast);
00673                                 tRow.ulCharPosEnd = ulCharPosLast;
00674                                 /* Add 1 for compatiblity with Word 6 and up */
00675                                 tRow.ulFileOffsetEnd = ulCharPosLast + 1;
00676                                 vAdd2RowInfoList(&tRow);
00677                                 (void)memset(&tRow, 0, sizeof(tRow));
00678                                 ulCharPosFirst = CP_INVALID;
00679                                 break;
00680                         case found_nothing:
00681                                 break;
00682                         default:
00683                                 DBG_DEC(eRowInfo);
00684                                 break;
00685                         }
00686                 }
00687         }
00688         ausParfPage = xfree(ausParfPage);
00689 } /* end of vGet2PapInfo */
00690 
00691 /*
00692  * Fill the font information block with information
00693  * from a WinWord 1 file.
00694  */
00695 void
00696 vGet1FontInfo(int iFodo,
00697         const UCHAR *aucGrpprl, size_t tBytes, font_block_type *pFont)
00698 {
00699         BOOL    bIcoChange, bFtcChange, bHpsChange, bKulChange;
00700         USHORT  usTmp;
00701         UCHAR   ucTmp;
00702         UCHAR   aucChpx[12];
00703 
00704         fail(iFodo < 0 || aucGrpprl == NULL || pFont == NULL);
00705 
00706         if (tBytes > sizeof(aucChpx)) {
00707                 NO_DBG_PRINT_BLOCK(aucGrpprl + iFodo, tBytes);
00708                 return;
00709         }
00710 
00711         /* Build the CHPX structure */
00712         (void)memset(aucChpx, 0, sizeof(aucChpx));
00713         (void)memcpy(aucChpx, aucGrpprl + iFodo, min(tBytes, sizeof(aucChpx)));
00714 
00715         usTmp = usGetWord(0, aucChpx);
00716         if ((usTmp & BIT(0)) != 0) {
00717                 pFont->usFontStyle ^= FONT_BOLD;
00718         }
00719         if ((usTmp & BIT(1)) != 0) {
00720                 pFont->usFontStyle ^= FONT_ITALIC;
00721         }
00722         if ((usTmp & BIT(2)) != 0) {
00723                 pFont->usFontStyle ^= FONT_STRIKE;
00724         }
00725         if ((usTmp & BIT(5)) != 0) {
00726                 pFont->usFontStyle ^= FONT_SMALL_CAPITALS;
00727         }
00728         if ((usTmp & BIT(6)) != 0) {
00729                 pFont->usFontStyle ^= FONT_CAPITALS;
00730         }
00731         if ((usTmp & BIT(7)) != 0) {
00732                 pFont->usFontStyle ^= FONT_HIDDEN;
00733         }
00734 
00735         ucTmp = ucGetByte(5, aucChpx);
00736         if (ucTmp != 0) {
00737                 if (ucTmp < 128) {
00738                         pFont->usFontStyle |= FONT_SUPERSCRIPT;
00739                         DBG_MSG("Superscript");
00740                 } else {
00741                         pFont->usFontStyle |= FONT_SUBSCRIPT;
00742                         DBG_MSG("Subscript");
00743                 }
00744         }
00745 
00746         bIcoChange = (usTmp & BIT(10)) != 0;
00747         bFtcChange = (usTmp & BIT(11)) != 0;
00748         bHpsChange = (usTmp & BIT(12)) != 0;
00749         bKulChange = (usTmp & BIT(13)) != 0;
00750 
00751         if (bFtcChange) {
00752                 usTmp = usGetWord(2, aucChpx);
00753                 if (usTmp <= (USHORT)UCHAR_MAX) {
00754                         pFont->ucFontNumber = (UCHAR)usTmp;
00755                 } else {
00756                         pFont->ucFontNumber = 0;
00757                 }
00758         }
00759 
00760         if (bHpsChange) {
00761                 pFont->usFontSize = (USHORT)ucGetByte(4, aucChpx);
00762         }
00763 
00764         if (bIcoChange || bKulChange) {
00765                 usTmp = usGetWord(6, aucChpx);
00766                 if (bIcoChange) {
00767                         pFont->ucFontColor = (UCHAR)((usTmp & 0x0f00) >> 8);
00768                         if (pFont->ucFontColor <= 7) {
00769                                 /* Add 1 for compatibility with Word 2 and up */
00770                                 pFont->ucFontColor++;
00771                         } else {
00772                                 DBG_DEC(pFont->ucFontColor);
00773                                 pFont->ucFontColor = 0;
00774                         }
00775                 }
00776                 if (bKulChange) {
00777                         usTmp = (usTmp & 0x7000) >> 12;
00778                         DBG_DEC_C(usTmp > 4, usTmp);
00779                         if (usTmp == 0) {
00780                                 pFont->usFontStyle &= ~FONT_UNDERLINE;
00781                         } else {
00782                                 pFont->usFontStyle |= FONT_UNDERLINE;
00783                         }
00784                 }
00785         }
00786 } /* end of vGet1FontInfo */
00787 
00788 /*
00789  * Fill the font information block with information
00790  * from a WinWord 1/2 file.
00791  */
00792 void
00793 vGet2FontInfo(int iFodo,
00794         const UCHAR *aucGrpprl, size_t tBytes, font_block_type *pFont)
00795 {
00796         BOOL    bIcoChange, bFtcChange, bHpsChange, bKulChange;
00797         USHORT  usTmp;
00798         UCHAR   ucTmp;
00799         UCHAR   aucChpx[18];
00800 
00801         fail(iFodo < 0 || aucGrpprl == NULL || pFont == NULL);
00802 
00803         if (tBytes > sizeof(aucChpx)) {
00804                 NO_DBG_PRINT_BLOCK(aucGrpprl + iFodo, tBytes);
00805                 return;
00806         }
00807 
00808         /* Build the CHPX structure */
00809         (void)memset(aucChpx, 0, sizeof(aucChpx));
00810         (void)memcpy(aucChpx, aucGrpprl + iFodo, min(tBytes, sizeof(aucChpx)));
00811 
00812         usTmp = usGetWord(0, aucChpx);
00813         if ((usTmp & BIT(0)) != 0) {
00814                 pFont->usFontStyle ^= FONT_BOLD;
00815         }
00816         if ((usTmp & BIT(1)) != 0) {
00817                 pFont->usFontStyle ^= FONT_ITALIC;
00818         }
00819         if (usTmp & BIT(3)) {
00820                 pFont->usFontStyle ^= FONT_MARKDEL;
00821         }
00822         if ((usTmp & BIT(5)) != 0) {
00823                 pFont->usFontStyle ^= FONT_SMALL_CAPITALS;
00824         }
00825         if ((usTmp & BIT(6)) != 0) {
00826                 pFont->usFontStyle ^= FONT_CAPITALS;
00827         }
00828         if ((usTmp & BIT(7)) != 0) {
00829                 pFont->usFontStyle ^= FONT_HIDDEN;
00830         }
00831         if (usTmp & BIT(10)) {
00832                 pFont->usFontStyle ^= FONT_STRIKE;
00833         }
00834 
00835         ucTmp = ucGetByte(10, aucChpx);
00836         DBG_MSG_C(ucTmp != 0 && ucTmp < 128, "Superscript");
00837         DBG_MSG_C(ucTmp >= 128, "Subscript");
00838 
00839         usTmp = usGetWord(2, aucChpx);
00840         if (usTmp == 0) {
00841                 /* No changes, nothing to do */
00842                 return;
00843         }
00844 
00845         bIcoChange = (usTmp & BIT(0)) != 0;
00846         bFtcChange = (usTmp & BIT(1)) != 0;
00847         bHpsChange = (usTmp & BIT(2)) != 0;
00848         bKulChange = (usTmp & BIT(3)) != 0;
00849 
00850         if (bFtcChange) {
00851                 usTmp = usGetWord(4, aucChpx);
00852                 if (usTmp <= (USHORT)UCHAR_MAX) {
00853                         pFont->ucFontNumber = (UCHAR)usTmp;
00854                 } else {
00855                         pFont->ucFontNumber = 0;
00856                 }
00857         }
00858 
00859         if (bHpsChange) {
00860                 pFont->usFontSize = usGetWord(6, aucChpx);
00861         }
00862 
00863         if (bIcoChange || bKulChange) {
00864                 ucTmp = ucGetByte(9, aucChpx);
00865                 if (bIcoChange) {
00866                         pFont->ucFontColor = ucTmp & 0x1f;
00867                         if (pFont->ucFontColor > 16) {
00868                                 DBG_DEC(pFont->ucFontColor);
00869                                 pFont->ucFontColor = 0;
00870                         }
00871                 }
00872                 if (bKulChange) {
00873                         ucTmp = (ucTmp & 0xe0) >> 5;
00874                         DBG_DEC_C(ucTmp > 4, ucTmp);
00875                         if (ucTmp == 0) {
00876                                 pFont->usFontStyle &= ~FONT_UNDERLINE;
00877                         } else {
00878                                 pFont->usFontStyle |= FONT_UNDERLINE;
00879                         }
00880                 }
00881         }
00882 } /* end of vGet2FontInfo */
00883 
00884 /*
00885  * Fill the picture information block with information from a WinWord 1 file.
00886  * Returns TRUE when successful, otherwise FALSE
00887  */
00888 static BOOL
00889 bGet1PicInfo(int iFodo,
00890         const UCHAR *aucGrpprl, size_t tBytes, picture_block_type *pPicture)
00891 {
00892         ULONG   ulTmp;
00893         UCHAR   aucChpx[12];
00894 
00895         fail(iFodo < 0 || aucGrpprl == NULL || pPicture == NULL);
00896 
00897         if (tBytes > sizeof(aucChpx)) {
00898                 NO_DBG_PRINT_BLOCK(aucGrpprl + iFodo, tBytes);
00899                 tBytes = sizeof(aucChpx);
00900         }
00901 
00902         /* Build the CHPX structure */
00903         (void)memset(aucChpx, 0, sizeof(aucChpx));
00904         (void)memcpy(aucChpx, aucGrpprl + iFodo, min(tBytes, sizeof(aucChpx)));
00905 
00906         ulTmp = ulGetLong(8, aucChpx);
00907         if (ulTmp != 0 && ulTmp < MAX_FILESIZE) {
00908                 pPicture->ulPictureOffset = ulTmp;
00909                 DBG_HEX(pPicture->ulPictureOffset);
00910                 return TRUE;
00911         }
00912         return FALSE;
00913 } /* end of bGet1PicInfo */
00914 
00915 /*
00916  * Fill the picture information block with information from a WinWord 2 file.
00917  * Returns TRUE when successful, otherwise FALSE
00918  */
00919 static BOOL
00920 bGet2PicInfo(int iFodo,
00921         const UCHAR *aucGrpprl, size_t tBytes, picture_block_type *pPicture)
00922 {
00923         ULONG   ulTmp;
00924         UCHAR   aucChpx[18];
00925 
00926         fail(iFodo < 0 || aucGrpprl == NULL || pPicture == NULL);
00927 
00928         if (tBytes > sizeof(aucChpx)) {
00929                 NO_DBG_PRINT_BLOCK(aucGrpprl + iFodo, tBytes);
00930                 tBytes = sizeof(aucChpx);
00931         }
00932 
00933         /* Build the CHPX structure */
00934         (void)memset(aucChpx, 0, sizeof(aucChpx));
00935         (void)memcpy(aucChpx, aucGrpprl + iFodo, min(tBytes, sizeof(aucChpx)));
00936 
00937         ulTmp = ulGetLong(14, aucChpx);
00938         if (ulTmp != 0 && ulTmp < MAX_FILESIZE) {
00939                 pPicture->ulPictureOffset = ulTmp;
00940                 DBG_HEX(pPicture->ulPictureOffset);
00941                 DBG_DEC(tBytes);
00942                 return TRUE;
00943         }
00944         return FALSE;
00945 } /* end of bGet2PicInfo */
00946 
00947 /*
00948  * Build the lists with Character Information for WinWord 1/2 files
00949  */
00950 void
00951 vGet2ChrInfo(FILE *pFile, int iWordVersion, const UCHAR *aucHeader)
00952 {
00953         font_block_type         tFont;
00954         picture_block_type      tPicture;
00955         USHORT  *ausCharPage;
00956         UCHAR   *aucBuffer;
00957         ULONG   ulFileOffset, ulCharPos, ulBeginCharInfo;
00958         size_t  tCharInfoLen, tOffset, tSize, tChrLen, tCharPageNum;
00959         size_t  tLenOld, tLen;
00960         int     iIndex, iIndex2, iRun, iFodo;
00961         BOOL    bSuccess1, bSuccess2;
00962         USHORT  usCharFirstPage, usCount, usIstd;
00963         UCHAR   aucFpage[BIG_BLOCK_SIZE];
00964 
00965         fail(pFile == NULL || aucHeader == NULL);
00966         fail(iWordVersion != 1 && iWordVersion != 2);
00967 
00968         ulBeginCharInfo = ulGetLong(0xa0, aucHeader); /* fcPlcfbteChpx */
00969         DBG_HEX(ulBeginCharInfo);
00970         tCharInfoLen = (size_t)usGetWord(0xa4, aucHeader); /* cbPlcfbteChpx */
00971         DBG_DEC(tCharInfoLen);
00972         if (tCharInfoLen < 4) {
00973                 DBG_DEC(tCharInfoLen);
00974                 return;
00975         }
00976 
00977         aucBuffer = xmalloc(tCharInfoLen);
00978         if (!bReadBytes(aucBuffer, tCharInfoLen, ulBeginCharInfo, pFile)) {
00979                 aucBuffer = xfree(aucBuffer);
00980                 return;
00981         }
00982         NO_DBG_PRINT_BLOCK(aucBuffer, tCharInfoLen);
00983 
00984         tLen = (tCharInfoLen - 4) / 6;
00985         ausCharPage = xcalloc(tLen, sizeof(USHORT));
00986         for (iIndex = 0, tOffset = (tLen + 1) * 4;
00987              iIndex < (int)tLen;
00988              iIndex++, tOffset += 2) {
00989                 ausCharPage[iIndex] = usGetWord(tOffset, aucBuffer);
00990                 NO_DBG_DEC(ausCharPage[iIndex]);
00991         }
00992         DBG_HEX(ulGetLong(0, aucBuffer));
00993         aucBuffer = xfree(aucBuffer);
00994         tCharPageNum = (size_t)usGetWord(0x142, aucHeader); /* cpnBteChp */
00995         DBG_DEC(tCharPageNum);
00996         if (tLen < tCharPageNum) {
00997                 /* Replace CharPage by a longer version */
00998                 tLenOld = tLen;
00999                 usCharFirstPage = usGetWord(0x13e, aucHeader); /* pnChrFirst */
01000                 NO_DBG_DEC(usCharFirstPage);
01001                 tLen += tCharPageNum - 1;
01002                 tSize = tLen * sizeof(USHORT);
01003                 ausCharPage = xrealloc(ausCharPage, tSize);
01004                 /* Add new values */
01005                 usCount = usCharFirstPage + 1;
01006                 for (iIndex = (int)tLenOld; iIndex < (int)tLen; iIndex++) {
01007                         ausCharPage[iIndex] = usCount;
01008                         NO_DBG_DEC(ausCharPage[iIndex]);
01009                         usCount++;
01010                 }
01011         }
01012 
01013         for (iIndex = 0; iIndex < (int)tLen; iIndex++) {
01014                 if (!bReadBytes(aucFpage, BIG_BLOCK_SIZE,
01015                                 (ULONG)ausCharPage[iIndex] * BIG_BLOCK_SIZE,
01016                                 pFile)) {
01017                         break;
01018                 }
01019                 NO_DBG_PRINT_BLOCK(aucFpage, BIG_BLOCK_SIZE);
01020                 iRun = (int)ucGetByte(0x1ff, aucFpage);
01021                 NO_DBG_DEC(iRun);
01022                 for (iIndex2 = 0; iIndex2 < iRun; iIndex2++) {
01023                         if ((iRun + 1) * 4 + iIndex2 >= BIG_BLOCK_SIZE) {
01024                                 break;
01025                         }
01026                         ulCharPos = ulGetLong(iIndex2 * 4, aucFpage);
01027                         ulFileOffset = ulCharPos;
01028                         iFodo = 2 * (int)ucGetByte(
01029                                 (iRun + 1) * 4 + iIndex2, aucFpage);
01030 
01031                         tChrLen = (size_t)ucGetByte(iFodo, aucFpage);
01032 
01033                         usIstd = usGetIstd(ulFileOffset);
01034                         vFillFontFromStylesheet(usIstd, &tFont);
01035                         if (iFodo != 0) {
01036                                 if (iWordVersion == 1) {
01037                                         vGet1FontInfo(iFodo,
01038                                                 aucFpage + 1, tChrLen, &tFont);
01039                                 } else if (iWordVersion == 2) {
01040                                         vGet2FontInfo(iFodo,
01041                                                 aucFpage + 1, tChrLen, &tFont);
01042                                 }
01043                         }
01044                         tFont.ulFileOffset = ulFileOffset;
01045                         vAdd2FontInfoList(&tFont);
01046 
01047                         if (iFodo <= 0) {
01048                                 continue;
01049                         }
01050 
01051                         (void)memset(&tPicture, 0, sizeof(tPicture));
01052                         bSuccess1 = iWordVersion == 1 &&
01053                                         bGet1PicInfo(iFodo, aucFpage + 1,
01054                                                 tChrLen, &tPicture);
01055                         bSuccess2 = iWordVersion == 2 &&
01056                                         bGet2PicInfo(iFodo, aucFpage + 1,
01057                                                 tChrLen, &tPicture);
01058                         if (bSuccess1 || bSuccess2) {
01059                                 tPicture.ulFileOffset = ulFileOffset;
01060                                 tPicture.ulFileOffsetPicture =
01061                                                 tPicture.ulPictureOffset;
01062                                 vAdd2PictInfoList(&tPicture);
01063                         }
01064                 }
01065         }
01066         ausCharPage = xfree(ausCharPage);
01067 } /* end of vGet2ChrInfo */