oox/source/xls/biffinputstream.cxx

   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: biffinputstream.cxx,v $
  10  * $Revision: 1.4.20.2 $
  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/xls/biffinputstream.hxx"
  32 #include <algorithm>
  33 #include <rtl/ustrbuf.hxx>
  34
  35 using ::rtl::OString;
  36 using ::rtl::OStringToOUString;
  37 using ::rtl::OUString;
  38 using ::rtl::OUStringBuffer;
  39
  40 namespace oox {
  41 namespace xls {
  42
  43 // ============================================================================
  44
  45 namespace prv {
  46
  47 BiffInputRecordBuffer::BiffInputRecordBuffer( BinaryInputStream& rInStrm ) :
  48     mrInStrm( rInStrm ),
  49     mpCurrentData( 0 ),
  50     mnHeaderPos( -1 ),
  51     mnBodyPos( 0 ),
  52     mnBufferBodyPos( 0 ),
  53     mnNextHeaderPos( 0 ),
  54     mnRecId( BIFF_ID_UNKNOWN ),
  55     mnRecSize( 0 ),
  56     mnRecPos( 0 ),
  57     mbValidHeader( false )
  58 {
  59     OSL_ENSURE( mrInStrm.isSeekable(), "BiffInputRecordBuffer::BiffInputRecordBuffer - stream must be seekable" );
  60     mrInStrm.seekToStart();
  61     maOriginalData.reserve( SAL_MAX_UINT16 );
  62     maDecodedData.reserve( SAL_MAX_UINT16 );
  63     enableDecoder( false );     // updates mpCurrentData
  64 }
  65
  66 void BiffInputRecordBuffer::restartAt( sal_Int64 nPos )
  67 {
  68     mnHeaderPos = -1;
  69     mnBodyPos = mnBufferBodyPos = 0;
  70     mnNextHeaderPos = nPos;
  71     mnRecId = BIFF_ID_UNKNOWN;
  72     mnRecSize = mnRecPos = 0;
  73     mbValidHeader = false;
  74 }
  75
  76 void BiffInputRecordBuffer::setDecoder( const BiffDecoderRef& rxDecoder )
  77 {
  78     mxDecoder = rxDecoder;
  79     enableDecoder( true );
  80     updateDecoded();
  81 }
  82
  83 void BiffInputRecordBuffer::enableDecoder( bool bEnable )
  84 {
  85     mpCurrentData = (bEnable && mxDecoder.get() && mxDecoder->isValid()) ? &maDecodedData : &maOriginalData;
  86 }
  87
  88 bool BiffInputRecordBuffer::startRecord( sal_Int64 nHeaderPos )
  89 {
  90     mbValidHeader = (0 <= nHeaderPos) && (nHeaderPos + 4 <= mrInStrm.getLength());
  91     if( mbValidHeader )
  92     {
  93         mnHeaderPos = nHeaderPos;
  94         mrInStrm.seek( nHeaderPos );
  95         mrInStrm >> mnRecId >> mnRecSize;
  96         mnBodyPos = mrInStrm.tell();
  97         mnNextHeaderPos = mnBodyPos + mnRecSize;
  98         mbValidHeader = !mrInStrm.isEof() && (mnNextHeaderPos <= mrInStrm.getLength());
  99     }
 100     if( !mbValidHeader )
 101     {
 102         mnHeaderPos = mnBodyPos = -1;
 103         mnNextHeaderPos = 0;
 104         mnRecId = BIFF_ID_UNKNOWN;
 105         mnRecSize = 0;
 106     }
 107     mnRecPos = 0;
 108     return mbValidHeader;
 109 }
 110
 111 bool BiffInputRecordBuffer::startNextRecord()
 112 {
 113     return startRecord( mnNextHeaderPos );
 114 }
 115
 116 sal_uInt16 BiffInputRecordBuffer::getNextRecId()
 117 {
 118     sal_uInt16 nRecId = BIFF_ID_UNKNOWN;
 119     if( mbValidHeader && (mnNextHeaderPos + 4 <= mrInStrm.getLength()) )
 120     {
 121         mrInStrm.seek( mnNextHeaderPos );
 122         mrInStrm >> nRecId;
 123     }
 124     return nRecId;
 125 }
 126
 127 void BiffInputRecordBuffer::read( void* opData, sal_uInt16 nBytes )
 128 {
 129     updateBuffer();
 130     OSL_ENSURE( nBytes > 0, "BiffInputRecordBuffer::read - nothing to read" );
 131     OSL_ENSURE( nBytes <= getRecLeft(), "BiffInputRecordBuffer::read - buffer overflow" );
 132     memcpy( opData, &(*mpCurrentData)[ mnRecPos ], nBytes );
 133     mnRecPos = mnRecPos + nBytes;
 134 }
 135
 136 void BiffInputRecordBuffer::skip( sal_uInt16 nBytes )
 137 {
 138     OSL_ENSURE( nBytes > 0, "BiffInputRecordBuffer::skip - nothing to skip" );
 139     OSL_ENSURE( nBytes <= getRecLeft(), "BiffInputRecordBuffer::skip - buffer overflow" );
 140     mnRecPos = mnRecPos + nBytes;
 141 }
 142
 143 void BiffInputRecordBuffer::updateBuffer()
 144 {
 145     OSL_ENSURE( mbValidHeader, "BiffInputRecordBuffer::updateBuffer - invalid access" );
 146     if( mnBodyPos != mnBufferBodyPos )
 147     {
 148         mrInStrm.seek( mnBodyPos );
 149         maOriginalData.resize( mnRecSize );
 150         if( mnRecSize > 0 )
 151             mrInStrm.readMemory( &maOriginalData.front(), static_cast< sal_Int32 >( mnRecSize ) );
 152         mnBufferBodyPos = mnBodyPos;
 153         updateDecoded();
 154     }
 155 }
 156
 157 void BiffInputRecordBuffer::updateDecoded()
 158 {
 159     if( mxDecoder.get() && mxDecoder->isValid() )
 160     {
 161         maDecodedData.resize( mnRecSize );
 162         if( mnRecSize > 0 )
 163             mxDecoder->decode( &maDecodedData.front(), &maOriginalData.front(), mnBodyPos, mnRecSize );
 164     }
 165 }
 166
 167 } // namespace prv
 168
 169 // ============================================================================
 170
 171 BiffInputStream::BiffInputStream( BinaryInputStream& rInStream, bool bContLookup ) :
 172     maRecBuffer( rInStream ),
 173     mnRecHandle( -1 ),
 174     mnRecId( BIFF_ID_UNKNOWN ),
 175     mnAltContId( BIFF_ID_UNKNOWN ),
 176     mnCurrRecSize( 0 ),
 177     mnComplRecSize( 0 ),
 178     mbHasComplRec( false ),
 179     mbCont( bContLookup )
 180 {
 181     mbEof = true;   // EOF will be true if stream is not inside a record
 182 }
 183
 184 // record control -------------------------------------------------------------
 185
 186 bool BiffInputStream::startNextRecord()
 187 {
 188     bool bValidRec = false;
 189     /*  #i4266# ignore zero records (id==len==0) (e.g. the application
 190         "Crystal Report" writes zero records between other records) */
 191     bool bIsZeroRec = false;
 192     do
 193     {
 194         // record header is never encrypted
 195         maRecBuffer.enableDecoder( false );
 196         // read header of next raw record, returns false at end of stream
 197         bValidRec = maRecBuffer.startNextRecord();
 198         // ignore record, if identifier and size are zero
 199         bIsZeroRec = (maRecBuffer.getRecId() == 0) && (maRecBuffer.getRecSize() == 0);
 200     }
 201     while( bValidRec && ((mbCont && isContinueId( maRecBuffer.getRecId() )) || bIsZeroRec) );
 202
 203     // setup other class members
 204     setupRecord();
 205     return isInRecord();
 206 }
 207
 208 bool BiffInputStream::startRecordByHandle( sal_Int64 nRecHandle )
 209 {
 210     rewindToRecord( nRecHandle );
 211     return startNextRecord();
 212 }
 213
 214 void BiffInputStream::resetRecord( bool bContLookup, sal_uInt16 nAltContId )
 215 {
 216     if( isInRecord() )
 217     {
 218         mbCont = bContLookup;
 219         mnAltContId = nAltContId;
 220         restartRecord( true );
 221         maRecBuffer.enableDecoder( true );
 222     }
 223 }
 224
 225 void BiffInputStream::rewindRecord()
 226 {
 227     rewindToRecord( mnRecHandle );
 228 }
 229
 230 // decoder --------------------------------------------------------------------
 231
 232 void BiffInputStream::setDecoder( const BiffDecoderRef& rxDecoder )
 233 {
 234     maRecBuffer.setDecoder( rxDecoder );
 235 }
 236
 237 void BiffInputStream::enableDecoder( bool bEnable )
 238 {
 239     maRecBuffer.enableDecoder( bEnable );
 240 }
 241
 242 // stream/record state and info -----------------------------------------------
 243
 244 sal_uInt16 BiffInputStream::getNextRecId()
 245 {
 246     sal_uInt16 nRecId = BIFF_ID_UNKNOWN;
 247     if( isInRecord() )
 248     {
 249         sal_Int64 nCurrPos = tell();            // save current position in record
 250         while( jumpToNextContinue() ) {}        // skip following CONTINUE records
 251         if( maRecBuffer.startNextRecord() )     // read header of next record
 252             nRecId = maRecBuffer.getRecId();
 253         seek( nCurrPos );                       // restore position, seek() resets old mbValid state
 254     }
 255     return nRecId;
 256 }
 257
 258 // BinaryStreamBase interface (seeking) ---------------------------------------
 259
 260 bool BiffInputStream::isSeekable() const
 261 {
 262     return true;
 263 }
 264
 265 sal_Int64 BiffInputStream::tell() const
 266 {
 267     return mbEof ? -1 : (mnCurrRecSize - maRecBuffer.getRecLeft());
 268 }
 269
 270 sal_Int64 BiffInputStream::getLength() const
 271 {
 272     if( !mbHasComplRec )
 273         const_cast< BiffInputStream* >( this )->calcRecordLength();
 274     return mnComplRecSize;
 275 }
 276
 277 void BiffInputStream::seek( sal_Int64 nRecPos )
 278 {
 279     if( isInRecord() )
 280     {
 281         if( mbEof || (nRecPos < tell()) )
 282             restartRecord( false );
 283         if( !mbEof && (nRecPos > tell()) )
 284             skip( static_cast< sal_Int32 >( nRecPos - tell() ) );
 285     }
 286 }
 287
 288 sal_Int64 BiffInputStream::tellBase() const
 289 {
 290     return maRecBuffer.getBaseStream().tell();
 291 }
 292
 293 sal_Int64 BiffInputStream::getBaseLength() const
 294 {
 295     return maRecBuffer.getBaseStream().getLength();
 296 }
 297
 298 // BinaryInputStream interface (stream read access) ---------------------------
 299
 300 sal_Int32 BiffInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes )
 301 {
 302     sal_Int32 nRet = 0;
 303     if( !mbEof )
 304     {
 305         orData.realloc( ::std::max< sal_Int32 >( nBytes, 0 ) );
 306         if( nBytes > 0 )
 307         {
 308             nRet = readMemory( orData.getArray(), nBytes );
 309             if( nRet < nBytes )
 310                 orData.realloc( nRet );
 311         }
 312     }
 313     return nRet;
 314 }
 315
 316 sal_Int32 BiffInputStream::readMemory( void* opMem, sal_Int32 nBytes )
 317 {
 318     sal_Int32 nRet = 0;
 319     if( !mbEof && opMem && (nBytes > 0) )
 320     {
 321         sal_uInt8* pnBuffer = reinterpret_cast< sal_uInt8* >( opMem );
 322         sal_Int32 nBytesLeft = nBytes;
 323
 324         while( !mbEof && (nBytesLeft > 0) )
 325         {
 326             sal_uInt16 nReadSize = getMaxRawReadSize( nBytesLeft );
 327             // check nReadSize, stream may already be located at end of a raw record
 328             if( nReadSize > 0 )
 329             {
 330                 maRecBuffer.read( pnBuffer, nReadSize );
 331                 nRet += nReadSize;
 332                 pnBuffer += nReadSize;
 333                 nBytesLeft -= nReadSize;
 334             }
 335             if( nBytesLeft > 0 )
 336                 jumpToNextContinue();
 337             OSL_ENSURE( !mbEof, "BiffInputStream::readMemory - record overread" );
 338         }
 339     }
 340     return nRet;
 341 }
 342
 343 void BiffInputStream::skip( sal_Int32 nBytes )
 344 {
 345     sal_Int32 nBytesLeft = nBytes;
 346     while( !mbEof && (nBytesLeft > 0) )
 347     {
 348         sal_uInt16 nSkipSize = getMaxRawReadSize( nBytesLeft );
 349         // check nSkipSize, stream may already be located at end of a raw record
 350         if( nSkipSize > 0 )
 351         {
 352             maRecBuffer.skip( nSkipSize );
 353             nBytesLeft -= nSkipSize;
 354         }
 355         if( nBytesLeft > 0 )
 356             jumpToNextContinue();
 357         OSL_ENSURE( !mbEof, "BiffInputStream::skip - record overread" );
 358     }
 359 }
 360
 361 // byte strings ---------------------------------------------------------------
 362
 363 OString BiffInputStream::readByteString( bool b16BitLen, bool bAllowNulChars )
 364 {
 365     sal_Int32 nStrLen = b16BitLen ? readuInt16() : readuInt8();
 366     return readCharArray( nStrLen, bAllowNulChars );
 367 }
 368
 369 OUString BiffInputStream::readByteStringUC( bool b16BitLen, rtl_TextEncoding eTextEnc, bool bAllowNulChars )
 370 {
 371     return OStringToOUString( readByteString( b16BitLen, bAllowNulChars ), eTextEnc );
 372 }
 373
 374 void BiffInputStream::skipByteString( bool b16BitLen )
 375 {
 376     skip( b16BitLen ? readuInt16() : readuInt8() );
 377 }
 378
 379 // Unicode strings ------------------------------------------------------------
 380
 381 OUString BiffInputStream::readUniStringChars( sal_uInt16 nChars, bool b16BitChars, bool bAllowNulChars )
 382 {
 383     OUStringBuffer aBuffer;
 384     aBuffer.ensureCapacity( nChars );
 385
 386     /*  This function has to react on CONTINUE records to read the repeated
 387         flags field, so readUnicodeArray() cannot be used here. */
 388     sal_uInt16 nCharsLeft = nChars;
 389     while( !mbEof && (nCharsLeft > 0) )
 390     {
 391         sal_uInt16 nPortionCount = 0;
 392         if( b16BitChars )
 393         {
 394             nPortionCount = ::std::min< sal_uInt16 >( nCharsLeft, maRecBuffer.getRecLeft() / 2 );
 395             OSL_ENSURE( (nPortionCount <= nCharsLeft) || ((maRecBuffer.getRecLeft() & 1) == 0),
 396                 "BiffInputStream::readUniStringChars - missing a byte" );
 397         }
 398         else
 399         {
 400             nPortionCount = getMaxRawReadSize( nCharsLeft );
 401         }
 402
 403         // read the character array
 404         appendUnicodeArray( aBuffer, nPortionCount, b16BitChars, bAllowNulChars );
 405
 406         // prepare for next CONTINUE record
 407         nCharsLeft = nCharsLeft - nPortionCount;
 408         if( nCharsLeft > 0 )
 409             jumpToNextStringContinue( b16BitChars );
 410     }
 411
 412     return aBuffer.makeStringAndClear();
 413 }
 414
 415 OUString BiffInputStream::readUniStringBody( sal_uInt16 nChars, bool bAllowNulChars )
 416 {
 417     bool b16BitChars;
 418     sal_Int32 nAddSize;
 419     readUniStringHeader( b16BitChars, nAddSize );
 420     OUString aString = readUniStringChars( nChars, b16BitChars, bAllowNulChars );
 421     skip( nAddSize );
 422     return aString;
 423 }
 424
 425 OUString BiffInputStream::readUniString( bool bAllowNulChars )
 426 {
 427     return readUniStringBody( readuInt16(), bAllowNulChars );
 428 }
 429
 430 void BiffInputStream::skipUniStringChars( sal_uInt16 nChars, bool b16BitChars )
 431 {
 432     sal_uInt16 nCharsLeft = nChars;
 433     while( !mbEof && (nCharsLeft > 0) )
 434     {
 435         sal_uInt16 nPortionCount;
 436         if( b16BitChars )
 437         {
 438             nPortionCount = ::std::min< sal_uInt16 >( nCharsLeft, maRecBuffer.getRecLeft() / 2 );
 439             OSL_ENSURE( (nPortionCount <= nCharsLeft) || ((maRecBuffer.getRecLeft() & 1) == 0),
 440                 "BiffInputStream::skipUniStringChars - missing a byte" );
 441             skip( 2 * nPortionCount );
 442         }
 443         else
 444         {
 445             nPortionCount = getMaxRawReadSize( nCharsLeft );
 446             skip( nPortionCount );
 447         }
 448
 449         // prepare for next CONTINUE record
 450         nCharsLeft = nCharsLeft - nPortionCount;
 451         if( nCharsLeft > 0 )
 452             jumpToNextStringContinue( b16BitChars );
 453     }
 454 }
 455
 456 void BiffInputStream::skipUniStringBody( sal_uInt16 nChars )
 457 {
 458     bool b16BitChars;
 459     sal_Int32 nAddSize;
 460     readUniStringHeader( b16BitChars, nAddSize );
 461     skipUniStringChars( nChars, b16BitChars );
 462     skip( nAddSize );
 463 }
 464
 465 void BiffInputStream::skipUniString()
 466 {
 467     skipUniStringBody( readuInt16() );
 468 }
 469
 470 // private --------------------------------------------------------------------
 471
 472 void BiffInputStream::readAtom( void* opMem, sal_uInt8 nSize )
 473 {
 474     // byte swapping is done in calling BinaryInputStream::readValue() template function
 475     if( ensureRawReadSize( nSize ) )
 476         maRecBuffer.read( opMem, nSize );
 477 }
 478
 479 void BiffInputStream::setupRecord()
 480 {
 481     // initialize class members
 482     mnRecHandle = maRecBuffer.getRecHeaderPos();
 483     mnRecId = maRecBuffer.getRecId();
 484     mnAltContId = BIFF_ID_UNKNOWN;
 485     mnCurrRecSize = mnComplRecSize = maRecBuffer.getRecSize();
 486     mbHasComplRec = !mbCont;
 487     mbEof = !isInRecord();
 488     // enable decoder in new record
 489     enableDecoder( true );
 490 }
 491
 492 void BiffInputStream::restartRecord( bool bInvalidateRecSize )
 493 {
 494     if( isInRecord() )
 495     {
 496         maRecBuffer.startRecord( getRecHandle() );
 497         mnCurrRecSize = maRecBuffer.getRecSize();
 498         if( bInvalidateRecSize )
 499         {
 500             mnComplRecSize = mnCurrRecSize;
 501             mbHasComplRec = !mbCont;
 502         }
 503         mbEof = false;
 504     }
 505 }
 506
 507 void BiffInputStream::rewindToRecord( sal_Int64 nRecHandle )
 508 {
 509     if( nRecHandle >= 0 )
 510     {
 511         maRecBuffer.restartAt( nRecHandle );
 512         mnRecHandle = -1;
 513         mbEof = true;   // as long as the record is not started
 514     }
 515 }
 516
 517 bool BiffInputStream::isContinueId( sal_uInt16 nRecId ) const
 518 {
 519     return (nRecId == BIFF_ID_CONT) || (nRecId == mnAltContId);
 520 }
 521
 522 bool BiffInputStream::jumpToNextContinue()
 523 {
 524     mbEof = mbEof || !mbCont || !isContinueId( maRecBuffer.getNextRecId() ) || !maRecBuffer.startNextRecord();
 525     if( !mbEof )
 526         mnCurrRecSize += maRecBuffer.getRecSize();
 527     return !mbEof;
 528 }
 529
 530 bool BiffInputStream::jumpToNextStringContinue( bool& rb16BitChars )
 531 {
 532     OSL_ENSURE( maRecBuffer.getRecLeft() == 0, "BiffInputStream::jumpToNextStringContinue - unexpected garbage" );
 533
 534     if( mbCont && (getRemaining() > 0) )
 535     {
 536         jumpToNextContinue();
 537     }
 538     else if( mnRecId == BIFF_ID_CONT )
 539     {
 540         /*  CONTINUE handling is off, but we have started reading in a CONTINUE
 541             record -> start next CONTINUE for TXO import. We really start a new
 542             record here - no chance to return to string origin. */
 543         mbEof = mbEof || (maRecBuffer.getNextRecId() != BIFF_ID_CONT) || !maRecBuffer.startNextRecord();
 544         if( !mbEof )
 545             setupRecord();
 546     }
 547
 548     // trying to read the flags invalidates stream, if no CONTINUE record has been found
 549     sal_uInt8 nFlags;
 550     readValue( nFlags );
 551     rb16BitChars = getFlag( nFlags, BIFF_STRF_16BIT );
 552     return !mbEof;
 553 }
 554
 555 void BiffInputStream::calcRecordLength()
 556 {
 557     sal_Int64 nCurrPos = tell();            // save current position in record
 558     while( jumpToNextContinue() ) {}        // jumpToNextContinue() adds up mnCurrRecSize
 559     mnComplRecSize = mnCurrRecSize;
 560     mbHasComplRec = true;
 561     seek( nCurrPos );                       // restore position, seek() resets old mbValid state
 562 }
 563
 564 bool BiffInputStream::ensureRawReadSize( sal_uInt16 nBytes )
 565 {
 566     if( !mbEof && (nBytes > 0) )
 567     {
 568         while( !mbEof && (maRecBuffer.getRecLeft() == 0) ) jumpToNextContinue();
 569         mbEof = mbEof || (nBytes > maRecBuffer.getRecLeft());
 570         OSL_ENSURE( !mbEof, "BiffInputStream::ensureRawReadSize - record overread" );
 571     }
 572     return !mbEof;
 573 }
 574
 575 sal_uInt16 BiffInputStream::getMaxRawReadSize( sal_Int32 nBytes ) const
 576 {
 577     return getLimitedValue< sal_uInt16, sal_Int32 >( nBytes, 0, maRecBuffer.getRecLeft() );
 578 }
 579
 580 void BiffInputStream::appendUnicodeArray( OUStringBuffer& orBuffer, sal_uInt16 nChars, bool b16BitChars, bool bAllowNulChars )
 581 {
 582     orBuffer.ensureCapacity( orBuffer.getLength() + nChars );
 583     sal_uInt16 nChar;
 584     for( sal_uInt16 nCharIdx = 0; !mbEof && (nCharIdx < nChars); ++nCharIdx )
 585     {
 586         if( b16BitChars ) readValue( nChar ); else nChar = readuInt8();
 587         orBuffer.append( static_cast< sal_Unicode >( (!bAllowNulChars && (nChar == 0)) ? '?' : nChar ) );
 588     }
 589 }
 590
 591 void BiffInputStream::readUniStringHeader( bool& orb16BitChars, sal_Int32& ornAddSize )
 592 {
 593     sal_uInt8 nFlags = readuInt8();
 594     OSL_ENSURE( !getFlag( nFlags, BIFF_STRF_UNKNOWN ), "BiffInputStream::readUniStringHeader - unknown flags" );
 595     orb16BitChars = getFlag( nFlags, BIFF_STRF_16BIT );
 596     sal_uInt16 nFontCount = getFlag( nFlags, BIFF_STRF_RICH ) ? readuInt16() : 0;
 597     sal_Int32 nPhoneticSize = getFlag( nFlags, BIFF_STRF_PHONETIC ) ? readInt32() : 0;
 598     ornAddSize = 4 * nFontCount + ::std::max< sal_Int32 >( 0, nPhoneticSize );
 599 }
 600
 601 // ============================================================================
 602
 603 BiffInputStreamPos::BiffInputStreamPos( BiffInputStream& rStrm ) :
 604     mrStrm( rStrm ),
 605     mnRecHandle( rStrm.getRecHandle() ),
 606     mnRecPos( rStrm.tell() )
 607 {
 608 }
 609
 610 bool BiffInputStreamPos::restorePosition()
 611 {
 612     bool bValidRec = mrStrm.startRecordByHandle( mnRecHandle );
 613     if( bValidRec )
 614         mrStrm.seek( mnRecPos );
 615     return bValidRec && !mrStrm.isEof();
 616 }
 617
 618 // ============================================================================
 619
 620 BiffInputStreamPosGuard::BiffInputStreamPosGuard( BiffInputStream& rStrm ) :
 621     BiffInputStreamPos( rStrm )
 622 {
 623 }
 624
 625 BiffInputStreamPosGuard::~BiffInputStreamPosGuard()
 626 {
 627     restorePosition();
 628 }
 629
 630 // ============================================================================
 631
 632 } // namespace xls
 633 } // namespace oox
 634