?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / oox / source / dump / dumperbase.cxx
blob81f63062b4ad85dff160c70c82724556093b142f
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: dumperbase.cxx,v $
10 * $Revision: 1.4.20.13 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 #include "oox/dump/dumperbase.hxx"
32
33 #include <algorithm>
34 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
35 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
36 #include <com/sun/star/io/XActiveDataSink.hpp>
37 #include <com/sun/star/io/XActiveDataSource.hpp>
38 #include <com/sun/star/io/XTextInputStream.hpp>
39 #include <com/sun/star/io/XTextOutputStream.hpp>
40 #include <rtl/math.hxx>
41 #include <osl/file.hxx>
42 #include <comphelper/docpasswordhelper.hxx>
43 #include "oox/helper/binaryoutputstream.hxx"
44 #include "oox/core/filterbase.hxx"
45 #include "oox/xls/biffhelper.hxx"
46
47 #if OOX_INCLUDE_DUMPER
48
49 using ::rtl::OString;
50 using ::rtl::OStringBuffer;
51 using ::rtl::OStringToOUString;
52 using ::rtl::OUString;
53 using ::rtl::OUStringBuffer;
54 using ::rtl::OUStringToOString;
55 using ::com::sun::star::uno::Exception;
56 using ::com::sun::star::uno::Reference;
57 using ::com::sun::star::uno::UNO_QUERY_THROW;
58 using ::com::sun::star::util::DateTime;
59 using ::com::sun::star::lang::XMultiServiceFactory;
60 using ::com::sun::star::ucb::XSimpleFileAccess;
61 using ::com::sun::star::io::XActiveDataSink;
62 using ::com::sun::star::io::XActiveDataSource;
63 using ::com::sun::star::io::XInputStream;
64 using ::com::sun::star::io::XOutputStream;
65 using ::com::sun::star::io::XTextInputStream;
66 using ::com::sun::star::io::XTextOutputStream;
67 using ::comphelper::MediaDescriptor;
68 using ::oox::core::FilterBase;
69
70 namespace oox {
71 namespace dump {
72
73 const sal_Unicode OOX_DUMP_BOM = 0xFEFF;
74 const sal_Int32 OOX_DUMP_MAXSTRLEN = 80;
75 const sal_Int32 OOX_DUMP_INDENT = 2;
76 const sal_Unicode OOX_DUMP_BINDOT = '.';
77 const sal_Unicode OOX_DUMP_CFG_LISTSEP = ',';
78 const sal_Unicode OOX_DUMP_CFG_QUOTE = '\'';
79 const sal_Unicode OOX_DUMP_LF = '\n';
80 const sal_Unicode OOX_DUMP_ITEMSEP = '=';
81 const sal_Int32 OOX_DUMP_BYTESPERLINE = 16;
82 const sal_Int64 OOX_DUMP_MAXARRAY = 16;
83
84 // ============================================================================
85 // ============================================================================
86
87 // file names -----------------------------------------------------------------
88
89 OUString InputOutputHelper::convertFileNameToUrl( const OUString& rFileName )
90 {
91 OUString aFileUrl;
92 if( ::osl::FileBase::getFileURLFromSystemPath( rFileName, aFileUrl ) == ::osl::FileBase::E_None )
93 return aFileUrl;
94 return OUString();
95 }
96
97 sal_Int32 InputOutputHelper::getFileNamePos( const OUString& rFileUrl )
98 {
99 sal_Int32 nSepPos = rFileUrl.lastIndexOf( '/' );
100 return (nSepPos < 0) ? 0 : (nSepPos + 1);
101 }
102
103 OUString InputOutputHelper::getFileNameExtension( const OUString& rFileUrl )
104 {
105 sal_Int32 nNamePos = getFileNamePos( rFileUrl );
106 sal_Int32 nExtPos = rFileUrl.lastIndexOf( '.' );
107 if( nExtPos >= nNamePos )
108 return rFileUrl.copy( nExtPos + 1 );
109 return OUString();
110 }
111
112 // input streams --------------------------------------------------------------
113
114 Reference< XInputStream > InputOutputHelper::getXInputStream( BinaryInputStream& rStrm )
115 {
116 if( BinaryXInputStream* pXStrm = dynamic_cast< BinaryXInputStream* >( &rStrm ) )
117 return pXStrm->getXInputStream();
118 return 0;
119 }
120
121 Reference< XInputStream > InputOutputHelper::openInputStream(
122 const Reference< XMultiServiceFactory >& rxFactory, const OUString& rFileName )
123 {
124 Reference< XInputStream > xInStrm;
125 if( rxFactory.is() ) try
126 {
127 Reference< XSimpleFileAccess > xFileAccess( rxFactory->createInstance( CREATE_OUSTRING( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY_THROW );
128 xInStrm = xFileAccess->openFileRead( rFileName );
129 }
130 catch( Exception& )
131 {
132 }
133 return xInStrm;
134 }
135
136 Reference< XTextInputStream > InputOutputHelper::openTextInputStream(
137 const Reference< XMultiServiceFactory >& rxFactory, const Reference< XInputStream >& rxInStrm, const OUString& rEncoding )
138 {
139 Reference< XTextInputStream > xTextInStrm;
140 if( rxFactory.is() && rxInStrm.is() ) try
141 {
142 Reference< XActiveDataSink > xDataSink( rxFactory->createInstance( CREATE_OUSTRING( "com.sun.star.io.TextInputStream" ) ), UNO_QUERY_THROW );
143 xDataSink->setInputStream( rxInStrm );
144 xTextInStrm.set( xDataSink, UNO_QUERY_THROW );
145 xTextInStrm->setEncoding( rEncoding );
146 }
147 catch( Exception& )
148 {
149 }
150 return xTextInStrm;
151 }
152
153 Reference< XTextInputStream > InputOutputHelper::openTextInputStream(
154 const Reference< XMultiServiceFactory >& rxFactory, const OUString& rFileName, const OUString& rEncoding )
155 {
156 return openTextInputStream( rxFactory, openInputStream( rxFactory, rFileName ), rEncoding );
157 }
158
159 // output streams -------------------------------------------------------------
160
161 Reference< XOutputStream > InputOutputHelper::openOutputStream(
162 const Reference< XMultiServiceFactory >& rxFactory, const OUString& rFileName )
163 {
164 Reference< XOutputStream > xOutStrm;
165 if( rxFactory.is() ) try
166 {
167 Reference< XSimpleFileAccess > xFileAccess( rxFactory->createInstance( CREATE_OUSTRING( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY_THROW );
168 xOutStrm = xFileAccess->openFileWrite( rFileName );
169 }
170 catch( Exception& )
171 {
172 }
173 return xOutStrm;
174 }
175
176 Reference< XTextOutputStream > InputOutputHelper::openTextOutputStream(
177 const Reference< XMultiServiceFactory >& rxFactory, const Reference< XOutputStream >& rxOutStrm, const OUString& rEncoding )
178 {
179 Reference< XTextOutputStream > xTextOutStrm;
180 if( rxFactory.is() && rxOutStrm.is() ) try
181 {
182 Reference< XActiveDataSource > xDataSource( rxFactory->createInstance( CREATE_OUSTRING( "com.sun.star.io.TextOutputStream" ) ), UNO_QUERY_THROW );
183 xDataSource->setOutputStream( rxOutStrm );
184 xTextOutStrm.set( xDataSource, UNO_QUERY_THROW );
185 xTextOutStrm->setEncoding( rEncoding );
186 }
187 catch( Exception& )
188 {
189 }
190 return xTextOutStrm;
191 }
192
193 Reference< XTextOutputStream > InputOutputHelper::openTextOutputStream(
194 const Reference< XMultiServiceFactory >& rxFactory, const OUString& rFileName, const OUString& rEncoding )
195 {
196 return openTextOutputStream( rxFactory, openOutputStream( rxFactory, rFileName ), rEncoding );
197 }
198
199 // ============================================================================
200 // ============================================================================
201
202 ItemFormat::ItemFormat() :
203 meDataType( DATATYPE_VOID ),
204 meFmtType( FORMATTYPE_NONE )
205 {
206 }
207
208 void ItemFormat::set( DataType eDataType, FormatType eFmtType, const OUString& rItemName )
209 {
210 meDataType = eDataType;
211 meFmtType = eFmtType;
212 maItemName = rItemName;
213 maListName = OUString();
214 }
215
216 void ItemFormat::set( DataType eDataType, FormatType eFmtType, const OUString& rItemName, const OUString& rListName )
217 {
218 set( eDataType, eFmtType, rItemName );
219 maListName = rListName;
220 }
221
222 OUStringVector::const_iterator ItemFormat::parse( const OUStringVector& rFormatVec )
223 {
224 set( DATATYPE_VOID, FORMATTYPE_NONE, OUString() );
225
226 OUStringVector::const_iterator aIt = rFormatVec.begin(), aEnd = rFormatVec.end();
227 OUString aDataType, aFmtType;
228 if( aIt != aEnd ) aDataType = *aIt++;
229 if( aIt != aEnd ) aFmtType = *aIt++;
230 if( aIt != aEnd ) maItemName = *aIt++;
231 if( aIt != aEnd ) maListName = *aIt++;
232
233 meDataType = StringHelper::convertToDataType( aDataType );
234 meFmtType = StringHelper::convertToFormatType( aFmtType );
235
236 if( meFmtType == FORMATTYPE_NONE )
237 {
238 if( aFmtType.equalsAscii( "unused" ) )
239 set( meDataType, FORMATTYPE_HEX, CREATE_OUSTRING( OOX_DUMP_UNUSED ) );
240 else if( aFmtType.equalsAscii( "unknown" ) )
241 set( meDataType, FORMATTYPE_HEX, CREATE_OUSTRING( OOX_DUMP_UNKNOWN ) );
242 }
243
244 return aIt;
245 }
246
247 OUStringVector ItemFormat::parse( const OUString& rFormatStr )
248 {
249 OUStringVector aFormatVec;
250 StringHelper::convertStringToStringList( aFormatVec, rFormatStr, false );
251 OUStringVector::const_iterator aIt = parse( aFormatVec );
252 return OUStringVector( aIt, const_cast< const OUStringVector& >( aFormatVec ).end() );
253 }
254
255 // ============================================================================
256 // ============================================================================
257
258 // append string to string ----------------------------------------------------
259
260 void StringHelper::appendChar( OUStringBuffer& rStr, sal_Unicode cChar, sal_Int32 nCount )
261 {
262 for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
263 rStr.append( cChar );
264 }
265
266 void StringHelper::appendString( OUStringBuffer& rStr, const OUString& rData, sal_Int32 nWidth, sal_Unicode cFill )
267 {
268 appendChar( rStr, cFill, nWidth - rData.getLength() );
269 rStr.append( rData );
270 }
271
272 // append decimal -------------------------------------------------------------
273
274 void StringHelper::appendDec( OUStringBuffer& rStr, sal_uInt8 nData, sal_Int32 nWidth, sal_Unicode cFill )
275 {
276 appendString( rStr, OUString::valueOf( static_cast< sal_Int32 >( nData ) ), nWidth, cFill );
277 }
278
279 void StringHelper::appendDec( OUStringBuffer& rStr, sal_Int8 nData, sal_Int32 nWidth, sal_Unicode cFill )
280 {
281 appendString( rStr, OUString::valueOf( static_cast< sal_Int32 >( nData ) ), nWidth, cFill );
282 }
283
284 void StringHelper::appendDec( OUStringBuffer& rStr, sal_uInt16 nData, sal_Int32 nWidth, sal_Unicode cFill )
285 {
286 appendString( rStr, OUString::valueOf( static_cast< sal_Int32 >( nData ) ), nWidth, cFill );
287 }
288
289 void StringHelper::appendDec( OUStringBuffer& rStr, sal_Int16 nData, sal_Int32 nWidth, sal_Unicode cFill )
290 {
291 appendString( rStr, OUString::valueOf( static_cast< sal_Int32 >( nData ) ), nWidth, cFill );
292 }
293
294 void StringHelper::appendDec( OUStringBuffer& rStr, sal_uInt32 nData, sal_Int32 nWidth, sal_Unicode cFill )
295 {
296 appendString( rStr, OUString::valueOf( static_cast< sal_Int64 >( nData ) ), nWidth, cFill );
297 }
298
299 void StringHelper::appendDec( OUStringBuffer& rStr, sal_Int32 nData, sal_Int32 nWidth, sal_Unicode cFill )
300 {
301 appendString( rStr, OUString::valueOf( nData ), nWidth, cFill );
302 }
303
304 void StringHelper::appendDec( OUStringBuffer& rStr, sal_uInt64 nData, sal_Int32 nWidth, sal_Unicode cFill )
305 {
306 /* Values greater than biggest signed 64bit integer will change to
307 negative when converting to sal_Int64. Therefore, the trailing digit
308 will be written separately. */
309 OUStringBuffer aBuffer;
310 if( nData > 9 )
311 aBuffer.append( OUString::valueOf( static_cast< sal_Int64 >( nData / 10 ) ) );
312 aBuffer.append( static_cast< sal_Unicode >( '0' + (nData % 10) ) );
313 appendString( rStr, aBuffer.makeStringAndClear(), nWidth, cFill );
314 }
315
316 void StringHelper::appendDec( OUStringBuffer& rStr, sal_Int64 nData, sal_Int32 nWidth, sal_Unicode cFill )
317 {
318 appendString( rStr, OUString::valueOf( nData ), nWidth, cFill );
319 }
320
321 void StringHelper::appendDec( OUStringBuffer& rStr, double fData, sal_Int32 nWidth, sal_Unicode cFill )
322 {
323 appendString( rStr, ::rtl::math::doubleToUString( fData, rtl_math_StringFormat_G, 15, '.', true ), nWidth, cFill );
324 }
325
326 // append hexadecimal ---------------------------------------------------------
327
328 void StringHelper::appendHex( OUStringBuffer& rStr, sal_uInt8 nData, bool bPrefix )
329 {
330 static const sal_Unicode spcHexDigits[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
331 if( bPrefix )
332 rStr.appendAscii( "0x" );
333 rStr.append( spcHexDigits[ (nData >> 4) & 0x0F ] ).append( spcHexDigits[ nData & 0x0F ] );
334 }
335
336 void StringHelper::appendHex( OUStringBuffer& rStr, sal_Int8 nData, bool bPrefix )
337 {
338 appendHex( rStr, static_cast< sal_uInt8 >( nData ), bPrefix );
339 }
340
341 void StringHelper::appendHex( OUStringBuffer& rStr, sal_uInt16 nData, bool bPrefix )
342 {
343 appendHex( rStr, static_cast< sal_uInt8 >( nData >> 8 ), bPrefix );
344 appendHex( rStr, static_cast< sal_uInt8 >( nData ), false );
345 }
346
347 void StringHelper::appendHex( OUStringBuffer& rStr, sal_Int16 nData, bool bPrefix )
348 {
349 appendHex( rStr, static_cast< sal_uInt16 >( nData ), bPrefix );
350 }
351
352 void StringHelper::appendHex( OUStringBuffer& rStr, sal_uInt32 nData, bool bPrefix )
353 {
354 appendHex( rStr, static_cast< sal_uInt16 >( nData >> 16 ), bPrefix );
355 appendHex( rStr, static_cast< sal_uInt16 >( nData ), false );
356 }
357
358 void StringHelper::appendHex( OUStringBuffer& rStr, sal_Int32 nData, bool bPrefix )
359 {
360 appendHex( rStr, static_cast< sal_uInt32 >( nData ), bPrefix );
361 }
362
363 void StringHelper::appendHex( OUStringBuffer& rStr, sal_uInt64 nData, bool bPrefix )
364 {
365 appendHex( rStr, static_cast< sal_uInt32 >( nData >> 32 ), bPrefix );
366 appendHex( rStr, static_cast< sal_uInt32 >( nData ), false );
367 }
368
369 void StringHelper::appendHex( OUStringBuffer& rStr, sal_Int64 nData, bool bPrefix )
370 {
371 appendHex( rStr, static_cast< sal_uInt64 >( nData ), bPrefix );
372 }
373
374 void StringHelper::appendHex( OUStringBuffer& rStr, double fData, bool bPrefix )
375 {
376 appendHex( rStr, *reinterpret_cast< const sal_uInt64* >( &fData ), bPrefix );
377 }
378
379 // append shortened hexadecimal -----------------------------------------------
380
381 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_uInt8 nData, bool bPrefix )
382 {
383 appendHex( rStr, nData, bPrefix );
384 }
385
386 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_Int8 nData, bool bPrefix )
387 {
388 appendHex( rStr, nData, bPrefix );
389 }
390
391 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_uInt16 nData, bool bPrefix )
392 {
393 if( nData > SAL_MAX_UINT8 )
394 appendHex( rStr, nData, bPrefix );
395 else
396 appendHex( rStr, static_cast< sal_uInt8 >( nData ), bPrefix );
397 }
398
399 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_Int16 nData, bool bPrefix )
400 {
401 appendShortHex( rStr, static_cast< sal_uInt16 >( nData ), bPrefix );
402 }
403
404 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_uInt32 nData, bool bPrefix )
405 {
406 if( nData > SAL_MAX_UINT16 )
407 appendHex( rStr, nData, bPrefix );
408 else
409 appendShortHex( rStr, static_cast< sal_uInt16 >( nData ), bPrefix );
410 }
411
412 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_Int32 nData, bool bPrefix )
413 {
414 appendShortHex( rStr, static_cast< sal_uInt32 >( nData ), bPrefix );
415 }
416
417 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_uInt64 nData, bool bPrefix )
418 {
419 if( nData > SAL_MAX_UINT32 )
420 appendHex( rStr, nData, bPrefix );
421 else
422 appendShortHex( rStr, static_cast< sal_uInt32 >( nData ), bPrefix );
423 }
424
425 void StringHelper::appendShortHex( OUStringBuffer& rStr, sal_Int64 nData, bool bPrefix )
426 {
427 appendShortHex( rStr, static_cast< sal_uInt64 >( nData ), bPrefix );
428 }
429
430 void StringHelper::appendShortHex( OUStringBuffer& rStr, double fData, bool bPrefix )
431 {
432 appendHex( rStr, fData, bPrefix );
433 }
434
435 // append binary --------------------------------------------------------------
436
437 void StringHelper::appendBin( OUStringBuffer& rStr, sal_uInt8 nData, bool bDots )
438 {
439 for( sal_uInt8 nMask = 0x80; nMask != 0; (nMask >>= 1) &= 0x7F )
440 {
441 rStr.append( static_cast< sal_Unicode >( (nData & nMask) ? '1' : '0' ) );
442 if( bDots && (nMask == 0x10) )
443 rStr.append( OOX_DUMP_BINDOT );
444 }
445 }
446
447 void StringHelper::appendBin( OUStringBuffer& rStr, sal_Int8 nData, bool bDots )
448 {
449 appendBin( rStr, static_cast< sal_uInt8 >( nData ), bDots );
450 }
451
452 void StringHelper::appendBin( OUStringBuffer& rStr, sal_uInt16 nData, bool bDots )
453 {
454 appendBin( rStr, static_cast< sal_uInt8 >( nData >> 8 ), bDots );
455 if( bDots )
456 rStr.append( OOX_DUMP_BINDOT );
457 appendBin( rStr, static_cast< sal_uInt8 >( nData ), bDots );
458 }
459
460 void StringHelper::appendBin( OUStringBuffer& rStr, sal_Int16 nData, bool bDots )
461 {
462 appendBin( rStr, static_cast< sal_uInt16 >( nData ), bDots );
463 }
464
465 void StringHelper::appendBin( OUStringBuffer& rStr, sal_uInt32 nData, bool bDots )
466 {
467 appendBin( rStr, static_cast< sal_uInt16 >( nData >> 16 ), bDots );
468 if( bDots )
469 rStr.append( OOX_DUMP_BINDOT );
470 appendBin( rStr, static_cast< sal_uInt16 >( nData ), bDots );
471 }
472
473 void StringHelper::appendBin( OUStringBuffer& rStr, sal_Int32 nData, bool bDots )
474 {
475 appendBin( rStr, static_cast< sal_uInt32 >( nData ), bDots );
476 }
477
478 void StringHelper::appendBin( OUStringBuffer& rStr, sal_uInt64 nData, bool bDots )
479 {
480 appendBin( rStr, static_cast< sal_uInt32 >( nData >> 32 ), bDots );
481 if( bDots )
482 rStr.append( OOX_DUMP_BINDOT );
483 appendBin( rStr, static_cast< sal_uInt32 >( nData ), bDots );
484 }
485
486 void StringHelper::appendBin( OUStringBuffer& rStr, sal_Int64 nData, bool bDots )
487 {
488 appendBin( rStr, static_cast< sal_uInt64 >( nData ), bDots );
489 }
490
491 void StringHelper::appendBin( OUStringBuffer& rStr, double fData, bool bDots )
492 {
493 appendBin( rStr, *reinterpret_cast< const sal_uInt64* >( &fData ), bDots );
494 }
495
496 // append formatted value -----------------------------------------------------
497
498 void StringHelper::appendBool( OUStringBuffer& rStr, bool bData )
499 {
500 rStr.appendAscii( bData ? "true" : "false" );
501 }
502
503 // append columns, rows, addresses --------------------------------------------
504
505 void StringHelper::appendAddrCol( OUStringBuffer& rStr, sal_Int32 nCol, bool bRel )
506 {
507 if( !bRel ) rStr.append( OOX_DUMP_ADDRABS );
508 sal_Int32 nPos = rStr.getLength();
509 for( sal_Int32 nTemp = nCol; nTemp >= 0; (nTemp /= 26) -= 1 )
510 rStr.insert( nPos, static_cast< sal_Unicode >( 'A' + (nTemp % 26) ) );
511 }
512
513 void StringHelper::appendAddrRow( OUStringBuffer& rStr, sal_Int32 nRow, bool bRel )
514 {
515 if( !bRel ) rStr.append( OOX_DUMP_ADDRABS );
516 appendDec( rStr, nRow + 1 );
517 }
518
519 void StringHelper::appendAddrName( OUStringBuffer& rStr, sal_Unicode cPrefix, sal_Int32 nColRow, bool bRel )
520 {
521 rStr.append( cPrefix );
522 if( bRel && (nColRow != 0) )
523 {
524 rStr.append( OOX_DUMP_R1C1OPEN );
525 appendDec( rStr, nColRow );
526 rStr.append( OOX_DUMP_R1C1CLOSE );
527 }
528 else if( !bRel )
529 appendDec( rStr, nColRow + 1 );
530 }
531
532 void StringHelper::appendAddress( OUStringBuffer& rStr, const Address& rPos )
533 {
534 appendAddrCol( rStr, rPos.mnCol, true );
535 appendAddrRow( rStr, rPos.mnRow, true );
536 }
537
538 void StringHelper::appendRange( OUStringBuffer& rStr, const Range& rRange )
539 {
540 appendAddress( rStr, rRange.maFirst );
541 rStr.append( OOX_DUMP_RANGESEP );
542 appendAddress( rStr, rRange.maLast );
543 }
544
545 void StringHelper::appendRangeList( OUStringBuffer& rStr, const RangeList& rRanges )
546 {
547 OUStringBuffer aData;
548 for( RangeList::const_iterator aIt = rRanges.begin(), aEnd = rRanges.end(); aIt != aEnd; ++aIt )
549 {
550 OUStringBuffer aRange;
551 appendRange( aRange, *aIt );
552 appendToken( aData, aRange.makeStringAndClear(), OOX_DUMP_LISTSEP );
553 }
554 rStr.append( aData.makeStringAndClear() );
555 }
556
557 void StringHelper::appendAddress( OUStringBuffer& rStr, const TokenAddress& rPos, bool bR1C1 )
558 {
559 if( bR1C1 && (rPos.mbRelCol || rPos.mbRelRow) )
560 {
561 appendAddrName( rStr, OOX_DUMP_R1C1ROW, rPos.mnRow, rPos.mbRelRow );
562 appendAddrName( rStr, OOX_DUMP_R1C1COL, rPos.mnCol, rPos.mbRelCol );
563 }
564 else
565 {
566 appendAddrCol( rStr, rPos.mnCol, rPos.mbRelCol );
567 appendAddrRow( rStr, rPos.mnRow, rPos.mbRelRow );
568 }
569 }
570
571 void StringHelper::appendRange( OUStringBuffer& rStr, const TokenRange& rRange, bool bR1C1 )
572 {
573 appendAddress( rStr, rRange.maFirst, bR1C1 );
574 rStr.append( OOX_DUMP_RANGESEP );
575 appendAddress( rStr, rRange.maLast, bR1C1 );
576 }
577
578 // encoded text output --------------------------------------------------------
579
580 void StringHelper::appendCChar( OUStringBuffer& rStr, sal_Unicode cChar, bool bPrefix )
581 {
582 if( cChar > 0x00FF )
583 {
584 if( bPrefix )
585 rStr.appendAscii( "\\u" );
586 appendHex( rStr, static_cast< sal_uInt16 >( cChar ), false );
587 }
588 else
589 {
590 if( bPrefix )
591 rStr.appendAscii( "\\x" );
592 appendHex( rStr, static_cast< sal_uInt8 >( cChar ), false );
593 }
594 }
595
596 void StringHelper::appendEncChar( OUStringBuffer& rStr, sal_Unicode cChar, sal_Int32 nCount, bool bPrefix )
597 {
598 if( cChar < 0x0020 )
599 {
600 // C-style hex code
601 OUStringBuffer aCode;
602 appendCChar( aCode, cChar, bPrefix );
603 for( sal_Int32 nIdx = 0; nIdx < nCount; ++nIdx )
604 rStr.append( aCode );
605 }
606 else
607 {
608 appendChar( rStr, cChar, nCount );
609 }
610 }
611
612 void StringHelper::appendEncString( OUStringBuffer& rStr, const OUString& rData, bool bPrefix )
613 {
614 sal_Int32 nBeg = 0;
615 sal_Int32 nIdx = 0;
616 sal_Int32 nEnd = rData.getLength();
617 while( nIdx < nEnd )
618 {
619 // find next character that needs encoding
620 while( (nIdx < nEnd) && (rData[ nIdx ] >= 0x20) ) ++nIdx;
621 // append portion
622 if( nBeg < nIdx )
623 {
624 if( (nBeg == 0) && (nIdx == nEnd) )
625 rStr.append( rData );
626 else
627 rStr.append( rData.copy( nBeg, nIdx - nBeg ) );
628 }
629 // append characters to be encoded
630 while( (nIdx < nEnd) && (rData[ nIdx ] < 0x20) )
631 {
632 appendCChar( rStr, rData[ nIdx ], bPrefix );
633 ++nIdx;
634 }
635 // adjust limits
636 nBeg = nIdx;
637 }
638 }
639
640 // token list -----------------------------------------------------------------
641
642 void StringHelper::appendToken( OUStringBuffer& rStr, const OUString& rToken, sal_Unicode cSep )
643 {
644 if( (rStr.getLength() > 0) && (rToken.getLength() > 0) )
645 rStr.append( cSep );
646 rStr.append( rToken );
647 }
648
649 void StringHelper::appendToken( OUStringBuffer& rStr, sal_Int64 nToken, sal_Unicode cSep )
650 {
651 OUStringBuffer aToken;
652 appendDec( aToken, nToken );
653 appendToken( rStr, aToken.makeStringAndClear(), cSep );
654 }
655
656 void StringHelper::prependToken( OUStringBuffer& rStr, const OUString& rToken, sal_Unicode cSep )
657 {
658 if( (rStr.getLength() > 0) && (rToken.getLength() > 0) )
659 rStr.insert( 0, cSep );
660 rStr.insert( 0, rToken );
661 }
662
663 void StringHelper::prependToken( OUStringBuffer& rStr, sal_Int64 nToken, sal_Unicode cSep )
664 {
665 OUStringBuffer aToken;
666 appendDec( aToken, nToken );
667 prependToken( rStr, aToken.makeStringAndClear(), cSep );
668 }
669
670 void StringHelper::appendIndex( OUStringBuffer& rStr, const OUString& rIdx )
671 {
672 rStr.append( sal_Unicode( '[' ) ).append( rIdx ).append( sal_Unicode( ']' ) );
673 }
674
675 void StringHelper::appendIndex( OUStringBuffer& rStr, sal_Int64 nIdx )
676 {
677 OUStringBuffer aToken;
678 appendDec( aToken, nIdx );
679 appendIndex( rStr, aToken.makeStringAndClear() );
680 }
681
682 void StringHelper::appendIndexedText( OUStringBuffer& rStr, const OUString& rData, const OUString& rIdx )
683 {
684 rStr.append( rData );
685 appendIndex( rStr, rIdx );
686 }
687
688 void StringHelper::appendIndexedText( OUStringBuffer& rStr, const OUString& rData, sal_Int64 nIdx )
689 {
690 rStr.append( rData );
691 appendIndex( rStr, nIdx );
692 }
693
694 OUString StringHelper::getToken( const OUString& rData, sal_Int32& rnPos, sal_Unicode cSep )
695 {
696 return trimSpaces( rData.getToken( 0, cSep, rnPos ) );
697 }
698
699 void StringHelper::enclose( OUStringBuffer& rStr, sal_Unicode cOpen, sal_Unicode cClose )
700 {
701 rStr.insert( 0, cOpen ).append( cClose ? cClose : cOpen );
702 }
703
704 // string conversion ----------------------------------------------------------
705
706 namespace {
707
708 sal_Int32 lclIndexOf( const OUString& rStr, sal_Unicode cChar, sal_Int32 nStartPos )
709 {
710 sal_Int32 nIndex = rStr.indexOf( cChar, nStartPos );
711 return (nIndex < 0) ? rStr.getLength() : nIndex;
712 }
713
714 OUString lclTrimQuotedStringList( const OUString& rStr )
715 {
716 OUStringBuffer aBuffer;
717 sal_Int32 nPos = 0;
718 sal_Int32 nLen = rStr.getLength();
719 while( nPos < nLen )
720 {
721 if( rStr[ nPos ] == OOX_DUMP_CFG_QUOTE )
722 {
723 // quoted string, skip leading quote character
724 ++nPos;
725 // process quoted text and ambedded literal quote characters
726 OUStringBuffer aToken;
727 do
728 {
729 // seek to next quote character and add text portion to token buffer
730 sal_Int32 nEnd = lclIndexOf( rStr, OOX_DUMP_CFG_QUOTE, nPos );
731 aToken.append( rStr.copy( nPos, nEnd - nPos ) );
732 // process literal quotes
733 while( (nEnd + 1 < nLen) && (rStr[ nEnd ] == OOX_DUMP_CFG_QUOTE) && (rStr[ nEnd + 1 ] == OOX_DUMP_CFG_QUOTE) )
734 {
735 aToken.append( OOX_DUMP_CFG_QUOTE );
736 nEnd += 2;
737 }
738 // nEnd is start of possible next text portion
739 nPos = nEnd;
740 }
741 while( (nPos < nLen) && (rStr[ nPos ] != OOX_DUMP_CFG_QUOTE) );
742 // add token, seek to list separator, ignore text following closing quote
743 aBuffer.append( aToken.makeStringAndClear() );
744 nPos = lclIndexOf( rStr, OOX_DUMP_CFG_LISTSEP, nPos );
745 if( nPos < nLen )
746 aBuffer.append( OOX_DUMP_LF );
747 // set current position behind list separator
748 ++nPos;
749 }
750 else
751 {
752 // find list separator, add token text to buffer
753 sal_Int32 nEnd = lclIndexOf( rStr, OOX_DUMP_CFG_LISTSEP, nPos );
754 aBuffer.append( rStr.copy( nPos, nEnd - nPos ) );
755 if( nEnd < nLen )
756 aBuffer.append( OOX_DUMP_LF );
757 // set current position behind list separator
758 nPos = nEnd + 1;
759 }
760 }
761
762 return aBuffer.makeStringAndClear();
763 }
764
765 } // namespace
766
767 OUString StringHelper::trimSpaces( const OUString& rStr )
768 {
769 sal_Int32 nBeg = 0;
770 while( (nBeg < rStr.getLength()) && ((rStr[ nBeg ] == ' ') || (rStr[ nBeg ] == '\t')) )
771 ++nBeg;
772 sal_Int32 nEnd = rStr.getLength();
773 while( (nEnd > nBeg) && ((rStr[ nEnd - 1 ] == ' ') || (rStr[ nEnd - 1 ] == '\t')) )
774 --nEnd;
775 return rStr.copy( nBeg, nEnd - nBeg );
776 }
777
778 OString StringHelper::convertToUtf8( const OUString& rStr )
779 {
780 return OUStringToOString( rStr, RTL_TEXTENCODING_UTF8 );
781 }
782
783 DataType StringHelper::convertToDataType( const OUString& rStr )
784 {
785 DataType eType = DATATYPE_VOID;
786 if( rStr.equalsAscii( "int8" ) )
787 eType = DATATYPE_INT8;
788 else if( rStr.equalsAscii( "uint8" ) )
789 eType = DATATYPE_UINT8;
790 else if( rStr.equalsAscii( "int16" ) )
791 eType = DATATYPE_INT16;
792 else if( rStr.equalsAscii( "uint16" ) )
793 eType = DATATYPE_UINT16;
794 else if( rStr.equalsAscii( "int32" ) )
795 eType = DATATYPE_INT32;
796 else if( rStr.equalsAscii( "uint32" ) )
797 eType = DATATYPE_UINT32;
798 else if( rStr.equalsAscii( "int64" ) )
799 eType = DATATYPE_INT64;
800 else if( rStr.equalsAscii( "uint64" ) )
801 eType = DATATYPE_UINT64;
802 else if( rStr.equalsAscii( "float" ) )
803 eType = DATATYPE_FLOAT;
804 else if( rStr.equalsAscii( "double" ) )
805 eType = DATATYPE_DOUBLE;
806 return eType;
807 }
808
809 FormatType StringHelper::convertToFormatType( const OUString& rStr )
810 {
811 FormatType eType = FORMATTYPE_NONE;
812 if( rStr.equalsAscii( "dec" ) )
813 eType = FORMATTYPE_DEC;
814 else if( rStr.equalsAscii( "hex" ) )
815 eType = FORMATTYPE_HEX;
816 else if( rStr.equalsAscii( "shorthex" ) )
817 eType = FORMATTYPE_SHORTHEX;
818 else if( rStr.equalsAscii( "bin" ) )
819 eType = FORMATTYPE_BIN;
820 else if( rStr.equalsAscii( "fix" ) )
821 eType = FORMATTYPE_FIX;
822 else if( rStr.equalsAscii( "bool" ) )
823 eType = FORMATTYPE_BOOL;
824 return eType;
825 }
826
827 bool StringHelper::convertFromDec( sal_Int64& ornData, const OUString& rData )
828 {
829 sal_Int32 nPos = 0;
830 sal_Int32 nLen = rData.getLength();
831 bool bNeg = false;
832 if( (nLen > 0) && (rData[ 0 ] == '-') )
833 {
834 bNeg = true;
835 ++nPos;
836 }
837 ornData = 0;
838 for( ; nPos < nLen; ++nPos )
839 {
840 sal_Unicode cChar = rData[ nPos ];
841 if( (cChar < '0') || (cChar > '9') )
842 return false;
843 (ornData *= 10) += (cChar - '0');
844 }
845 if( bNeg )
846 ornData *= -1;
847 return true;
848 }
849
850 bool StringHelper::convertFromHex( sal_Int64& ornData, const OUString& rData )
851 {
852 ornData = 0;
853 for( sal_Int32 nPos = 0, nLen = rData.getLength(); nPos < nLen; ++nPos )
854 {
855 sal_Unicode cChar = rData[ nPos ];
856 if( ('0' <= cChar) && (cChar <= '9') )
857 cChar -= '0';
858 else if( ('A' <= cChar) && (cChar <= 'F') )
859 cChar -= ('A' - 10);
860 else if( ('a' <= cChar) && (cChar <= 'f') )
861 cChar -= ('a' - 10);
862 else
863 return false;
864 (ornData <<= 4) += cChar;
865 }
866 return true;
867 }
868
869 bool StringHelper::convertStringToInt( sal_Int64& ornData, const OUString& rData )
870 {
871 if( (rData.getLength() > 2) && (rData[ 0 ] == '0') && ((rData[ 1 ] == 'X') || (rData[ 1 ] == 'x')) )
872 return convertFromHex( ornData, rData.copy( 2 ) );
873 return convertFromDec( ornData, rData );
874 }
875
876 bool StringHelper::convertStringToDouble( double& orfData, const OUString& rData )
877 {
878 rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
879 sal_Int32 nSize = 0;
880 orfData = rtl::math::stringToDouble( rData, '.', '\0', &eStatus, &nSize );
881 return (eStatus == rtl_math_ConversionStatus_Ok) && (nSize == rData.getLength());
882 }
883
884 bool StringHelper::convertStringToBool( const OUString& rData )
885 {
886 if( rData.equalsAscii( "true" ) )
887 return true;
888 if( rData.equalsAscii( "false" ) )
889 return false;
890 sal_Int64 nData;
891 return convertStringToInt( nData, rData ) && (nData != 0);
892 }
893
894 void StringHelper::convertStringToStringList( OUStringVector& orVec, const OUString& rData, bool bIgnoreEmpty )
895 {
896 orVec.clear();
897 OUString aUnquotedData = lclTrimQuotedStringList( rData );
898 sal_Int32 nPos = 0;
899 sal_Int32 nLen = aUnquotedData.getLength();
900 while( (0 <= nPos) && (nPos < nLen) )
901 {
902 OUString aToken = getToken( aUnquotedData, nPos, OOX_DUMP_LF );
903 if( !bIgnoreEmpty || (aToken.getLength() > 0) )
904 orVec.push_back( aToken );
905 }
906 }
907
908 void StringHelper::convertStringToIntList( Int64Vector& orVec, const OUString& rData, bool bIgnoreEmpty )
909 {
910 orVec.clear();
911 OUString aUnquotedData = lclTrimQuotedStringList( rData );
912 sal_Int32 nPos = 0;
913 sal_Int32 nLen = aUnquotedData.getLength();
914 sal_Int64 nData;
915 while( (0 <= nPos) && (nPos < nLen) )
916 {
917 bool bOk = convertStringToInt( nData, getToken( aUnquotedData, nPos, OOX_DUMP_LF ) );
918 if( !bIgnoreEmpty || bOk )
919 orVec.push_back( bOk ? nData : 0 );
920 }
921 }
922
923 // ============================================================================
924 // ============================================================================
925
926 FormulaStack::FormulaStack() :
927 mbError( false )
928 {
929 }
930
931 void FormulaStack::pushOperand( const String& rOp, const OUString& rTokClass )
932 {
933 maFmlaStack.push( rOp );
934 maClassStack.push( rTokClass );
935 }
936
937 void FormulaStack::pushOperand( const String& rOp )
938 {
939 pushOperand( rOp, OUString( OOX_DUMP_BASECLASS ) );
940 }
941
942 void FormulaStack::pushUnaryOp( const String& rLOp, const String& rROp )
943 {
944 pushUnaryOp( maFmlaStack, rLOp, rROp );
945 pushUnaryOp( maClassStack, rLOp, rROp );
946 }
947
948 void FormulaStack::pushBinaryOp( const String& rOp )
949 {
950 pushBinaryOp( maFmlaStack, rOp );
951 pushBinaryOp( maClassStack, rOp );
952 }
953
954 void FormulaStack::pushFuncOp( const String& rFunc, const OUString& rTokClass, sal_uInt8 nParamCount )
955 {
956 pushFuncOp( maFmlaStack, rFunc, nParamCount );
957 pushFuncOp( maClassStack, rTokClass, nParamCount );
958 }
959
960 void FormulaStack::replaceOnTop( const OUString& rOld, const OUString& rNew )
961 {
962 if( !maFmlaStack.empty() )
963 {
964 sal_Int32 nPos = maFmlaStack.top().indexOf( rOld );
965 if( nPos >= 0 )
966 maFmlaStack.top() = maFmlaStack.top().copy( 0, nPos ) + rNew + maFmlaStack.top().copy( nPos + rOld.getLength() );
967 }
968 }
969
970 const OUString& FormulaStack::getString( const StringStack& rStack ) const
971 {
972 static const OUString saStackError = OOX_DUMP_ERRSTRING( "stack" );
973 return (mbError || rStack.empty()) ? saStackError : rStack.top();
974 }
975
976 void FormulaStack::pushUnaryOp( StringStack& rStack, const OUString& rLOp, const OUString& rROp )
977 {
978 if( check( !rStack.empty() ) )
979 rStack.top() = rLOp + rStack.top() + rROp;
980 }
981
982 void FormulaStack::pushBinaryOp( StringStack& rStack, const OUString& rOp )
983 {
984 OUString aSecond;
985 if( check( !rStack.empty() ) )
986 {
987 aSecond = rStack.top();
988 rStack.pop();
989 }
990 if( check( !rStack.empty() ) )
991 rStack.top() = rStack.top() + rOp + aSecond;
992 }
993
994 void FormulaStack::pushFuncOp( StringStack& rStack, const OUString& rOp, sal_uInt8 nParamCount )
995 {
996 OUStringBuffer aFunc;
997 for( sal_uInt8 nParam = 0; (nParam < nParamCount) && check( !rStack.empty() ); ++nParam )
998 {
999 StringHelper::prependToken( aFunc, rStack.top(), OOX_DUMP_FUNCSEP );
1000 rStack.pop();
1001 }
1002 StringHelper::enclose( aFunc, '(', ')' );
1003 aFunc.insert( 0, rOp );
1004 rStack.push( aFunc.makeStringAndClear() );
1005 }
1006
1007 // ============================================================================
1008 // ============================================================================
1009
1010 Base::~Base()
1011 {
1012 }
1013
1014 // ============================================================================
1015 // ============================================================================
1016
1017 ConfigItemBase::~ConfigItemBase()
1018 {
1019 }
1020
1021 void ConfigItemBase::readConfigBlock( const ConfigInputStreamRef& rxStrm )
1022 {
1023 readConfigBlockContents( rxStrm );
1024 }
1025
1026 void ConfigItemBase::implProcessConfigItemStr(
1027 const ConfigInputStreamRef& /*rxStrm*/, const OUString& /*rKey*/, const OUString& /*rData*/ )
1028 {
1029 }
1030
1031 void ConfigItemBase::implProcessConfigItemInt(
1032 const ConfigInputStreamRef& /*rxStrm*/, sal_Int64 /*nKey*/, const OUString& /*rData*/ )
1033 {
1034 }
1035
1036 void ConfigItemBase::readConfigBlockContents( const ConfigInputStreamRef& rxStrm )
1037 {
1038 bool bLoop = true;
1039 while( bLoop && !rxStrm->isEOF() )
1040 {
1041 OUString aKey, aData;
1042 switch( readConfigLine( rxStrm, aKey, aData ) )
1043 {
1044 case LINETYPE_DATA:
1045 processConfigItem( rxStrm, aKey, aData );
1046 break;
1047 case LINETYPE_END:
1048 bLoop = false;
1049 break;
1050 }
1051 }
1052 }
1053
1054 ConfigItemBase::LineType ConfigItemBase::readConfigLine(
1055 const ConfigInputStreamRef& rxStrm, OUString& orKey, OUString& orData ) const
1056 {
1057 OUString aLine;
1058 while( !rxStrm->isEOF() && (aLine.getLength() == 0) )
1059 {
1060 try { aLine = rxStrm->readLine(); } catch( Exception& ) { aLine = OUString(); }
1061 if( (aLine.getLength() > 0) && (aLine[ 0 ] == OOX_DUMP_BOM) )
1062 aLine = aLine.copy( 1 );
1063 aLine = StringHelper::trimSpaces( aLine );
1064 if( aLine.getLength() > 0 )
1065 {
1066 // ignore comments (starting with hash or semicolon)
1067 sal_Unicode cChar = aLine[ 0 ];
1068 if( (cChar == '#') || (cChar == ';') )
1069 aLine = OUString();
1070 }
1071 }
1072
1073 LineType eResult = LINETYPE_END;
1074 if( aLine.getLength() > 0 )
1075 {
1076 sal_Int32 nEqPos = aLine.indexOf( '=' );
1077 if( nEqPos < 0 )
1078 {
1079 orKey = aLine;
1080 }
1081 else
1082 {
1083 orKey = StringHelper::trimSpaces( aLine.copy( 0, nEqPos ) );
1084 orData = StringHelper::trimSpaces( aLine.copy( nEqPos + 1 ) );
1085 }
1086
1087 if( (orKey.getLength() > 0) && ((orData.getLength() > 0) || !orKey.equalsAscii( "end" )) )
1088 eResult = LINETYPE_DATA;
1089 }
1090
1091 return eResult;
1092 }
1093
1094 ConfigItemBase::LineType ConfigItemBase::readConfigLine( const ConfigInputStreamRef& rxStrm ) const
1095 {
1096 OUString aKey, aData;
1097 return readConfigLine( rxStrm, aKey, aData );
1098 }
1099
1100 void ConfigItemBase::processConfigItem(
1101 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1102 {
1103 sal_Int64 nKey;
1104 if( StringHelper::convertStringToInt( nKey, rKey ) )
1105 implProcessConfigItemInt( rxStrm, nKey, rData );
1106 else
1107 implProcessConfigItemStr( rxStrm, rKey, rData );
1108 }
1109
1110 // ============================================================================
1111
1112 NameListBase::~NameListBase()
1113 {
1114 }
1115
1116 void NameListBase::setName( sal_Int64 nKey, const String& rName )
1117 {
1118 implSetName( nKey, rName );
1119 }
1120
1121 void NameListBase::includeList( const NameListRef& rxList )
1122 {
1123 if( rxList.get() )
1124 {
1125 for( const_iterator aIt = rxList->begin(), aEnd = rxList->end(); aIt != aEnd; ++aIt )
1126 maMap[ aIt->first ] = aIt->second;
1127 implIncludeList( *rxList );
1128 }
1129 }
1130
1131 bool NameListBase::implIsValid() const
1132 {
1133 return true;
1134 }
1135
1136 void NameListBase::implProcessConfigItemStr(
1137 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1138 {
1139 if( rKey.equalsAscii( "include" ) )
1140 include( rData );
1141 else if( rKey.equalsAscii( "exclude" ) )
1142 exclude( rData );
1143 else
1144 ConfigItemBase::implProcessConfigItemStr( rxStrm, rKey, rData );
1145 }
1146
1147 void NameListBase::implProcessConfigItemInt(
1148 const ConfigInputStreamRef& /*rxStrm*/, sal_Int64 nKey, const OUString& rData )
1149 {
1150 implSetName( nKey, rData );
1151 }
1152
1153 void NameListBase::insertRawName( sal_Int64 nKey, const OUString& rName )
1154 {
1155 maMap[ nKey ] = rName;
1156 }
1157
1158 const OUString* NameListBase::findRawName( sal_Int64 nKey ) const
1159 {
1160 const_iterator aIt = maMap.find( nKey );
1161 return (aIt == end()) ? 0 : &aIt->second;
1162 }
1163
1164 void NameListBase::include( const OUString& rListKeys )
1165 {
1166 OUStringVector aVec;
1167 StringHelper::convertStringToStringList( aVec, rListKeys, true );
1168 for( OUStringVector::const_iterator aIt = aVec.begin(), aEnd = aVec.end(); aIt != aEnd; ++aIt )
1169 includeList( mrCfgData.getNameList( *aIt ) );
1170 }
1171
1172 void NameListBase::exclude( const OUString& rKeys )
1173 {
1174 Int64Vector aVec;
1175 StringHelper::convertStringToIntList( aVec, rKeys, true );
1176 for( Int64Vector::const_iterator aIt = aVec.begin(), aEnd = aVec.end(); aIt != aEnd; ++aIt )
1177 maMap.erase( *aIt );
1178 }
1179
1180 // ============================================================================
1181
1182 ConstList::ConstList( const SharedConfigData& rCfgData ) :
1183 NameListBase( rCfgData ),
1184 maDefName( OOX_DUMP_ERR_NONAME ),
1185 mbQuoteNames( false )
1186 {
1187 }
1188
1189 void ConstList::implProcessConfigItemStr(
1190 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1191 {
1192 if( rKey.equalsAscii( "default" ) )
1193 setDefaultName( rData );
1194 else if( rKey.equalsAscii( "quote-names" ) )
1195 setQuoteNames( StringHelper::convertStringToBool( rData ) );
1196 else
1197 NameListBase::implProcessConfigItemStr( rxStrm, rKey, rData );
1198 }
1199
1200 void ConstList::implSetName( sal_Int64 nKey, const OUString& rName )
1201 {
1202 insertRawName( nKey, rName );
1203 }
1204
1205 OUString ConstList::implGetName( const Config& /*rCfg*/, sal_Int64 nKey ) const
1206 {
1207 const OUString* pName = findRawName( nKey );
1208 OUString aName = pName ? *pName : maDefName;
1209 if( mbQuoteNames )
1210 {
1211 OUStringBuffer aBuffer( aName );
1212 StringHelper::enclose( aBuffer, OOX_DUMP_STRQUOTE );
1213 aName = aBuffer.makeStringAndClear();
1214 }
1215 return aName;
1216 }
1217
1218 OUString ConstList::implGetNameDbl( const Config& /*rCfg*/, double /*fValue*/ ) const
1219 {
1220 return OUString();
1221 }
1222
1223 void ConstList::implIncludeList( const NameListBase& rList )
1224 {
1225 if( const ConstList* pConstList = dynamic_cast< const ConstList* >( &rList ) )
1226 {
1227 maDefName = pConstList->maDefName;
1228 mbQuoteNames = pConstList->mbQuoteNames;
1229 }
1230 }
1231
1232 // ============================================================================
1233
1234 MultiList::MultiList( const SharedConfigData& rCfgData ) :
1235 ConstList( rCfgData ),
1236 mbIgnoreEmpty( true )
1237 {
1238 }
1239
1240 void MultiList::setNamesFromVec( sal_Int64 nStartKey, const OUStringVector& rNames )
1241 {
1242 sal_Int64 nKey = nStartKey;
1243 for( OUStringVector::const_iterator aIt = rNames.begin(), aEnd = rNames.end(); aIt != aEnd; ++aIt, ++nKey )
1244 if( !mbIgnoreEmpty || (aIt->getLength() > 0) )
1245 insertRawName( nKey, *aIt );
1246 }
1247
1248 void MultiList::implProcessConfigItemStr(
1249 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1250 {
1251 if( rKey.equalsAscii( "ignore-empty" ) )
1252 mbIgnoreEmpty = StringHelper::convertStringToBool( rData );
1253 else
1254 ConstList::implProcessConfigItemStr( rxStrm, rKey, rData );
1255 }
1256
1257 void MultiList::implSetName( sal_Int64 nKey, const OUString& rName )
1258 {
1259 OUStringVector aNames;
1260 StringHelper::convertStringToStringList( aNames, rName, false );
1261 setNamesFromVec( nKey, aNames );
1262 }
1263
1264 // ============================================================================
1265
1266 FlagsList::FlagsList( const SharedConfigData& rCfgData ) :
1267 NameListBase( rCfgData ),
1268 mnIgnore( 0 )
1269 {
1270 }
1271
1272 void FlagsList::implProcessConfigItemStr(
1273 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1274 {
1275 if( rKey.equalsAscii( "ignore" ) )
1276 {
1277 sal_Int64 nIgnore;
1278 if( StringHelper::convertStringToInt( nIgnore, rData ) )
1279 setIgnoreFlags( nIgnore );
1280 }
1281 else
1282 {
1283 NameListBase::implProcessConfigItemStr( rxStrm, rKey, rData );
1284 }
1285 }
1286
1287 void FlagsList::implSetName( sal_Int64 nKey, const OUString& rName )
1288 {
1289 insertRawName( nKey, rName );
1290 }
1291
1292 OUString FlagsList::implGetName( const Config& /*rCfg*/, sal_Int64 nKey ) const
1293 {
1294 sal_Int64 nFlags = nKey;
1295 setFlag( nFlags, mnIgnore, false );
1296 sal_Int64 nFound = 0;
1297 OUStringBuffer aName;
1298 // add known flags
1299 for( const_iterator aIt = begin(), aEnd = end(); aIt != aEnd; ++aIt )
1300 {
1301 sal_Int64 nMask = aIt->first;
1302 const OUString& rFlagName = aIt->second;
1303 bool bNegated = (rFlagName.getLength() > 0) && (rFlagName[ 0 ] == '!');
1304 sal_Int32 nBothSep = bNegated ? rFlagName.indexOf( '!', 1 ) : -1;
1305 bool bFlag = getFlag( nFlags, nMask );
1306 if( bFlag )
1307 {
1308 if( !bNegated )
1309 StringHelper::appendToken( aName, rFlagName );
1310 else if( nBothSep > 0 )
1311 StringHelper::appendToken( aName, rFlagName.copy( nBothSep + 1 ) );
1312 }
1313 else if( bNegated )
1314 {
1315 if( nBothSep > 0 )
1316 StringHelper::appendToken( aName, rFlagName.copy( 1, nBothSep - 1 ) );
1317 else
1318 StringHelper::appendToken( aName, rFlagName.copy( 1 ) );
1319 }
1320 setFlag( nFound, nMask );
1321 }
1322 // add unknown flags
1323 setFlag( nFlags, nFound, false );
1324 if( nFlags != 0 )
1325 {
1326 OUStringBuffer aUnknown( CREATE_OUSTRING( OOX_DUMP_UNKNOWN ) );
1327 aUnknown.append( OOX_DUMP_ITEMSEP );
1328 StringHelper::appendShortHex( aUnknown, nFlags, true );
1329 StringHelper::enclose( aUnknown, '(', ')' );
1330 StringHelper::appendToken( aName, aUnknown.makeStringAndClear() );
1331 }
1332 return aName.makeStringAndClear();
1333 }
1334
1335 OUString FlagsList::implGetNameDbl( const Config& /*rCfg*/, double /*fValue*/ ) const
1336 {
1337 return OUString();
1338 }
1339
1340 void FlagsList::implIncludeList( const NameListBase& rList )
1341 {
1342 if( const FlagsList* pFlagsList = dynamic_cast< const FlagsList* >( &rList ) )
1343 mnIgnore = pFlagsList->mnIgnore;
1344 }
1345
1346 // ============================================================================
1347
1348 CombiList::CombiList( const SharedConfigData& rCfgData ) :
1349 FlagsList( rCfgData )
1350 {
1351 }
1352
1353 void CombiList::implSetName( sal_Int64 nKey, const OUString& rName )
1354 {
1355 if( (nKey & (nKey - 1)) != 0 ) // more than a single bit set?
1356 {
1357 ExtItemFormat& rItemFmt = maFmtMap[ nKey ];
1358 OUStringVector aRemain = rItemFmt.parse( rName );
1359 rItemFmt.mbShiftValue = aRemain.empty() || !aRemain.front().equalsAscii( "noshift" );
1360 }
1361 else
1362 {
1363 FlagsList::implSetName( nKey, rName );
1364 }
1365 }
1366
1367 OUString CombiList::implGetName( const Config& rCfg, sal_Int64 nKey ) const
1368 {
1369 sal_Int64 nFlags = nKey;
1370 sal_Int64 nFound = 0;
1371 OUStringBuffer aName;
1372 // add known flag fields
1373 for( ExtItemFormatMap::const_iterator aIt = maFmtMap.begin(), aEnd = maFmtMap.end(); aIt != aEnd; ++aIt )
1374 {
1375 sal_Int64 nMask = aIt->first;
1376 if( nMask != 0 )
1377 {
1378 const ExtItemFormat& rItemFmt = aIt->second;
1379
1380 sal_uInt64 nUFlags = static_cast< sal_uInt64 >( nFlags );
1381 sal_uInt64 nUMask = static_cast< sal_uInt64 >( nMask );
1382 if( rItemFmt.mbShiftValue )
1383 while( (nUMask & 1) == 0 ) { nUFlags >>= 1; nUMask >>= 1; }
1384
1385 sal_uInt64 nUValue = nUFlags & nUMask;
1386 sal_Int64 nSValue = static_cast< sal_Int64 >( nUValue );
1387 if( getFlag< sal_uInt64 >( nUValue, (nUMask + 1) >> 1 ) )
1388 setFlag( nSValue, static_cast< sal_Int64 >( ~nUMask ) );
1389
1390 OUStringBuffer aItem( rItemFmt.maItemName );
1391 OUStringBuffer aValue;
1392 switch( rItemFmt.meDataType )
1393 {
1394 case DATATYPE_INT8: StringHelper::appendValue( aValue, static_cast< sal_Int8 >( nSValue ), rItemFmt.meFmtType ); break;
1395 case DATATYPE_UINT8: StringHelper::appendValue( aValue, static_cast< sal_uInt8 >( nUValue ), rItemFmt.meFmtType ); break;
1396 case DATATYPE_INT16: StringHelper::appendValue( aValue, static_cast< sal_Int16 >( nSValue ), rItemFmt.meFmtType ); break;
1397 case DATATYPE_UINT16: StringHelper::appendValue( aValue, static_cast< sal_uInt16 >( nUValue ), rItemFmt.meFmtType ); break;
1398 case DATATYPE_INT32: StringHelper::appendValue( aValue, static_cast< sal_Int32 >( nSValue ), rItemFmt.meFmtType ); break;
1399 case DATATYPE_UINT32: StringHelper::appendValue( aValue, static_cast< sal_uInt32 >( nUValue ), rItemFmt.meFmtType ); break;
1400 case DATATYPE_INT64: StringHelper::appendValue( aValue, nSValue, rItemFmt.meFmtType ); break;
1401 case DATATYPE_UINT64: StringHelper::appendValue( aValue, nUValue, rItemFmt.meFmtType ); break;
1402 case DATATYPE_FLOAT: StringHelper::appendValue( aValue, static_cast< float >( nSValue ), rItemFmt.meFmtType ); break;
1403 case DATATYPE_DOUBLE: StringHelper::appendValue( aValue, static_cast< double >( nSValue ), rItemFmt.meFmtType ); break;
1404 default:;
1405 }
1406 StringHelper::appendToken( aItem, aValue.makeStringAndClear(), OOX_DUMP_ITEMSEP );
1407 if( rItemFmt.maListName.getLength() > 0 )
1408 {
1409 OUString aValueName = rCfg.getName( rItemFmt.maListName, static_cast< sal_Int64 >( nUValue ) );
1410 StringHelper::appendToken( aItem, aValueName, OOX_DUMP_ITEMSEP );
1411 }
1412 StringHelper::enclose( aItem, '(', ')' );
1413 StringHelper::appendToken( aName, aItem.makeStringAndClear() );
1414 setFlag( nFound, nMask );
1415 }
1416 }
1417 setFlag( nFlags, nFound, false );
1418 StringHelper::appendToken( aName, FlagsList::implGetName( rCfg, nFlags ) );
1419 return aName.makeStringAndClear();
1420 }
1421
1422 void CombiList::implIncludeList( const NameListBase& rList )
1423 {
1424 if( const CombiList* pCombiList = dynamic_cast< const CombiList* >( &rList ) )
1425 maFmtMap = pCombiList->maFmtMap;
1426 FlagsList::implIncludeList( rList );
1427 }
1428
1429 // ============================================================================
1430
1431 UnitConverter::UnitConverter( const SharedConfigData& rCfgData ) :
1432 NameListBase( rCfgData ),
1433 mfFactor( 1.0 )
1434 {
1435 }
1436
1437 void UnitConverter::implSetName( sal_Int64 /*nKey*/, const OUString& /*rName*/ )
1438 {
1439 // nothing to do
1440 }
1441
1442 OUString UnitConverter::implGetName( const Config& rCfg, sal_Int64 nKey ) const
1443 {
1444 return implGetNameDbl( rCfg, static_cast< double >( nKey ) );
1445 }
1446
1447 OUString UnitConverter::implGetNameDbl( const Config& /*rCfg*/, double fValue ) const
1448 {
1449 OUStringBuffer aValue;
1450 StringHelper::appendDec( aValue, mfFactor * fValue );
1451 aValue.append( maUnitName );
1452 return aValue.makeStringAndClear();
1453 }
1454
1455 void UnitConverter::implIncludeList( const NameListBase& /*rList*/ )
1456 {
1457 }
1458
1459 // ============================================================================
1460
1461 NameListRef NameListWrapper::getNameList( const Config& rCfg ) const
1462 {
1463 return mxList.get() ? mxList : (mxList = rCfg.getNameList( maName ));
1464 }
1465
1466 // ============================================================================
1467 // ============================================================================
1468
1469 SharedConfigData::SharedConfigData( const OUString& rFileName,
1470 const Reference< XMultiServiceFactory >& rxFactory, const StorageRef& rxRootStrg,
1471 const OUString& rSysFileName, MediaDescriptor& rMediaDesc ) :
1472 mxFactory( rxFactory ),
1473 mxRootStrg( rxRootStrg ),
1474 maSysFileName( rSysFileName ),
1475 mrMediaDesc( rMediaDesc ),
1476 mbLoaded( false ),
1477 mbPwCancelled( false )
1478 {
1479 OUString aFileUrl = InputOutputHelper::convertFileNameToUrl( rFileName );
1480 if( aFileUrl.getLength() > 0 )
1481 {
1482 sal_Int32 nNamePos = InputOutputHelper::getFileNamePos( aFileUrl );
1483 maConfigPath = aFileUrl.copy( 0, nNamePos );
1484 mbLoaded = readConfigFile( aFileUrl );
1485 }
1486 }
1487
1488 SharedConfigData::~SharedConfigData()
1489 {
1490 }
1491
1492 void SharedConfigData::setOption( const OUString& rKey, const OUString& rData )
1493 {
1494 maConfigData[ rKey ] = rData;
1495 }
1496
1497 const OUString* SharedConfigData::getOption( const OUString& rKey ) const
1498 {
1499 ConfigDataMap::const_iterator aIt = maConfigData.find( rKey );
1500 return (aIt == maConfigData.end()) ? 0 : &aIt->second;
1501 }
1502
1503 void SharedConfigData::setNameList( const OUString& rListName, const NameListRef& rxList )
1504 {
1505 if( rListName.getLength() > 0 )
1506 maNameLists[ rListName ] = rxList;
1507 }
1508
1509 void SharedConfigData::eraseNameList( const OUString& rListName )
1510 {
1511 maNameLists.erase( rListName );
1512 }
1513
1514 NameListRef SharedConfigData::getNameList( const OUString& rListName ) const
1515 {
1516 NameListRef xList;
1517 NameListMap::const_iterator aIt = maNameLists.find( rListName );
1518 if( aIt != maNameLists.end() )
1519 xList = aIt->second;
1520 return xList;
1521 }
1522
1523 OUString SharedConfigData::requestPassword( ::comphelper::IDocPasswordVerifier& rVerifier )
1524 {
1525 OUString aPassword;
1526 if( !mbPwCancelled )
1527 {
1528 ::std::vector< OUString > aDefaultPasswords;
1529 aDefaultPasswords.push_back( CREATE_OUSTRING( "VelvetSweatshop" ) );
1530 aPassword = ::comphelper::DocPasswordHelper::requestAndVerifyDocPassword(
1531 rVerifier, mrMediaDesc, ::comphelper::DocPasswordRequestType_MS, &aDefaultPasswords );
1532 mbPwCancelled = aPassword.getLength() == 0;
1533 }
1534 return aPassword;
1535 }
1536
1537 bool SharedConfigData::implIsValid() const
1538 {
1539 return mbLoaded && mxFactory.is() && mxRootStrg.get() && (maSysFileName.getLength() > 0);
1540 }
1541
1542 void SharedConfigData::implProcessConfigItemStr(
1543 const ConfigInputStreamRef& rxStrm, const OUString& rKey, const OUString& rData )
1544 {
1545 if( rKey.equalsAscii( "include-config-file" ) )
1546 readConfigFile( maConfigPath + rData );
1547 else if( rKey.equalsAscii( "constlist" ) )
1548 readNameList< ConstList >( rxStrm, rData );
1549 else if( rKey.equalsAscii( "multilist" ) )
1550 readNameList< MultiList >( rxStrm, rData );
1551 else if( rKey.equalsAscii( "flagslist" ) )
1552 readNameList< FlagsList >( rxStrm, rData );
1553 else if( rKey.equalsAscii( "combilist" ) )
1554 readNameList< CombiList >( rxStrm, rData );
1555 else if( rKey.equalsAscii( "shortlist" ) )
1556 createShortList( rData );
1557 else if( rKey.equalsAscii( "unitconverter" ) )
1558 createUnitConverter( rData );
1559 else
1560 setOption( rKey, rData );
1561 }
1562
1563 bool SharedConfigData::readConfigFile( const OUString& rFileUrl )
1564 {
1565 bool bLoaded = maConfigFiles.count( rFileUrl ) > 0;
1566 if( !bLoaded )
1567 {
1568 Reference< XTextInputStream > xTextInStrm =
1569 InputOutputHelper::openTextInputStream( mxFactory, rFileUrl, CREATE_OUSTRING( "UTF-8" ) );
1570 if( xTextInStrm.is() )
1571 {
1572 maConfigFiles.insert( rFileUrl );
1573 readConfigBlockContents( xTextInStrm );
1574 bLoaded = true;
1575 }
1576 }
1577 return bLoaded;
1578 }
1579
1580 void SharedConfigData::createShortList( const OUString& rData )
1581 {
1582 OUStringVector aDataVec;
1583 StringHelper::convertStringToStringList( aDataVec, rData, false );
1584 if( aDataVec.size() >= 3 )
1585 {
1586 sal_Int64 nStartKey;
1587 if( StringHelper::convertStringToInt( nStartKey, aDataVec[ 1 ] ) )
1588 {
1589 ::boost::shared_ptr< MultiList > xList = createNameList< MultiList >( aDataVec[ 0 ] );
1590 if( xList.get() )
1591 {
1592 aDataVec.erase( aDataVec.begin(), aDataVec.begin() + 2 );
1593 xList->setNamesFromVec( nStartKey, aDataVec );
1594 }
1595 }
1596 }
1597 }
1598
1599 void SharedConfigData::createUnitConverter( const OUString& rData )
1600 {
1601 OUStringVector aDataVec;
1602 StringHelper::convertStringToStringList( aDataVec, rData, false );
1603 if( aDataVec.size() >= 2 )
1604 {
1605 OUString aFactor = aDataVec[ 1 ];
1606 bool bRecip = (aFactor.getLength() > 0) && (aFactor[ 0 ] == '/');
1607 if( bRecip )
1608 aFactor = aFactor.copy( 1 );
1609 double fFactor;
1610 if( StringHelper::convertStringToDouble( fFactor, aFactor ) && (fFactor != 0.0) )
1611 {
1612 ::boost::shared_ptr< UnitConverter > xList = createNameList< UnitConverter >( aDataVec[ 0 ] );
1613 if( xList.get() )
1614 {
1615 xList->setFactor( bRecip ? (1.0 / fFactor) : fFactor );
1616 if( aDataVec.size() >= 3 )
1617 xList->setUnitName( aDataVec[ 2 ] );
1618 }
1619 }
1620 }
1621 }
1622
1623 // ============================================================================
1624
1625 Config::Config( const Config& rParent ) :
1626 Base() // c'tor needs to be called explicitly to avoid compiler warning
1627 {
1628 construct( rParent );
1629 }
1630
1631 Config::Config( const sal_Char* pcEnvVar, const FilterBase& rFilter )
1632 {
1633 construct( pcEnvVar, rFilter );
1634 }
1635
1636 Config::Config( const sal_Char* pcEnvVar, const Reference< XMultiServiceFactory >& rxFactory, const StorageRef& rxRootStrg, const OUString& rSysFileName, MediaDescriptor& rMediaDesc )
1637 {
1638 construct( pcEnvVar, rxFactory, rxRootStrg, rSysFileName, rMediaDesc );
1639 }
1640
1641 Config::~Config()
1642 {
1643 }
1644
1645 void Config::construct( const Config& rParent )
1646 {
1647 *this = rParent;
1648 }
1649
1650 void Config::construct( const sal_Char* pcEnvVar, const FilterBase& rFilter )
1651 {
1652 if( rFilter.getFileUrl().getLength() > 0 )
1653 construct( pcEnvVar, rFilter.getGlobalFactory(), rFilter.getStorage(), rFilter.getFileUrl(), rFilter.getMediaDescriptor() );
1654 }
1655
1656 void Config::construct( const sal_Char* pcEnvVar, const Reference< XMultiServiceFactory >& rxFactory, const StorageRef& rxRootStrg, const OUString& rSysFileName, MediaDescriptor& rMediaDesc )
1657 {
1658 if( pcEnvVar && rxRootStrg.get() && (rSysFileName.getLength() > 0) )
1659 if( const sal_Char* pcFileName = ::getenv( pcEnvVar ) )
1660 mxCfgData.reset( new SharedConfigData( OUString::createFromAscii( pcFileName ), rxFactory, rxRootStrg, rSysFileName, rMediaDesc ) );
1661 }
1662
1663 void Config::setStringOption( const String& rKey, const String& rData )
1664 {
1665 mxCfgData->setOption( rKey, rData );
1666 }
1667
1668 const OUString& Config::getStringOption( const String& rKey, const OUString& rDefault ) const
1669 {
1670 const OUString* pData = implGetOption( rKey );
1671 return pData ? *pData : rDefault;
1672 }
1673
1674 bool Config::getBoolOption( const String& rKey, bool bDefault ) const
1675 {
1676 const OUString* pData = implGetOption( rKey );
1677 return pData ? StringHelper::convertStringToBool( *pData ) : bDefault;
1678 }
1679
1680 bool Config::isDumperEnabled() const
1681 {
1682 return getBoolOption( "enable-dumper", false );
1683 }
1684
1685 bool Config::isImportEnabled() const
1686 {
1687 return getBoolOption( "enable-import", true );
1688 }
1689
1690 void Config::setNameList( const String& rListName, const NameListRef& rxList )
1691 {
1692 mxCfgData->setNameList( rListName, rxList );
1693 }
1694
1695 void Config::eraseNameList( const String& rListName )
1696 {
1697 mxCfgData->eraseNameList( rListName );
1698 }
1699
1700 NameListRef Config::getNameList( const String& rListName ) const
1701 {
1702 return implGetNameList( rListName );
1703 }
1704
1705 OUString Config::requestPassword( ::comphelper::IDocPasswordVerifier& rVerifier )
1706 {
1707 return mxCfgData->requestPassword( rVerifier );
1708 }
1709
1710 bool Config::isPasswordCancelled() const
1711 {
1712 return mxCfgData->isPasswordCancelled();
1713 }
1714
1715 bool Config::implIsValid() const
1716 {
1717 return isValid( mxCfgData );
1718 }
1719
1720 const OUString* Config::implGetOption( const OUString& rKey ) const
1721 {
1722 return mxCfgData->getOption( rKey );
1723 }
1724
1725 NameListRef Config::implGetNameList( const OUString& rListName ) const
1726 {
1727 return mxCfgData->getNameList( rListName );
1728 }
1729
1730 // ============================================================================
1731 // ============================================================================
1732
1733 Output::Output( const Reference< XTextOutputStream >& rxStrm )
1734 {
1735 construct( rxStrm );
1736 }
1737
1738 Output::Output( const Reference< XMultiServiceFactory >& rxFactory, const OUString& rFileName )
1739 {
1740 construct( InputOutputHelper::openTextOutputStream( rxFactory, rFileName, CREATE_OUSTRING( "UTF-8" ) ) );
1741 }
1742
1743 // ----------------------------------------------------------------------------
1744
1745 void Output::newLine()
1746 {
1747 if( maLine.getLength() > 0 )
1748 {
1749 mxStrm->writeString( maIndent );
1750 maLine.append( sal_Unicode( '\n' ) );
1751 mxStrm->writeString( maLine.makeStringAndClear() );
1752 mnCol = 0;
1753 mnLastItem = 0;
1754 }
1755 }
1756
1757 void Output::emptyLine( size_t nCount )
1758 {
1759 for( size_t nIdx = 0; nIdx < nCount; ++nIdx )
1760 mxStrm->writeString( OUString( sal_Unicode( '\n' ) ) );
1761 }
1762
1763 void Output::incIndent()
1764 {
1765 OUStringBuffer aBuffer( maIndent );
1766 StringHelper::appendChar( aBuffer, ' ', OOX_DUMP_INDENT );
1767 maIndent = aBuffer.makeStringAndClear();
1768 }
1769
1770 void Output::decIndent()
1771 {
1772 if( maIndent.getLength() >= OOX_DUMP_INDENT )
1773 maIndent = maIndent.copy( OOX_DUMP_INDENT );
1774 }
1775
1776 void Output::resetIndent()
1777 {
1778 maIndent = OUString();
1779 }
1780
1781 void Output::startTable( sal_Int32 nW1 )
1782 {
1783 startTable( 1, &nW1 );
1784 }
1785
1786 void Output::startTable( sal_Int32 nW1, sal_Int32 nW2 )
1787 {
1788 sal_Int32 pnColWidths[ 2 ];
1789 pnColWidths[ 0 ] = nW1;
1790 pnColWidths[ 1 ] = nW2;
1791 startTable( 2, pnColWidths );
1792 }
1793
1794 void Output::startTable( sal_Int32 nW1, sal_Int32 nW2, sal_Int32 nW3 )
1795 {
1796 sal_Int32 pnColWidths[ 3 ];
1797 pnColWidths[ 0 ] = nW1;
1798 pnColWidths[ 1 ] = nW2;
1799 pnColWidths[ 2 ] = nW3;
1800 startTable( 3, pnColWidths );
1801 }
1802
1803 void Output::startTable( sal_Int32 nW1, sal_Int32 nW2, sal_Int32 nW3, sal_Int32 nW4 )
1804 {
1805 sal_Int32 pnColWidths[ 4 ];
1806 pnColWidths[ 0 ] = nW1;
1807 pnColWidths[ 1 ] = nW2;
1808 pnColWidths[ 2 ] = nW3;
1809 pnColWidths[ 3 ] = nW4;
1810 startTable( 4, pnColWidths );
1811 }
1812
1813 void Output::startTable( size_t nColCount, const sal_Int32* pnColWidths )
1814 {
1815 maColPos.clear();
1816 maColPos.push_back( 0 );
1817 sal_Int32 nColPos = 0;
1818 for( size_t nCol = 0; nCol < nColCount; ++nCol )
1819 {
1820 nColPos = nColPos + pnColWidths[ nCol ];
1821 maColPos.push_back( nColPos );
1822 }
1823 }
1824
1825 void Output::tab()
1826 {
1827 tab( mnCol + 1 );
1828 }
1829
1830 void Output::tab( size_t nCol )
1831 {
1832 mnCol = nCol;
1833 if( mnCol < maColPos.size() )
1834 {
1835 sal_Int32 nColPos = maColPos[ mnCol ];
1836 if( maLine.getLength() >= nColPos )
1837 maLine.setLength( ::std::max< sal_Int32 >( nColPos - 1, 0 ) );
1838 StringHelper::appendChar( maLine, ' ', nColPos - maLine.getLength() );
1839 }
1840 else
1841 {
1842 StringHelper::appendChar( maLine, ' ', 2 );
1843 }
1844 }
1845
1846 void Output::endTable()
1847 {
1848 maColPos.clear();
1849 }
1850
1851 void Output::resetItemIndex( sal_Int64 nIdx )
1852 {
1853 mnItemIdx = nIdx;
1854 }
1855
1856 void Output::startItem( const String& rItemName )
1857 {
1858 if( mnItemLevel == 0 )
1859 {
1860 if( (mnMultiLevel > 0) && (maLine.getLength() > 0) )
1861 tab();
1862 if( rItemName.has() )
1863 {
1864 writeItemName( rItemName );
1865 writeChar( OOX_DUMP_ITEMSEP );
1866 }
1867 }
1868 ++mnItemLevel;
1869 mnLastItem = maLine.getLength();
1870 }
1871
1872 void Output::contItem()
1873 {
1874 if( mnItemLevel > 0 )
1875 {
1876 if( (maLine.getLength() == 0) || (maLine[ maLine.getLength() - 1 ] != OOX_DUMP_ITEMSEP) )
1877 writeChar( OOX_DUMP_ITEMSEP );
1878 mnLastItem = maLine.getLength();
1879 }
1880 }
1881
1882 void Output::endItem()
1883 {
1884 if( mnItemLevel > 0 )
1885 {
1886 maLastItem = OUString( maLine.getStr() + mnLastItem );
1887 if( (maLastItem.getLength() == 0) && (mnLastItem > 0) && (maLine[ mnLastItem - 1 ] == OOX_DUMP_ITEMSEP) )
1888 maLine.setLength( mnLastItem - 1 );
1889 --mnItemLevel;
1890 }
1891 if( mnItemLevel == 0 )
1892 {
1893 if( mnMultiLevel == 0 )
1894 newLine();
1895 }
1896 else
1897 contItem();
1898 }
1899
1900 void Output::startMultiItems()
1901 {
1902 ++mnMultiLevel;
1903 }
1904
1905 void Output::endMultiItems()
1906 {
1907 if( mnMultiLevel > 0 )
1908 --mnMultiLevel;
1909 if( mnMultiLevel == 0 )
1910 newLine();
1911 }
1912
1913 // ----------------------------------------------------------------------------
1914
1915 void Output::writeChar( sal_Unicode cChar, sal_Int32 nCount )
1916 {
1917 StringHelper::appendEncChar( maLine, cChar, nCount );
1918 }
1919
1920 void Output::writeAscii( const sal_Char* pcStr )
1921 {
1922 if( pcStr )
1923 maLine.appendAscii( pcStr );
1924 }
1925
1926 void Output::writeString( const OUString& rStr )
1927 {
1928 StringHelper::appendEncString( maLine, rStr );
1929 }
1930
1931 void Output::writeArray( const sal_uInt8* pnData, sal_Size nSize, sal_Unicode cSep )
1932 {
1933 const sal_uInt8* pnEnd = pnData ? (pnData + nSize) : 0;
1934 for( const sal_uInt8* pnByte = pnData; pnByte < pnEnd; ++pnByte )
1935 {
1936 if( pnByte > pnData )
1937 writeChar( cSep );
1938 writeHex( *pnByte, false );
1939 }
1940 }
1941
1942 void Output::writeBool( bool bData )
1943 {
1944 StringHelper::appendBool( maLine, bData );
1945 }
1946
1947 void Output::writeColorABGR( sal_Int32 nColor )
1948 {
1949 writeChar( 'a' );
1950 writeDec( static_cast< sal_uInt8 >( nColor >> 24 ) );
1951 writeAscii( ",r" );
1952 writeDec( static_cast< sal_uInt8 >( nColor ) );
1953 writeAscii( ",g" );
1954 writeDec( static_cast< sal_uInt8 >( nColor >> 8 ) );
1955 writeAscii( ",b" );
1956 writeDec( static_cast< sal_uInt8 >( nColor >> 16 ) );
1957 }
1958
1959 void Output::writeDateTime( const DateTime& rDateTime )
1960 {
1961 writeDec( rDateTime.Year, 4, '0' );
1962 writeChar( '-' );
1963 writeDec( rDateTime.Month, 2, '0' );
1964 writeChar( '-' );
1965 writeDec( rDateTime.Day, 2, '0' );
1966 writeChar( 'T' );
1967 writeDec( rDateTime.Hours, 2, '0' );
1968 writeChar( ':' );
1969 writeDec( rDateTime.Minutes, 2, '0' );
1970 writeChar( ':' );
1971 writeDec( rDateTime.Seconds, 2, '0' );
1972 }
1973
1974 void Output::writeColIndex( sal_Int32 nCol )
1975 {
1976 StringHelper::appendAddrCol( maLine, nCol, true );
1977 }
1978
1979 void Output::writeRowIndex( sal_Int32 nRow )
1980 {
1981 StringHelper::appendAddrRow( maLine, nRow, true );
1982 }
1983
1984 void Output::writeColRowRange( sal_Int32 nColRow1, sal_Int32 nColRow2 )
1985 {
1986 writeDec( nColRow1 );
1987 writeChar( OOX_DUMP_RANGESEP );
1988 writeDec( nColRow2 );
1989 }
1990
1991 void Output::writeColRange( sal_Int32 nCol1, sal_Int32 nCol2 )
1992 {
1993 writeColIndex( nCol1 );
1994 writeChar( OOX_DUMP_RANGESEP );
1995 writeColIndex( nCol2 );
1996 }
1997
1998 void Output::writeRowRange( sal_Int32 nRow1, sal_Int32 nRow2 )
1999 {
2000 writeRowIndex( nRow1 );
2001 writeChar( OOX_DUMP_RANGESEP );
2002 writeRowIndex( nRow2 );
2003 }
2004
2005 void Output::writeAddress( const Address& rPos )
2006 {
2007 StringHelper::appendAddress( maLine, rPos );
2008 }
2009
2010 void Output::writeRange( const Range& rRange )
2011 {
2012 StringHelper::appendRange( maLine, rRange );
2013 }
2014
2015 void Output::writeRangeList( const RangeList& rRanges )
2016 {
2017 StringHelper::appendRangeList( maLine, rRanges );
2018 }
2019
2020 // ----------------------------------------------------------------------------
2021
2022 void Output::construct( const Reference< XTextOutputStream >& rxStrm )
2023 {
2024 mxStrm = rxStrm;
2025 mnCol = mnItemLevel = mnMultiLevel = 0;
2026 mnItemIdx = 0;
2027 mnLastItem = 0;
2028 if( mxStrm.is() )
2029 {
2030 writeChar( OOX_DUMP_BOM );
2031 newLine();
2032 }
2033 }
2034
2035 bool Output::implIsValid() const
2036 {
2037 return mxStrm.is();
2038 }
2039
2040 void Output::writeItemName( const String& rItemName )
2041 {
2042 if( rItemName.has() && (rItemName[ 0 ] == '#') )
2043 {
2044 writeString( rItemName.copy( 1 ) );
2045 StringHelper::appendIndex( maLine, mnItemIdx++ );
2046 }
2047 else
2048 writeString( rItemName );
2049 }
2050
2051 // ============================================================================
2052
2053 StorageIterator::StorageIterator( const StorageRef& rxStrg ) :
2054 mxStrg( rxStrg )
2055 {
2056 if( mxStrg.get() )
2057 mxStrg->getElementNames( maNames );
2058 maIt = maNames.begin();
2059 }
2060
2061 StorageIterator::~StorageIterator()
2062 {
2063 }
2064
2065 size_t StorageIterator::getElementCount() const
2066 {
2067 return maNames.size();
2068 }
2069
2070 StorageIterator& StorageIterator::operator++()
2071 {
2072 if( maIt != maNames.end() )
2073 ++maIt;
2074 return *this;
2075 }
2076
2077 OUString StorageIterator::getName() const
2078 {
2079 OUString aName;
2080 if( maIt != maNames.end() )
2081 aName = *maIt;
2082 return aName;
2083 }
2084
2085 bool StorageIterator::isStream() const
2086 {
2087 return isValid() && mxStrg->openInputStream( *maIt ).is();
2088 }
2089
2090 bool StorageIterator::isStorage() const
2091 {
2092 if( !isValid() )
2093 return false;
2094 StorageRef xStrg = mxStrg->openSubStorage( *maIt, false );
2095 return xStrg.get() && xStrg->isStorage();
2096 }
2097
2098 bool StorageIterator::implIsValid() const
2099 {
2100 return mxStrg.get() && mxStrg->isStorage() && (maIt != maNames.end());
2101 }
2102
2103 // ============================================================================
2104 // ============================================================================
2105
2106 ObjectBase::~ObjectBase()
2107 {
2108 }
2109
2110 void ObjectBase::construct( const ConfigRef& rxConfig )
2111 {
2112 mxConfig = rxConfig;
2113 }
2114
2115 void ObjectBase::construct( const ObjectBase& rParent )
2116 {
2117 *this = rParent;
2118 }
2119
2120 void ObjectBase::dump()
2121 {
2122 if( isValid() )
2123 implDump();
2124 }
2125
2126 bool ObjectBase::implIsValid() const
2127 {
2128 return isValid( mxConfig );
2129 }
2130
2131 void ObjectBase::implDump()
2132 {
2133 }
2134
2135 void ObjectBase::reconstructConfig( const ConfigRef& rxConfig )
2136 {
2137 if( isValid( rxConfig ) )
2138 mxConfig = rxConfig;
2139 }
2140
2141 // ============================================================================
2142 // ============================================================================
2143
2144 void StorageObjectBase::construct( const ObjectBase& rParent, const StorageRef& rxStrg, const OUString& rSysPath )
2145 {
2146 ObjectBase::construct( rParent );
2147 mxStrg = rxStrg;
2148 maSysPath = rSysPath;
2149 }
2150
2151 void StorageObjectBase::construct( const ObjectBase& rParent )
2152 {
2153 ObjectBase::construct( rParent );
2154 if( ObjectBase::implIsValid() )
2155 {
2156 mxStrg = cfg().getRootStorage();
2157 maSysPath = cfg().getSysFileName();
2158 }
2159 }
2160
2161 bool StorageObjectBase::implIsValid() const
2162 {
2163 return mxStrg.get() && mxStrg->isStorage() && (maSysPath.getLength() > 0) && ObjectBase::implIsValid();
2164 }
2165
2166 void StorageObjectBase::implDump()
2167 {
2168 try
2169 {
2170 Reference< XSimpleFileAccess > xFileAccess( getFactory()->createInstance( CREATE_OUSTRING( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY_THROW );
2171 xFileAccess->kill( maSysPath + OOX_DUMP_DUMPEXT );
2172 }
2173 catch( Exception& )
2174 {
2175 }
2176 extractStorage( mxStrg, OUString(), maSysPath );
2177 }
2178
2179 void StorageObjectBase::implDumpStream( const BinaryInputStreamRef&, const OUString&, const OUString&, const OUString& )
2180 {
2181 }
2182
2183 void StorageObjectBase::implDumpStorage( const StorageRef& rxStrg, const OUString& rStrgPath, const OUString& rSysPath )
2184 {
2185 extractStorage( rxStrg, rStrgPath, rSysPath );
2186 }
2187
2188 void StorageObjectBase::addPreferredStream( const String& rStrmName )
2189 {
2190 if( rStrmName.has() )
2191 maPreferred.push_back( PreferredItem( rStrmName, false ) );
2192 }
2193
2194 void StorageObjectBase::addPreferredStorage( const String& rStrgPath )
2195 {
2196 if( rStrgPath.has() )
2197 maPreferred.push_back( PreferredItem( rStrgPath, true ) );
2198 }
2199
2200 OUString StorageObjectBase::getSysFileName( const OUString& rStrmName, const OUString& rSysOutPath )
2201 {
2202 // encode all characters < 0x20
2203 OUStringBuffer aBuffer;
2204 StringHelper::appendEncString( aBuffer, rStrmName, false );
2205
2206 // replace all characters reserved in file system
2207 OUString aFileName = aBuffer.makeStringAndClear();
2208 static const sal_Unicode spcReserved[] = { '/', '\\', ':', '*', '?', '<', '>', '|' };
2209 for( const sal_Unicode* pcChar = spcReserved; pcChar < STATIC_ARRAY_END( spcReserved ); ++pcChar )
2210 aFileName = aFileName.replace( *pcChar, '_' );
2211
2212 // build full path
2213 return rSysOutPath + OUString( sal_Unicode( '/' ) ) + aFileName;
2214 }
2215
2216 void StorageObjectBase::extractStream( StorageBase& rStrg, const OUString& rStrgPath, const OUString& rStrmName, const OUString& rSysFileName )
2217 {
2218 BinaryXInputStream aInStrm( rStrg.openInputStream( rStrmName ), true );
2219 if( !aInStrm.isEof() )
2220 {
2221 BinaryXOutputStream aOutStrm( InputOutputHelper::openOutputStream( getFactory(), rSysFileName ), true );
2222 if( !aOutStrm.isEof() )
2223 aOutStrm.copyStream( aInStrm );
2224 }
2225 BinaryXInputStreamRef xDumpStrm( new BinaryXInputStream( InputOutputHelper::openInputStream( getFactory(), rSysFileName ), true ) );
2226 if( !xDumpStrm->isEof() )
2227 implDumpStream( xDumpStrm, rStrgPath, rStrmName, rSysFileName );
2228 }
2229
2230 void StorageObjectBase::extractStorage( const StorageRef& rxStrg, const OUString& rStrgPath, const OUString& rSysPath )
2231 {
2232 OUString aSysOutPath = rSysPath + OOX_DUMP_DUMPEXT;
2233
2234 // create directory in file system
2235 ::osl::FileBase::RC eRes = ::osl::Directory::create( aSysOutPath );
2236 if( (eRes != ::osl::FileBase::E_None) && (eRes != ::osl::FileBase::E_EXIST) )
2237 return;
2238
2239 // process preferred storages and streams in root storage first
2240 if( rStrgPath.getLength() == 0 )
2241 for( PreferredItemVector::iterator aIt = maPreferred.begin(), aEnd = maPreferred.end(); aIt != aEnd; ++aIt )
2242 extractItem( rxStrg, rStrgPath, aIt->maName, aSysOutPath, aIt->mbStorage, !aIt->mbStorage );
2243
2244 // process children of the storage
2245 for( StorageIterator aIt( rxStrg ); aIt.isValid(); ++aIt )
2246 {
2247 // skip processed preferred items
2248 OUString aItemName = aIt.getName();
2249 bool bFound = false;
2250 if( rStrgPath.getLength() == 0 )
2251 for( PreferredItemVector::iterator aIIt = maPreferred.begin(), aIEnd = maPreferred.end(); !bFound && (aIIt != aIEnd); ++aIIt )
2252 bFound = aIIt->maName == aItemName;
2253 if( !bFound )
2254 extractItem( rxStrg, rStrgPath, aItemName, aSysOutPath, aIt.isStorage(), aIt.isStream() );
2255 }
2256 }
2257
2258 void StorageObjectBase::extractItem( const StorageRef& rxStrg, const OUString& rStrgPath, const OUString& rItemName, const OUString& rSysOutPath, bool bIsStrg, bool bIsStrm )
2259 {
2260 OUString aSysFileName = getSysFileName( rItemName, rSysOutPath );
2261 if( bIsStrg )
2262 {
2263 OUStringBuffer aStrgPath( rStrgPath );
2264 StringHelper::appendToken( aStrgPath, rItemName, '/' );
2265 implDumpStorage( rxStrg->openSubStorage( rItemName, false ), aStrgPath.makeStringAndClear(), aSysFileName );
2266 }
2267 else if( bIsStrm )
2268 {
2269 extractStream( *rxStrg, rStrgPath, rItemName, aSysFileName );
2270 }
2271 }
2272
2273 // ============================================================================
2274 // ============================================================================
2275
2276 OutputObjectBase::~OutputObjectBase()
2277 {
2278 }
2279
2280 void OutputObjectBase::construct( const ObjectBase& rParent, const OUString& rSysFileName )
2281 {
2282 ObjectBase::construct( rParent );
2283 if( ObjectBase::implIsValid() )
2284 mxOut.reset( new Output( getFactory(), rSysFileName + OOX_DUMP_DUMPEXT ) );
2285 }
2286
2287 void OutputObjectBase::construct( const ObjectBase& rParent, const OutputRef& rxOut )
2288 {
2289 ObjectBase::construct( rParent );
2290 mxOut = rxOut;
2291 }
2292
2293 void OutputObjectBase::construct( const OutputObjectBase& rParent )
2294 {
2295 *this = rParent;
2296 }
2297
2298 bool OutputObjectBase::implIsValid() const
2299 {
2300 return isValid( mxOut ) && ObjectBase::implIsValid();
2301 }
2302
2303 void OutputObjectBase::writeEmptyItem( const String& rName )
2304 {
2305 ItemGuard aItem( *mxOut, rName );
2306 }
2307
2308 void OutputObjectBase::writeInfoItem( const String& rName, const String& rData )
2309 {
2310 ItemGuard aItem( *mxOut, rName );
2311 mxOut->writeString( rData );
2312 }
2313
2314 void OutputObjectBase::writeCharItem( const String& rName, sal_Unicode cData )
2315 {
2316 ItemGuard aItem( *mxOut, rName );
2317 mxOut->writeChar( OOX_DUMP_STRQUOTE );
2318 mxOut->writeChar( cData );
2319 mxOut->writeChar( OOX_DUMP_STRQUOTE );
2320 }
2321
2322 void OutputObjectBase::writeStringItem( const String& rName, const OUString& rData )
2323 {
2324 ItemGuard aItem( *mxOut, rName );
2325 mxOut->writeAscii( "(len=" );
2326 mxOut->writeDec( rData.getLength() );
2327 mxOut->writeAscii( ")," );
2328 OUStringBuffer aValue( rData.copy( 0, ::std::min( rData.getLength(), OOX_DUMP_MAXSTRLEN ) ) );
2329 StringHelper::enclose( aValue, OOX_DUMP_STRQUOTE );
2330 mxOut->writeString( aValue.makeStringAndClear() );
2331 if( rData.getLength() > OOX_DUMP_MAXSTRLEN )
2332 mxOut->writeAscii( ",cut" );
2333 }
2334
2335 void OutputObjectBase::writeArrayItem( const String& rName, const sal_uInt8* pnData, sal_Size nSize, sal_Unicode cSep )
2336 {
2337 ItemGuard aItem( *mxOut, rName );
2338 mxOut->writeArray( pnData, nSize, cSep );
2339 }
2340
2341 void OutputObjectBase::writeBoolItem( const String& rName, bool bData )
2342 {
2343 ItemGuard aItem( *mxOut, rName );
2344 mxOut->writeBool( bData );
2345 }
2346
2347 double OutputObjectBase::writeRkItem( const String& rName, sal_Int32 nRk )
2348 {
2349 MultiItemsGuard aMultiGuard( out() );
2350 writeHexItem( rName, static_cast< sal_uInt32 >( nRk ), "RK-FLAGS" );
2351 double fValue = ::oox::xls::BiffHelper::calcDoubleFromRk( nRk );
2352 writeDecItem( "decoded", fValue );
2353 return fValue;
2354 }
2355
2356 void OutputObjectBase::writeColorABGRItem( const String& rName, sal_Int32 nColor )
2357 {
2358 ItemGuard aItem( *mxOut, rName );
2359 writeHexItem( rName, nColor );
2360 mxOut->writeColorABGR( nColor );
2361 }
2362
2363 void OutputObjectBase::writeDateTimeItem( const String& rName, const DateTime& rDateTime )
2364 {
2365 ItemGuard aItem( *mxOut, rName );
2366 mxOut->writeDateTime( rDateTime );
2367 }
2368
2369 void OutputObjectBase::writeGuidItem( const String& rName, const OUString& rGuid )
2370 {
2371 ItemGuard aItem( *mxOut, rName );
2372 mxOut->writeString( rGuid );
2373 aItem.cont();
2374 mxOut->writeString( cfg().getStringOption( rGuid, OUString() ) );
2375 }
2376
2377 void OutputObjectBase::writeColIndexItem( const String& rName, sal_Int32 nCol )
2378 {
2379 Output& rOut = out();
2380 ItemGuard aItem( rOut, rName );
2381 rOut.writeDec( nCol );
2382 aItem.cont();
2383 rOut.writeColIndex( nCol );
2384 }
2385
2386 void OutputObjectBase::writeRowIndexItem( const String& rName, sal_Int32 nRow )
2387 {
2388 Output& rOut = out();
2389 ItemGuard aItem( rOut, rName );
2390 rOut.writeDec( nRow );
2391 aItem.cont();
2392 rOut.writeRowIndex( nRow );
2393 }
2394
2395 void OutputObjectBase::writeColRangeItem( const String& rName, sal_Int32 nCol1, sal_Int32 nCol2 )
2396 {
2397 Output& rOut = out();
2398 ItemGuard aItem( rOut, rName );
2399 rOut.writeColRowRange( nCol1, nCol2 );
2400 aItem.cont();
2401 rOut.writeColRange( nCol1, nCol2 );
2402 }
2403
2404 void OutputObjectBase::writeRowRangeItem( const String& rName, sal_Int32 nRow1, sal_Int32 nRow2 )
2405 {
2406 Output& rOut = out();
2407 ItemGuard aItem( rOut, rName );
2408 rOut.writeColRowRange( nRow1, nRow2 );
2409 aItem.cont();
2410 rOut.writeRowRange( nRow1, nRow2 );
2411 }
2412
2413 void OutputObjectBase::writeAddressItem( const String& rName, const Address& rPos )
2414 {
2415 ItemGuard aItem( out(), rName );
2416 StringHelper::appendAddress( out().getLine(), rPos );
2417 }
2418
2419 void OutputObjectBase::writeRangeItem( const String& rName, const Range& rRange )
2420 {
2421 ItemGuard aItem( out(), rName );
2422 StringHelper::appendRange( out().getLine(), rRange );
2423 }
2424
2425 void OutputObjectBase::writeRangeListItem( const String& rName, const RangeList& rRanges )
2426 {
2427 MultiItemsGuard aMultiGuard( out() );
2428 writeEmptyItem( rName );
2429 writeDecItem( "count", static_cast< sal_uInt16 >( rRanges.size() ) );
2430 ItemGuard aItem( out(), "ranges" );
2431 StringHelper::appendRangeList( out().getLine(), rRanges );
2432 }
2433
2434 void OutputObjectBase::writeTokenAddressItem( const String& rName, const TokenAddress& rPos, bool bNameMode )
2435 {
2436 ItemGuard aItem( out(), rName );
2437 StringHelper::appendAddress( out().getLine(), rPos, bNameMode );
2438 }
2439
2440 void OutputObjectBase::writeTokenAddress3dItem( const String& rName, const OUString& rRef, const TokenAddress& rPos, bool bNameMode )
2441 {
2442 ItemGuard aItem( out(), rName );
2443 out().writeString( rRef );
2444 StringHelper::appendAddress( out().getLine(), rPos, bNameMode );
2445 }
2446
2447 void OutputObjectBase::writeTokenRangeItem( const String& rName, const TokenRange& rRange, bool bNameMode )
2448 {
2449 ItemGuard aItem( out(), rName );
2450 StringHelper::appendRange( out().getLine(), rRange, bNameMode );
2451 }
2452
2453 void OutputObjectBase::writeTokenRange3dItem( const String& rName, const OUString& rRef, const TokenRange& rRange, bool bNameMode )
2454 {
2455 ItemGuard aItem( out(), rName );
2456 out().writeString( rRef );
2457 StringHelper::appendRange( out().getLine(), rRange, bNameMode );
2458 }
2459
2460 // ============================================================================
2461 // ============================================================================
2462
2463 InputObjectBase::~InputObjectBase()
2464 {
2465 }
2466
2467 void InputObjectBase::construct( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName )
2468 {
2469 OutputObjectBase::construct( rParent, rSysFileName );
2470 mxStrm = rxStrm;
2471 }
2472
2473 void InputObjectBase::construct( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OutputRef& rxOut )
2474 {
2475 OutputObjectBase::construct( rParent, rxOut );
2476 mxStrm = rxStrm;
2477 }
2478
2479 void InputObjectBase::construct( const OutputObjectBase& rParent, const BinaryInputStreamRef& rxStrm )
2480 {
2481 OutputObjectBase::construct( rParent );
2482 mxStrm = rxStrm;
2483 }
2484
2485 void InputObjectBase::construct( const InputObjectBase& rParent )
2486 {
2487 *this = rParent;
2488 }
2489
2490 bool InputObjectBase::implIsValid() const
2491 {
2492 return mxStrm.get() && OutputObjectBase::implIsValid();
2493 }
2494
2495 void InputObjectBase::skipBlock( sal_Int64 nBytes, bool bShowSize )
2496 {
2497 sal_Int64 nEndPos = ::std::min< sal_Int64 >( mxStrm->tell() + nBytes, mxStrm->getLength() );
2498 if( mxStrm->tell() < nEndPos )
2499 {
2500 if( bShowSize )
2501 writeDecItem( "skipped-data-size", static_cast< sal_uInt64 >( nEndPos - mxStrm->tell() ) );
2502 mxStrm->seek( nEndPos );
2503 }
2504 }
2505
2506 void InputObjectBase::dumpRawBinary( sal_Int64 nBytes, bool bShowOffset, bool bStream )
2507 {
2508 Output& rOut = out();
2509 TableGuard aTabGuard( rOut,
2510 bShowOffset ? 12 : 0,
2511 3 * OOX_DUMP_BYTESPERLINE / 2 + 1,
2512 3 * OOX_DUMP_BYTESPERLINE / 2 + 1,
2513 OOX_DUMP_BYTESPERLINE / 2 + 1 );
2514
2515 sal_Int64 nMaxShowSize = cfg().getIntOption< sal_Int64 >(
2516 bStream ? "max-binary-stream-size" : "max-binary-data-size", SAL_MAX_INT64 );
2517
2518 bool bSeekable = mxStrm->getLength() >= 0;
2519 sal_Int64 nEndPos = bSeekable ? ::std::min< sal_Int64 >( mxStrm->tell() + nBytes, mxStrm->getLength() ) : 0;
2520 sal_Int64 nDumpEnd = bSeekable ? ::std::min< sal_Int64 >( mxStrm->tell() + nMaxShowSize, nEndPos ) : nMaxShowSize;
2521 sal_Int64 nPos = bSeekable ? mxStrm->tell() : 0;
2522 bool bLoop = true;
2523
2524 while( bLoop && (nPos < nDumpEnd) )
2525 {
2526 rOut.writeHex( static_cast< sal_uInt32 >( nPos ) );
2527 rOut.tab();
2528
2529 sal_uInt8 pnLineData[ OOX_DUMP_BYTESPERLINE ];
2530 sal_Int32 nLineSize = bSeekable ? ::std::min( static_cast< sal_Int32 >( nDumpEnd - mxStrm->tell() ), OOX_DUMP_BYTESPERLINE ) : OOX_DUMP_BYTESPERLINE;
2531 sal_Int32 nReadSize = mxStrm->readMemory( pnLineData, nLineSize );
2532 bLoop = nReadSize == nLineSize;
2533 nPos += nReadSize;
2534
2535 if( nReadSize > 0 )
2536 {
2537 const sal_uInt8* pnByte = 0;
2538 const sal_uInt8* pnEnd = 0;
2539 for( pnByte = pnLineData, pnEnd = pnLineData + nReadSize; pnByte != pnEnd; ++pnByte )
2540 {
2541 if( (pnByte - pnLineData) == (OOX_DUMP_BYTESPERLINE / 2) ) rOut.tab();
2542 rOut.writeHex( *pnByte, false );
2543 rOut.writeChar( ' ' );
2544 }
2545
2546 aTabGuard.tab( 3 );
2547 for( pnByte = pnLineData, pnEnd = pnLineData + nReadSize; pnByte != pnEnd; ++pnByte )
2548 {
2549 if( (pnByte - pnLineData) == (OOX_DUMP_BYTESPERLINE / 2) ) rOut.tab();
2550 rOut.writeChar( static_cast< sal_Unicode >( (*pnByte < 0x20) ? '.' : *pnByte ) );
2551 }
2552 rOut.newLine();
2553 }
2554 }
2555
2556 // skip undumped data
2557 if( bSeekable )
2558 skipBlock( nEndPos - mxStrm->tell() );
2559 }
2560
2561 void InputObjectBase::dumpBinary( const String& rName, sal_Int64 nBytes, bool bShowOffset )
2562 {
2563 {
2564 MultiItemsGuard aMultiGuard( out() );
2565 writeEmptyItem( rName );
2566 writeDecItem( "size", nBytes );
2567 }
2568 IndentGuard aIndGuard( out() );
2569 dumpRawBinary( nBytes, bShowOffset );
2570 }
2571
2572 void InputObjectBase::dumpRemaining( sal_Int64 nBytes )
2573 {
2574 if( nBytes > 0 )
2575 {
2576 if( cfg().getBoolOption( "show-trailing-unknown", true ) )
2577 dumpBinary( "remaining-data", nBytes, false );
2578 else
2579 skipBlock( nBytes );
2580 }
2581 }
2582
2583 void InputObjectBase::dumpRemainingTo( sal_Int64 nPos )
2584 {
2585 if( mxStrm->isEof() )
2586 writeInfoItem( "stream-state", OOX_DUMP_ERR_STREAM );
2587 else
2588 dumpRemaining( nPos - mxStrm->tell() );
2589 mxStrm->seek( nPos );
2590 }
2591
2592 void InputObjectBase::dumpRemainingStream()
2593 {
2594 dumpRemainingTo( mxStrm->getLength() );
2595 }
2596
2597 void InputObjectBase::dumpArray( const String& rName, sal_Int32 nBytes, sal_Unicode cSep )
2598 {
2599 sal_Int32 nDumpSize = getLimitedValue< sal_Int32, sal_Int64 >( mxStrm->getLength() - mxStrm->tell(), 0, nBytes );
2600 if( nDumpSize > OOX_DUMP_MAXARRAY )
2601 {
2602 dumpBinary( rName, nBytes, false );
2603 }
2604 else if( nDumpSize > 1 )
2605 {
2606 sal_uInt8 pnData[ OOX_DUMP_MAXARRAY ];
2607 mxStrm->readMemory( pnData, nDumpSize );
2608 writeArrayItem( rName, pnData, nDumpSize, cSep );
2609 }
2610 else if( nDumpSize == 1 )
2611 dumpHex< sal_uInt8 >( rName );
2612 }
2613
2614 sal_Unicode InputObjectBase::dumpChar( const String& rName, rtl_TextEncoding eTextEnc )
2615 {
2616 sal_uInt8 nChar;
2617 *mxStrm >> nChar;
2618 OUString aChar = OStringToOUString( OString( static_cast< sal_Char >( nChar ) ), eTextEnc );
2619 sal_Unicode cChar = (aChar.getLength() > 0) ? aChar[ 0 ] : 0;
2620 writeCharItem( rName( "char" ), cChar );
2621 return cChar;
2622 }
2623
2624 sal_Unicode InputObjectBase::dumpUnicode( const String& rName )
2625 {
2626 sal_uInt16 nChar;
2627 *mxStrm >> nChar;
2628 sal_Unicode cChar = static_cast< sal_Unicode >( nChar );
2629 writeCharItem( rName( "char" ), cChar );
2630 return cChar;
2631 }
2632
2633 OUString InputObjectBase::dumpCharArray( const String& rName, sal_Int32 nLen, rtl_TextEncoding eTextEnc )
2634 {
2635 sal_Int32 nDumpSize = getLimitedValue< sal_Int32, sal_Int64 >( mxStrm->getLength() - mxStrm->tell(), 0, nLen );
2636 OUString aString;
2637 if( nDumpSize > 0 )
2638 {
2639 ::std::vector< sal_Char > aBuffer( static_cast< sal_Size >( nLen ) + 1 );
2640 sal_Int32 nCharsRead = mxStrm->readMemory( &aBuffer.front(), nLen );
2641 aBuffer[ nCharsRead ] = 0;
2642 aString = OStringToOUString( OString( &aBuffer.front() ), eTextEnc );
2643 }
2644 writeStringItem( rName( "text" ), aString );
2645 return aString;
2646 }
2647
2648 OUString InputObjectBase::dumpUnicodeArray( const String& rName, sal_Int32 nLen )
2649 {
2650 OUStringBuffer aBuffer;
2651 for( sal_Int32 nIndex = 0; !mxStrm->isEof() && (nIndex < nLen); ++nIndex )
2652 aBuffer.append( static_cast< sal_Unicode >( mxStrm->readuInt16() ) );
2653 OUString aString = aBuffer.makeStringAndClear();
2654 writeStringItem( rName( "text" ), aString );
2655 return aString;
2656 }
2657
2658 OUString InputObjectBase::dumpNullCharArray( const String& rName, rtl_TextEncoding eTextEnc )
2659 {
2660 OStringBuffer aBuffer;
2661 sal_uInt8 nChar;
2662 for( *mxStrm >> nChar; !mxStrm->isEof() && (nChar > 0); *mxStrm >> nChar )
2663 aBuffer.append( static_cast< sal_Char >( nChar ) );
2664 OUString aString = OStringToOUString( aBuffer.makeStringAndClear(), eTextEnc );
2665 writeStringItem( rName( "text" ), aString );
2666 return aString;
2667 }
2668
2669 OUString InputObjectBase::dumpNullUnicodeArray( const String& rName )
2670 {
2671 OUStringBuffer aBuffer;
2672 sal_uInt16 nChar;
2673 for( *mxStrm >> nChar; !mxStrm->isEof() && (nChar > 0); *mxStrm >> nChar )
2674 aBuffer.append( static_cast< sal_Unicode >( nChar ) );
2675 OUString aString = aBuffer.makeStringAndClear();
2676 writeStringItem( rName( "text" ), aString );
2677 return aString;
2678 }
2679
2680 double InputObjectBase::dumpRk( const String& rName )
2681 {
2682 sal_Int32 nRk;
2683 *mxStrm >> nRk;
2684 return writeRkItem( rName( "rk-value" ), nRk );
2685 }
2686
2687 sal_Int32 InputObjectBase::dumpColorABGR( const String& rName )
2688 {
2689 sal_Int32 nColor;
2690 *mxStrm >> nColor;
2691 writeColorABGRItem( rName( "color" ), nColor );
2692 return nColor;
2693 }
2694
2695 DateTime InputObjectBase::dumpFileTime( const String& rName )
2696 {
2697 DateTime aDateTime;
2698
2699 ItemGuard aItem( out(), rName( "file-time" ) );
2700 sal_Int64 nFileTime = dumpDec< sal_Int64 >( EMPTY_STRING );
2701 // file time is in 10^-7 seconds (100 nanoseconds), convert to 1/100 seconds
2702 nFileTime /= 100000;
2703 // entire days
2704 sal_Int64 nDays = nFileTime / sal_Int64( 360000 * 24 );
2705 // number of entire years
2706 sal_Int64 nYears = (nDays - (nDays / (4 * 365)) + (nDays / (100 * 365)) - (nDays / (400 * 365))) / 365;
2707 // remaining days in the year
2708 sal_Int64 nDaysInYear = nDays - (nYears * 365 + nYears / 4 - nYears / 100 + nYears / 400);
2709 // the year (file dates start from 1601-01-01)
2710 aDateTime.Year = static_cast< sal_uInt16 >( 1601 + nYears );
2711 // leap year?
2712 bool bLeap = ((aDateTime.Year % 4 == 0) && (aDateTime.Year % 100 != 0)) || (aDateTime.Year % 400 == 0);
2713 // static arrays with number of days in month
2714 static const sal_Int64 spnDaysInMonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
2715 static const sal_Int64 spnDaysInMonthL[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
2716 const sal_Int64* pnDaysInMonth = bLeap ? spnDaysInMonthL : spnDaysInMonth;
2717 // the month
2718 aDateTime.Month = 1;
2719 while( nDaysInYear >= *pnDaysInMonth )
2720 {
2721 nDaysInYear -= *pnDaysInMonth++;
2722 ++aDateTime.Month;
2723 }
2724 // the day
2725 aDateTime.Day = static_cast< sal_uInt16 >( nDaysInYear + 1 );
2726 // number of 1/100 seconds in the day
2727 sal_Int64 nTimeInDay = nFileTime % sal_Int64( 360000 * 24 );
2728 // 1/100 seconds
2729 aDateTime.HundredthSeconds = static_cast< sal_uInt16 >( nTimeInDay % 100 );
2730 nTimeInDay /= 100;
2731 // seconds
2732 aDateTime.Seconds = static_cast< sal_uInt16 >( nTimeInDay % 60 );
2733 nTimeInDay /= 60;
2734 // minutes
2735 aDateTime.Minutes = static_cast< sal_uInt16 >( nTimeInDay % 60 );
2736 nTimeInDay /= 60;
2737 // hours
2738 aDateTime.Hours = static_cast< sal_uInt16 >( nTimeInDay );
2739
2740 writeDateTimeItem( EMPTY_STRING, aDateTime );
2741 return aDateTime;
2742 }
2743
2744 OUString InputObjectBase::dumpGuid( const String& rName )
2745 {
2746 OUStringBuffer aBuffer;
2747 sal_uInt32 nData32;
2748 sal_uInt16 nData16;
2749 sal_uInt8 nData8;
2750
2751 *mxStrm >> nData32;
2752 StringHelper::appendHex( aBuffer, nData32, false );
2753 aBuffer.append( sal_Unicode( '-' ) );
2754 *mxStrm >> nData16;
2755 StringHelper::appendHex( aBuffer, nData16, false );
2756 aBuffer.append( sal_Unicode( '-' ) );
2757 *mxStrm >> nData16;
2758 StringHelper::appendHex( aBuffer, nData16, false );
2759 aBuffer.append( sal_Unicode( '-' ) );
2760 *mxStrm >> nData8;
2761 StringHelper::appendHex( aBuffer, nData8, false );
2762 *mxStrm >> nData8;
2763 StringHelper::appendHex( aBuffer, nData8, false );
2764 aBuffer.append( sal_Unicode( '-' ) );
2765 for( int nIndex = 0; nIndex < 6; ++nIndex )
2766 {
2767 *mxStrm >> nData8;
2768 StringHelper::appendHex( aBuffer, nData8, false );
2769 }
2770 StringHelper::enclose( aBuffer, '{', '}' );
2771 OUString aGuid = aBuffer.makeStringAndClear();
2772 writeGuidItem( rName( "guid" ), aGuid );
2773 return aGuid;
2774 }
2775
2776 void InputObjectBase::dumpItem( const ItemFormat& rItemFmt )
2777 {
2778 switch( rItemFmt.meDataType )
2779 {
2780 case DATATYPE_VOID: break;
2781 case DATATYPE_INT8: dumpValue< sal_Int8 >( rItemFmt ); break;
2782 case DATATYPE_UINT8: dumpValue< sal_uInt8 >( rItemFmt ); break;
2783 case DATATYPE_INT16: dumpValue< sal_Int16 >( rItemFmt ); break;
2784 case DATATYPE_UINT16: dumpValue< sal_uInt16 >( rItemFmt ); break;
2785 case DATATYPE_INT32: dumpValue< sal_Int32 >( rItemFmt ); break;
2786 case DATATYPE_UINT32: dumpValue< sal_uInt32 >( rItemFmt ); break;
2787 case DATATYPE_INT64: dumpValue< sal_Int64 >( rItemFmt ); break;
2788 case DATATYPE_UINT64: dumpValue< sal_uInt64 >( rItemFmt ); break;
2789 case DATATYPE_FLOAT: dumpValue< float >( rItemFmt ); break;
2790 case DATATYPE_DOUBLE: dumpValue< double >( rItemFmt ); break;
2791 default:;
2792 }
2793 }
2794
2795 // ============================================================================
2796 // ============================================================================
2797
2798 BinaryStreamObject::BinaryStreamObject( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName )
2799 {
2800 InputObjectBase::construct( rParent, rxStrm, rSysFileName );
2801 }
2802
2803 BinaryStreamObject::BinaryStreamObject( const OutputObjectBase& rParent, const BinaryInputStreamRef& rxStrm )
2804 {
2805 InputObjectBase::construct( rParent, rxStrm );
2806 }
2807
2808 void BinaryStreamObject::dumpBinaryStream( bool bShowOffset )
2809 {
2810 in().seek( 0 );
2811 dumpRawBinary( in().getLength(), bShowOffset, true );
2812 out().emptyLine();
2813 }
2814
2815 void BinaryStreamObject::implDump()
2816 {
2817 dumpBinaryStream();
2818 }
2819
2820 // ============================================================================
2821
2822 namespace {
2823
2824 bool lclIsEof( BinaryInputStream& rStrm )
2825 {
2826 return rStrm.isEof() || (rStrm.isSeekable() && (rStrm.tell() >= rStrm.getLength()));
2827 }
2828
2829 template< typename BufferType, typename CharType >
2830 CharType lclAppendChar( BufferType& orBuffer, CharType cChar )
2831 {
2832 if( (cChar == 0x0A) || (cChar == 0x0D) )
2833 return cChar;
2834 orBuffer.append( cChar );
2835 return 0;
2836 }
2837
2838 template< typename BufferType, typename CharType, typename StreamDataType >
2839 bool lclReadLine( BufferType& orBuffer, sal_Unicode& orcNextLineChar, BinaryInputStream& rStrm )
2840 {
2841 CharType cLineEndChar = (orcNextLineChar == 0) ? 0 : lclAppendChar( orBuffer, static_cast< CharType >( orcNextLineChar ) );
2842 orcNextLineChar = 0;
2843
2844 // read chars until EOF or line end character (LF or CR)
2845 bool bIsEof = lclIsEof( rStrm );
2846 while( !bIsEof && (cLineEndChar == 0) )
2847 {
2848 CharType cChar = static_cast< CharType >( rStrm.readValue< StreamDataType >() );
2849 bIsEof = rStrm.isEof();
2850 cLineEndChar = bIsEof ? 0 : lclAppendChar( orBuffer, cChar );
2851 }
2852
2853 // try to skip LF following CR, or CR following LF
2854 if( !lclIsEof( rStrm ) && (cLineEndChar != 0) )
2855 {
2856 CharType cChar = static_cast< CharType >( rStrm.readValue< StreamDataType >() );
2857 bool bLineEnd = ((cChar == 0x0A) || (cChar == 0x0D)) && (cChar != cLineEndChar);
2858 if( !rStrm.isEof() && !bLineEnd )
2859 orcNextLineChar = static_cast< sal_Unicode >( cChar );
2860 }
2861
2862 return (cLineEndChar != 0) || (orBuffer.getLength() > 0);
2863 }
2864
2865 } // namespace
2866
2867 // ----------------------------------------------------------------------------
2868
2869 TextStreamObject::TextStreamObject( const ObjectBase& rParent,
2870 const BinaryInputStreamRef& rxStrm, rtl_TextEncoding eTextEnc, const OUString& rSysFileName ) :
2871 meTextEnc( eTextEnc )
2872 {
2873 InputObjectBase::construct( rParent, rxStrm, rSysFileName );
2874 }
2875
2876 TextStreamObject::TextStreamObject( const OutputObjectBase& rParent,
2877 const BinaryInputStreamRef& rxStrm, rtl_TextEncoding eTextEnc ) :
2878 meTextEnc( eTextEnc )
2879 {
2880 InputObjectBase::construct( rParent, rxStrm );
2881 }
2882
2883 void TextStreamObject::implDump()
2884 {
2885 OUString aLine;
2886 sal_Unicode cNextLineChar = 0;
2887 sal_uInt32 nLine = 0;
2888 while( readLine( aLine, cNextLineChar ) )
2889 implDumpLine( aLine, ++nLine );
2890 out().emptyLine();
2891 }
2892
2893 void TextStreamObject::implDumpLine( const OUString& rLine, sal_uInt32 nLine )
2894 {
2895 Output& rOut = out();
2896 TableGuard aTabGuard( rOut, 8 );
2897 rOut.writeDec( nLine, 6 );
2898 rOut.tab();
2899 rOut.writeString( rLine );
2900 rOut.newLine();
2901 }
2902
2903 bool TextStreamObject::readCharLine( OUString& orLine, sal_Unicode& orcNextLineChar )
2904 {
2905 OStringBuffer aBuffer;
2906 bool bHasData = lclReadLine< OStringBuffer, sal_Char, sal_uInt8 >( aBuffer, orcNextLineChar, in() );
2907 if( bHasData )
2908 orLine = OStringToOUString( aBuffer.makeStringAndClear(), meTextEnc );
2909 return bHasData;
2910 }
2911
2912 bool TextStreamObject::readUcs2Line( OUString& orLine, sal_Unicode& orcNextLineChar )
2913 {
2914 OUStringBuffer aBuffer;
2915 bool bHasData = lclReadLine< OUStringBuffer, sal_Unicode, sal_uInt16 >( aBuffer, orcNextLineChar, in() );
2916 if( bHasData )
2917 orLine = aBuffer.makeStringAndClear();
2918 return bHasData;
2919 }
2920
2921 bool TextStreamObject::readLine( OUString& orLine, sal_Unicode& orcNextLineChar )
2922 {
2923 return (meTextEnc == RTL_TEXTENCODING_UCS2) ?
2924 readUcs2Line( orLine, orcNextLineChar ) :
2925 readCharLine( orLine, orcNextLineChar );
2926 }
2927
2928 // ============================================================================
2929
2930 XmlStreamObject::XmlStreamObject( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName ) :
2931 TextStreamObject( rParent, rxStrm, RTL_TEXTENCODING_UTF8, rSysFileName )
2932 {
2933 }
2934
2935 void XmlStreamObject::implDump()
2936 {
2937 maIncompleteLine = OUString();
2938 TextStreamObject::implDump();
2939 if( maIncompleteLine.getLength() > 0 )
2940 {
2941 out().resetIndent();
2942 out().writeString( maIncompleteLine );
2943 out().emptyLine();
2944 writeInfoItem( "stream-state", OOX_DUMP_ERR_STREAM );
2945 }
2946 }
2947
2948 void XmlStreamObject::implDumpLine( const OUString& rLine, sal_uInt32 )
2949 {
2950 // build input line from cached incomplete element and new text data
2951 OUStringBuffer aLine;
2952 if( maIncompleteLine.getLength() > 0 )
2953 aLine.append( maIncompleteLine ).append( sal_Unicode( ' ' ) );
2954 aLine.append( rLine );
2955 maIncompleteLine = OUString();
2956
2957 Output& rOut = out();
2958 if( aLine.getLength() == 0 )
2959 {
2960 rOut.newLine();
2961 return;
2962 }
2963
2964 const sal_Unicode* pcPos = aLine.getStr();
2965 const sal_Unicode* pcEnd = pcPos + aLine.getLength();
2966 while( pcPos < pcEnd )
2967 {
2968 OUStringBuffer aOutLine;
2969 bool bIsStartElement = false;
2970 bool bIsComplElement = false;
2971 bool bIsEndElement = false;
2972
2973 /* check for start element at beginning of the line - pcEnd and thus (pcPos+1)
2974 are dereferenceable, because OUStringBuffer::getStr is null-terminated. */
2975 if( (*pcPos == '<') && (pcPos[ 1 ] != '/') )
2976 {
2977 const sal_Unicode* pcElementEnd = ::std::find( pcPos, pcEnd, '>' );
2978 if( pcElementEnd == pcEnd )
2979 {
2980 // incomplete start element
2981 maIncompleteLine = OUString( pcPos, static_cast< sal_Int32 >( pcEnd - pcPos ) );
2982 pcPos = pcEnd;
2983 }
2984 else
2985 {
2986 bIsComplElement = (pcPos[ 1 ] == '?') || (pcPos[ 1 ] == '!') || (pcElementEnd[ -1 ] == '/');
2987 bIsStartElement = !bIsComplElement;
2988 ++pcElementEnd;
2989 aOutLine.append( pcPos, static_cast< sal_Int32 >( pcElementEnd - pcPos ) );
2990 pcPos = pcElementEnd;
2991 }
2992 }
2993
2994 // check for following element text
2995 if( !bIsComplElement && (pcPos < pcEnd) )
2996 {
2997 const sal_Unicode* pcElementStart = ::std::find( pcPos, pcEnd, '<' );
2998 // append text between elements
2999 if( pcPos < pcElementStart )
3000 {
3001 OUString aText( pcPos, static_cast< sal_Int32 >( pcElementStart - pcPos ) );
3002 if( aText.trim().getLength() > 0 )
3003 aOutLine.append( aText );
3004 pcPos = pcElementStart;
3005 }
3006 }
3007
3008 // check for stand-alone or following end element
3009 if( !bIsComplElement && (pcPos < pcEnd) && (pcPos[ 1 ] == '/') )
3010 {
3011 const sal_Unicode* pcElementEnd = ::std::find( pcPos, pcEnd, '>' );
3012 if( pcElementEnd == pcEnd )
3013 {
3014 // incomplete end element
3015 aOutLine.append( pcPos, static_cast< sal_Int32 >( pcEnd - pcPos ) );
3016 maIncompleteLine = aOutLine.makeStringAndClear();
3017 pcPos = pcEnd;
3018 }
3019 else
3020 {
3021 bIsEndElement = true;
3022 ++pcElementEnd;
3023 aOutLine.append( pcPos, static_cast< sal_Int32 >( pcElementEnd - pcPos ) );
3024 pcPos = pcElementEnd;
3025 }
3026 }
3027
3028 // flush output line
3029 if( maIncompleteLine.getLength() == 0 )
3030 {
3031 if( !bIsStartElement && bIsEndElement ) rOut.decIndent();
3032 rOut.writeString( aOutLine.makeStringAndClear() );
3033 rOut.newLine();
3034 if( bIsStartElement && !bIsEndElement ) rOut.incIndent();
3035 }
3036 }
3037 }
3038
3039 // ============================================================================
3040 // ============================================================================
3041
3042 void RecordObjectBase::construct( const ObjectBase& rParent,
3043 const BinaryInputStreamRef& rxBaseStrm, const OUString& rSysFileName,
3044 const BinaryInputStreamRef& rxRecStrm, const String& rRecNames, const String& rSimpleRecs )
3045 {
3046 InputObjectBase::construct( rParent, rxRecStrm, rSysFileName );
3047 constructRecObjBase( rxBaseStrm, rRecNames, rSimpleRecs );
3048 }
3049
3050 void RecordObjectBase::construct( const OutputObjectBase& rParent, const BinaryInputStreamRef& rxBaseStrm,
3051 const BinaryInputStreamRef& rxRecStrm, const String& rRecNames, const String& rSimpleRecs )
3052 {
3053 InputObjectBase::construct( rParent, rxRecStrm );
3054 constructRecObjBase( rxBaseStrm, rRecNames, rSimpleRecs );
3055 }
3056
3057 bool RecordObjectBase::implIsValid() const
3058 {
3059 return mxBaseStrm.get() && InputObjectBase::implIsValid();
3060 }
3061
3062 void RecordObjectBase::implDump()
3063 {
3064 NameListRef xRecNames = getRecNames();
3065
3066 typedef ::std::map< sal_Int64, ItemFormat > ItemFormatMap;
3067 ItemFormatMap aSimpleRecs;
3068 if( NameListBase* pSimpleRecs = maSimpleRecs.getNameList( cfg() ).get() )
3069 for( NameListBase::const_iterator aIt = pSimpleRecs->begin(), aEnd = pSimpleRecs->end(); aIt != aEnd; ++aIt )
3070 aSimpleRecs[ aIt->first ].parse( aIt->second );
3071
3072 while( implStartRecord( *mxBaseStrm, mnRecPos, mnRecId, mnRecSize ) )
3073 {
3074 // record header
3075 out().emptyLine();
3076 writeHeader();
3077 implWriteExtHeader();
3078 IndentGuard aIndGuard( out() );
3079 sal_Int64 nRecPos = in().tell();
3080
3081 // record body
3082 if( !mbBinaryOnly && cfg().hasName( xRecNames, mnRecId ) )
3083 {
3084 ItemFormatMap::const_iterator aIt = aSimpleRecs.find( mnRecId );
3085 if( aIt != aSimpleRecs.end() )
3086 dumpItem( aIt->second );
3087 else
3088 implDumpRecordBody();
3089 }
3090
3091 // remaining undumped data
3092 if( !in().isEof() && (in().tell() == nRecPos) )
3093 dumpRawBinary( mnRecSize, false );
3094 else
3095 dumpRemainingTo( nRecPos + mnRecSize );
3096 }
3097 }
3098
3099 void RecordObjectBase::implWriteExtHeader()
3100 {
3101 }
3102
3103 void RecordObjectBase::implDumpRecordBody()
3104 {
3105 }
3106
3107 void RecordObjectBase::constructRecObjBase( const BinaryInputStreamRef& rxBaseStrm, const String& rRecNames, const String& rSimpleRecs )
3108 {
3109 mxBaseStrm = rxBaseStrm;
3110 maRecNames = rRecNames;
3111 maSimpleRecs = rSimpleRecs;
3112 mnRecPos = mnRecId = mnRecSize = 0;
3113 mbBinaryOnly = false;
3114 if( InputObjectBase::implIsValid() )
3115 mbShowRecPos = cfg().getBoolOption( "show-record-position", true );
3116 }
3117
3118 void RecordObjectBase::writeHeader()
3119 {
3120 MultiItemsGuard aMultiGuard( out() );
3121 writeEmptyItem( "REC" );
3122 if( mbShowRecPos && mxBaseStrm->isSeekable() )
3123 writeShortHexItem( "pos", mnRecPos, "CONV-DEC" );
3124 writeShortHexItem( "size", mnRecSize, "CONV-DEC" );
3125 ItemGuard aItem( out(), "id" );
3126 out().writeShortHex( mnRecId );
3127 addNameToItem( mnRecId, "CONV-DEC" );
3128 addNameToItem( mnRecId, maRecNames );
3129 }
3130
3131 // ============================================================================
3132
3133 void SequenceRecordObjectBase::construct(
3134 const ObjectBase& rParent, const BinaryInputStreamRef& rxBaseStrm, const ::rtl::OUString& rSysFileName,
3135 const BinaryInputStreamRef& rxRecStrm, const String& rRecNames, const String& rSimpleRecs )
3136 {
3137 RecordObjectBase::construct( rParent, rxBaseStrm, rSysFileName, rxRecStrm, rRecNames, rSimpleRecs );
3138 }
3139
3140 void SequenceRecordObjectBase::construct( const OutputObjectBase& rParent,
3141 const BinaryInputStreamRef& rxBaseStrm, const BinaryInputStreamRef& rxRecStrm,
3142 const String& rRecNames, const String& rSimpleRecs )
3143 {
3144 RecordObjectBase::construct( rParent, rxBaseStrm, rxRecStrm, rRecNames, rSimpleRecs );
3145 }
3146
3147 void SequenceRecordObjectBase::construct( const ObjectBase& rParent,
3148 const BinaryInputStreamRef& rxBaseStrm, const ::rtl::OUString& rSysFileName,
3149 const String& rRecNames, const String& rSimpleRecs )
3150 {
3151 BinaryInputStreamRef xRecStrm( new SequenceInputStream( *mxRecData ) );
3152 RecordObjectBase::construct( rParent, rxBaseStrm, rSysFileName, xRecStrm, rRecNames, rSimpleRecs );
3153 }
3154
3155 void SequenceRecordObjectBase::construct( const OutputObjectBase& rParent,
3156 const BinaryInputStreamRef& rxBaseStrm, const String& rRecNames, const String& rSimpleRecs )
3157 {
3158 BinaryInputStreamRef xRecStrm( new SequenceInputStream( *mxRecData ) );
3159 RecordObjectBase::construct( rParent, rxBaseStrm, xRecStrm, rRecNames, rSimpleRecs );
3160 }
3161
3162 bool SequenceRecordObjectBase::implStartRecord( BinaryInputStream& rBaseStrm, sal_Int64& ornRecPos, sal_Int64& ornRecId, sal_Int64& ornRecSize )
3163 {
3164 bool bValid = true;
3165 if( rBaseStrm.isSeekable() )
3166 {
3167 ornRecPos = rBaseStrm.tell();
3168 // do not try to overread seekable streams, may cause assertions
3169 bValid = ornRecPos < rBaseStrm.getLength();
3170 }
3171
3172 // read the record header
3173 if( bValid )
3174 bValid = implReadRecordHeader( rBaseStrm, ornRecId, ornRecSize ) && !rBaseStrm.isEof() && (0 <= ornRecSize) && (ornRecSize <= 0x00100000);
3175
3176 // read record contents into data sequence
3177 if( bValid )
3178 {
3179 sal_Int32 nRecSize = static_cast< sal_Int32 >( ornRecSize );
3180 mxRecData->realloc( nRecSize );
3181 bValid = (nRecSize == 0) || (rBaseStrm.readData( *mxRecData, nRecSize ) == nRecSize);
3182 in().seekToStart();
3183 }
3184 return bValid;
3185 }
3186
3187 // ============================================================================
3188 // ============================================================================
3189
3190 DumperBase::~DumperBase()
3191 {
3192 }
3193
3194 bool DumperBase::isImportEnabled() const
3195 {
3196 return !isValid() || cfg().isImportEnabled();
3197 }
3198
3199 bool DumperBase::isImportCancelled() const
3200 {
3201 return isValid() && cfg().isPasswordCancelled();
3202 }
3203
3204 void DumperBase::construct( const ConfigRef& rxConfig )
3205 {
3206 if( isValid( rxConfig ) && rxConfig->isDumperEnabled() )
3207 ObjectBase::construct( rxConfig );
3208 }
3209
3210 // ============================================================================
3211 // ============================================================================
3212
3213 } // namespace dump
3214 } // namespace oox
3215
3216 #endif
3217
vba interoperability for OOo