?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Imported from antiword-0.37.tar.gz.
[antiword.git] / blocklist.c
blobc847c27e9664fc95b8eb806b19e5cc77ea2e6db9
1 /*
2 * blocklist.c
3 * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
4 *
5 * Description:
6 * Build, read and destroy the lists of Word "text" blocks
7 */
8
9 #include <stdlib.h>
10 #include "antiword.h"
11
12
13 /*
14 * Private structure to hide the way the information
15 * is stored from the rest of the program
16 */
17 typedef struct list_mem_tag {
18 text_block_type tInfo;
19 struct list_mem_tag *pNext;
20 } list_mem_type;
21
22 typedef struct readinfo_tag {
23 list_mem_type *pBlockCurrent;
24 ULONG ulBlockOffset;
25 size_t tByteNext;
26 UCHAR aucBlock[BIG_BLOCK_SIZE];
27 } readinfo_type;
28
29 /* Variables to describe the start of the block lists */
30 static list_mem_type *pTextAnchor = NULL;
31 static list_mem_type *pFootnoteAnchor = NULL;
32 static list_mem_type *pHdrFtrAnchor = NULL;
33 static list_mem_type *pMacroAnchor = NULL;
34 static list_mem_type *pAnnotationAnchor = NULL;
35 static list_mem_type *pEndnoteAnchor = NULL;
36 static list_mem_type *pTextBoxAnchor = NULL;
37 static list_mem_type *pHdrTextBoxAnchor = NULL;
38 /* Variable needed to build the block list */
39 static list_mem_type *pBlockLast = NULL;
40 /* Variable needed to read the block lists */
41 static readinfo_type tOthers = { NULL, 0, 0, };
42 static readinfo_type tHdrFtr = { NULL, 0, 0, };
43 static readinfo_type tFootnote = { NULL, 0, 0, };
44
45
46 /*
47 * pFreeOneList - free a text block list
48 *
49 * Will always return NULL
50 */
51 static list_mem_type *
52 pFreeOneList(list_mem_type *pAnchor)
53 {
54 list_mem_type *pCurr, *pNext;
55
56 pCurr = pAnchor;
57 while (pCurr != NULL) {
58 pNext = pCurr->pNext;
59 pCurr = xfree(pCurr);
60 pCurr = pNext;
61 }
62 return NULL;
63 } /* end of pFreeOneList */
64
65 /*
66 * vDestroyTextBlockList - destroy the text block lists
67 */
68 void
69 vDestroyTextBlockList(void)
70 {
71 DBG_MSG("vDestroyTextBlockList");
72
73 /* Free the lists one by one */
74 pTextAnchor = pFreeOneList(pTextAnchor);
75 pFootnoteAnchor = pFreeOneList(pFootnoteAnchor);
76 pHdrFtrAnchor = pFreeOneList(pHdrFtrAnchor);
77 pMacroAnchor = pFreeOneList(pMacroAnchor);
78 pAnnotationAnchor = pFreeOneList(pAnnotationAnchor);
79 pEndnoteAnchor = pFreeOneList(pEndnoteAnchor);
80 pTextBoxAnchor = pFreeOneList(pTextBoxAnchor);
81 pHdrTextBoxAnchor = pFreeOneList(pHdrTextBoxAnchor);
82 /* Reset all the controle variables */
83 pBlockLast = NULL;
84 tOthers.pBlockCurrent = NULL;
85 tHdrFtr.pBlockCurrent = NULL;
86 tFootnote.pBlockCurrent = NULL;
87 } /* end of vDestroyTextBlockList */
88
89 /*
90 * bAdd2TextBlockList - add an element to the text block list
91 *
92 * returns: TRUE when successful, otherwise FALSE
93 */
94 BOOL
95 bAdd2TextBlockList(const text_block_type *pTextBlock)
96 {
97 list_mem_type *pListMember;
98
99 fail(pTextBlock == NULL);
100 fail(pTextBlock->ulFileOffset == FC_INVALID);
101 fail(pTextBlock->ulCharPos == CP_INVALID);
102 fail(pTextBlock->ulLength == 0);
103 fail(pTextBlock->bUsesUnicode && odd(pTextBlock->ulLength));
104
105 NO_DBG_MSG("bAdd2TextBlockList");
106 NO_DBG_HEX(pTextBlock->ulFileOffset);
107 NO_DBG_HEX(pTextBlock->ulCharPos);
108 NO_DBG_HEX(pTextBlock->ulLength);
109 NO_DBG_DEC(pTextBlock->bUsesUnicode);
110 NO_DBG_DEC(pTextBlock->usPropMod);
111
112 if (pTextBlock->ulFileOffset == FC_INVALID ||
113 pTextBlock->ulCharPos == CP_INVALID ||
114 pTextBlock->ulLength == 0 ||
115 (pTextBlock->bUsesUnicode && odd(pTextBlock->ulLength))) {
116 werr(0, "Software (textblock) error");
117 return FALSE;
118 }
119 /*
120 * Check for continuous blocks of the same character size and
121 * the same properties modifier
122 */
123 if (pBlockLast != NULL &&
124 pBlockLast->tInfo.ulFileOffset +
125 pBlockLast->tInfo.ulLength == pTextBlock->ulFileOffset &&
126 pBlockLast->tInfo.ulCharPos +
127 pBlockLast->tInfo.ulLength == pTextBlock->ulCharPos &&
128 pBlockLast->tInfo.bUsesUnicode == pTextBlock->bUsesUnicode &&
129 pBlockLast->tInfo.usPropMod == pTextBlock->usPropMod) {
130 /* These are continous blocks */
131 pBlockLast->tInfo.ulLength += pTextBlock->ulLength;
132 return TRUE;
133 }
134 /* Make a new block */
135 pListMember = xmalloc(sizeof(list_mem_type));
136 /* Add the block to the list */
137 pListMember->tInfo = *pTextBlock;
138 pListMember->pNext = NULL;
139 if (pTextAnchor == NULL) {
140 pTextAnchor = pListMember;
141 } else {
142 fail(pBlockLast == NULL);
143 pBlockLast->pNext = pListMember;
144 }
145 pBlockLast = pListMember;
146 return TRUE;
147 } /* end of bAdd2TextBlockList */
148
149 /*
150 * vSpitList - Split the list in two
151 */
152 static void
153 vSpitList(list_mem_type **ppAnchorCurr, list_mem_type **ppAnchorNext,
154 ULONG ulListLen)
155 {
156 list_mem_type *pCurr;
157 long lCharsToGo, lBytesTooFar;
158
159 fail(ppAnchorCurr == NULL);
160 fail(ppAnchorNext == NULL);
161 fail(ulListLen > (ULONG)LONG_MAX);
162
163 pCurr = NULL;
164 lCharsToGo = (long)ulListLen;
165 lBytesTooFar = -1;
166 if (ulListLen != 0) {
167 DBG_DEC(ulListLen);
168 for (pCurr = *ppAnchorCurr;
169 pCurr != NULL;
170 pCurr = pCurr->pNext) {
171 NO_DBG_DEC(pCurr->tInfo.ulLength);
172 fail(pCurr->tInfo.ulLength == 0);
173 fail(pCurr->tInfo.ulLength > (ULONG)LONG_MAX);
174 if (pCurr->tInfo.bUsesUnicode) {
175 fail(odd(pCurr->tInfo.ulLength));
176 lCharsToGo -= (long)(pCurr->tInfo.ulLength / 2);
177 if (lCharsToGo < 0) {
178 lBytesTooFar = -2 * lCharsToGo;
179 }
180 } else {
181 lCharsToGo -= (long)pCurr->tInfo.ulLength;
182 if (lCharsToGo < 0) {
183 lBytesTooFar = -lCharsToGo;
184 }
185 }
186 if (lCharsToGo <= 0) {
187 break;
188 }
189 }
190 }
191 /* Split the list */
192 if (ulListLen == 0) {
193 /* Current blocklist is empty */
194 *ppAnchorNext = *ppAnchorCurr;
195 *ppAnchorCurr = NULL;
196 } else if (pCurr == NULL) {
197 /* No blocks for the next list */
198 *ppAnchorNext = NULL;
199 } else if (lCharsToGo == 0) {
200 /* Move the integral number of blocks to the next list */
201 *ppAnchorNext = pCurr->pNext;
202 pCurr->pNext = NULL;
203 } else {
204 /* Split the part current block list, part next block list */
205 DBG_DEC(lBytesTooFar);
206 fail(lBytesTooFar <= 0);
207 *ppAnchorNext = xmalloc(sizeof(list_mem_type));
208 DBG_HEX(pCurr->tInfo.ulFileOffset);
209 (*ppAnchorNext)->tInfo.ulFileOffset =
210 pCurr->tInfo.ulFileOffset +
211 pCurr->tInfo.ulLength -
212 lBytesTooFar;
213 DBG_HEX((*ppAnchorNext)->tInfo.ulFileOffset);
214 DBG_HEX(pCurr->tInfo.ulCharPos);
215 (*ppAnchorNext)->tInfo.ulCharPos =
216 pCurr->tInfo.ulCharPos +
217 pCurr->tInfo.ulLength -
218 lBytesTooFar;
219 DBG_HEX((*ppAnchorNext)->tInfo.ulCharPos);
220 (*ppAnchorNext)->tInfo.ulLength = (ULONG)lBytesTooFar;
221 pCurr->tInfo.ulLength -= (ULONG)lBytesTooFar;
222 (*ppAnchorNext)->tInfo.bUsesUnicode = pCurr->tInfo.bUsesUnicode;
223 (*ppAnchorNext)->tInfo.usPropMod = pCurr->tInfo.usPropMod;
224 /* Move the integral number of blocks to the next list */
225 (*ppAnchorNext)->pNext = pCurr->pNext;
226 pCurr->pNext = NULL;
227 }
228 } /* end of vSpitList */
229
230 #if defined(DEBUG) || defined(__riscos)
231 /*
232 * ulComputeListLength - compute the length of a list
233 *
234 * returns the list length in characters
235 */
236 static ULONG
237 ulComputeListLength(const list_mem_type *pAnchor)
238 {
239 const list_mem_type *pCurr;
240 ULONG ulTotal;
241
242 ulTotal = 0;
243 for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
244 fail(pCurr->tInfo.ulLength == 0);
245 if (pCurr->tInfo.bUsesUnicode) {
246 fail(odd(pCurr->tInfo.ulLength));
247 ulTotal += pCurr->tInfo.ulLength / 2;
248 } else {
249 ulTotal += pCurr->tInfo.ulLength;
250 }
251 }
252 return ulTotal;
253 } /* end of ulComputeListLength */
254 #endif /* DEBUG || __riscos */
255
256 #if defined(DEBUG)
257 /*
258 * vCheckList - check the number of bytes in a block list
259 */
260 static void
261 vCheckList(const list_mem_type *pAnchor, ULONG ulListLen, char *szMsg)
262 {
263 ULONG ulTotal;
264
265 ulTotal = ulComputeListLength(pAnchor);
266 DBG_DEC(ulTotal);
267 if (ulTotal != ulListLen) {
268 DBG_DEC(ulListLen);
269 werr(1, szMsg);
270 }
271 } /* end of vCheckList */
272 #endif /* DEBUG */
273
274 /*
275 * bIsEmptyBox - check to see if the given text box is empty
276 */
277 static BOOL
278 bIsEmptyBox(FILE *pFile, const list_mem_type *pAnchor)
279 {
280 const list_mem_type *pCurr;
281 size_t tIndex, tSize;
282 UCHAR *aucBuffer;
283 char cChar;
284
285 fail(pFile == NULL);
286
287 if (pAnchor == NULL) {
288 return TRUE;
289 }
290
291 aucBuffer = NULL;
292 for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
293 fail(pCurr->tInfo.ulLength == 0);
294 tSize = (size_t)pCurr->tInfo.ulLength;
295 #if defined(__dos) && !defined(__DJGPP__)
296 if (pCurr->tInfo.ulLength > 0xffffUL) {
297 tSize = 0xffff;
298 }
299 #endif /* __dos && !__DJGPP__ */
300 fail(aucBuffer != NULL);
301 aucBuffer = xmalloc(tSize);
302 if (!bReadBytes(aucBuffer, tSize,
303 pCurr->tInfo.ulFileOffset, pFile)) {
304 aucBuffer = xfree(aucBuffer);
305 return FALSE;
306 }
307 for (tIndex = 0; tIndex < tSize; tIndex++) {
308 cChar = (char)aucBuffer[tIndex];
309 switch (cChar) {
310 case '\0': case '\r': case '\n':
311 case '\f': case '\t': case '\v':
312 case ' ':
313 break;
314 default:
315 aucBuffer = xfree(aucBuffer);
316 return FALSE;
317 }
318 }
319 aucBuffer = xfree(aucBuffer);
320 }
321 fail(aucBuffer != NULL);
322 return TRUE;
323 } /* end of bIsEmptyBox */
324
325 /*
326 * vSplitBlockList - split the block list in the various parts
327 *
328 * Split the blocklist in a Text block list, a Footnote block list, a
329 * HeaderFooter block list, a Macro block list, an Annotation block list,
330 * an Endnote block list, a TextBox list and a HeaderTextBox list.
331 *
332 * NOTE:
333 * The various ul*Len input parameters are given in characters, but the
334 * length of the blocks are in bytes.
335 */
336 void
337 vSplitBlockList(FILE *pFile, ULONG ulTextLen, ULONG ulFootnoteLen,
338 ULONG ulHdrFtrLen, ULONG ulMacroLen, ULONG ulAnnotationLen,
339 ULONG ulEndnoteLen, ULONG ulTextBoxLen, ULONG ulHdrTextBoxLen,
340 BOOL bMustExtend)
341 {
342 list_mem_type *apAnchors[8];
343 list_mem_type *pGarbageAnchor, *pCurr;
344 size_t tIndex;
345
346 DBG_MSG("vSplitBlockList");
347
348 pGarbageAnchor = NULL;
349
350 DBG_MSG_C(ulTextLen != 0, "Text block list");
351 vSpitList(&pTextAnchor, &pFootnoteAnchor, ulTextLen);
352 DBG_MSG_C(ulFootnoteLen != 0, "Footnote block list");
353 vSpitList(&pFootnoteAnchor, &pHdrFtrAnchor, ulFootnoteLen);
354 DBG_MSG_C(ulHdrFtrLen != 0, "Header/Footer block list");
355 vSpitList(&pHdrFtrAnchor, &pMacroAnchor, ulHdrFtrLen);
356 DBG_MSG_C(ulMacroLen != 0, "Macro block list");
357 vSpitList(&pMacroAnchor, &pAnnotationAnchor, ulMacroLen);
358 DBG_MSG_C(ulAnnotationLen != 0, "Annotation block list");
359 vSpitList(&pAnnotationAnchor, &pEndnoteAnchor, ulAnnotationLen);
360 DBG_MSG_C(ulEndnoteLen != 0, "Endnote block list");
361 vSpitList(&pEndnoteAnchor, &pTextBoxAnchor, ulEndnoteLen);
362 DBG_MSG_C(ulTextBoxLen != 0, "Textbox block list");
363 vSpitList(&pTextBoxAnchor, &pHdrTextBoxAnchor, ulTextBoxLen);
364 DBG_MSG_C(ulHdrTextBoxLen != 0, "HeaderTextbox block list");
365 vSpitList(&pHdrTextBoxAnchor, &pGarbageAnchor, ulHdrTextBoxLen);
366
367 /* Free the garbage block list, this should not be needed */
368 DBG_DEC_C(pGarbageAnchor != NULL, pGarbageAnchor->tInfo.ulLength);
369 pGarbageAnchor = pFreeOneList(pGarbageAnchor);
370
371 #if defined(DEBUG)
372 vCheckList(pTextAnchor, ulTextLen, "Software error (Text)");
373 vCheckList(pFootnoteAnchor, ulFootnoteLen, "Software error (Footnote)");
374 vCheckList(pHdrFtrAnchor, ulHdrFtrLen, "Software error (Hdr/Ftr)");
375 vCheckList(pMacroAnchor, ulMacroLen, "Software error (Macro)");
376 vCheckList(pAnnotationAnchor, ulAnnotationLen,
377 "Software error (Annotation)");
378 vCheckList(pEndnoteAnchor, ulEndnoteLen, "Software error (Endnote)");
379 vCheckList(pTextBoxAnchor, ulTextBoxLen, "Software error (TextBox)");
380 vCheckList(pHdrTextBoxAnchor, ulHdrTextBoxLen,
381 "Software error (HdrTextBox)");
382 #endif /* DEBUG */
383
384 /* Remove the list if the text box is empty */
385 if (bIsEmptyBox(pFile, pTextBoxAnchor)) {
386 pTextBoxAnchor = pFreeOneList(pTextBoxAnchor);
387 }
388 if (bIsEmptyBox(pFile, pHdrTextBoxAnchor)) {
389 pHdrTextBoxAnchor = pFreeOneList(pHdrTextBoxAnchor);
390 }
391
392 if (!bMustExtend) {
393 return;
394 }
395 /*
396 * All blocks (except the last one) must have a length that
397 * is a multiple of the Big Block Size
398 */
399
400 apAnchors[0] = pTextAnchor;
401 apAnchors[1] = pFootnoteAnchor;
402 apAnchors[2] = pHdrFtrAnchor;
403 apAnchors[3] = pMacroAnchor;
404 apAnchors[4] = pAnnotationAnchor;
405 apAnchors[5] = pEndnoteAnchor;
406 apAnchors[6] = pTextBoxAnchor;
407 apAnchors[7] = pHdrTextBoxAnchor;
408
409 for (tIndex = 0; tIndex < elementsof(apAnchors); tIndex++) {
410 for (pCurr = apAnchors[tIndex];
411 pCurr != NULL;
412 pCurr = pCurr->pNext) {
413 if (pCurr->pNext != NULL &&
414 pCurr->tInfo.ulLength % BIG_BLOCK_SIZE != 0) {
415 DBG_DEC(tIndex);
416 DBG_HEX(pCurr->tInfo.ulFileOffset);
417 DBG_HEX(pCurr->tInfo.ulCharPos);
418 DBG_DEC(pCurr->tInfo.ulLength);
419 pCurr->tInfo.ulLength /= BIG_BLOCK_SIZE;
420 pCurr->tInfo.ulLength++;
421 pCurr->tInfo.ulLength *= BIG_BLOCK_SIZE;
422 DBG_DEC(pCurr->tInfo.ulLength);
423 }
424 }
425 }
426 } /* end of vSplitBlockList */
427
428 #if defined(__riscos)
429 /*
430 * ulGetDocumentLength - get the total character length of the printable lists
431 *
432 * returns: The total number of characters
433 */
434 ULONG
435 ulGetDocumentLength(void)
436 {
437 long ulTotal;
438
439 DBG_MSG("ulGetDocumentLength");
440
441 ulTotal = ulComputeListLength(pTextAnchor);
442 ulTotal += ulComputeListLength(pFootnoteAnchor);
443 ulTotal += ulComputeListLength(pEndnoteAnchor);
444 ulTotal += ulComputeListLength(pTextBoxAnchor);
445 ulTotal += ulComputeListLength(pHdrTextBoxAnchor);
446 DBG_DEC(ulTotal);
447 return ulTotal;
448 } /* end of ulGetDocumentLength */
449 #endif /* __riscos */
450
451 #if 0
452 /*
453 * bExistsHdrFtr - are there headers and/or footers?
454 */
455 BOOL
456 bExistsHdrFtr(void)
457 {
458 return pHdrFtrAnchor != NULL &&
459 pHdrFtrAnchor->tInfo.ulLength != 0;
460 } /* end of bExistsHdrFtr */
461 #endif
462
463 /*
464 * bExistsTextBox - is there a text box?
465 */
466 BOOL
467 bExistsTextBox(void)
468 {
469 return pTextBoxAnchor != NULL &&
470 pTextBoxAnchor->tInfo.ulLength != 0;
471 } /* end of bExistsTextBox */
472
473 /*
474 * bExistsHdrTextBox - is there a header text box?
475 */
476 BOOL
477 bExistsHdrTextBox(void)
478 {
479 return pHdrTextBoxAnchor != NULL &&
480 pHdrTextBoxAnchor->tInfo.ulLength != 0;
481 } /* end of bExistsHdrTextBox */
482
483 /*
484 * usGetNextByte - get the next byte from the specified block list
485 */
486 static USHORT
487 usGetNextByte(FILE *pFile, readinfo_type *pInfoCurrent, list_mem_type *pAnchor,
488 ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
489 {
490 ULONG ulReadOff;
491 size_t tReadLen;
492
493 fail(pInfoCurrent == NULL);
494
495 if (pInfoCurrent->pBlockCurrent == NULL ||
496 pInfoCurrent->tByteNext >= sizeof(pInfoCurrent->aucBlock) ||
497 pInfoCurrent->ulBlockOffset + pInfoCurrent->tByteNext >=
498 pInfoCurrent->pBlockCurrent->tInfo.ulLength) {
499 if (pInfoCurrent->pBlockCurrent == NULL) {
500 /* First block, first part */
501 pInfoCurrent->pBlockCurrent = pAnchor;
502 pInfoCurrent->ulBlockOffset = 0;
503 } else if (pInfoCurrent->ulBlockOffset +
504 sizeof(pInfoCurrent->aucBlock) <
505 pInfoCurrent->pBlockCurrent->tInfo.ulLength) {
506 /* Same block, next part */
507 pInfoCurrent->ulBlockOffset +=
508 sizeof(pInfoCurrent->aucBlock);
509 } else {
510 /* Next block, first part */
511 pInfoCurrent->pBlockCurrent =
512 pInfoCurrent->pBlockCurrent->pNext;
513 pInfoCurrent->ulBlockOffset = 0;
514 }
515 if (pInfoCurrent->pBlockCurrent == NULL) {
516 /* Past the last part of the last block */
517 return (USHORT)EOF;
518 }
519 tReadLen = (size_t)
520 (pInfoCurrent->pBlockCurrent->tInfo.ulLength -
521 pInfoCurrent->ulBlockOffset);
522 if (tReadLen > sizeof(pInfoCurrent->aucBlock)) {
523 tReadLen = sizeof(pInfoCurrent->aucBlock);
524 }
525 ulReadOff = pInfoCurrent->pBlockCurrent->tInfo.ulFileOffset +
526 pInfoCurrent->ulBlockOffset;
527 if (!bReadBytes(pInfoCurrent->aucBlock,
528 tReadLen, ulReadOff, pFile)) {
529 /* Don't read from this list any longer */
530 pInfoCurrent->pBlockCurrent = NULL;
531 return (USHORT)EOF;
532 }
533 pInfoCurrent->tByteNext = 0;
534 }
535 if (pulFileOffset != NULL) {
536 *pulFileOffset =
537 pInfoCurrent->pBlockCurrent->tInfo.ulFileOffset +
538 pInfoCurrent->ulBlockOffset +
539 pInfoCurrent->tByteNext;
540 }
541 if (pulCharPos != NULL) {
542 *pulCharPos =
543 pInfoCurrent->pBlockCurrent->tInfo.ulCharPos +
544 pInfoCurrent->ulBlockOffset +
545 pInfoCurrent->tByteNext;
546 }
547 if (pusPropMod != NULL) {
548 *pusPropMod = pInfoCurrent->pBlockCurrent->tInfo.usPropMod;
549 }
550 return (USHORT)pInfoCurrent->aucBlock[pInfoCurrent->tByteNext++];
551 } /* end of usGetNextByte */
552
553
554 /*
555 * usGetNextChar - get the next character from the specified block list
556 */
557 static USHORT
558 usGetNextChar(FILE *pFile, list_id_enum eListID,
559 ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
560 {
561 readinfo_type *pReadinfo;
562 list_mem_type *pAnchor;
563 USHORT usLSB, usMSB;
564
565 switch (eListID) {
566 case text_list:
567 pReadinfo = &tOthers;
568 pAnchor = pTextAnchor;
569 break;
570 case footnote_list:
571 pReadinfo = &tFootnote;
572 pAnchor = pFootnoteAnchor;
573 break;
574 case hdrftr_list:
575 pReadinfo = &tHdrFtr;
576 pAnchor = pHdrFtrAnchor;
577 break;
578 case endnote_list:
579 pReadinfo = &tOthers;
580 pAnchor = pEndnoteAnchor;
581 break;
582 case textbox_list:
583 pReadinfo = &tOthers;
584 pAnchor = pTextBoxAnchor;
585 break;
586 case hdrtextbox_list:
587 pReadinfo = &tOthers;
588 pAnchor = pHdrTextBoxAnchor;
589 break;
590 default:
591 DBG_DEC(eListID);
592 return (USHORT)EOF;
593 }
594
595 usLSB = usGetNextByte(pFile, pReadinfo, pAnchor,
596 pulFileOffset, pulCharPos, pusPropMod);
597 if (usLSB == (USHORT)EOF) {
598 return (USHORT)EOF;
599 }
600 fail(pReadinfo->pBlockCurrent == NULL);
601
602 if (pReadinfo->pBlockCurrent->tInfo.bUsesUnicode) {
603 usMSB = usGetNextByte(pFile,
604 pReadinfo, pAnchor, NULL, NULL, NULL);
605 } else {
606 usMSB = 0x00;
607 }
608 if (usMSB == (USHORT)EOF) {
609 DBG_MSG("usGetNextChar: Unexpected EOF");
610 DBG_HEX_C(pulFileOffset != NULL, *pulFileOffset);
611 DBG_HEX_C(pulCharPos != NULL, *pulCharPos);
612 return (USHORT)EOF;
613 }
614 return (usMSB << 8) | usLSB;
615 } /* end of usGetNextChar */
616
617 /*
618 * usNextChar - get the next character from the given block list
619 */
620 USHORT
621 usNextChar(FILE *pFile, list_id_enum eListID,
622 ULONG *pulFileOffset, ULONG *pulCharPos, USHORT *pusPropMod)
623 {
624 USHORT usRetVal;
625
626 fail(pFile == NULL);
627
628 usRetVal = usGetNextChar(pFile, eListID,
629 pulFileOffset, pulCharPos, pusPropMod);
630 if (usRetVal == (USHORT)EOF) {
631 if (pulFileOffset != NULL) {
632 *pulFileOffset = FC_INVALID;
633 }
634 if (pulCharPos != NULL) {
635 *pulCharPos = CP_INVALID;
636 }
637 if (pusPropMod != NULL) {
638 *pusPropMod = IGNORE_PROPMOD;
639 }
640 }
641 return usRetVal;
642 } /* end of usNextChar */
643
644 /*
645 * usToHdrFtrPosition - Go to a character position in header/foorter list
646 *
647 * Returns the character found on the specified character position
648 */
649 USHORT
650 usToHdrFtrPosition(FILE *pFile, ULONG ulCharPos)
651 {
652 ULONG ulCharPosCurr;
653 USHORT usChar;
654
655 tHdrFtr.pBlockCurrent = NULL; /* To reset the header/footer list */
656 do {
657 usChar = usNextChar(pFile,
658 hdrftr_list, NULL, &ulCharPosCurr, NULL);
659 } while (usChar != (USHORT)EOF && ulCharPosCurr != ulCharPos);
660 return usChar;
661 } /* end of usToHdrFtrPosition */
662
663 /*
664 * usToFootnotePosition - Go to a character position in footnote list
665 *
666 * Returns the character found on the specified character position
667 */
668 USHORT
669 usToFootnotePosition(FILE *pFile, ULONG ulCharPos)
670 {
671 ULONG ulCharPosCurr;
672 USHORT usChar;
673
674 tFootnote.pBlockCurrent = NULL; /* To reset the footnote list */
675 do {
676 usChar = usNextChar(pFile,
677 footnote_list, NULL, &ulCharPosCurr, NULL);
678 } while (usChar != (USHORT)EOF && ulCharPosCurr != ulCharPos);
679 return usChar;
680 } /* end of usToFootnotePosition */
681
682 /*
683 * Convert a character position to an offset in the file.
684 * Logical to physical offset.
685 *
686 * Returns: FC_INVALID: in case of error
687 * otherwise: the computed file offset
688 */
689 ULONG
690 ulCharPos2FileOffsetX(ULONG ulCharPos, list_id_enum *peListID)
691 {
692 static list_id_enum eListIDs[8] = {
693 text_list, footnote_list, hdrftr_list,
694 macro_list, annotation_list, endnote_list,
695 textbox_list, hdrtextbox_list,
696 };
697 list_mem_type *apAnchors[8];
698 list_mem_type *pCurr;
699 list_id_enum eListGuess;
700 ULONG ulBestGuess;
701 size_t tIndex;
702
703 fail(peListID == NULL);
704
705 if (ulCharPos == CP_INVALID) {
706 *peListID = no_list;
707 return FC_INVALID;
708 }
709
710 apAnchors[0] = pTextAnchor;
711 apAnchors[1] = pFootnoteAnchor;
712 apAnchors[2] = pHdrFtrAnchor;
713 apAnchors[3] = pMacroAnchor;
714 apAnchors[4] = pAnnotationAnchor;
715 apAnchors[5] = pEndnoteAnchor;
716 apAnchors[6] = pTextBoxAnchor;
717 apAnchors[7] = pHdrTextBoxAnchor;
718
719 eListGuess = no_list; /* Best guess is no list */
720 ulBestGuess = FC_INVALID; /* Best guess is "file offset not found" */
721
722 for (tIndex = 0; tIndex < elementsof(apAnchors); tIndex++) {
723 for (pCurr = apAnchors[tIndex];
724 pCurr != NULL;
725 pCurr = pCurr->pNext) {
726 if (ulCharPos == pCurr->tInfo.ulCharPos +
727 pCurr->tInfo.ulLength &&
728 pCurr->pNext != NULL) {
729 /*
730 * The character position is one beyond this
731 * block, so we guess it's the first byte of
732 * the next block (if there is a next block)
733 */
734 eListGuess= eListIDs[tIndex];
735 ulBestGuess = pCurr->pNext->tInfo.ulFileOffset;
736 }
737
738 if (ulCharPos < pCurr->tInfo.ulCharPos ||
739 ulCharPos >= pCurr->tInfo.ulCharPos +
740 pCurr->tInfo.ulLength) {
741 /* Character position is not in this block */
742 continue;
743 }
744
745 /* The character position is in the current block */
746 *peListID = eListIDs[tIndex];
747 return pCurr->tInfo.ulFileOffset +
748 ulCharPos - pCurr->tInfo.ulCharPos;
749 }
750 }
751 /* Passed beyond the end of the last list */
752 NO_DBG_HEX(ulCharPos);
753 NO_DBG_HEX(ulBestGuess);
754 *peListID = eListGuess;
755 return ulBestGuess;
756 } /* end of ulCharPos2FileOffsetX */
757
758 /*
759 * Convert a character position to an offset in the file.
760 * Logical to physical offset.
761 *
762 * Returns: FC_INVALID: in case of error
763 * otherwise: the computed file offset
764 */
765 ULONG
766 ulCharPos2FileOffset(ULONG ulCharPos)
767 {
768 list_id_enum eListID;
769
770 return ulCharPos2FileOffsetX(ulCharPos, &eListID);
771 } /* end of ulCharPos2FileOffset */
772
773 /*
774 * Convert an offset in the header/footer list to a character position.
775 *
776 * Returns: CP_INVALID: in case of error
777 * otherwise: the computed character position
778 */
779 ULONG
780 ulHdrFtrOffset2CharPos(ULONG ulHdrFtrOffset)
781 {
782 list_mem_type *pCurr;
783 ULONG ulOffset;
784
785 ulOffset = ulHdrFtrOffset;
786 for (pCurr = pHdrFtrAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
787 if (ulOffset >= pCurr->tInfo.ulLength) {
788 /* The offset is not in this block */
789 ulOffset -= pCurr->tInfo.ulLength;
790 continue;
791 }
792 return pCurr->tInfo.ulCharPos + ulOffset;
793 }
794 return CP_INVALID;
795 } /* end of ulHdrFtrOffset2CharPos */
796
797 /*
798 * Get the sequence number beloning to the given file offset
799 *
800 * Returns the sequence number
801 */
802 ULONG
803 ulGetSeqNumber(ULONG ulFileOffset)
804 {
805 list_mem_type *pCurr;
806 ULONG ulSeq;
807
808 if (ulFileOffset == FC_INVALID) {
809 return FC_INVALID;
810 }
811
812 ulSeq = 0;
813 for (pCurr = pTextAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
814 if (ulFileOffset >= pCurr->tInfo.ulFileOffset &&
815 ulFileOffset < pCurr->tInfo.ulFileOffset +
816 pCurr->tInfo.ulLength) {
817 /* The file offset is within the current textblock */
818 return ulSeq + ulFileOffset - pCurr->tInfo.ulFileOffset;
819 }
820 ulSeq += pCurr->tInfo.ulLength;
821 }
822 return FC_INVALID;
823 } /* end of ulGetSeqNumber */
Antiword git mirror