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

00001 /*
-00002  * findtext.c
-00003  * Copyright (C) 1998-2004 A.J. van Os; Released under GNU GPL
-00004  *
-00005  * Description:
-00006  * Find the blocks that contain the text of MS Word files
-00007  */
-00008 
-00009 #include <stdio.h>
-00010 #include <stdlib.h>
-00011 #include "antiword.h"
-00012 
-00013 
-00014 /*
-00015  * bAddTextBlocks - Add the blocks to the text block list
-00016  *
-00017  * Returns TRUE when successful, FALSE if not
-00018  */
-00019 BOOL
-00020 bAddTextBlocks(ULONG ulCharPosFirst, ULONG ulTotalLength,
-00021         BOOL bUsesUnicode, USHORT usPropMod,
-00022         ULONG ulStartBlock, const ULONG *aulBBD, size_t tBBDLen)
-00023 {
-00024         text_block_type tTextBlock;
-00025         ULONG   ulCharPos, ulOffset, ulIndex;
-00026         long    lToGo;
-00027 
-00028         fail(ulTotalLength > (ULONG)LONG_MAX / 2);
-00029         fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
-00030         fail(aulBBD == NULL);
-00031 
-00032         NO_DBG_HEX(ulCharPosFirst);
-00033         NO_DBG_DEC(ulTotalLength);
-00034 
-00035         if (bUsesUnicode) {
-00036                 /* One character equals two bytes */
-00037                 NO_DBG_MSG("Uses Unicode");
-00038                 lToGo = (long)ulTotalLength * 2;
-00039         } else {
-00040                 /* One character equals one byte */
-00041                 NO_DBG_MSG("Uses ASCII");
-00042                 lToGo = (long)ulTotalLength;
-00043         }
-00044 
-00045         ulCharPos = ulCharPosFirst;
-00046         ulOffset = ulCharPosFirst;
-00047         for (ulIndex = ulStartBlock;
-00048              ulIndex != END_OF_CHAIN && lToGo > 0;
-00049              ulIndex = aulBBD[ulIndex]) {
-00050                 if (ulIndex >= (ULONG)tBBDLen) {
-00051                         DBG_DEC(ulIndex);
-00052                         DBG_DEC(tBBDLen);
-00053                         werr(1, "The Big Block Depot is damaged");
-00054                 }
-00055                 if (ulOffset >= BIG_BLOCK_SIZE) {
-00056                         ulOffset -= BIG_BLOCK_SIZE;
-00057                         continue;
-00058                 }
-00059                 tTextBlock.ulFileOffset =
-00060                         (ulIndex + 1) * BIG_BLOCK_SIZE + ulOffset;
-00061                 tTextBlock.ulCharPos = ulCharPos;
-00062                 tTextBlock.ulLength = min(BIG_BLOCK_SIZE - ulOffset,
-00063                                                 (ULONG)lToGo);
-00064                 tTextBlock.bUsesUnicode = bUsesUnicode;
-00065                 tTextBlock.usPropMod = usPropMod;
-00066                 ulOffset = 0;
-00067                 if (!bAdd2TextBlockList(&tTextBlock)) {
-00068                         DBG_HEX(tTextBlock.ulFileOffset);
-00069                         DBG_HEX(tTextBlock.ulCharPos);
-00070                         DBG_DEC(tTextBlock.ulLength);
-00071                         DBG_DEC(tTextBlock.bUsesUnicode);
-00072                         DBG_DEC(tTextBlock.usPropMod);
-00073                         return FALSE;
-00074                 }
-00075                 ulCharPos += tTextBlock.ulLength;
-00076                 lToGo -= (long)tTextBlock.ulLength;
-00077         }
-00078         DBG_DEC_C(lToGo != 0, lToGo);
-00079         return lToGo == 0;
-00080 } /* end of bAddTextBlocks */
-00081 
-00082 /*
-00083  * bGet6DocumentText - make a list of the text blocks of Word 6/7 files
-00084  *
-00085  * Code for "fast saved" files.
-00086  *
-00087  * Returns TRUE when successful, FALSE if not
-00088  */
-00089 BOOL
-00090 bGet6DocumentText(FILE *pFile, BOOL bUsesUnicode, ULONG ulStartBlock,
-00091         const ULONG *aulBBD, size_t tBBDLen, const UCHAR *aucHeader)
-00092 {
-00093         UCHAR   *aucBuffer;
-00094         ULONG   ulBeginTextInfo, ulTextOffset, ulTotLength;
-00095         size_t  tTextInfoLen;
-00096         int     iIndex, iType, iOff, iLen, iPieces;
-00097         USHORT  usPropMod;
-00098 
-00099         DBG_MSG("bGet6DocumentText");
-00100 
-00101         fail(pFile == NULL);
-00102         fail(aulBBD == NULL);
-00103         fail(aucHeader == NULL);
-00104 
-00105         ulBeginTextInfo = ulGetLong(0x160, aucHeader);  /* fcClx */
-00106         DBG_HEX(ulBeginTextInfo);
-00107         tTextInfoLen = (size_t)ulGetLong(0x164, aucHeader);     /* lcbClx */
-00108         DBG_DEC(tTextInfoLen);
-00109 
-00110         aucBuffer = xmalloc(tTextInfoLen);
-00111         if (!bReadBuffer(pFile, ulStartBlock,
-00112                         aulBBD, tBBDLen, BIG_BLOCK_SIZE,
-00113                         aucBuffer, ulBeginTextInfo, tTextInfoLen)) {
-00114                 aucBuffer = xfree(aucBuffer);
-00115                 return FALSE;
-00116         }
-00117         NO_DBG_PRINT_BLOCK(aucBuffer, tTextInfoLen);
-00118 
-00119         iOff = 0;
-00120         while ((size_t)iOff < tTextInfoLen) {
-00121                 iType = (int)ucGetByte(iOff, aucBuffer);
-00122                 iOff++;
-00123                 if (iType == 0) {
-00124                         DBG_FIXME();
-00125                         iOff++;
-00126                         continue;
-00127                 }
-00128                 if (iType == 1) {
-00129                         iLen = (int)usGetWord(iOff, aucBuffer);
-00130                         vAdd2PropModList(aucBuffer + iOff);
-00131                         iOff += iLen + 2;
-00132                         continue;
-00133                 }
-00134                 if (iType != 2) {
-00135                         werr(0, "Unknown type of 'fastsaved' format");
-00136                         aucBuffer = xfree(aucBuffer);
-00137                         return FALSE;
-00138                 }
-00139                 /* Type 2 */
-00140                 iLen = (int)usGetWord(iOff, aucBuffer);
-00141                 NO_DBG_DEC(iLen);
-00142                 iOff += 4;
-00143                 iPieces = (iLen - 4) / 12;
-00144                 DBG_DEC(iPieces);
-00145                 for (iIndex = 0; iIndex < iPieces; iIndex++) {
-00146                         ulTextOffset = ulGetLong(
-00147                                 iOff + (iPieces + 1) * 4 + iIndex * 8 + 2,
-00148                                 aucBuffer);
-00149                         usPropMod = usGetWord(
-00150                                 iOff + (iPieces + 1) * 4 + iIndex * 8 + 6,
-00151                                 aucBuffer);
-00152                         ulTotLength = ulGetLong(iOff + (iIndex + 1) * 4,
-00153                                                 aucBuffer) -
-00154                                         ulGetLong(iOff + iIndex * 4,
-00155                                                 aucBuffer);
-00156                         NO_DBG_HEX_C(usPropMod != 0, usPropMod);
-00157                         if (!bAddTextBlocks(ulTextOffset, ulTotLength,
-00158                                         bUsesUnicode, usPropMod,
-00159                                         ulStartBlock,
-00160                                         aulBBD, tBBDLen)) {
-00161                                 aucBuffer = xfree(aucBuffer);
-00162                                 return FALSE;
-00163                         }
-00164                 }
-00165                 break;
-00166         }
-00167         aucBuffer = xfree(aucBuffer);
-00168         return TRUE;
-00169 } /* end of bGet6DocumentText */
-00170 
-00171 /*
-00172  * bGet8DocumentText - make a list of the text blocks of Word 8/97 files
-00173  *
-00174  * Returns TRUE when successful, FALSE if not
-00175  */
-00176 BOOL
-00177 bGet8DocumentText(FILE *pFile, const pps_info_type *pPPS,
-00178         const ULONG *aulBBD, size_t tBBDLen,
-00179         const ULONG *aulSBD, size_t tSBDLen,
-00180         const UCHAR *aucHeader)
-00181 {
-00182         const ULONG     *aulBlockDepot;
-00183         UCHAR   *aucBuffer;
-00184         ULONG   ulTextOffset, ulBeginTextInfo;
-00185         ULONG   ulTotLength, ulLen;
-00186         long    lIndex, lPieces, lOff;
-00187         size_t  tTextInfoLen, tBlockDepotLen, tBlockSize;
-00188         int     iType, iLen;
-00189         BOOL    bUsesUnicode;
-00190         USHORT  usPropMod;
-00191 
-00192         DBG_MSG("bGet8DocumentText");
-00193 
-00194         fail(pFile == NULL || pPPS == NULL);
-00195         fail(aulBBD == NULL || aulSBD == NULL);
-00196         fail(aucHeader == NULL);
-00197 
-00198         ulBeginTextInfo = ulGetLong(0x1a2, aucHeader);  /* fcClx */
-00199         DBG_HEX(ulBeginTextInfo);
-00200         tTextInfoLen = (size_t)ulGetLong(0x1a6, aucHeader);     /* lcbClx */
-00201         DBG_DEC(tTextInfoLen);
-00202 
-00203         DBG_DEC(pPPS->tTable.ulSB);
-00204         DBG_HEX(pPPS->tTable.ulSize);
-00205         if (pPPS->tTable.ulSize == 0) {
-00206                 return FALSE;
-00207         }
-00208 
-00209         if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
-00210                 /* Use the Small Block Depot */
-00211                 aulBlockDepot = aulSBD;
-00212                 tBlockDepotLen = tSBDLen;
-00213                 tBlockSize = SMALL_BLOCK_SIZE;
-00214         } else {
-00215                 /* Use the Big Block Depot */
-00216                 aulBlockDepot = aulBBD;
-00217                 tBlockDepotLen = tBBDLen;
-00218                 tBlockSize = BIG_BLOCK_SIZE;
-00219         }
-00220         aucBuffer = xmalloc(tTextInfoLen);
-00221         if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
-00222                         aulBlockDepot, tBlockDepotLen, tBlockSize,
-00223                         aucBuffer, ulBeginTextInfo, tTextInfoLen)) {
-00224                 aucBuffer = xfree(aucBuffer);
-00225                 return FALSE;
-00226         }
-00227         NO_DBG_PRINT_BLOCK(aucBuffer, tTextInfoLen);
-00228 
-00229         lOff = 0;
-00230         while (lOff < (long)tTextInfoLen) {
-00231                 iType = (int)ucGetByte(lOff, aucBuffer);
-00232                 lOff++;
-00233                 if (iType == 0) {
-00234                         DBG_FIXME();
-00235                         lOff++;
-00236                         continue;
-00237                 }
-00238                 if (iType == 1) {
-00239                         iLen = (int)usGetWord(lOff, aucBuffer);
-00240                         vAdd2PropModList(aucBuffer + lOff);
-00241                         lOff += (long)iLen + 2;
-00242                         continue;
-00243                 }
-00244                 if (iType != 2) {
-00245                         werr(0, "Unknown type of 'fastsaved' format");
-00246                         aucBuffer = xfree(aucBuffer);
-00247                         return FALSE;
-00248                 }
-00249                 /* Type 2 */
-00250                 ulLen = ulGetLong(lOff, aucBuffer);
-00251                 if (ulLen < 4) {
-00252                         DBG_DEC(ulLen);
-00253                         return FALSE;
-00254                 }
-00255                 lOff += 4;
-00256                 lPieces = (long)((ulLen - 4) / 12);
-00257                 DBG_DEC(lPieces);
-00258                 for (lIndex = 0; lIndex < lPieces; lIndex++) {
-00259                         ulTextOffset = ulGetLong(
-00260                                 lOff + (lPieces + 1) * 4 + lIndex * 8 + 2,
-00261                                 aucBuffer);
-00262                         usPropMod = usGetWord(
-00263                                 lOff + (lPieces + 1) * 4 + lIndex * 8 + 6,
-00264                                 aucBuffer);
-00265                         ulTotLength = ulGetLong(lOff + (lIndex + 1) * 4,
-00266                                                 aucBuffer) -
-00267                                         ulGetLong(lOff + lIndex * 4,
-00268                                                 aucBuffer);
-00269                         if ((ulTextOffset & BIT(30)) == 0) {
-00270                                 bUsesUnicode = TRUE;
-00271                         } else {
-00272                                 bUsesUnicode = FALSE;
-00273                                 ulTextOffset &= ~BIT(30);
-00274                                 ulTextOffset /= 2;
-00275                         }
-00276                         NO_DBG_HEX_C(usPropMod != 0, usPropMod);
-00277                         if (!bAddTextBlocks(ulTextOffset, ulTotLength,
-00278                                         bUsesUnicode, usPropMod,
-00279                                         pPPS->tWordDocument.ulSB,
-00280                                         aulBBD, tBBDLen)) {
-00281                                 aucBuffer = xfree(aucBuffer);
-00282                                 return FALSE;
-00283                         }
-00284                 }
-00285                 break;
-00286         }
-00287         aucBuffer = xfree(aucBuffer);
-00288         return TRUE;
-00289 } /* end of bGet8DocumentText */
-