LCOV - code coverage report
Current view: top level - tools/source/stream - stream.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 828 1172 70.6 %
Date: 2014-11-03 Functions: 94 148 63.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : // TODO: Read->RefreshBuffer-> React to changes from nBufActualLen
      21             : 
      22             : #include <cstddef>
      23             : 
      24             : #include <string.h>
      25             : #include <stdio.h>
      26             : #include <ctype.h>
      27             : #include <stdlib.h>
      28             : 
      29             : #include <boost/static_assert.hpp>
      30             : 
      31             : #include <osl/endian.h>
      32             : 
      33             : #include <comphelper/string.hxx>
      34             : 
      35             : #define SWAPNIBBLES(c)      \
      36             : unsigned char nSwapTmp=c;   \
      37             : nSwapTmp <<= 4;             \
      38             : c >>= 4;                    \
      39             : c |= nSwapTmp;
      40             : 
      41             : #include <tools/debug.hxx>
      42             : #include <tools/stream.hxx>
      43             : #include <osl/thread.h>
      44             : #include <algorithm>
      45             : 
      46             : // !!! Do not inline if already the operators <<,>> are inline
      47       22286 : inline static void SwapUShort( sal_uInt16& r )
      48       22286 :     {   r = OSL_SWAPWORD(r);   }
      49       19848 : inline static void SwapShort( short& r )
      50       19848 :     {   r = OSL_SWAPWORD(r);   }
      51      247730 : inline static void SwapULong( sal_uInt32& r )
      52      247730 :     {   r = OSL_SWAPDWORD(r);   }
      53       96245 : inline static void SwapLongInt( sal_Int32& r )
      54       96245 :     {   r = OSL_SWAPDWORD(r);   }
      55             : 
      56           0 : inline static void SwapUInt64( sal_uInt64& r )
      57             :     {
      58             :         union
      59             :         {
      60             :             sal_uInt64 n;
      61             :             sal_uInt32 c[2];
      62             :         } s;
      63             : 
      64           0 :         s.n = r;
      65           0 :         s.c[0] ^= s.c[1]; // swap the 32 bit words
      66           0 :         s.c[1] ^= s.c[0];
      67           0 :         s.c[0] ^= s.c[1];
      68             :         // swap the bytes in the words
      69           0 :         s.c[0] = OSL_SWAPDWORD(s.c[0]);
      70           0 :         s.c[1] = OSL_SWAPDWORD(s.c[1]);
      71           0 :         r = s.n;
      72           0 :     }
      73           0 : inline static void SwapInt64( sal_Int64& r )
      74             :     {
      75             :         union
      76             :         {
      77             :             sal_Int64 n;
      78             :             sal_Int32 c[2];
      79             :         } s;
      80             : 
      81           0 :         s.n = r;
      82           0 :         s.c[0] ^= s.c[1]; // swap the 32 bit words
      83           0 :         s.c[1] ^= s.c[0];
      84           0 :         s.c[0] ^= s.c[1];
      85             :         // swap the bytes in the words
      86           0 :         s.c[0] = OSL_SWAPDWORD(s.c[0]);
      87           0 :         s.c[1] = OSL_SWAPDWORD(s.c[1]);
      88           0 :         r = s.n;
      89           0 :     }
      90             : 
      91             : #ifdef UNX
      92           0 : inline static void SwapFloat( float& r )
      93             :     {
      94             :         union
      95             :         {
      96             :             float f;
      97             :             sal_uInt32 c;
      98             :         } s;
      99             : 
     100           0 :         s.f = r;
     101           0 :         s.c = OSL_SWAPDWORD( s.c );
     102           0 :         r = s.f;
     103           0 :     }
     104             : 
     105           0 : inline static void SwapDouble( double& r )
     106             :     {
     107             :         if( sizeof(double) != 8 )
     108             :         {
     109             :           DBG_ASSERT( false, "Can only swap 8-Byte-doubles\n" );
     110             :         }
     111             :         else
     112             :         {
     113             :             union
     114             :             {
     115             :                 double d;
     116             :                 sal_uInt32 c[2];
     117             :             } s;
     118             : 
     119           0 :             s.d = r;
     120           0 :             s.c[0] ^= s.c[1]; // swap 32-bit values in situ
     121           0 :             s.c[1] ^= s.c[0];
     122           0 :             s.c[0] ^= s.c[1];
     123           0 :             s.c[0] = OSL_SWAPDWORD(s.c[0]); // swap dword itself in situ
     124           0 :             s.c[1] = OSL_SWAPDWORD(s.c[1]);
     125           0 :             r = s.d;
     126             :         }
     127           0 :     }
     128             : #endif
     129             : 
     130             : //SDO
     131             : 
     132             : #define READNUMBER_WITHOUT_SWAP(datatype,value) \
     133             :     if( bIoRead && sizeof(datatype)<=nBufFree)             \
     134             :     {                                                       \
     135             :         for (std::size_t i = 0; i < sizeof(datatype); i++)  \
     136             :             ((char *)&value)[i] = pBufPos[i];              \
     137             :         nBufActualPos += sizeof(datatype);                  \
     138             :         pBufPos += sizeof(datatype);                        \
     139             :         nBufFree -= sizeof(datatype);                       \
     140             :     }                                                       \
     141             :     else                                                    \
     142             :     {                                                       \
     143             :         Read( (char*)&value, sizeof(datatype) );            \
     144             :     }                                                       \
     145             : 
     146             : 
     147             : #define WRITENUMBER_WITHOUT_SWAP(datatype,value) \
     148             :     if( bIoWrite && sizeof(datatype) <= nBufFree)    \
     149             :     {                                                   \
     150             :         for (std::size_t i = 0; i < sizeof(datatype); i++)  \
     151             :             pBufPos[i] = ((char *)&value)[i];               \
     152             :         nBufFree -= sizeof(datatype);                       \
     153             :         nBufActualPos += sizeof(datatype);                  \
     154             :         if( nBufActualPos > nBufActualLen )                 \
     155             :             nBufActualLen = nBufActualPos;                  \
     156             :         pBufPos += sizeof(datatype);                        \
     157             :         bIsDirty = true;                                    \
     158             :     }                                                       \
     159             :     else                                                    \
     160             :     {                                                       \
     161             :         Write( (char*)&value, sizeof(datatype) );           \
     162             :     }                                                       \
     163             : 
     164             : //  class SvLockBytes
     165             : 
     166       57245 : void SvLockBytes::close()
     167             : {
     168       57245 :     if (m_bOwner)
     169           0 :         delete m_pStream;
     170       57245 :     m_pStream = 0;
     171       57245 : }
     172             : 
     173           0 : TYPEINIT0(SvLockBytes);
     174             : 
     175             : // virtual
     176           2 : ErrCode SvLockBytes::ReadAt(sal_uInt64 const nPos, void * pBuffer, sal_Size nCount,
     177             :                             sal_Size * pRead) const
     178             : {
     179           2 :     if (!m_pStream)
     180             :     {
     181             :         OSL_FAIL("SvLockBytes::ReadAt(): Bad stream");
     182           0 :         return ERRCODE_NONE;
     183             :     }
     184             : 
     185           2 :     m_pStream->Seek(nPos);
     186           2 :     sal_Size nTheRead = m_pStream->Read(pBuffer, nCount);
     187           2 :     if (pRead)
     188           2 :         *pRead = nTheRead;
     189           2 :     return m_pStream->GetErrorCode();
     190             : }
     191             : 
     192             : // virtual
     193           0 : ErrCode SvLockBytes::WriteAt(sal_uInt64 const nPos, const void * pBuffer, sal_Size nCount,
     194             :                              sal_Size * pWritten)
     195             : {
     196           0 :     if (!m_pStream)
     197             :     {
     198             :         OSL_FAIL("SvLockBytes::WriteAt(): Bad stream");
     199           0 :         return ERRCODE_NONE;
     200             :     }
     201             : 
     202           0 :     m_pStream->Seek(nPos);
     203           0 :     sal_Size nTheWritten = m_pStream->Write(pBuffer, nCount);
     204           0 :     if (pWritten)
     205           0 :         *pWritten = nTheWritten;
     206           0 :     return m_pStream->GetErrorCode();
     207             : }
     208             : 
     209             : // virtual
     210           0 : ErrCode SvLockBytes::Flush() const
     211             : {
     212           0 :     if (!m_pStream)
     213             :     {
     214             :         OSL_FAIL("SvLockBytes::Flush(): Bad stream");
     215           0 :         return ERRCODE_NONE;
     216             :     }
     217             : 
     218           0 :     m_pStream->Flush();
     219           0 :     return m_pStream->GetErrorCode();
     220             : }
     221             : 
     222             : // virtual
     223           0 : ErrCode SvLockBytes::SetSize(sal_uInt64 const nSize)
     224             : {
     225           0 :     if (!m_pStream)
     226             :     {
     227             :         OSL_FAIL("SvLockBytes::SetSize(): Bad stream");
     228           0 :         return ERRCODE_NONE;
     229             :     }
     230             : 
     231           0 :     m_pStream->SetStreamSize(nSize);
     232           0 :     return m_pStream->GetErrorCode();
     233             : }
     234             : 
     235           0 : ErrCode SvLockBytes::Stat(SvLockBytesStat * pStat, SvLockBytesStatFlag) const
     236             : {
     237           0 :     if (!m_pStream)
     238             :     {
     239             :         OSL_FAIL("SvLockBytes::Stat(): Bad stream");
     240           0 :         return ERRCODE_NONE;
     241             :     }
     242             : 
     243           0 :     if (pStat)
     244             :     {
     245           0 :         sal_uInt64 const nPos = m_pStream->Tell();
     246           0 :         pStat->nSize = m_pStream->Seek(STREAM_SEEK_TO_END);
     247           0 :         m_pStream->Seek(nPos);
     248             :     }
     249           0 :     return ERRCODE_NONE;
     250             : }
     251             : 
     252             : //  class SvOpenLockBytes
     253             : 
     254           0 : TYPEINIT1(SvOpenLockBytes, SvLockBytes);
     255             : 
     256             : //  class SvAsyncLockBytes
     257             : 
     258           0 : TYPEINIT1(SvAsyncLockBytes, SvOpenLockBytes);
     259             : 
     260             : // virtual
     261           0 : ErrCode SvAsyncLockBytes::ReadAt(sal_uInt64 const nPos, void * pBuffer, sal_Size nCount,
     262             :                                  sal_Size * pRead) const
     263             : {
     264           0 :     if (m_bTerminated)
     265           0 :         return SvOpenLockBytes::ReadAt(nPos, pBuffer, nCount, pRead);
     266             :     else
     267             :     {
     268             :         sal_Size nTheCount =
     269           0 :             std::min<sal_Size>(nPos < m_nSize ? m_nSize - nPos : 0, nCount);
     270             :         ErrCode nError = SvOpenLockBytes::ReadAt(nPos, pBuffer, nTheCount,
     271           0 :                                                  pRead);
     272           0 :         return !nCount || nTheCount == nCount || nError ? nError :
     273           0 :                                                           ERRCODE_IO_PENDING;
     274             :     }
     275             : }
     276             : 
     277             : // virtual
     278           0 : ErrCode SvAsyncLockBytes::WriteAt(sal_uInt64 const nPos, const void * pBuffer,
     279             :                                   sal_Size nCount, sal_Size * pWritten)
     280             : {
     281           0 :     if (m_bTerminated)
     282           0 :         return SvOpenLockBytes::WriteAt(nPos, pBuffer, nCount, pWritten);
     283             :     else
     284             :     {
     285             :         sal_Size nTheCount =
     286           0 :             std::min<sal_Size>(nPos < m_nSize ? m_nSize - nPos : 0, nCount);
     287             :         ErrCode nError = SvOpenLockBytes::WriteAt(nPos, pBuffer, nTheCount,
     288           0 :                                                   pWritten);
     289           0 :         return !nCount || nTheCount == nCount || nError ? nError :
     290           0 :                                                           ERRCODE_IO_PENDING;
     291             :     }
     292             : }
     293             : 
     294             : // virtual
     295           0 : ErrCode SvAsyncLockBytes::FillAppend(const void * pBuffer, sal_Size nCount,
     296             :                                      sal_Size * pWritten)
     297             : {
     298           0 :     sal_Size nTheWritten(0);
     299             :     ErrCode nError = SvOpenLockBytes::WriteAt(m_nSize, pBuffer, nCount,
     300           0 :                                               &nTheWritten);
     301           0 :     if (!nError)
     302           0 :         m_nSize += nTheWritten;
     303           0 :     if (pWritten)
     304           0 :         *pWritten = nTheWritten;
     305           0 :     return nError;
     306             : }
     307             : 
     308             : // virtual
     309           0 : sal_uInt64 SvAsyncLockBytes::Seek(sal_uInt64 const nPos)
     310             : {
     311             :     // check if a truncated STREAM_SEEK_TO_END was passed
     312             :     assert(nPos != SAL_MAX_UINT32);
     313           0 :     if (nPos != STREAM_SEEK_TO_END)
     314           0 :         m_nSize = nPos;
     315           0 :     return m_nSize;
     316             : }
     317             : 
     318             : //  class SvStream
     319             : 
     320      153319 : sal_Size SvStream::GetData( void* pData, sal_Size nSize )
     321             : {
     322      153319 :     if( !GetError() )
     323             :     {
     324             :         DBG_ASSERT( xLockBytes.Is(), "pure virtual function" );
     325      153030 :         sal_Size nRet(0);
     326      153030 :         nError = xLockBytes->ReadAt(m_nActPos, pData, nSize, &nRet);
     327      153030 :         m_nActPos += nRet;
     328      153030 :         return nRet;
     329             :     }
     330         289 :     else return 0;
     331             : }
     332             : 
     333       38483 : sal_Size SvStream::PutData( const void* pData, sal_Size nSize )
     334             : {
     335       38483 :     if( !GetError() )
     336             :     {
     337             :         DBG_ASSERT( xLockBytes.Is(), "pure virtual function" );
     338       38481 :         sal_Size nRet(0);
     339       38481 :         nError = xLockBytes->WriteAt(m_nActPos, pData, nSize, &nRet);
     340       38481 :         m_nActPos += nRet;
     341       38481 :         return nRet;
     342             :     }
     343           2 :     else return 0;
     344             : }
     345             : 
     346      470317 : sal_uInt64 SvStream::SeekPos(sal_uInt64 const nPos)
     347             : {
     348             :     // check if a truncated STREAM_SEEK_TO_END was passed
     349             :     assert(nPos != SAL_MAX_UINT32);
     350      470317 :     if( !GetError() && nPos == STREAM_SEEK_TO_END )
     351             :     {
     352             :         DBG_ASSERT( xLockBytes.Is(), "pure virtual function" );
     353       99100 :         SvLockBytesStat aStat;
     354       99100 :         xLockBytes->Stat( &aStat, SVSTATFLAG_DEFAULT );
     355       99100 :         m_nActPos = aStat.nSize;
     356             :     }
     357             :     else
     358      371217 :         m_nActPos = nPos;
     359      470317 :     return m_nActPos;
     360             : }
     361             : 
     362       63631 : void SvStream::FlushData()
     363             : {
     364       63631 :     if( !GetError() )
     365             :     {
     366             :         DBG_ASSERT( xLockBytes.Is(), "pure virtual function" );
     367       63509 :         nError = xLockBytes->Flush();
     368             :     }
     369       63631 : }
     370             : 
     371        6627 : void SvStream::SetSize(sal_uInt64 const nSize)
     372             : {
     373             :     DBG_ASSERT( xLockBytes.Is(), "pure virtual function" );
     374        6627 :     nError = xLockBytes->SetSize( nSize );
     375        6627 : }
     376             : 
     377      207645 : void SvStream::ImpInit()
     378             : {
     379      207645 :     m_nActPos           = 0;
     380      207645 :     nCompressMode       = COMPRESSMODE_NONE;
     381      207645 :     eStreamCharSet      = osl_getThreadTextEncoding();
     382      207645 :     nCryptMask          = 0;
     383      207645 :     bIsEof              = false;
     384             : #if defined UNX
     385      207645 :     eLineDelimiter      = LINEEND_LF;   // UNIX-Format
     386             : #else
     387             :     eLineDelimiter      = LINEEND_CRLF; // DOS-Format
     388             : #endif
     389             : 
     390      207645 :     SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
     391             : 
     392      207645 :     m_nBufFilePos       = 0;
     393      207645 :     nBufActualPos       = 0;
     394      207645 :     bIsDirty            = false;
     395      207645 :     bIsConsistent       = true;
     396      207645 :     bIsWritable         = true;
     397             : 
     398      207645 :     pRWBuf              = 0;
     399      207645 :     pBufPos             = 0;
     400      207645 :     nBufSize            = 0;
     401      207645 :     nBufActualLen       = 0;
     402      207645 :     bIoRead             = false;
     403      207645 :     bIoWrite            = false;
     404      207645 :     nBufFree            = 0;
     405             : 
     406      207645 :     eStreamMode         = 0;
     407             : 
     408      207645 :     nVersion           = 0;
     409             : 
     410      207645 :     ClearError();
     411      207645 : }
     412             : 
     413       57274 : SvStream::SvStream( SvLockBytes* pLockBytesP )
     414             : {
     415       57274 :     ImpInit();
     416       57274 :     xLockBytes = pLockBytesP;
     417       57274 :     if( pLockBytesP ) {
     418       57274 :         const SvStream* pStrm = pLockBytesP->GetStream();
     419       57274 :         if( pStrm ) {
     420           0 :             SetError( pStrm->GetErrorCode() );
     421             :         }
     422             :     }
     423       57274 :     SetBufferSize( 256 );
     424       57274 : }
     425             : 
     426      150371 : SvStream::SvStream()
     427             : {
     428      150371 :     ImpInit();
     429      150371 : }
     430             : 
     431      472383 : SvStream::~SvStream()
     432             : {
     433      207570 :     if ( xLockBytes.Is() )
     434       57243 :         Flush();
     435             : 
     436      207570 :     if( pRWBuf )
     437      151452 :         delete[] pRWBuf;
     438      264813 : }
     439             : 
     440      264527 : void SvStream::ClearError()
     441             : {
     442      264527 :     bIsEof = false;
     443      264527 :     nError = SVSTREAM_OK;
     444      264527 : }
     445             : 
     446     3869844 : void SvStream::SetError( sal_uInt32 nErrorCode )
     447             : {
     448     3869844 :     if ( nError == SVSTREAM_OK )
     449     3869280 :         nError = nErrorCode;
     450     3869844 : }
     451             : 
     452      372403 : void SvStream::SetNumberFormatInt( sal_uInt16 nNewFormat )
     453             : {
     454      372403 :     nNumberFormatInt = nNewFormat;
     455      372403 :     bSwap = false;
     456             : #ifdef OSL_BIGENDIAN
     457             :     if( nNumberFormatInt == NUMBERFORMAT_INT_LITTLEENDIAN )
     458             :         bSwap = true;
     459             : #else
     460      372403 :     if( nNumberFormatInt == NUMBERFORMAT_INT_BIGENDIAN )
     461       27258 :         bSwap = true;
     462             : #endif
     463      372403 : }
     464             : 
     465      282123 : void SvStream::SetBufferSize( sal_uInt16 nBufferSize )
     466             : {
     467      282123 :     sal_uInt64 const nActualFilePos = Tell();
     468      282123 :     bool bDontSeek = (pRWBuf == 0);
     469             : 
     470      282123 :     if( bIsDirty && bIsConsistent && bIsWritable )  // due to Windows NT: Access denied
     471          74 :         Flush();
     472             : 
     473      282123 :     if( nBufSize )
     474             :     {
     475       69487 :         delete[] pRWBuf;
     476       69487 :         m_nBufFilePos += nBufActualPos;
     477             :     }
     478             : 
     479      282123 :     pRWBuf          = 0;
     480      282123 :     nBufActualLen   = 0;
     481      282123 :     nBufActualPos   = 0;
     482      282123 :     nBufSize        = nBufferSize;
     483      282123 :     if( nBufSize )
     484      221014 :         pRWBuf = new sal_uInt8[ nBufSize ];
     485      282123 :     bIsConsistent   = true;
     486      282123 :     pBufPos         = pRWBuf;
     487      282123 :     bIoRead = bIoWrite = false;
     488      282123 :     if( !bDontSeek )
     489       69487 :         SeekPos( nActualFilePos );
     490      282123 : }
     491             : 
     492       22686 : void SvStream::ClearBuffer()
     493             : {
     494       22686 :     nBufActualLen   = 0;
     495       22686 :     nBufActualPos   = 0;
     496       22686 :     m_nBufFilePos   = 0;
     497       22686 :     pBufPos         = pRWBuf;
     498       22686 :     bIsDirty        = false;
     499       22686 :     bIsConsistent   = true;
     500       22686 :     bIoRead = bIoWrite = false;
     501             : 
     502       22686 :     bIsEof          = false;
     503       22686 : }
     504             : 
     505       17896 : void SvStream::ResetError()
     506             : {
     507       17896 :     ClearError();
     508       17896 : }
     509             : 
     510         362 : bool SvStream::ReadByteStringLine( OUString& rStr, rtl_TextEncoding eSrcCharSet,
     511             :                                        sal_Int32 nMaxBytesToRead )
     512             : {
     513         362 :     OString aStr;
     514         362 :     bool bRet = ReadLine( aStr, nMaxBytesToRead);
     515         362 :     rStr = OStringToOUString(aStr, eSrcCharSet);
     516         362 :     return bRet;
     517             : }
     518             : 
     519      873991 : bool SvStream::ReadLine( OString& rStr, sal_Int32 nMaxBytesToRead )
     520             : {
     521             :     sal_Char    buf[256+1];
     522      873991 :     bool        bEnd        = false;
     523      873991 :     sal_uInt64  nOldFilePos = Tell();
     524      873991 :     sal_Char    c           = 0;
     525      873991 :     sal_Size       nTotalLen   = 0;
     526             : 
     527      873991 :     OStringBuffer aBuf(4096);
     528     2760281 :     while( !bEnd && !GetError() )   // Don't test for EOF as we
     529             :                                     // are reading block-wise!
     530             :     {
     531     1014259 :         sal_uInt16 nLen = (sal_uInt16)Read( buf, sizeof(buf)-1 );
     532     1014259 :         if ( !nLen )
     533             :         {
     534        1960 :             if ( aBuf.isEmpty() )
     535             :             {
     536             :                 // Exit on first block-read error
     537        1954 :                 bIsEof = true;
     538        1954 :                 rStr = OString();
     539        1954 :                 return false;
     540             :             }
     541             :             else
     542           6 :                 break;
     543             :         }
     544             : 
     545             :         sal_uInt16 j, n;
     546    61358506 :         for( j = n = 0; j < nLen ; ++j )
     547             :         {
     548    61218227 :             c = buf[j];
     549    61218227 :             if ( c == '\n' || c == '\r' )
     550             :             {
     551      872020 :                 bEnd = true;
     552      872020 :                 break;
     553             :             }
     554    60346207 :             if ( n < j )
     555           0 :                 buf[n] = c;
     556    60346207 :             ++n;
     557             :         }
     558     1012299 :         nTotalLen += j;
     559     1012299 :         if (nTotalLen > static_cast<sal_Size>(nMaxBytesToRead))
     560             :         {
     561           0 :             n -= nTotalLen - nMaxBytesToRead;
     562           0 :             nTotalLen = nMaxBytesToRead;
     563           0 :             bEnd = true;
     564             :         }
     565     1012299 :         if ( n )
     566      934429 :             aBuf.append(buf, n);
     567             :     }
     568             : 
     569      872037 :     if ( !bEnd && !GetError() && !aBuf.isEmpty() )
     570           6 :         bEnd = true;
     571             : 
     572      872037 :     nOldFilePos += nTotalLen;
     573      872037 :     if( Tell() > nOldFilePos )
     574      872020 :         nOldFilePos++;
     575      872037 :     Seek( nOldFilePos );  // Seek pointer due to BlockRead above
     576             : 
     577      872037 :     if ( bEnd && (c=='\r' || c=='\n') )  // Special treatment for DOS files
     578             :     {
     579             :         char cTemp;
     580      872020 :         sal_Size nLen = Read((char*)&cTemp , sizeof(cTemp) );
     581      872020 :         if ( nLen ) {
     582      871043 :             if( cTemp == c || (cTemp != '\n' && cTemp != '\r') )
     583      871043 :                 Seek( nOldFilePos );
     584             :         }
     585             :     }
     586             : 
     587      872037 :     if ( bEnd )
     588      872026 :         bIsEof = false;
     589      872037 :     rStr = aBuf.makeStringAndClear();
     590      872037 :     return bEnd;
     591             : }
     592             : 
     593           8 : bool SvStream::ReadUniStringLine( OUString& rStr, sal_Int32 nMaxCodepointsToRead )
     594             : {
     595             :     sal_Unicode buf[256+1];
     596           8 :     bool        bEnd        = false;
     597           8 :     sal_uInt64  nOldFilePos = Tell();
     598           8 :     sal_Unicode c           = 0;
     599           8 :     sal_Size       nTotalLen   = 0;
     600             : 
     601             :     DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "ReadUniStringLine: swapping sizeof(sal_Unicode) not implemented" );
     602             : 
     603           8 :     OUStringBuffer aBuf(4096);
     604          20 :     while( !bEnd && !GetError() )   // Don't test for EOF as we
     605             :                                     // are reading block-wise!
     606             :     {
     607          12 :         sal_uInt16 nLen = (sal_uInt16)Read( (char*)buf, sizeof(buf)-sizeof(sal_Unicode) );
     608          12 :         nLen /= sizeof(sal_Unicode);
     609          12 :         if ( !nLen )
     610             :         {
     611           8 :             if ( aBuf.isEmpty() )
     612             :             {
     613             :                 // exit on first BlockRead error
     614           4 :                 bIsEof = true;
     615           4 :                 rStr = OUString();
     616           4 :                 return false;
     617             :             }
     618             :             else
     619           4 :                 break;
     620             :         }
     621             : 
     622             :         sal_uInt16 j, n;
     623          24 :         for( j = n = 0; j < nLen ; ++j )
     624             :         {
     625          20 :             if ( bSwap )
     626           0 :                 SwapUShort( buf[n] );
     627          20 :             c = buf[j];
     628          20 :             if ( c == '\n' || c == '\r' )
     629             :             {
     630           0 :                 bEnd = true;
     631           0 :                 break;
     632             :             }
     633             :             // erAck 26.02.01: Old behavior was no special treatment of '\0'
     634             :             // character here, but a following rStr+=c did ignore it. Is this
     635             :             // really intended? Or should a '\0' better terminate a line?
     636             :             // The nOldFilePos stuff wasn't correct then anyways.
     637          20 :             if ( c )
     638             :             {
     639          20 :                 if ( n < j )
     640           0 :                     buf[n] = c;
     641          20 :                 ++n;
     642             :             }
     643             :         }
     644           4 :         nTotalLen += j;
     645           4 :         if (nTotalLen > static_cast<sal_Size>(nMaxCodepointsToRead))
     646             :         {
     647           0 :             n -= nTotalLen - nMaxCodepointsToRead;
     648           0 :             nTotalLen = nMaxCodepointsToRead;
     649           0 :             bEnd = true;
     650             :         }
     651           4 :         if ( n )
     652           4 :             aBuf.append( buf, n );
     653             :     }
     654             : 
     655           4 :     if ( !bEnd && !GetError() && !aBuf.isEmpty() )
     656           4 :         bEnd = true;
     657             : 
     658           4 :     nOldFilePos += nTotalLen * sizeof(sal_Unicode);
     659           4 :     if( Tell() > nOldFilePos )
     660           0 :         nOldFilePos += sizeof(sal_Unicode);
     661           4 :     Seek( nOldFilePos );  // seek due to BlockRead above
     662             : 
     663           4 :     if ( bEnd && (c=='\r' || c=='\n') )  // special treatment for DOS files
     664             :     {
     665             :         sal_Unicode cTemp;
     666           0 :         Read( (char*)&cTemp, sizeof(cTemp) );
     667           0 :         if ( bSwap )
     668           0 :             SwapUShort( cTemp );
     669           0 :         if( cTemp == c || (cTemp != '\n' && cTemp != '\r') )
     670           0 :             Seek( nOldFilePos );
     671             :     }
     672             : 
     673           4 :     if ( bEnd )
     674           4 :         bIsEof = false;
     675           4 :     rStr = aBuf.makeStringAndClear();
     676           4 :     return bEnd;
     677             : }
     678             : 
     679         370 : bool SvStream::ReadUniOrByteStringLine( OUString& rStr, rtl_TextEncoding eSrcCharSet,
     680             :                                             sal_Int32 nMaxCodepointsToRead )
     681             : {
     682         370 :     if ( eSrcCharSet == RTL_TEXTENCODING_UNICODE )
     683           8 :         return ReadUniStringLine( rStr, nMaxCodepointsToRead );
     684             :     else
     685         362 :         return ReadByteStringLine( rStr, eSrcCharSet, nMaxCodepointsToRead );
     686             : }
     687             : 
     688           8 : OString read_zeroTerminated_uInt8s_ToOString(SvStream& rStream)
     689             : {
     690           8 :     OStringBuffer aOutput(256);
     691             : 
     692             :     sal_Char buf[ 256 + 1 ];
     693           8 :     bool bEnd = false;
     694           8 :     sal_uInt64 nFilePos = rStream.Tell();
     695             : 
     696          24 :     while( !bEnd && !rStream.GetError() )
     697             :     {
     698           8 :         sal_Size nLen = rStream.Read(buf, sizeof(buf)-1);
     699           8 :         if (!nLen)
     700           0 :             break;
     701             : 
     702           8 :         sal_Size nReallyRead = nLen;
     703           8 :         const sal_Char* pPtr = buf;
     704          48 :         while (nLen && *pPtr)
     705          32 :             ++pPtr, --nLen;
     706             : 
     707           8 :         bEnd =  ( nReallyRead < sizeof(buf)-1 )         // read less than attempted to read
     708          16 :                 ||  (  ( nLen > 0 )                    // OR it is inside the block we read
     709           0 :                     &&  ( 0 == *pPtr )                  //    AND found a string terminator
     710           8 :                     );
     711             : 
     712           8 :         aOutput.append(buf, pPtr - buf);
     713             :     }
     714             : 
     715           8 :     nFilePos += aOutput.getLength();
     716           8 :     if (rStream.Tell() > nFilePos)
     717           6 :         rStream.Seek(nFilePos+1);  // seek due to FileRead above
     718           8 :     return aOutput.makeStringAndClear();
     719             : }
     720             : 
     721           0 : OUString read_zeroTerminated_uInt8s_ToOUString(SvStream& rStream, rtl_TextEncoding eEnc)
     722             : {
     723             :     return OStringToOUString(
     724           0 :         read_zeroTerminated_uInt8s_ToOString(rStream), eEnc);
     725             : }
     726             : 
     727             : /** Attempt to write a prefixed sequence of nUnits 16bit units from an OUString,
     728             :     returned value is number of bytes written */
     729      146186 : sal_Size write_uInt16s_FromOUString(SvStream& rStrm, const OUString& rStr,
     730             :     sal_Size nUnits)
     731             : {
     732             :     DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "write_uInt16s_FromOUString: swapping sizeof(sal_Unicode) not implemented" );
     733             :     sal_Size nWritten;
     734      146186 :     if (!rStrm.IsEndianSwap())
     735      146186 :         nWritten = rStrm.Write( (char*)rStr.getStr(), nUnits * sizeof(sal_Unicode) );
     736             :     else
     737             :     {
     738           0 :         sal_Size nLen = nUnits;
     739             :         sal_Unicode aBuf[384];
     740           0 :         sal_Unicode* const pTmp = ( nLen > 384 ? new sal_Unicode[nLen] : aBuf);
     741           0 :         memcpy( pTmp, rStr.getStr(), nLen * sizeof(sal_Unicode) );
     742           0 :         sal_Unicode* p = pTmp;
     743           0 :         const sal_Unicode* const pStop = pTmp + nLen;
     744           0 :         while ( p < pStop )
     745             :         {
     746           0 :             SwapUShort( *p );
     747           0 :             p++;
     748             :         }
     749           0 :         nWritten = rStrm.Write( (char*)pTmp, nLen * sizeof(sal_Unicode) );
     750           0 :         if ( pTmp != aBuf )
     751           0 :             delete [] pTmp;
     752             :     }
     753      146186 :     return nWritten;
     754             : }
     755             : 
     756       25066 : bool SvStream::WriteUnicodeOrByteText( const OUString& rStr, rtl_TextEncoding eDestCharSet )
     757             : {
     758       25066 :     if ( eDestCharSet == RTL_TEXTENCODING_UNICODE )
     759             :     {
     760       25062 :         write_uInt16s_FromOUString(*this, rStr, rStr.getLength());
     761       25062 :         return nError == SVSTREAM_OK;
     762             :     }
     763             :     else
     764             :     {
     765           4 :         OString aStr(OUStringToOString(rStr, eDestCharSet));
     766           4 :         write_uInt8s_FromOString(*this, aStr, aStr.getLength());
     767           4 :         return nError == SVSTREAM_OK;
     768             :     }
     769             : }
     770             : 
     771           0 : bool SvStream::WriteByteStringLine( const OUString& rStr, rtl_TextEncoding eDestCharSet )
     772             : {
     773           0 :     return WriteLine(OUStringToOString(rStr, eDestCharSet));
     774             : }
     775             : 
     776      182265 : bool SvStream::WriteLine(const OString& rStr)
     777             : {
     778      182265 :     Write(rStr.getStr(), rStr.getLength());
     779      182265 :     endl(*this);
     780      182265 :     return nError == SVSTREAM_OK;
     781             : }
     782             : 
     783           0 : bool SvStream::WriteUniOrByteChar( sal_Unicode ch, rtl_TextEncoding eDestCharSet )
     784             : {
     785           0 :     if ( eDestCharSet == RTL_TEXTENCODING_UNICODE )
     786           0 :         WriteUnicode(ch);
     787             :     else
     788             :     {
     789           0 :         OString aStr(&ch, 1, eDestCharSet);
     790           0 :         Write(aStr.getStr(), aStr.getLength());
     791             :     }
     792           0 :     return nError == SVSTREAM_OK;
     793             : }
     794             : 
     795           0 : bool SvStream::StartWritingUnicodeText()
     796             : {
     797           0 :     SetEndianSwap( false );     // write native format
     798             :     // BOM, Byte Order Mark, U+FEFF, see
     799             :     // http://www.unicode.org/faq/utf_bom.html#BOM
     800             :     // Upon read: 0xfeff(-257) => no swap; 0xfffe(-2) => swap
     801           0 :     WriteUInt16( 0xfeff );
     802           0 :     return nError == SVSTREAM_OK;
     803             : }
     804             : 
     805          40 : bool SvStream::StartReadingUnicodeText( rtl_TextEncoding eReadBomCharSet )
     806             : {
     807          40 :     if (!(  eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
     808             :             eReadBomCharSet == RTL_TEXTENCODING_UNICODE ||
     809           6 :             eReadBomCharSet == RTL_TEXTENCODING_UTF8))
     810           6 :         return true;    // nothing to read
     811             : 
     812          34 :     bool bTryUtf8 = false;
     813             :     sal_uInt16 nFlag;
     814          34 :     sal_sSize nBack = sizeof(nFlag);
     815          34 :     this->ReadUInt16( nFlag );
     816          34 :     switch ( nFlag )
     817             :     {
     818             :         case 0xfeff :
     819             :             // native UTF-16
     820           0 :             if (    eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
     821             :                     eReadBomCharSet == RTL_TEXTENCODING_UNICODE)
     822           0 :                 nBack = 0;
     823           0 :         break;
     824             :         case 0xfffe :
     825             :             // swapped UTF-16
     826           0 :             if (    eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
     827             :                     eReadBomCharSet == RTL_TEXTENCODING_UNICODE)
     828             :             {
     829           0 :                 SetEndianSwap( !bSwap );
     830           0 :                 nBack = 0;
     831             :             }
     832           0 :         break;
     833             :         case 0xefbb :
     834           0 :             if (nNumberFormatInt == NUMBERFORMAT_INT_BIGENDIAN &&
     835           0 :                     (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
     836             :                      eReadBomCharSet == RTL_TEXTENCODING_UTF8))
     837           0 :                 bTryUtf8 = true;
     838           0 :         break;
     839             :         case 0xbbef :
     840           0 :             if (nNumberFormatInt == NUMBERFORMAT_INT_LITTLEENDIAN &&
     841           0 :                     (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
     842             :                      eReadBomCharSet == RTL_TEXTENCODING_UTF8))
     843           0 :                 bTryUtf8 = true;
     844           0 :         break;
     845             :         default:
     846             :             ;   // nothing
     847             :     }
     848          34 :     if (bTryUtf8)
     849             :     {
     850             :         unsigned char nChar;
     851           0 :         nBack += sizeof(nChar);
     852           0 :         this->ReadUChar( nChar );
     853           0 :         if (nChar == 0xbf)
     854           0 :             nBack = 0;      // it is UTF-8
     855             :     }
     856          34 :     if (nBack)
     857          34 :         SeekRel( -nBack );      // no BOM, pure data
     858          34 :     return nError == SVSTREAM_OK;
     859             : }
     860             : 
     861     2240764 : sal_uInt64 SvStream::SeekRel(sal_Int64 const nPos)
     862             : {
     863     2240764 :     sal_uInt64 nActualPos = Tell();
     864             : 
     865     2240764 :     if ( nPos >= 0 )
     866             :     {
     867     2071971 :         if (SAL_MAX_UINT64 - nActualPos > static_cast<sal_uInt64>(nPos))
     868     2071971 :             nActualPos += nPos;
     869             :     }
     870             :     else
     871             :     {
     872      168793 :         sal_uInt64 const nAbsPos = static_cast<sal_uInt64>(-nPos);
     873      168793 :         if ( nActualPos >= nAbsPos )
     874      168793 :             nActualPos -= nAbsPos;
     875             :     }
     876             : 
     877     2240764 :     pBufPos = pRWBuf + nActualPos;
     878     2240764 :     return Seek( nActualPos );
     879             : }
     880             : 
     881    13501340 : SvStream& SvStream::ReadUInt16(sal_uInt16& r)
     882             : {
     883    13501340 :     sal_uInt16 n = 0;
     884    13501340 :     READNUMBER_WITHOUT_SWAP(sal_uInt16, n)
     885    13501340 :     if (good())
     886             :     {
     887    13497028 :         if (bSwap)
     888       22286 :             SwapUShort(n);
     889    13497028 :         r = n;
     890             :     }
     891    13501340 :     return *this;
     892             : }
     893             : 
     894     1841785 : SvStream& SvStream::ReadUInt32(sal_uInt32& r)
     895             : {
     896     1841785 :     sal_uInt32 n = 0;
     897     1841785 :     READNUMBER_WITHOUT_SWAP(sal_uInt32, n)
     898     1841785 :     if (good())
     899             :     {
     900     1838617 :         if (bSwap)
     901      245264 :             SwapULong(n);
     902     1838617 :         r = n;
     903             :     }
     904     1841785 :     return *this;
     905             : }
     906             : 
     907           0 : SvStream& SvStream::ReadUInt64(sal_uInt64& r)
     908             : {
     909           0 :     sal_uInt64 n = 0;
     910           0 :     READNUMBER_WITHOUT_SWAP(sal_uInt64, n)
     911           0 :     if (good())
     912             :     {
     913           0 :         if (bSwap)
     914           0 :             SwapUInt64(n);
     915           0 :         r = n;
     916             :     }
     917           0 :     return *this;
     918             : }
     919             : 
     920      395792 : SvStream& SvStream::ReadInt16(sal_Int16& r)
     921             : {
     922      395792 :     sal_Int16 n = 0;
     923      395792 :     READNUMBER_WITHOUT_SWAP(sal_Int16, n)
     924      395792 :     if (good())
     925             :     {
     926      395720 :         if (bSwap)
     927       19848 :             SwapShort(n);
     928      395720 :         r = n;
     929             :     }
     930      395792 :     return *this;
     931             : }
     932             : 
     933     2004758 : SvStream& SvStream::ReadInt32(sal_Int32& r)
     934             : {
     935     2004758 :     sal_Int32 n = 0;
     936     2004758 :     READNUMBER_WITHOUT_SWAP(sal_Int32, n)
     937     2004758 :     if (good())
     938             :     {
     939     1995844 :         if (bSwap)
     940       96245 :             SwapLongInt(n);
     941     1995844 :         r = n;
     942             :     }
     943     2004758 :     return *this;
     944             : }
     945             : 
     946           0 : SvStream& SvStream::ReadInt64(sal_Int64& r)
     947             : {
     948           0 :     sal_Int64 n = 0;
     949           0 :     READNUMBER_WITHOUT_SWAP(sal_Int64, n)
     950           0 :     if (good())
     951             :     {
     952           0 :         if (bSwap)
     953           0 :             SwapInt64(n);
     954           0 :         r = n;
     955             :     }
     956           0 :     return *this;
     957             : }
     958             : 
     959        4760 : SvStream& SvStream::ReadSChar( signed char& r )
     960             : {
     961        7424 :     if( (bIoRead || !bIsConsistent) &&
     962        2664 :         sizeof(signed char) <= nBufFree )
     963             :     {
     964        2662 :         r = *pBufPos;
     965        2662 :         nBufActualPos += sizeof(signed char);
     966        2662 :         pBufPos += sizeof(signed char);
     967        2662 :         nBufFree -= sizeof(signed char);
     968             :     }
     969             :     else
     970        2098 :         Read( (char*)&r, sizeof(signed char) );
     971        4760 :     return *this;
     972             : }
     973             : 
     974             : // Special treatment for Chars due to PutBack
     975             : 
     976    22999402 : SvStream& SvStream::ReadChar( char& r )
     977             : {
     978    45858782 :     if( (bIoRead || !bIsConsistent) &&
     979    22859380 :         sizeof(char) <= nBufFree )
     980             :     {
     981    22853852 :         r = *pBufPos;
     982    22853852 :         nBufActualPos += sizeof(char);
     983    22853852 :         pBufPos += sizeof(char);
     984    22853852 :         nBufFree -= sizeof(char);
     985             :     }
     986             :     else
     987      145550 :         Read( (char*)&r, sizeof(char) );
     988    22999402 :     return *this;
     989             : }
     990             : 
     991    54946135 : SvStream& SvStream::ReadUChar( unsigned char& r )
     992             : {
     993   109653347 :     if( (bIoRead || !bIsConsistent) &&
     994    54707212 :         sizeof(char) <= nBufFree )
     995             :     {
     996    34586968 :         r = *pBufPos;
     997    34586968 :         nBufActualPos += sizeof(char);
     998    34586968 :         pBufPos += sizeof(char);
     999    34586968 :         nBufFree -= sizeof(char);
    1000             :     }
    1001             :     else
    1002    20359167 :         Read( (char*)&r, sizeof(char) );
    1003    54946135 :     return *this;
    1004             : }
    1005             : 
    1006      407163 : SvStream& SvStream::ReadCharAsBool( bool& r )
    1007             : {
    1008      813906 :     if( (bIoRead || !bIsConsistent) &&
    1009      406743 :         sizeof(char) <= nBufFree )
    1010             :     {
    1011             :         SAL_WARN_IF(
    1012             :             *pBufPos > 1, "tools.stream", unsigned(*pBufPos) << " not 0/1");
    1013      406483 :         r = *pBufPos != 0;
    1014      406483 :         nBufActualPos += sizeof(char);
    1015      406483 :         pBufPos += sizeof(char);
    1016      406483 :         nBufFree -= sizeof(char);
    1017             :     }
    1018             :     else
    1019             :     {
    1020             :         unsigned char c;
    1021         680 :         if (Read(&c, 1) == 1)
    1022             :         {
    1023             :             SAL_WARN_IF(c > 1, "tools.stream", unsigned(c) << " not 0/1");
    1024         680 :             r = c != 0;
    1025             :         }
    1026             :     }
    1027      407163 :     return *this;
    1028             : }
    1029             : 
    1030       14856 : SvStream& SvStream::ReadFloat(float& r)
    1031             : {
    1032       14856 :     float n = 0;
    1033       14856 :     READNUMBER_WITHOUT_SWAP(float, n)
    1034       14856 :     if (good())
    1035             :     {
    1036             : #if defined UNX
    1037       14856 :         if (bSwap)
    1038           0 :           SwapFloat(n);
    1039             : #endif
    1040       14856 :         r = n;
    1041             :     }
    1042       14856 :     return *this;
    1043             : }
    1044             : 
    1045       23572 : SvStream& SvStream::ReadDouble(double& r)
    1046             : {
    1047       23572 :     double n = 0;
    1048       23572 :     READNUMBER_WITHOUT_SWAP(double, n)
    1049       23572 :     if (good())
    1050             :     {
    1051             : #if defined UNX
    1052       23572 :         if (bSwap)
    1053           0 :           SwapDouble(n);
    1054             : #endif
    1055       23572 :         r = n;
    1056             :     }
    1057       23572 :     return *this;
    1058             : }
    1059             : 
    1060         178 : SvStream& SvStream::ReadStream( SvStream& rStream )
    1061             : {
    1062         178 :     const sal_uInt32 cBufLen = 0x8000;
    1063         178 :     char* pBuf = new char[ cBufLen ];
    1064             : 
    1065             :     sal_uInt32 nCount;
    1066         274 :     do {
    1067         274 :         nCount = Read( pBuf, cBufLen );
    1068         274 :         rStream.Write( pBuf, nCount );
    1069             :     } while( nCount == cBufLen );
    1070             : 
    1071         178 :     delete[] pBuf;
    1072         178 :     return *this;
    1073             : }
    1074             : 
    1075     6838414 : SvStream& SvStream::WriteUInt16( sal_uInt16 v )
    1076             : {
    1077     6838414 :     if( bSwap )
    1078           0 :         SwapUShort(v);
    1079     6838414 :     WRITENUMBER_WITHOUT_SWAP(sal_uInt16,v)
    1080     6838414 :     return *this;
    1081             : }
    1082             : 
    1083     1888677 : SvStream& SvStream::WriteUInt32( sal_uInt32 v )
    1084             : {
    1085     1888677 :     if( bSwap )
    1086        2466 :         SwapULong(v);
    1087     1888677 :     WRITENUMBER_WITHOUT_SWAP(sal_uInt32,v)
    1088     1888677 :     return *this;
    1089             : }
    1090             : 
    1091        1399 : SvStream& SvStream::WriteUInt64( sal_uInt64 v )
    1092             : {
    1093        1399 :     if( bSwap )
    1094           0 :         SwapUInt64(v);
    1095        1399 :     WRITENUMBER_WITHOUT_SWAP(sal_uInt64,v)
    1096        1399 :     return *this;
    1097             : }
    1098             : 
    1099      146743 : SvStream& SvStream::WriteInt16( sal_Int16 v )
    1100             : {
    1101      146743 :     if( bSwap )
    1102           0 :         SwapShort(v);
    1103      146743 :     WRITENUMBER_WITHOUT_SWAP(sal_Int16,v)
    1104      146743 :     return *this;
    1105             : }
    1106             : 
    1107     3052590 : SvStream& SvStream::WriteInt32( sal_Int32 v )
    1108             : {
    1109     3052590 :     if( bSwap )
    1110           0 :         SwapLongInt(v);
    1111     3052590 :     WRITENUMBER_WITHOUT_SWAP(sal_Int32,v)
    1112     3052590 :     return *this;
    1113             : }
    1114             : 
    1115           0 : SvStream& SvStream::WriteInt64  (sal_Int64 v)
    1116             : {
    1117           0 :     if( bSwap )
    1118           0 :         SwapInt64(v);
    1119           0 :     WRITENUMBER_WITHOUT_SWAP(sal_Int64,v)
    1120           0 :     return *this;
    1121             : }
    1122             : 
    1123        7078 : SvStream& SvStream::WriteSChar( signed char v )
    1124             : {
    1125             :     //SDO
    1126        7078 :     if(bIoWrite && sizeof(signed char) <= nBufFree )
    1127             :     {
    1128        7078 :         *pBufPos = v;
    1129        7078 :         pBufPos++; // sizeof(char);
    1130        7078 :         nBufActualPos++;
    1131        7078 :         if( nBufActualPos > nBufActualLen )  // Append ?
    1132        7078 :             nBufActualLen = nBufActualPos;
    1133        7078 :         nBufFree--; // = sizeof(char);
    1134        7078 :         bIsDirty = true;
    1135             :     }
    1136             :     else
    1137           0 :         Write( (char*)&v, sizeof(signed char) );
    1138        7078 :     return *this;
    1139             : }
    1140             : 
    1141             : // Special treatment for Chars due to PutBack
    1142             : 
    1143     3057832 : SvStream& SvStream::WriteChar( char v )
    1144             : {
    1145             :     //SDO
    1146     3057832 :     if(bIoWrite && sizeof(char) <= nBufFree )
    1147             :     {
    1148     3045890 :         *pBufPos = v;
    1149     3045890 :         pBufPos++; // sizeof(char);
    1150     3045890 :         nBufActualPos++;
    1151     3045890 :         if( nBufActualPos > nBufActualLen )  // Append ?
    1152     3045890 :             nBufActualLen = nBufActualPos;
    1153     3045890 :         nBufFree--; // = sizeof(char);
    1154     3045890 :         bIsDirty = true;
    1155             :     }
    1156             :     else
    1157       11942 :         Write( (char*)&v, sizeof(char) );
    1158     3057832 :     return *this;
    1159             : }
    1160             : 
    1161      904071 : SvStream& SvStream::WriteUChar( unsigned char v )
    1162             : {
    1163             : //SDO
    1164      904071 :     if(bIoWrite && sizeof(char) <= nBufFree )
    1165             :     {
    1166      826778 :         *(unsigned char*)pBufPos = v;
    1167      826778 :         pBufPos++; // = sizeof(char);
    1168      826778 :         nBufActualPos++; // = sizeof(char);
    1169      826778 :         if( nBufActualPos > nBufActualLen )  // Append ?
    1170      826778 :             nBufActualLen = nBufActualPos;
    1171      826778 :         nBufFree--;
    1172      826778 :         bIsDirty = true;
    1173             :     }
    1174             :     else
    1175       77293 :         Write( (char*)&v, sizeof(char) );
    1176      904071 :     return *this;
    1177             : }
    1178             : 
    1179       21408 : SvStream& SvStream::WriteUInt8( sal_uInt8 v )
    1180             : {
    1181       21408 :     return WriteUChar(v);
    1182             : }
    1183             : 
    1184           0 : SvStream& SvStream::WriteUnicode( sal_Unicode v )
    1185             : {
    1186           0 :     return WriteUInt16(v);
    1187             : }
    1188             : 
    1189         744 : SvStream& SvStream::WriteFloat( float v )
    1190             : {
    1191             : #ifdef UNX
    1192         744 :     if( bSwap )
    1193           0 :       SwapFloat(v);
    1194             : #endif
    1195         744 :     WRITENUMBER_WITHOUT_SWAP(float,v)
    1196         744 :     return *this;
    1197             : }
    1198             : 
    1199       21664 : SvStream& SvStream::WriteDouble ( const double& r )
    1200             : {
    1201             : #if defined UNX
    1202       21664 :     if( bSwap )
    1203             :     {
    1204           0 :       double nHelp = r;
    1205           0 :       SwapDouble(nHelp);
    1206           0 :       WRITENUMBER_WITHOUT_SWAP(double,nHelp)
    1207           0 :       return *this;
    1208             :     }
    1209             :     else
    1210             : #endif
    1211             :     {
    1212       21664 :         WRITENUMBER_WITHOUT_SWAP(double,r);
    1213             :     }
    1214       21664 :     return *this;
    1215             : }
    1216             : 
    1217    10456845 : SvStream& SvStream::WriteCharPtr( const char* pBuf )
    1218             : {
    1219    10456845 :     Write( pBuf, strlen( pBuf ) );
    1220    10456845 :     return *this;
    1221             : }
    1222             : 
    1223          88 : SvStream& SvStream::WriteStream( SvStream& rStream )
    1224             : {
    1225          88 :     const sal_uInt32 cBufLen = 0x8000;
    1226          88 :     char* pBuf = new char[ cBufLen ];
    1227             :     sal_uInt32 nCount;
    1228        2275 :     do {
    1229        2275 :         nCount = rStream.Read( pBuf, cBufLen );
    1230        2275 :         Write( pBuf, nCount );
    1231             :     } while( nCount == cBufLen );
    1232             : 
    1233          88 :     delete[] pBuf;
    1234          88 :     return *this;
    1235             : }
    1236             : 
    1237      226388 : OUString SvStream::ReadUniOrByteString( rtl_TextEncoding eSrcCharSet )
    1238             : {
    1239             :     // read UTF-16 string directly from stream ?
    1240      226388 :     if (eSrcCharSet == RTL_TEXTENCODING_UNICODE)
    1241       25560 :         return read_uInt32_lenPrefixed_uInt16s_ToOUString(*this);
    1242      200828 :     return read_uInt16_lenPrefixed_uInt8s_ToOUString(*this, eSrcCharSet);
    1243             : }
    1244             : 
    1245      290138 : SvStream& SvStream::WriteUniOrByteString( const OUString& rStr, rtl_TextEncoding eDestCharSet )
    1246             : {
    1247             :     // write UTF-16 string directly into stream ?
    1248      290138 :     if (eDestCharSet == RTL_TEXTENCODING_UNICODE)
    1249       27758 :         write_uInt32_lenPrefixed_uInt16s_FromOUString(*this, rStr);
    1250             :     else
    1251      262380 :         write_uInt16_lenPrefixed_uInt8s_FromOUString(*this, rStr, eDestCharSet);
    1252      290138 :     return *this;
    1253             : }
    1254             : 
    1255    29690472 : sal_Size SvStream::Read( void* pData, sal_Size nCount )
    1256             : {
    1257    29690472 :     sal_Size nSaveCount = nCount;
    1258    29690472 :     if( !bIsConsistent )
    1259           0 :         RefreshBuffer();
    1260             : 
    1261    29690472 :     if( !pRWBuf )
    1262             :     {
    1263     3381290 :         nCount = GetData( (char*)pData,nCount);
    1264     3381290 :         if( nCryptMask )
    1265           0 :             EncryptBuffer(pData, nCount);
    1266     3381290 :         m_nBufFilePos += nCount;
    1267             :     }
    1268             :     else
    1269             :     {
    1270             :         // check if block is completely within buffer
    1271    26309182 :         bIoRead = true;
    1272    26309182 :         bIoWrite = false;
    1273    26309182 :         if( nCount <= (sal_Size)(nBufActualLen - nBufActualPos ) )
    1274             :         {
    1275             :             // => yes
    1276     5441363 :             memcpy(pData, pBufPos, (size_t) nCount);
    1277     5441363 :             nBufActualPos = nBufActualPos + (sal_uInt16)nCount;
    1278     5441363 :             pBufPos += nCount;
    1279     5441363 :             nBufFree = nBufFree - (sal_uInt16)nCount;
    1280             :         }
    1281             :         else
    1282             :         {
    1283    20867819 :             if( bIsDirty ) // Does stream require a flush?
    1284             :             {
    1285         534 :                 SeekPos(m_nBufFilePos);
    1286         534 :                 if( nCryptMask )
    1287           0 :                     CryptAndWriteBuffer(pRWBuf, nBufActualLen);
    1288             :                 else
    1289         534 :                     PutData( pRWBuf, nBufActualLen );
    1290         534 :                 bIsDirty = false;
    1291             :             }
    1292             : 
    1293             :             // Does data block fit into buffer?
    1294    20867819 :             if( nCount > nBufSize )
    1295             :             {
    1296             :                 // => No! Thus read directly
    1297             :                 // into target area without using the buffer
    1298             : 
    1299      185756 :                 bIoRead = false;
    1300             : 
    1301      185756 :                 SeekPos(m_nBufFilePos + nBufActualPos);
    1302      185756 :                 nBufActualLen = 0;
    1303      185756 :                 pBufPos       = pRWBuf;
    1304      185756 :                 nCount = GetData( (char*)pData, nCount );
    1305      185756 :                 if( nCryptMask )
    1306           0 :                     EncryptBuffer(pData, nCount);
    1307      185756 :                 m_nBufFilePos += nCount;
    1308      185756 :                 m_nBufFilePos += nBufActualPos;
    1309      185756 :                 nBufActualPos = 0;
    1310             :             }
    1311             :             else
    1312             :             {
    1313             :                 // => Yes. Fill buffer first, then copy to target area
    1314             : 
    1315    20682063 :                 m_nBufFilePos += nBufActualPos;
    1316    20682063 :                 SeekPos(m_nBufFilePos);
    1317             : 
    1318             :                 // TODO: Typecast before GetData, sal_uInt16 nCountTmp
    1319    20682063 :                 sal_Size nCountTmp = GetData( pRWBuf, nBufSize );
    1320    20682063 :                 if( nCryptMask )
    1321           0 :                     EncryptBuffer(pRWBuf, nCountTmp);
    1322    20682063 :                 nBufActualLen = (sal_uInt16)nCountTmp;
    1323    20682063 :                 if( nCount > nCountTmp )
    1324             :                 {
    1325    20128056 :                     nCount = nCountTmp;  // trim count back, EOF see below
    1326             :                 }
    1327    20682063 :                 memcpy( pData, pRWBuf, (size_t)nCount );
    1328    20682063 :                 nBufActualPos = (sal_uInt16)nCount;
    1329    20682063 :                 pBufPos = pRWBuf + nCount;
    1330             :             }
    1331             :         }
    1332             :     }
    1333    29690472 :     bIsEof = false;
    1334    29690472 :     nBufFree = nBufActualLen - nBufActualPos;
    1335    29690472 :     if( nCount != nSaveCount && nError != ERRCODE_IO_PENDING )
    1336    20166049 :         bIsEof = true;
    1337    29690472 :     if( nCount == nSaveCount && nError == ERRCODE_IO_PENDING )
    1338           0 :         nError = ERRCODE_NONE;
    1339    29690472 :     return nCount;
    1340             : }
    1341             : 
    1342    15632487 : sal_Size SvStream::Write( const void* pData, sal_Size nCount )
    1343             : {
    1344    15632487 :     if( !nCount )
    1345      139859 :         return 0;
    1346    15492628 :     if( !bIsWritable )
    1347             :     {
    1348           0 :         SetError( ERRCODE_IO_CANTWRITE );
    1349           0 :         return 0;
    1350             :     }
    1351    15492628 :     if( !bIsConsistent )
    1352           0 :         RefreshBuffer();   // Remove changes in buffer through PutBack
    1353             : 
    1354    15492628 :     if( !pRWBuf )
    1355             :     {
    1356      427202 :         if( nCryptMask )
    1357           0 :             nCount = CryptAndWriteBuffer( pData, nCount );
    1358             :         else
    1359      427202 :             nCount = PutData( (char*)pData, nCount );
    1360      427202 :         m_nBufFilePos += nCount;
    1361      427202 :         return nCount;
    1362             :     }
    1363             : 
    1364    15065426 :     bIoRead = false;
    1365    15065426 :     bIoWrite = true;
    1366    15065426 :     if( nCount <= (sal_Size)(nBufSize - nBufActualPos) )
    1367             :     {
    1368    14638610 :         memcpy( pBufPos, pData, (size_t)nCount );
    1369    14638610 :         nBufActualPos = nBufActualPos + (sal_uInt16)nCount;
    1370             :         // Update length if buffer was updated
    1371    14638610 :         if( nBufActualPos > nBufActualLen )
    1372    14636419 :             nBufActualLen = nBufActualPos;
    1373             : 
    1374    14638610 :         pBufPos += nCount;
    1375    14638610 :         bIsDirty = true;
    1376             :     }
    1377             :     else
    1378             :     {
    1379             :         // Does stream require flushing?
    1380      426816 :         if( bIsDirty )
    1381             :         {
    1382      333145 :             SeekPos(m_nBufFilePos);
    1383      333145 :             if( nCryptMask )
    1384           0 :                 CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen );
    1385             :             else
    1386      333145 :                 PutData( pRWBuf, nBufActualLen );
    1387      333145 :             bIsDirty = false;
    1388             :         }
    1389             : 
    1390             :         // Does data block fit into buffer?
    1391      426816 :         if( nCount > nBufSize )
    1392             :         {
    1393      107292 :             bIoWrite = false;
    1394      107292 :             m_nBufFilePos += nBufActualPos;
    1395      107292 :             nBufActualLen = 0;
    1396      107292 :             nBufActualPos = 0;
    1397      107292 :             pBufPos       = pRWBuf;
    1398      107292 :             SeekPos(m_nBufFilePos);
    1399      107292 :             if( nCryptMask )
    1400           0 :                 nCount = CryptAndWriteBuffer( pData, nCount );
    1401             :             else
    1402      107292 :                 nCount = PutData( (char*)pData, nCount );
    1403      107292 :             m_nBufFilePos += nCount;
    1404             :         }
    1405             :         else
    1406             :         {
    1407             :             // Copy block to buffer
    1408      319524 :             memcpy( pRWBuf, pData, (size_t)nCount );
    1409             : 
    1410             :             // Mind the order!
    1411      319524 :             m_nBufFilePos += nBufActualPos;
    1412      319524 :             nBufActualPos = (sal_uInt16)nCount;
    1413      319524 :             pBufPos = pRWBuf + nCount;
    1414      319524 :             nBufActualLen = (sal_uInt16)nCount;
    1415      319524 :             bIsDirty = true;
    1416             :         }
    1417             :     }
    1418    15065426 :     nBufFree = nBufSize - nBufActualPos;
    1419    15065426 :     return nCount;
    1420             : }
    1421             : 
    1422    10814843 : sal_uInt64 SvStream::Seek(sal_uInt64 const nFilePos)
    1423             : {
    1424    10814843 :     bIoRead = bIoWrite = false;
    1425    10814843 :     bIsEof = false;
    1426    10814843 :     if( !pRWBuf )
    1427             :     {
    1428     1662932 :         m_nBufFilePos = SeekPos( nFilePos );
    1429             :         DBG_ASSERT(Tell() == m_nBufFilePos,"Out Of Sync!");
    1430     1662932 :         return m_nBufFilePos;
    1431             :     }
    1432             : 
    1433             :     // Is seek position within buffer?
    1434     9151911 :     if (nFilePos >= m_nBufFilePos && nFilePos <= (m_nBufFilePos + nBufActualLen))
    1435             :     {
    1436     5226232 :         nBufActualPos = (sal_uInt16)(nFilePos - m_nBufFilePos);
    1437     5226232 :         pBufPos = pRWBuf + nBufActualPos;
    1438             :         // Update nBufFree to avoid crash upon PutBack
    1439     5226232 :         nBufFree = nBufActualLen - nBufActualPos;
    1440             :     }
    1441             :     else
    1442             :     {
    1443     3925679 :         if( bIsDirty && bIsConsistent)
    1444             :         {
    1445     3035291 :             SeekPos(m_nBufFilePos);
    1446     3035291 :             if( nCryptMask )
    1447           0 :                 CryptAndWriteBuffer( pRWBuf, nBufActualLen );
    1448             :             else
    1449     3035291 :                 PutData( pRWBuf, nBufActualLen );
    1450     3035291 :             bIsDirty = false;
    1451             :         }
    1452     3925679 :         nBufActualLen = 0;
    1453     3925679 :         nBufActualPos = 0;
    1454     3925679 :         pBufPos       = pRWBuf;
    1455     3925679 :         m_nBufFilePos = SeekPos( nFilePos );
    1456             :     }
    1457     9151911 :     return m_nBufFilePos + nBufActualPos;
    1458             : }
    1459             : 
    1460             : //STREAM_SEEK_TO_END in the some of the Seek backends is special cased to be
    1461             : //efficient, in others e.g. SotStorageStream it's really horribly slow, and in
    1462             : //those this should be overridden
    1463        4650 : sal_uInt64 SvStream::remainingSize()
    1464             : {
    1465        4650 :     sal_uInt64 const nCurr = Tell();
    1466        4650 :     sal_uInt64 const nEnd = Seek(STREAM_SEEK_TO_END);
    1467        4650 :     sal_uInt64 nMaxAvailable = nEnd-nCurr;
    1468        4650 :     Seek(nCurr);
    1469        4650 :     return nMaxAvailable;
    1470             : }
    1471             : 
    1472      321782 : void SvStream::Flush()
    1473             : {
    1474      321782 :     if( bIsDirty && bIsConsistent )
    1475             :     {
    1476       34707 :         SeekPos(m_nBufFilePos);
    1477       34707 :         if( nCryptMask )
    1478           0 :             CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen );
    1479             :         else
    1480       34707 :             if( PutData( pRWBuf, nBufActualLen ) != nBufActualLen )
    1481          10 :                 SetError( SVSTREAM_WRITE_ERROR );
    1482       34707 :         bIsDirty = false;
    1483             :     }
    1484      321782 :     if( bIsWritable )
    1485      274771 :         FlushData();
    1486      321782 : }
    1487             : 
    1488          44 : void SvStream::RefreshBuffer()
    1489             : {
    1490          44 :     if( bIsDirty && bIsConsistent )
    1491             :     {
    1492           0 :         SeekPos(m_nBufFilePos);
    1493           0 :         if( nCryptMask )
    1494           0 :             CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen );
    1495             :         else
    1496           0 :             PutData( pRWBuf, nBufActualLen );
    1497           0 :         bIsDirty = false;
    1498             :     }
    1499          44 :     SeekPos(m_nBufFilePos);
    1500          44 :     nBufActualLen = (sal_uInt16)GetData( pRWBuf, nBufSize );
    1501          44 :     if( nBufActualLen && nError == ERRCODE_IO_PENDING )
    1502           0 :         nError = ERRCODE_NONE;
    1503          44 :     if( nCryptMask )
    1504           0 :         EncryptBuffer(pRWBuf, (sal_Size)nBufActualLen);
    1505          44 :     bIsConsistent = true;
    1506          44 :     bIoRead = bIoWrite = false;
    1507          44 : }
    1508             : 
    1509           0 : SvStream& SvStream::WriteInt32AsString(sal_Int32 nInt32)
    1510             : {
    1511             :     char buffer[12];
    1512           0 :     sal_Size nLen = sprintf(buffer, "%" SAL_PRIdINT32, nInt32);
    1513           0 :     Write(buffer, nLen);
    1514           0 :     return *this;
    1515             : }
    1516             : 
    1517           0 : SvStream& SvStream::WriteUInt32AsString(sal_uInt32 nUInt32)
    1518             : {
    1519             :     char buffer[11];
    1520           0 :     sal_Size nLen = sprintf(buffer, "%" SAL_PRIuUINT32, nUInt32);
    1521           0 :     Write(buffer, nLen);
    1522           0 :     return *this;
    1523             : }
    1524             : 
    1525             : #define CRYPT_BUFSIZE 1024
    1526             : 
    1527             : /// Encrypt and write
    1528           0 : sal_Size SvStream::CryptAndWriteBuffer( const void* pStart, sal_Size nLen)
    1529             : {
    1530             :     unsigned char  pTemp[CRYPT_BUFSIZE];
    1531           0 :     unsigned char* pDataPtr = (unsigned char*)pStart;
    1532           0 :     sal_Size nCount = 0;
    1533             :     sal_Size nBufCount;
    1534           0 :     unsigned char nMask = nCryptMask;
    1535           0 :     do
    1536             :     {
    1537           0 :         if( nLen >= CRYPT_BUFSIZE )
    1538           0 :             nBufCount = CRYPT_BUFSIZE;
    1539             :         else
    1540           0 :             nBufCount = nLen;
    1541           0 :         nLen -= nBufCount;
    1542           0 :         memcpy( pTemp, pDataPtr, (sal_uInt16)nBufCount );
    1543             :         // **** Verschluesseln *****
    1544           0 :         for ( sal_uInt16 n=0; n < CRYPT_BUFSIZE; n++ )
    1545             :         {
    1546           0 :             unsigned char aCh = pTemp[n];
    1547           0 :             aCh ^= nMask;
    1548           0 :             SWAPNIBBLES(aCh)
    1549           0 :             pTemp[n] = aCh;
    1550             :         }
    1551             :         // *************************
    1552           0 :         nCount += PutData( (char*)pTemp, nBufCount );
    1553           0 :         pDataPtr += nBufCount;
    1554             :     }
    1555             :     while ( nLen );
    1556           0 :     return nCount;
    1557             : }
    1558             : 
    1559           0 : bool SvStream::EncryptBuffer(void* pStart, sal_Size nLen)
    1560             : {
    1561           0 :     unsigned char* pTemp = (unsigned char*)pStart;
    1562           0 :     unsigned char nMask = nCryptMask;
    1563             : 
    1564           0 :     for ( sal_Size n=0; n < nLen; n++, pTemp++ )
    1565             :     {
    1566           0 :         unsigned char aCh = *pTemp;
    1567           0 :         SWAPNIBBLES(aCh)
    1568           0 :         aCh ^= nMask;
    1569           0 :         *pTemp = aCh;
    1570             :     }
    1571           0 :     return true;
    1572             : }
    1573             : 
    1574          20 : static unsigned char implGetCryptMask(const sal_Char* pStr, sal_Int32 nLen, long nVersion)
    1575             : {
    1576          20 :     unsigned char nCryptMask = 0;
    1577             : 
    1578          20 :     if (!nLen)
    1579          20 :         return nCryptMask;
    1580             : 
    1581           0 :     if( nVersion <= SOFFICE_FILEFORMAT_31 )
    1582             :     {
    1583           0 :         while( nLen )
    1584             :         {
    1585           0 :             nCryptMask ^= *pStr;
    1586           0 :             pStr++;
    1587           0 :             nLen--;
    1588             :         }
    1589             :     }
    1590             :     else // BugFix #25888#
    1591             :     {
    1592           0 :         for( sal_uInt16 i = 0; i < nLen; i++ ) {
    1593           0 :             nCryptMask ^= pStr[i];
    1594           0 :             if( nCryptMask & 0x80 ) {
    1595           0 :                 nCryptMask <<= 1;
    1596           0 :                 nCryptMask++;
    1597             :             }
    1598             :             else
    1599           0 :                 nCryptMask <<= 1;
    1600             :         }
    1601             :     }
    1602             : 
    1603           0 :     if( !nCryptMask )
    1604           0 :         nCryptMask = 67;
    1605             : 
    1606           0 :     return nCryptMask;
    1607             : }
    1608             : 
    1609          20 : void SvStream::SetCryptMaskKey(const OString& rCryptMaskKey)
    1610             : {
    1611          20 :     m_aCryptMaskKey = rCryptMaskKey;
    1612             :     nCryptMask = implGetCryptMask(m_aCryptMaskKey.getStr(),
    1613          20 :         m_aCryptMaskKey.getLength(), GetVersion());
    1614          20 : }
    1615             : 
    1616           0 : void SvStream::SyncSvStream( sal_Size nNewStreamPos )
    1617             : {
    1618           0 :     ClearBuffer();
    1619           0 :     SvStream::m_nBufFilePos = nNewStreamPos;
    1620           0 : }
    1621             : 
    1622           0 : void SvStream::SyncSysStream()
    1623             : {
    1624           0 :     Flush();
    1625           0 :     SeekPos( Tell() );
    1626           0 : }
    1627             : 
    1628        7349 : bool SvStream::SetStreamSize(sal_uInt64 const nSize)
    1629             : {
    1630             : #ifdef DBG_UTIL
    1631             :     sal_uInt64 nFPos = Tell();
    1632             : #endif
    1633        7349 :     sal_uInt16 nBuf = nBufSize;
    1634        7349 :     SetBufferSize( 0 );
    1635        7349 :     SetSize( nSize );
    1636        7349 :     SetBufferSize( nBuf );
    1637             :     DBG_ASSERT(Tell()==nFPos,"SetStreamSize failed");
    1638        7349 :     return (nError == 0);
    1639             : }
    1640             : 
    1641      239723 : SvStream& endl( SvStream& rStr )
    1642             : {
    1643      239723 :     LineEnd eDelim = rStr.GetLineDelimiter();
    1644      239723 :     if ( eDelim == LINEEND_CR )
    1645           0 :         rStr.WriteChar('\r');
    1646      239723 :     else if( eDelim == LINEEND_LF )
    1647      239723 :         rStr.WriteChar('\n');
    1648             :     else
    1649           0 :         rStr.WriteChar('\r').WriteChar('\n');
    1650      239723 :     return rStr;
    1651             : }
    1652             : 
    1653           0 : SvStream& endlu( SvStream& rStrm )
    1654             : {
    1655           0 :     switch ( rStrm.GetLineDelimiter() )
    1656             :     {
    1657             :         case LINEEND_CR :
    1658           0 :             rStrm.WriteUnicode('\r');
    1659           0 :         break;
    1660             :         case LINEEND_LF :
    1661           0 :             rStrm.WriteUnicode('\n');
    1662           0 :         break;
    1663             :         default:
    1664           0 :             rStrm.WriteUnicode('\r').WriteUnicode('\n');
    1665             :     }
    1666           0 :     return rStrm;
    1667             : }
    1668             : 
    1669           0 : SvStream& endlub( SvStream& rStrm )
    1670             : {
    1671           0 :     if ( rStrm.GetStreamCharSet() == RTL_TEXTENCODING_UNICODE )
    1672           0 :         return endlu( rStrm );
    1673             :     else
    1674           0 :         return endl( rStrm );
    1675             : }
    1676             : 
    1677       49052 : SvMemoryStream::SvMemoryStream( void* pBuffer, sal_Size bufSize,
    1678       49052 :                                 StreamMode eMode )
    1679             : {
    1680       49052 :     if( eMode & STREAM_WRITE )
    1681        8816 :         bIsWritable = true;
    1682             :     else
    1683       40236 :         bIsWritable = false;
    1684       49052 :     nEndOfData  = bufSize;
    1685       49052 :     bOwnsData   = false;
    1686       49052 :     pBuf        = (sal_uInt8 *) pBuffer;
    1687       49052 :     nResize     = 0L;
    1688       49052 :     nSize       = bufSize;
    1689       49052 :     nPos        = 0L;
    1690       49052 :     SetBufferSize( 0 );
    1691       49052 : }
    1692             : 
    1693       85981 : SvMemoryStream::SvMemoryStream( sal_Size nInitSize, sal_Size nResizeOffset )
    1694             : {
    1695       85981 :     bIsWritable = true;
    1696       85981 :     bOwnsData   = true;
    1697       85981 :     nEndOfData  = 0L;
    1698       85981 :     nResize     = nResizeOffset;
    1699       85981 :     nPos        = 0;
    1700       85981 :     pBuf        = 0;
    1701       85981 :     if( nResize != 0 && nResize < 16 )
    1702           0 :         nResize = 16;
    1703       85981 :     if( nInitSize && !AllocateMemory( nInitSize ) )
    1704             :     {
    1705           0 :         SetError( SVSTREAM_OUTOFMEMORY );
    1706           0 :         nSize = 0;
    1707             :     }
    1708             :     else
    1709       85981 :         nSize = nInitSize;
    1710       85981 :     SetBufferSize( 64 );
    1711       85981 : }
    1712             : 
    1713      295091 : SvMemoryStream::~SvMemoryStream()
    1714             : {
    1715      135033 :     if( pBuf )
    1716             :     {
    1717      130756 :         if( bOwnsData )
    1718       83594 :             FreeMemory();
    1719             :         else
    1720       47162 :             Flush();
    1721             :     }
    1722      160058 : }
    1723             : 
    1724          34 : const void* SvMemoryStream::GetBuffer()
    1725             : {
    1726          34 :     Flush();
    1727          34 :     return (const void*)GetData();
    1728             : }
    1729             : 
    1730       15420 : sal_uIntPtr SvMemoryStream::GetSize()
    1731             : {
    1732       15420 :     Flush();
    1733       15420 :     sal_uInt64 const nTemp = Tell();
    1734       15420 :     sal_uInt64 const nLength = Seek( STREAM_SEEK_TO_END );
    1735       15420 :     Seek( nTemp );
    1736       15420 :     return nLength;
    1737             : }
    1738             : 
    1739         390 : void* SvMemoryStream::SetBuffer( void* pNewBuf, sal_Size nCount,
    1740             :                                  bool bOwnsDat, sal_Size nEOF )
    1741             : {
    1742             :     void* pResult;
    1743         390 :     SetBufferSize( 0 ); // Buffering in der Basisklasse initialisieren
    1744         390 :     Seek( 0 );
    1745         390 :     if( bOwnsData )
    1746             :     {
    1747         390 :         pResult = 0;
    1748         390 :         if( pNewBuf != pBuf )
    1749         390 :             FreeMemory();
    1750             :     }
    1751             :     else
    1752           0 :         pResult = pBuf;
    1753             : 
    1754         390 :     pBuf        = (sal_uInt8 *) pNewBuf;
    1755         390 :     nPos        = 0;
    1756         390 :     nSize       = nCount;
    1757         390 :     nResize     = 0;
    1758         390 :     bOwnsData   = bOwnsDat;
    1759             : 
    1760         390 :     if( nEOF > nCount )
    1761           0 :         nEOF = nCount;
    1762         390 :     nEndOfData = nEOF;
    1763             : 
    1764         390 :     ResetError();
    1765             : 
    1766         390 :     return pResult;
    1767             : }
    1768             : 
    1769     1647091 : sal_Size SvMemoryStream::GetData( void* pData, sal_Size nCount )
    1770             : {
    1771     1647091 :     sal_Size nMaxCount = nEndOfData-nPos;
    1772     1647091 :     if( nCount > nMaxCount )
    1773       46340 :         nCount = nMaxCount;
    1774     1647091 :     memcpy( pData, pBuf+nPos, (size_t)nCount );
    1775     1647091 :     nPos += nCount;
    1776     1647091 :     return nCount;
    1777             : }
    1778             : 
    1779     3822753 : sal_Size SvMemoryStream::PutData( const void* pData, sal_Size nCount )
    1780             : {
    1781     3822753 :     if( GetError() )
    1782           0 :         return 0L;
    1783             : 
    1784     3822753 :     sal_Size nMaxCount = nSize-nPos;
    1785             : 
    1786             :     // check for overflow
    1787     3822753 :     if( nCount > nMaxCount )
    1788             :     {
    1789       28345 :         if( nResize == 0 )
    1790             :         {
    1791             :             // copy as much as possible
    1792           0 :             nCount = nMaxCount;
    1793           0 :             SetError( SVSTREAM_OUTOFMEMORY );
    1794             :         }
    1795             :         else
    1796             :         {
    1797             :             long nNewResize;
    1798       28345 :             if( nSize && nSize > nResize )
    1799       26331 :                 nNewResize = nSize;
    1800             :             else
    1801        2014 :                 nNewResize = nResize;
    1802             : 
    1803       28345 :             if( (nCount-nMaxCount) < nResize )
    1804             :             {
    1805             :                 // lacking memory is smaller than nResize,
    1806             :                 // resize accordingly
    1807       19570 :                 if( !ReAllocateMemory( nNewResize) )
    1808             :                 {
    1809           0 :                     nCount = 0;
    1810           0 :                     SetError( SVSTREAM_WRITE_ERROR );
    1811             :                 }
    1812             :             }
    1813             :             else
    1814             :             {
    1815             :                 // lacking memory is larger than nResize,
    1816             :                 // resize by (nCoount-nMaxCount) + resize offset
    1817        8775 :                 if( !ReAllocateMemory( nCount-nMaxCount+nNewResize ) )
    1818             :                 {
    1819           0 :                     nCount = 0;
    1820           0 :                     SetError( SVSTREAM_WRITE_ERROR );
    1821             :                 }
    1822             :             }
    1823             :         }
    1824             :     }
    1825             :     assert(pBuf && "Possibly Reallocate failed");
    1826     3822753 :     memcpy( pBuf+nPos, pData, (size_t)nCount);
    1827             : 
    1828     3822753 :     nPos += nCount;
    1829     3822753 :     if( nPos > nEndOfData )
    1830     2029473 :         nEndOfData = nPos;
    1831     3822753 :     return nCount;
    1832             : }
    1833             : 
    1834     7580803 : sal_uInt64 SvMemoryStream::SeekPos(sal_uInt64 const nNewPos)
    1835             : {
    1836             :     // nEndOfData: First position in stream not allowed to read from
    1837             :     // nSize: Size of allocated buffer
    1838             : 
    1839             :     // check if a truncated STREAM_SEEK_TO_END was passed
    1840             :     assert(nNewPos != SAL_MAX_UINT32);
    1841     7580803 :     if( nNewPos < nEndOfData )
    1842     3749505 :         nPos = nNewPos;
    1843     3831298 :     else if( nNewPos == STREAM_SEEK_TO_END )
    1844       59311 :         nPos = nEndOfData;
    1845             :     else
    1846             :     {
    1847     3771987 :         if( nNewPos >= nSize ) // Does buffer need extension?
    1848             :         {
    1849        4429 :             if( nResize )  // Is extension possible?
    1850             :             {
    1851        1278 :                 long nDiff = (long)(nNewPos - nSize + 1);
    1852        1278 :                 nDiff += (long)nResize;
    1853        1278 :                 ReAllocateMemory( nDiff );
    1854        1278 :                 nPos = nNewPos;
    1855        1278 :                 nEndOfData = nNewPos;
    1856             :             }
    1857             :             else  // Extension not possible, set pos to end of data
    1858             :             {
    1859             :                 // SetError( SVSTREAM_OUTOFMEMORY );
    1860        3151 :                 nPos = nEndOfData;
    1861             :             }
    1862             :         }
    1863             :         else  // Expand buffer size
    1864             :         {
    1865     3767558 :             nPos = nNewPos;
    1866     3767558 :             nEndOfData = nNewPos;
    1867             :         }
    1868             :     }
    1869     7580803 :     return nPos;
    1870             : }
    1871             : 
    1872      203743 : void SvMemoryStream::FlushData()
    1873             : {
    1874      203743 : }
    1875             : 
    1876       16038 : void SvMemoryStream::ResetError()
    1877             : {
    1878       16038 :     SvStream::ClearError();
    1879       16038 : }
    1880             : 
    1881       81750 : bool SvMemoryStream::AllocateMemory( sal_Size nNewSize )
    1882             : {
    1883       81750 :     pBuf = new sal_uInt8[nNewSize];
    1884       81750 :     return( pBuf != 0 );
    1885             : }
    1886             : 
    1887             : // (using Bozo algorithm)
    1888       31633 : bool SvMemoryStream::ReAllocateMemory( long nDiff )
    1889             : {
    1890       31633 :     bool bRetVal    = false;
    1891       31633 :     long nTemp      = (long)nSize;
    1892       31633 :     nTemp           += nDiff;
    1893       31633 :     sal_Size nNewSize  = (sal_Size)nTemp;
    1894             : 
    1895       31633 :     if( nNewSize )
    1896             :     {
    1897       31633 :         sal_uInt8* pNewBuf   = new sal_uInt8[nNewSize];
    1898             : 
    1899       31633 :         if( pNewBuf )
    1900             :         {
    1901       31633 :             bRetVal = true; // Success!
    1902       31633 :             if( nNewSize < nSize )      // Are we shrinking?
    1903             :             {
    1904          64 :                 memcpy( pNewBuf, pBuf, (size_t)nNewSize );
    1905          64 :                 if( nPos > nNewSize )
    1906          10 :                     nPos = 0L;
    1907          64 :                 if( nEndOfData >= nNewSize )
    1908          10 :                     nEndOfData = nNewSize-1L;
    1909             :             }
    1910             :             else
    1911             :             {
    1912       31569 :                 memcpy( pNewBuf, pBuf, (size_t)nSize );
    1913             :             }
    1914             : 
    1915       31633 :             FreeMemory();
    1916             : 
    1917       31633 :             pBuf  = pNewBuf;
    1918       31633 :             nSize = nNewSize;
    1919             :         }
    1920             :     }
    1921             :     else
    1922             :     {
    1923           0 :         bRetVal = true;
    1924           0 :         FreeMemory();
    1925           0 :         pBuf = 0;
    1926           0 :         nSize = 0;
    1927           0 :         nEndOfData = 0;
    1928           0 :         nPos = 0;
    1929             :     }
    1930             : 
    1931       31633 :     return bRetVal;
    1932             : }
    1933             : 
    1934      115617 : void SvMemoryStream::FreeMemory()
    1935             : {
    1936      115617 :     delete[] pBuf;
    1937      115617 : }
    1938             : 
    1939          46 : void* SvMemoryStream::SwitchBuffer( sal_Size nInitSize, sal_Size nResizeOffset)
    1940             : {
    1941          46 :     Flush();
    1942          46 :     if( !bOwnsData )
    1943           0 :         return 0;
    1944          46 :     Seek( STREAM_SEEK_TO_BEGIN );
    1945             : 
    1946          46 :     void* pRetVal = pBuf;
    1947          46 :     pBuf          = 0;
    1948          46 :     nEndOfData    = 0L;
    1949          46 :     nResize       = nResizeOffset;
    1950          46 :     nPos          = 0;
    1951             : 
    1952          46 :     if( nResize != 0 && nResize < 16 )
    1953           0 :         nResize = 16;
    1954             : 
    1955          46 :     ResetError();
    1956             : 
    1957          46 :     if( nInitSize && !AllocateMemory(nInitSize) )
    1958             :     {
    1959           0 :         SetError( SVSTREAM_OUTOFMEMORY );
    1960           0 :         nSize = 0;
    1961             :     }
    1962             :     else
    1963          46 :         nSize = nInitSize;
    1964             : 
    1965          46 :     SetBufferSize( 64 );
    1966          46 :     return pRetVal;
    1967             : }
    1968             : 
    1969        1990 : void SvMemoryStream::SetSize(sal_uInt64 const nNewSize)
    1970             : {
    1971        1990 :     long nDiff = (long)nNewSize - (long)nSize;
    1972        1990 :     ReAllocateMemory( nDiff );
    1973        1990 : }
    1974             : 
    1975           0 : SvScriptStream::SvScriptStream(const OUString& rUrl):
    1976           0 :     mpProcess(NULL), mpHandle(NULL)
    1977             : {
    1978             :     oslProcessError rc;
    1979             :     rc = osl_executeProcess_WithRedirectedIO(
    1980             :         rUrl.pData,
    1981             :         NULL, 0,
    1982             :         osl_Process_HIDDEN,
    1983             :         NULL,
    1984             :         NULL,
    1985             :         NULL, 0,
    1986             :         &mpProcess,
    1987           0 :         NULL, &mpHandle, NULL);
    1988           0 :     if (osl_Process_E_None != rc)
    1989             :     {
    1990           0 :         mpProcess = NULL;
    1991           0 :         mpHandle = NULL;
    1992             :     }
    1993           0 : }
    1994             : 
    1995           0 : SvScriptStream::~SvScriptStream()
    1996             : {
    1997           0 :     if (mpProcess)
    1998             :     {
    1999           0 :         osl_terminateProcess(mpProcess);
    2000           0 :         osl_freeProcessHandle(mpProcess);
    2001             :     }
    2002           0 :     if (mpHandle)
    2003           0 :         osl_closeFile(mpHandle);
    2004           0 : }
    2005             : 
    2006           0 : bool SvScriptStream::ReadLine(OString &rStr, sal_Int32)
    2007             : {
    2008           0 :     rStr = OString();
    2009           0 :     if (!good())
    2010           0 :         return false;
    2011             : 
    2012           0 :     OStringBuffer sBuf;
    2013           0 :     sal_Char aChar('\n');
    2014             :     sal_uInt64 nBytesRead;
    2015           0 :     while (osl_File_E_None == osl_readFile(mpHandle, &aChar, 1, &nBytesRead)
    2016           0 :             && nBytesRead == 1 && aChar != '\n')
    2017             :     {
    2018           0 :         sBuf.append( aChar );
    2019             :     }
    2020           0 :     rStr = sBuf.makeStringAndClear();
    2021           0 :     if (!rStr.isEmpty())
    2022           0 :         return true;
    2023             : 
    2024           0 :     return false;
    2025             : }
    2026             : 
    2027           0 : bool SvScriptStream::good() const
    2028             : {
    2029           0 :     return mpHandle != NULL;
    2030             : }
    2031             : 
    2032           0 : TYPEINIT0 ( SvDataCopyStream )
    2033             : 
    2034           0 : void SvDataCopyStream::Assign( const SvDataCopyStream& )
    2035             : {
    2036           0 : }
    2037             : 
    2038             : //Create a OString of nLen bytes from rStream
    2039      213381 : OString read_uInt8s_ToOString(SvStream& rStrm, sal_Size nLen)
    2040             : {
    2041      213381 :     rtl_String *pStr = NULL;
    2042      213381 :     if (nLen)
    2043             :     {
    2044      133675 :         nLen = std::min(nLen, static_cast<sal_Size>(SAL_MAX_INT32));
    2045             :         //alloc a (ref-count 1) rtl_String of the desired length.
    2046             :         //rtl_String's buffer is uninitialized, except for null termination
    2047      133675 :         pStr = rtl_string_alloc(sal::static_int_cast<sal_Int32>(nLen));
    2048             :         SAL_WARN_IF(!pStr, "tools", "allocation failed");
    2049      133675 :         if (pStr)
    2050             :         {
    2051      133675 :             sal_Size nWasRead = rStrm.Read(pStr->buffer, nLen);
    2052      133675 :             if (nWasRead != nLen)
    2053             :             {
    2054             :                 //on (typically unlikely) short read set length to what we could
    2055             :                 //read, and null terminate. Excess buffer capacity remains of
    2056             :                 //course, could create a (true) replacement OString if it matters.
    2057          26 :                 pStr->length = sal::static_int_cast<sal_Int32>(nWasRead);
    2058          26 :                 pStr->buffer[pStr->length] = 0;
    2059             :             }
    2060             :         }
    2061             :     }
    2062             : 
    2063             :     //take ownership of buffer and return, otherwise return empty string
    2064      213381 :     return pStr ? OString(pStr, SAL_NO_ACQUIRE) : OString();
    2065             : }
    2066             : 
    2067             : //Create a OUString of nLen sal_Unicodes from rStream
    2068      111512 : OUString read_uInt16s_ToOUString(SvStream& rStrm, sal_Size nLen)
    2069             : {
    2070      111512 :     rtl_uString *pStr = NULL;
    2071      111512 :     if (nLen)
    2072             :     {
    2073      108198 :         nLen = std::min(nLen, static_cast<sal_Size>(SAL_MAX_INT32));
    2074             :         //alloc a (ref-count 1) rtl_uString of the desired length.
    2075             :         //rtl_String's buffer is uninitialized, except for null termination
    2076      108198 :         pStr = rtl_uString_alloc(sal::static_int_cast<sal_Int32>(nLen));
    2077             :         SAL_WARN_IF(!pStr, "tools", "allocation failed");
    2078      108198 :         if (pStr)
    2079             :         {
    2080      108198 :             sal_Size nWasRead = rStrm.Read(pStr->buffer, nLen*2)/2;
    2081      108198 :             if (nWasRead != nLen)
    2082             :             {
    2083             :                 //on (typically unlikely) short read set length to what we could
    2084             :                 //read, and null terminate. Excess buffer capacity remains of
    2085             :                 //course, could create a (true) replacement OUString if it matters.
    2086           8 :                 pStr->length = sal::static_int_cast<sal_Int32>(nWasRead);
    2087           8 :                 pStr->buffer[pStr->length] = 0;
    2088             :             }
    2089      108198 :             if (rStrm.IsEndianSwap())
    2090             :             {
    2091           0 :                 for (sal_Int32 i = 0; i < pStr->length; ++i)
    2092           0 :                     pStr->buffer[i] = OSL_SWAPWORD(pStr->buffer[i]);
    2093             :             }
    2094             :         }
    2095             :     }
    2096             : 
    2097             :     //take ownership of buffer and return, otherwise return empty string
    2098      111512 :     return pStr ? OUString(pStr, SAL_NO_ACQUIRE) : OUString();
    2099             : }
    2100             : 
    2101             : namespace
    2102             : {
    2103      109040 :     template <typename T, typename O> T tmpl_convertLineEnd(const T &rIn, LineEnd eLineEnd)
    2104             :     {
    2105             :         // Determine linebreaks and compute length
    2106      109040 :         bool            bConvert    = false;    // Needs conversion
    2107      109040 :         sal_Int32       nStrLen     = rIn.getLength();
    2108      109040 :         sal_Int32       nLineEndLen = (eLineEnd == LINEEND_CRLF) ? 2 : 1;
    2109      109040 :         sal_Int32       nLen        = 0;        // Target length
    2110      109040 :         sal_Int32       i           = 0;        // Source counter
    2111             : 
    2112      962565 :         while (i < nStrLen)
    2113             :         {
    2114             :             // \r or \n causes linebreak
    2115      744485 :             if ( (rIn[i] == '\r') || (rIn[i] == '\n') )
    2116             :             {
    2117       13882 :                 nLen = nLen + nLineEndLen;
    2118             : 
    2119             :                 // If set already, skip expensive test
    2120       13882 :                 if ( !bConvert )
    2121             :                 {
    2122             :                     // Muessen wir Konvertieren
    2123       30178 :                     if ( ((eLineEnd != LINEEND_LF) && (rIn[i] == '\n')) ||
    2124           0 :                          ((eLineEnd == LINEEND_CRLF) && (i+1) < nStrLen && (rIn[i+1] != '\n')) ||
    2125             :                          ((eLineEnd == LINEEND_LF) &&
    2126       16383 :                           ((rIn[i] == '\r') || ((i+1) < nStrLen && rIn[i+1] == '\r'))) ||
    2127             :                          ((eLineEnd == LINEEND_CR) &&
    2128           0 :                           ((rIn[i] == '\n') || ((i+1) < nStrLen && rIn[i+1] == '\n'))) )
    2129        5403 :                         bConvert = true;
    2130             :                 }
    2131             : 
    2132             :                 // skip char if \r\n or \n\r
    2133       13904 :                 if ( (i+1) < nStrLen && ((rIn[i+1] == '\r') || (rIn[i+1] == '\n')) &&
    2134          22 :                      (rIn[i] != rIn[i+1]) )
    2135           0 :                     ++i;
    2136             :             }
    2137             :             else
    2138      730603 :                 ++nLen;
    2139      744485 :             ++i;
    2140             :         }
    2141             : 
    2142      109040 :         if (!bConvert)
    2143      103637 :             return rIn;
    2144             : 
    2145             :         // convert linebreaks, insert string
    2146        5403 :         O aNewData(nLen);
    2147        5403 :         i = 0;
    2148       16561 :         while (i < nStrLen)
    2149             :         {
    2150             :             // \r or \n causes linebreak
    2151        5755 :             if ( (rIn[i] == '\r') || (rIn[i] == '\n') )
    2152             :             {
    2153        5490 :                 if ( eLineEnd == LINEEND_CRLF )
    2154             :                 {
    2155           0 :                     aNewData.append('\r');
    2156           0 :                     aNewData.append('\n');
    2157             :                 }
    2158             :                 else
    2159             :                 {
    2160        5490 :                     if ( eLineEnd == LINEEND_CR )
    2161           0 :                         aNewData.append('\r');
    2162             :                     else
    2163        5490 :                         aNewData.append('\n');
    2164             :                 }
    2165             : 
    2166        5490 :                 if ( (i+1) < nStrLen && ((rIn[i+1] == '\r') || (rIn[i+1] == '\n')) &&
    2167           0 :                      (rIn[i] != rIn[i+1]) )
    2168           0 :                     ++i;
    2169             :             }
    2170             :             else
    2171             :             {
    2172         265 :                 aNewData.append(rIn[i]);
    2173             :             }
    2174             : 
    2175        5755 :             ++i;
    2176             :         }
    2177             : 
    2178        5403 :         return aNewData.makeStringAndClear();
    2179             :     }
    2180             : }
    2181             : 
    2182         168 : OString convertLineEnd(const OString &rIn, LineEnd eLineEnd)
    2183             : {
    2184         168 :     return tmpl_convertLineEnd<OString, OStringBuffer>(rIn, eLineEnd);
    2185             : }
    2186             : 
    2187      108872 : OUString convertLineEnd(const OUString &rIn, LineEnd eLineEnd)
    2188             : {
    2189      108872 :     return tmpl_convertLineEnd<OUString, OUStringBuffer>(rIn, eLineEnd);
    2190             : }
    2191             : 
    2192       27758 : sal_Size write_uInt32_lenPrefixed_uInt16s_FromOUString(SvStream& rStrm,
    2193             :                                                 const OUString &rStr)
    2194             : {
    2195       27758 :     sal_Size nWritten = 0;
    2196       27758 :     sal_uInt32 nUnits = std::min<sal_Size>(rStr.getLength(), std::numeric_limits<sal_uInt32>::max());
    2197             :     SAL_WARN_IF(static_cast<sal_Size>(nUnits) != static_cast<sal_Size>(rStr.getLength()),
    2198             :         "tools.stream",
    2199             :         "string too long for prefix count to fit in output type");
    2200       27758 :     rStrm.WriteUInt32(nUnits);
    2201       27758 :     if (rStrm.good())
    2202             :     {
    2203       27758 :         nWritten += sizeof(sal_uInt32);
    2204       27758 :         nWritten += write_uInt16s_FromOUString(rStrm, rStr, nUnits);
    2205             :     }
    2206       27758 :     return nWritten;
    2207             : }
    2208             : 
    2209       93366 : sal_Size write_uInt16_lenPrefixed_uInt16s_FromOUString(SvStream& rStrm,
    2210             :                                                 const OUString &rStr)
    2211             : {
    2212       93366 :     sal_Size nWritten = 0;
    2213       93366 :     sal_uInt16 nUnits = std::min<sal_Size>(rStr.getLength(), std::numeric_limits<sal_uInt16>::max());
    2214             :     SAL_WARN_IF(nUnits != rStr.getLength(),
    2215             :         "tools.stream",
    2216             :         "string too long for prefix count to fit in output type");
    2217       93366 :     rStrm.WriteUInt16(nUnits);
    2218       93366 :     if (rStrm.good())
    2219             :     {
    2220       93366 :         nWritten += sizeof(nUnits);
    2221       93366 :         nWritten += write_uInt16s_FromOUString(rStrm, rStr, nUnits);
    2222             :     }
    2223       93366 :     return nWritten;
    2224             : }
    2225             : 
    2226      314395 : sal_Size write_uInt16_lenPrefixed_uInt8s_FromOString(SvStream& rStrm,
    2227             :                                               const OString &rStr)
    2228             : {
    2229      314395 :     sal_Size nWritten = 0;
    2230      314395 :     sal_uInt16 nUnits = std::min<sal_Size>(rStr.getLength(), std::numeric_limits<sal_uInt16>::max());
    2231             :     SAL_WARN_IF(static_cast<sal_Size>(nUnits) != static_cast<sal_Size>(rStr.getLength()),
    2232             :         "tools.stream",
    2233             :         "string too long for sal_uInt16 count to fit in output type");
    2234      314395 :     rStrm.WriteUInt16( nUnits );
    2235      314395 :     if (rStrm.good())
    2236             :     {
    2237      314395 :         nWritten += sizeof(sal_uInt16);
    2238      314395 :         nWritten += write_uInt8s_FromOString(rStrm, rStr, nUnits);
    2239             :     }
    2240      314395 :     return nWritten;
    2241             : }
    2242             : 
    2243             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10