?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m57
[ooovba.git] / lotuswordpro / source / filter / tocread.cxx
blob2e101ab6a5ac844566f05b79ed398d48f6dec53d
1 /*************************************************************************
2 *
3 * The Contents of this file are made available subject to the terms of
4 * either of the following licenses
5 *
6 * - GNU Lesser General Public License Version 2.1
7 * - Sun Industry Standards Source License Version 1.1
8 *
9 * Sun Microsystems Inc., October, 2000
10 *
11 * GNU Lesser General Public License Version 2.1
12 * =============================================
13 * Copyright 2000 by Sun Microsystems, Inc.
14 * 901 San Antonio Road, Palo Alto, CA 94303, USA
15 *
16 * This library is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU Lesser General Public
18 * License version 2.1, as published by the Free Software Foundation.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
28 * MA 02111-1307 USA
29 *
30 *
31 * Sun Industry Standards Source License Version 1.1
32 * =================================================
33 * The contents of this file are subject to the Sun Industry Standards
34 * Source License Version 1.1 (the "License"); You may not use this file
35 * except in compliance with the License. You may obtain a copy of the
36 * License at http://www.openoffice.org/license.html.
37 *
38 * Software provided under this License is provided on an "AS IS" basis,
39 * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
40 * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
41 * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
42 * See the License for the specific provisions governing your rights and
43 * obligations concerning the Software.
44 *
45 * The Initial Developer of the Original Code is: IBM Corporation
46 *
47 * Copyright: 2008 by IBM Corporation
48 *
49 * All Rights Reserved.
50 *
51 * Contributor(s): _______________________________________
52 *
53 *
54 ************************************************************************/
55 #include "first.hxx"
56 #include "assert.h"
57 namespace OpenStormBento
58 {
59
60 BenError
61 CBenTOCReader::ReadLabelAndTOC()
62 {
63 BenError Err;
64
65 unsigned long TOCOffset;
66 if ((Err = ReadLabel(&TOCOffset, &cTOCSize)) != BenErr_OK)
67 return Err;
68
69 if ((Err = cpContainer->SeekToPosition(TOCOffset)) != BenErr_OK)
70 return Err;
71
72 cpTOC = new BenByte[cTOCSize];
73 if ((Err = cpContainer->ReadKnownSize(cpTOC, cTOCSize)) != BenErr_OK)
74 return Err;
75
76 if ((Err = ReadTOC()) != BenErr_OK)
77 return Err;
78
79 return BenErr_OK;
80 }
81
82 BenError
83 CBenTOCReader::ReadLabel(unsigned long * pTOCOffset, unsigned long * pTOCSize)
84 {
85 // If seek fails, then probably because stream is smaller than
86 // BEN_LABEL_SIZE and thus can't be Bento container
87 BenError Err;
88 if ((Err = cpContainer->SeekFromEnd(-BEN_LABEL_SIZE)) != BenErr_OK)
89 return BenErr_NotBentoContainer;
90
91 BenByte Label[BEN_LABEL_SIZE];
92 if ((Err = cpContainer->ReadKnownSize(Label, BEN_LABEL_SIZE)) != BenErr_OK)
93 return Err;
94
95 if (memcmp(Label, gsBenMagicBytes, BEN_MAGIC_BYTES_SIZE) != 0)
96 if ((Err = SearchForLabel(Label)) != BenErr_OK)
97 return Err;
98
99 BenByte * pCurrLabel = Label + BEN_MAGIC_BYTES_SIZE;
100
101 BenWord Flags = UtGetIntelWord(pCurrLabel); pCurrLabel += 2; // Flags
102 // Newer files are 0x0101--indicates if big or little endian. Older
103 // files are 0x0 for flags
104 assert(Flags == 0x0101 || Flags == 0x0);
105
106 cBlockSize = UtGetIntelWord(pCurrLabel) * 1024; pCurrLabel += 2;
107
108 // Check major version
109 if (UtGetIntelWord(pCurrLabel) != BEN_CURR_MAJOR_VERSION)
110 return BenErr_UnknownBentoFormatVersion;
111 pCurrLabel += 2;
112
113 UtGetIntelWord(pCurrLabel); pCurrLabel += 2; // Minor version
114
115 *pTOCOffset = UtGetIntelDWord(pCurrLabel); pCurrLabel += 4;
116 *pTOCSize = UtGetIntelDWord(pCurrLabel);
117
118 assert(pCurrLabel + 4 == Label + BEN_LABEL_SIZE);
119
120 return BenErr_OK;
121 }
122
123 #define LABEL_READ_BUFFER_SIZE 500
124 #define MAX_SEARCH_AMOUNT 1024 * 1024
125
126 BenError
127 CBenTOCReader::SearchForLabel(BenByte * pLabel)
128 {
129 BenError Err;
130
131 unsigned long Length;
132 if ((Err = cpContainer->GetSize(&Length)) != BenErr_OK)
133 return Err;
134
135 // Always ready to check for MagicBytes from
136 // CurrOffset - BEN_MAGIC_BYTES_SIZE to CurrOffset - 1
137 unsigned long CurrOffset = Length - BEN_LABEL_SIZE + BEN_MAGIC_BYTES_SIZE -
138 1;
139
140 char Buffer[LABEL_READ_BUFFER_SIZE];
141
142 unsigned long BufferStartOffset = Length; // Init to big value
143
144 while (CurrOffset >= BEN_MAGIC_BYTES_SIZE)
145 {
146 // Don't search backwards more than 1 meg
147 if (Length - CurrOffset > MAX_SEARCH_AMOUNT)
148 break;
149
150 unsigned long UsedBufferSize;
151
152 // If before beginning of buffer
153 if (CurrOffset - BEN_MAGIC_BYTES_SIZE < BufferStartOffset)
154 {
155 if (CurrOffset < LABEL_READ_BUFFER_SIZE)
156 UsedBufferSize = CurrOffset;
157 else UsedBufferSize = LABEL_READ_BUFFER_SIZE;
158
159 if ((Err = cpContainer->SeekToPosition(CurrOffset - UsedBufferSize))
160 != BenErr_OK)
161 return Err;
162
163 if ((Err = cpContainer->ReadKnownSize(Buffer, UsedBufferSize)) !=
164 BenErr_OK)
165 return Err;
166
167 BufferStartOffset = CurrOffset - UsedBufferSize;
168 }
169
170 if (memcmp(Buffer + (CurrOffset - BEN_MAGIC_BYTES_SIZE -
171 BufferStartOffset), gsBenMagicBytes, BEN_MAGIC_BYTES_SIZE) == 0)
172 {
173 if ((Err = cpContainer->SeekToPosition(CurrOffset -
174 BEN_MAGIC_BYTES_SIZE)) != BenErr_OK)
175 return Err;
176
177 return cpContainer->ReadKnownSize(pLabel, BEN_LABEL_SIZE);
178 }
179
180 --CurrOffset;
181 }
182
183 return BenErr_NotBentoContainer; // Didn't find magic bytes
184 }
185
186 BenError
187 CBenTOCReader::ReadTOC()
188 {
189 BenError Err;
190 BenByte LookAhead = GetCode();
191 BenGeneration Generation = 0;
192
193 // Read in all objects
194 while (LookAhead == BEN_NEW_OBJECT)
195 {
196 BenObjectID ObjectID;
197 if ((Err = GetDWord(&ObjectID)) != BenErr_OK)
198 return Err;
199 pCBenObject pObject = NULL;
200
201 // Read in all properties for object
202 do
203 {
204 BenObjectID PropertyID;
205
206 if ((Err = GetDWord(&PropertyID)) != BenErr_OK)
207 return Err;
208 pCBenProperty pProperty = NULL;
209
210 // Read in all values for property
211 do
212 {
213 BenObjectID ReferencedListID = 0;
214
215 BenObjectID TypeID;
216 if ((Err = GetDWord(&TypeID)) != BenErr_OK)
217 return Err;
218 LookAhead = GetCode();
219
220 if (LookAhead == BEN_EXPLICIT_GEN)
221 {
222 if ((Err = GetDWord(&Generation)) != BenErr_OK)
223 return Err;
224 LookAhead = GetCode();
225 }
226
227 if (LookAhead == BEN_REFERENCE_LIST_ID)
228 {
229 // Eat it, unless BENUTIL_SUPPORT turned on
230 if ((Err = GetDWord(&ReferencedListID)) != BenErr_OK)
231 return Err;
232 LookAhead = GetCode();
233 }
234
235 if (PropertyID == BEN_PROPID_GLOBAL_PROPERTY_NAME ||
236 PropertyID == BEN_PROPID_GLOBAL_TYPE_NAME)
237 {
238 // Read property or type name
239
240 if (pObject != NULL || TypeID != BEN_TYPEID_7_BIT_ASCII ||
241 LookAhead != BEN_OFFSET4_LEN4)
242 return BenErr_NamedObjectError;
243
244 BenContainerPos Pos;
245 unsigned long Length;
246
247 if ((Err = GetDWord(&Pos)) != BenErr_OK)
248 return Err;
249 if ((Err = GetDWord(&Length)) != BenErr_OK)
250 return Err;
251 LookAhead = GetCode();
252
253 if ((Err = cpContainer->SeekToPosition(Pos)) != BenErr_OK)
254 return Err;
255
256 #define STACK_BUFFER_SIZE 256
257 char sStackBuffer[STACK_BUFFER_SIZE];
258 char * sAllocBuffer;
259 char * sBuffer;
260 if (Length > STACK_BUFFER_SIZE)
261 {
262 sBuffer = new char[Length];
263 sAllocBuffer = sBuffer;
264 }
265 else
266 {
267 sBuffer = sStackBuffer;
268 sAllocBuffer = NULL;
269 }
270
271 if ((Err = cpContainer->ReadKnownSize(sBuffer, Length)) !=
272 BenErr_OK)
273 {
274 delete[] sAllocBuffer;
275 return Err;
276 }
277
278 pCBenNamedObjectListElmt pPrevNamedObjectListElmt;
279 if (FindNamedObject(cpContainer->GetNamedObjects(),
280 sBuffer, &pPrevNamedObjectListElmt) != NULL)
281 {
282 delete[] sAllocBuffer;
283 return BenErr_DuplicateName;
284 }
285
286 pCBenObject pPrevObject = (pCBenObject) cpContainer->
287 GetObjects()->GetLast();
288
289 if (PropertyID == BEN_PROPID_GLOBAL_PROPERTY_NAME)
290 pObject = new CBenPropertyName(cpContainer, ObjectID,
291 pPrevObject, sBuffer, pPrevNamedObjectListElmt);
292 else pObject = new CBenTypeName(cpContainer, ObjectID,
293 pPrevObject, sBuffer, pPrevNamedObjectListElmt);
294
295 delete[] sAllocBuffer;
296 }
297 // If BENUTIL_SUPPORT turned on, read in references object
298 // like regular object
299 #ifndef BENUTIL_SUPPORT
300 else if (PropertyID == BEN_PROPID_OBJ_REFERENCES)
301 {
302 // Don't need to read in references object--we assume
303 // that all references use object ID as key
304 if ((Err = ReadSegments(NULL, &LookAhead)) != BenErr_OK)
305 return Err;
306 }
307 #endif
308 else if (ObjectID == BEN_OBJID_TOC)
309 {
310 if (PropertyID == BEN_PROPID_TOC_SEED)
311 {
312 if (TypeID != BEN_TYPEID_TOC_TYPE ||
313 LookAhead != BEN_IMMEDIATE4)
314 return BenErr_TOCSeedError;
315
316 BenDWord Data;
317 if ((Err = GetDWord(&Data)) != BenErr_OK)
318 return Err;
319 LookAhead = GetCode();
320
321 cpContainer->SetNextAvailObjectID(Data);
322 }
323 else
324 {
325 // Ignore the other BEN_OBJID_TOC properties
326 if ((Err = ReadSegments(NULL, &LookAhead)) != BenErr_OK)
327 return Err;
328 }
329 }
330 else
331 {
332 if (pProperty != NULL)
333 return BenErr_PropertyWithMoreThanOneValue;
334
335 if (pObject == NULL)
336 pObject = new CBenObject(cpContainer, ObjectID,
337 (pCBenObject) cpContainer->GetObjects()->GetLast());
338
339 pProperty = new CBenProperty(pObject, PropertyID, TypeID,
340 (pCBenProperty) pObject->GetProperties()->GetLast());
341
342 #ifdef BENUTIL_SUPPORT
343 pProperty->UseValue()->
344 SetReferencedListObjectID(ReferencedListID);
345 #endif
346
347 if ((Err = ReadSegments(pProperty->UseValue(),
348 &LookAhead)) != BenErr_OK)
349 return Err;
350 }
351 } while (LookAhead == BEN_NEW_TYPE);
352 } while (LookAhead == BEN_NEW_PROPERTY);
353 }
354
355 if (LookAhead == BEN_READ_PAST_END_OF_TOC)
356 return BenErr_OK;
357 else return BenErr_InvalidTOC;
358 }
359
360 BenError
361 CBenTOCReader::ReadSegments(pCBenValue pValue, BenByte * pLookAhead)
362 {
363 BenError Err;
364
365 while (*pLookAhead >= BEN_SEGMENT_CODE_START &&
366 *pLookAhead <= BEN_SEGMENT_CODE_END)
367 {
368 if ((Err = ReadSegment(pValue, pLookAhead)) !=
369 BenErr_OK)
370 return Err;
371 }
372
373 return BenErr_OK;
374 }
375
376 BenError
377 CBenTOCReader::ReadSegment(pCBenValue pValue, BenByte * pLookAhead)
378 {
379 BenError Err;
380
381 UtBool Immediate = UT_FALSE;
382 UtBool EightByteOffset = UT_FALSE;
383 unsigned long Offset, Length;
384
385 switch (*pLookAhead)
386 {
387 case BEN_CONT_OFFSET4_LEN4:
388 case BEN_OFFSET4_LEN4:
389 if ((Err = GetDWord(&Offset)) != BenErr_OK)
390 return Err;
391 if ((Err = GetDWord(&Length)) != BenErr_OK)
392 return Err;
393 break;
394
395 case BEN_IMMEDIATE0:
396 Length = 0; Immediate = UT_TRUE;
397 break;
398
399 case BEN_IMMEDIATE1:
400 Length = 1; Immediate = UT_TRUE;
401 break;
402
403 case BEN_IMMEDIATE2:
404 Length = 2; Immediate = UT_TRUE;
405 break;
406
407 case BEN_IMMEDIATE3:
408 Length = 3; Immediate = UT_TRUE;
409 break;
410
411 case BEN_CONT_IMMEDIATE4:
412 case BEN_IMMEDIATE4:
413 Length = 4; Immediate = UT_TRUE;
414 break;
415
416 case BEN_CONT_OFFSET8_LEN4:
417 case BEN_OFFSET8_LEN4:
418 EightByteOffset = UT_TRUE;
419 break;
420
421 default:
422 return BenErr_OK;
423 }
424
425 BenByte ImmData[4];
426 if (Immediate && Length != 0)
427 if ((Err = GetData(ImmData, 4)) != BenErr_OK)
428 return Err;
429
430 *pLookAhead = GetCode();
431
432 if (EightByteOffset)
433 return BenErr_64BitOffsetNotSupported;
434
435 if (pValue != NULL)
436 {
437 if (! Immediate)
438 new CBenValueSegment(pValue, Offset, Length);
439 else if (Length != 0)
440 {
441 assert(Length <= 4);
442 new CBenValueSegment(pValue, ImmData, (unsigned short) Length);
443 }
444 }
445
446 return BenErr_OK;
447 }
448
449 UtBool
450 CBenTOCReader::CanGetData(unsigned long Amt)
451 {
452 return cCurr + Amt <= cTOCSize;
453 }
454
455 BenError
456 CBenTOCReader::GetByte(BenByte * pByte)
457 {
458 if (! CanGetData(1))
459 return BenErr_ReadPastEndOfTOC;
460
461 *pByte = UtGetIntelByte(cpTOC + cCurr);
462 ++cCurr;
463 return BenErr_OK;
464 }
465
466 BenError
467 CBenTOCReader::GetWord(BenWord * pWord)
468 {
469 if (! CanGetData(2))
470 return BenErr_ReadPastEndOfTOC;
471
472 *pWord = UtGetIntelWord(cpTOC + cCurr);
473 cCurr += 2;
474 return BenErr_OK;
475 }
476
477 BenError
478 CBenTOCReader::GetDWord(BenDWord * pDWord)
479 {
480 if (! CanGetData(4))
481 return BenErr_ReadPastEndOfTOC;
482
483 *pDWord = UtGetIntelDWord(cpTOC + cCurr);
484 cCurr += 4;
485 return BenErr_OK;
486 }
487
488 BenByte
489 CBenTOCReader::GetCode()
490 {
491 BenByte Code;
492 do
493 {
494 if (GetByte(&Code) != BenErr_OK)
495 return BEN_READ_PAST_END_OF_TOC;
496
497 if (Code == BEN_END_OF_BUFFER)
498 // Advance to next block
499 cCurr = cBlockSize * ((cCurr + (cBlockSize - 1)) /
500 cBlockSize);
501 }
502 while (Code == BEN_NOOP || Code == BEN_END_OF_BUFFER);
503 return Code;
504 }
505
506 BenError
507 CBenTOCReader::GetData(BenDataPtr pBuffer, unsigned long Amt)
508 {
509 if (! CanGetData(Amt))
510 return BenErr_ReadPastEndOfTOC;
511
512 UtHugeMemcpy(pBuffer, cpTOC + cCurr, Amt);
513 cCurr += Amt;
514 return BenErr_OK;
515 }
516 }//end OpenStormBento namespace
vba interoperability for OOo