1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_tools.hxx" 26 27 // ToDo: 28 // - Read->RefreshBuffer->Auf Aenderungen von nBufActualLen reagieren 29 30 #include <cstddef> 31 32 #include <string.h> 33 #include <stdio.h> 34 #include <ctype.h> // isspace 35 #include <stdlib.h> // strtol, _crotl 36 37 #include "boost/static_assert.hpp" 38 39 /* 40 #if defined( DBG_UTIL ) && (OSL_DEBUG_LEVEL > 1) 41 // prueft Synchronisation des Buffers nach allen Read, Write, Seek 42 #define OV_DEBUG 43 #endif 44 */ 45 46 #include <tools/solar.h> 47 48 #if defined(BLC) 49 #define SWAPNIBBLES(c) c=_crotl(c,4); 50 #else 51 #define SWAPNIBBLES(c) \ 52 unsigned char nSwapTmp=c; \ 53 nSwapTmp <<= 4; \ 54 c >>= 4; \ 55 c |= nSwapTmp; 56 #endif 57 58 #include <tools/debug.hxx> 59 #define ENABLE_BYTESTRING_STREAM_OPERATORS 60 #include <tools/stream.hxx> 61 #include <osl/thread.h> 62 #include <algorithm> 63 64 // ----------------------------------------------------------------------- 65 66 DBG_NAME( Stream ) 67 68 // ----------------------------------------------------------------------- 69 70 // sprintf Param-Mode 71 #define SPECIAL_PARAM_NONE 0 // Format-Str, Number 72 #define SPECIAL_PARAM_WIDTH 1 // Format-Str, Width, Number 73 #define SPECIAL_PARAM_PRECISION 2 // Format-Str, Precision, Number 74 #define SPECIAL_PARAM_BOTH 3 // Format-Str, Width, Precision, Number 75 76 // ----------------------------------------------------------------------- 77 78 // !!! Nicht inline, wenn Operatoren <<,>> inline sind 79 inline static void SwapUShort( sal_uInt16& r ) 80 { r = SWAPSHORT(r); } 81 inline static void SwapShort( short& r ) 82 { r = SWAPSHORT(r); } 83 inline static void SwapLong( long& r ) 84 { r = SWAPLONG(r); } 85 inline static void SwapULong( sal_uInt32& r ) 86 { r = SWAPLONG(r); } 87 inline static void SwapLongInt( int& r ) 88 { r = SWAPLONG(r); } 89 inline static void SwapLongUInt( unsigned int& r ) 90 { r = SWAPLONG(r); } 91 #ifdef UNX 92 inline static void SwapFloat( float& r ) 93 { 94 union 95 { 96 float f; 97 sal_uInt32 c; 98 } s; 99 100 s.f = r; 101 s.c = SWAPLONG( s.c ); 102 r = s.f; 103 } 104 inline static void SwapDouble( double& r ) 105 { 106 if( sizeof(double) != 8 ) 107 { 108 DBG_ASSERT( sal_False, "Can only swap 8-Byte-doubles\n" ); 109 } 110 else 111 { 112 union 113 { 114 double d; 115 sal_uInt32 c[2]; 116 } s; 117 118 s.d = r; 119 s.c[0] ^= s.c[1]; // zwei 32-Bit-Werte in situ vertauschen 120 s.c[1] ^= s.c[0]; 121 s.c[0] ^= s.c[1]; 122 s.c[0] = SWAPLONG(s.c[0]); // und die beiden 32-Bit-Werte selbst in situ drehen 123 s.c[1] = SWAPLONG(s.c[1]); 124 r = s.d; 125 } 126 } 127 #endif 128 129 //SDO 130 131 #define READNUMBER_WITHOUT_SWAP(datatype,value) \ 132 {\ 133 int tmp = eIOMode; \ 134 if( (tmp == STREAM_IO_READ) && sizeof(datatype)<=nBufFree) \ 135 {\ 136 for (std::size_t i = 0; i < sizeof(datatype); i++)\ 137 ((char *)&value)[i] = pBufPos[i];\ 138 nBufActualPos += sizeof(datatype);\ 139 pBufPos += sizeof(datatype);\ 140 nBufFree -= sizeof(datatype);\ 141 }\ 142 else\ 143 Read( (char*)&value, sizeof(datatype) );\ 144 } 145 146 #define WRITENUMBER_WITHOUT_SWAP(datatype,value) \ 147 {\ 148 int tmp = eIOMode; \ 149 if( (tmp==STREAM_IO_WRITE) && sizeof(datatype) <= nBufFree)\ 150 {\ 151 for (std::size_t i = 0; i < sizeof(datatype); i++)\ 152 pBufPos[i] = ((char *)&value)[i];\ 153 nBufFree -= sizeof(datatype);\ 154 nBufActualPos += sizeof(datatype);\ 155 if( nBufActualPos > nBufActualLen )\ 156 nBufActualLen = nBufActualPos;\ 157 pBufPos += sizeof(datatype);\ 158 bIsDirty = sal_True;\ 159 }\ 160 else\ 161 Write( (char*)&value, sizeof(datatype) );\ 162 } 163 164 //============================================================================ 165 // 166 // class SvLockBytes 167 // 168 //============================================================================ 169 170 void SvLockBytes::close() 171 { 172 if (m_bOwner) 173 delete m_pStream; 174 m_pStream = 0; 175 } 176 177 //============================================================================ 178 TYPEINIT0(SvLockBytes); 179 180 //============================================================================ 181 // virtual 182 ErrCode SvLockBytes::ReadAt(sal_Size nPos, void * pBuffer, sal_Size nCount, 183 sal_Size * pRead) const 184 { 185 if (!m_pStream) 186 { 187 DBG_ERROR("SvLockBytes::ReadAt(): Bad stream"); 188 return ERRCODE_NONE; 189 } 190 191 m_pStream->Seek(nPos); 192 sal_Size nTheRead = m_pStream->Read(pBuffer, nCount); 193 if (pRead) 194 *pRead = nTheRead; 195 return m_pStream->GetErrorCode(); 196 } 197 198 //============================================================================ 199 // virtual 200 ErrCode SvLockBytes::WriteAt(sal_Size nPos, const void * pBuffer, sal_Size nCount, 201 sal_Size * pWritten) 202 { 203 if (!m_pStream) 204 { 205 DBG_ERROR("SvLockBytes::WriteAt(): Bad stream"); 206 return ERRCODE_NONE; 207 } 208 209 m_pStream->Seek(nPos); 210 sal_Size nTheWritten = m_pStream->Write(pBuffer, nCount); 211 if (pWritten) 212 *pWritten = nTheWritten; 213 return m_pStream->GetErrorCode(); 214 } 215 216 //============================================================================ 217 // virtual 218 ErrCode SvLockBytes::Flush() const 219 { 220 if (!m_pStream) 221 { 222 DBG_ERROR("SvLockBytes::Flush(): Bad stream"); 223 return ERRCODE_NONE; 224 } 225 226 m_pStream->Flush(); 227 return m_pStream->GetErrorCode(); 228 } 229 230 //============================================================================ 231 // virtual 232 ErrCode SvLockBytes::SetSize(sal_Size nSize) 233 { 234 if (!m_pStream) 235 { 236 DBG_ERROR("SvLockBytes::SetSize(): Bad stream"); 237 return ERRCODE_NONE; 238 } 239 240 m_pStream->SetStreamSize(nSize); 241 return m_pStream->GetErrorCode(); 242 } 243 244 //============================================================================ 245 ErrCode SvLockBytes::LockRegion(sal_Size, sal_Size, LockType) 246 { 247 DBG_ERROR("SvLockBytes::LockRegion(): Not implemented"); 248 return ERRCODE_NONE; 249 } 250 251 //============================================================================ 252 253 ErrCode SvLockBytes::UnlockRegion(sal_Size, sal_Size, LockType) 254 { 255 DBG_ERROR("SvLockBytes::UnlockRegion(): Not implemented"); 256 return ERRCODE_NONE; 257 } 258 259 //============================================================================ 260 ErrCode SvLockBytes::Stat(SvLockBytesStat * pStat, SvLockBytesStatFlag) const 261 { 262 if (!m_pStream) 263 { 264 DBG_ERROR("SvLockBytes::Stat(): Bad stream"); 265 return ERRCODE_NONE; 266 } 267 268 if (pStat) 269 { 270 sal_Size nPos = m_pStream->Tell(); 271 pStat->nSize = m_pStream->Seek(STREAM_SEEK_TO_END); 272 m_pStream->Seek(nPos); 273 } 274 return ERRCODE_NONE; 275 } 276 277 //============================================================================ 278 // 279 // class SvOpenLockBytes 280 // 281 //============================================================================ 282 283 TYPEINIT1(SvOpenLockBytes, SvLockBytes); 284 285 //============================================================================ 286 // 287 // class SvAsyncLockBytes 288 // 289 //============================================================================ 290 291 TYPEINIT1(SvAsyncLockBytes, SvOpenLockBytes); 292 293 //============================================================================ 294 // virtual 295 ErrCode SvAsyncLockBytes::ReadAt(sal_Size nPos, void * pBuffer, sal_Size nCount, 296 sal_Size * pRead) const 297 { 298 if (m_bTerminated) 299 return SvOpenLockBytes::ReadAt(nPos, pBuffer, nCount, pRead); 300 else 301 { 302 sal_Size nTheCount = std::min(nPos < m_nSize ? m_nSize - nPos : 0, nCount); 303 ErrCode nError = SvOpenLockBytes::ReadAt(nPos, pBuffer, nTheCount, 304 pRead); 305 return !nCount || nTheCount == nCount || nError ? nError : 306 ERRCODE_IO_PENDING; 307 } 308 } 309 310 //============================================================================ 311 // virtual 312 ErrCode SvAsyncLockBytes::WriteAt(sal_Size nPos, const void * pBuffer, 313 sal_Size nCount, sal_Size * pWritten) 314 { 315 if (m_bTerminated) 316 return SvOpenLockBytes::WriteAt(nPos, pBuffer, nCount, pWritten); 317 else 318 { 319 sal_Size nTheCount = std::min(nPos < m_nSize ? m_nSize - nPos : 0, nCount); 320 ErrCode nError = SvOpenLockBytes::WriteAt(nPos, pBuffer, nTheCount, 321 pWritten); 322 return !nCount || nTheCount == nCount || nError ? nError : 323 ERRCODE_IO_PENDING; 324 } 325 } 326 327 //============================================================================ 328 // virtual 329 ErrCode SvAsyncLockBytes::FillAppend(const void * pBuffer, sal_Size nCount, 330 sal_Size * pWritten) 331 { 332 sal_Size nTheWritten; 333 ErrCode nError = SvOpenLockBytes::WriteAt(m_nSize, pBuffer, nCount, 334 &nTheWritten); 335 if (!nError) 336 m_nSize += nTheWritten; 337 if (pWritten) 338 *pWritten = nTheWritten; 339 return nError; 340 } 341 342 //============================================================================ 343 // virtual 344 sal_Size SvAsyncLockBytes::Seek(sal_Size nPos) 345 { 346 if (nPos != STREAM_SEEK_TO_END) 347 m_nSize = nPos; 348 return m_nSize; 349 } 350 351 //============================================================================ 352 // 353 // class SvStream 354 // 355 //============================================================================ 356 357 sal_Size SvStream::GetData( void* pData, sal_Size nSize ) 358 { 359 if( !GetError() ) 360 { 361 DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); 362 sal_Size nRet; 363 nError = xLockBytes->ReadAt( nActPos, pData, nSize, &nRet ); 364 nActPos += nRet; 365 return nRet; 366 } 367 else return 0; 368 } 369 370 ErrCode SvStream::SetLockBytes( SvLockBytesRef& rLB ) 371 { 372 xLockBytes = rLB; 373 RefreshBuffer(); 374 return ERRCODE_NONE; 375 } 376 377 //======================================================================== 378 379 sal_Size SvStream::PutData( const void* pData, sal_Size nSize ) 380 { 381 if( !GetError() ) 382 { 383 DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); 384 sal_Size nRet; 385 nError = xLockBytes->WriteAt( nActPos, pData, nSize, &nRet ); 386 nActPos += nRet; 387 return nRet; 388 } 389 else return 0; 390 } 391 392 //======================================================================== 393 394 sal_Size SvStream::SeekPos( sal_Size nPos ) 395 { 396 if( !GetError() && nPos == STREAM_SEEK_TO_END ) 397 { 398 DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); 399 SvLockBytesStat aStat; 400 xLockBytes->Stat( &aStat, SVSTATFLAG_DEFAULT ); 401 nActPos = aStat.nSize; 402 } 403 else 404 nActPos = nPos; 405 return nActPos; 406 } 407 408 //======================================================================== 409 410 void SvStream::FlushData() 411 { 412 if( !GetError() ) 413 { 414 DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); 415 nError = xLockBytes->Flush(); 416 } 417 } 418 419 //======================================================================== 420 421 void SvStream::SetSize( sal_Size nSize ) 422 { 423 DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); 424 nError = xLockBytes->SetSize( nSize ); 425 } 426 427 void SvStream::ImpInit() 428 { 429 nActPos = 0; 430 nCompressMode = COMPRESSMODE_NONE; 431 eStreamCharSet = osl_getThreadTextEncoding(); 432 // eTargetCharSet = osl_getThreadTextEncoding(); 433 nCryptMask = 0; 434 bIsEof = sal_False; 435 #if defined UNX 436 eLineDelimiter = LINEEND_LF; // UNIX-Format 437 #else 438 eLineDelimiter = LINEEND_CRLF; // DOS-Format 439 #endif 440 441 SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN ); 442 443 nBufFilePos = 0; 444 nBufActualPos = 0; 445 bIsDirty = sal_False; 446 bIsConsistent = sal_True; 447 bIsWritable = sal_True; 448 449 pRWBuf = 0; 450 pBufPos = 0; 451 nBufSize = 0; 452 nBufActualLen = 0; 453 eIOMode = STREAM_IO_DONTKNOW; 454 nBufFree = 0; 455 456 nRadix = 10; 457 nPrecision = 0; // all significant digits 458 nWidth = 0; // default width 459 cFiller = ' '; 460 nJustification = JUSTIFY_RIGHT; 461 eStreamMode = 0; 462 CreateFormatString(); 463 464 nVersion = 0; 465 466 ClearError(); 467 } 468 469 /************************************************************************* 470 |* 471 |* Stream::Stream() 472 |* 473 |* Beschreibung STREAM.SDW 474 |* Ersterstellung OV 08.06.94 475 |* Letzte Aenderung OV 08.06.94 476 |* 477 *************************************************************************/ 478 479 SvStream::SvStream( SvLockBytes* pLockBytesP ) 480 { 481 DBG_CTOR( Stream, NULL ); 482 483 ImpInit(); 484 xLockBytes = pLockBytesP; 485 const SvStream* pStrm; 486 if( pLockBytesP ) { 487 pStrm = pLockBytesP->GetStream(); 488 if( pStrm ) { 489 SetError( pStrm->GetErrorCode() ); 490 } 491 } 492 SetBufferSize( 256 ); 493 } 494 495 SvStream::SvStream() 496 { 497 DBG_CTOR( Stream, NULL ); 498 499 ImpInit(); 500 } 501 502 /************************************************************************* 503 |* 504 |* Stream::~Stream() 505 |* 506 |* Beschreibung STREAM.SDW 507 |* Ersterstellung OV 08.06.94 508 |* Letzte Aenderung OV 08.06.94 509 |* 510 *************************************************************************/ 511 512 SvStream::~SvStream() 513 { 514 DBG_DTOR( Stream, NULL ); 515 516 if ( xLockBytes.Is() ) 517 Flush(); 518 519 if( pRWBuf ) 520 delete[] pRWBuf; 521 } 522 523 /************************************************************************* 524 |* 525 |* Stream::IsA() 526 |* 527 |* Beschreibung STREAM.SDW 528 |* Ersterstellung OV 08.06.94 529 |* Letzte Aenderung OV 08.06.94 530 |* 531 *************************************************************************/ 532 533 sal_uInt16 SvStream::IsA() const 534 { 535 return (sal_uInt16)ID_STREAM; 536 } 537 538 /************************************************************************* 539 |* 540 |* Stream::ClearError() 541 |* 542 |* Beschreibung STREAM.SDW 543 |* Ersterstellung OV 08.06.94 544 |* Letzte Aenderung OV 08.06.94 545 |* 546 *************************************************************************/ 547 548 void SvStream::ClearError() 549 { 550 bIsEof = sal_False; 551 nError = SVSTREAM_OK; 552 } 553 554 /************************************************************************* 555 |* 556 |* Stream::SetError() 557 |* 558 |* Beschreibung STREAM.SDW 559 |* Ersterstellung OV 08.06.94 560 |* Letzte Aenderung OV 08.06.94 561 |* 562 *************************************************************************/ 563 564 void SvStream::SetError( sal_uInt32 nErrorCode ) 565 { 566 if ( nError == SVSTREAM_OK ) 567 nError = nErrorCode; 568 } 569 570 571 /************************************************************************* 572 |* 573 |* Stream::SetNumberFormatInt() 574 |* 575 |* Beschreibung STREAM.SDW 576 |* Ersterstellung OV 08.06.94 577 |* Letzte Aenderung OV 08.06.94 578 |* 579 *************************************************************************/ 580 581 void SvStream::SetNumberFormatInt( sal_uInt16 nNewFormat ) 582 { 583 nNumberFormatInt = nNewFormat; 584 bSwap = sal_False; 585 #ifdef OSL_BIGENDIAN 586 if( nNumberFormatInt == NUMBERFORMAT_INT_LITTLEENDIAN ) 587 bSwap = sal_True; 588 #else 589 if( nNumberFormatInt == NUMBERFORMAT_INT_BIGENDIAN ) 590 bSwap = sal_True; 591 #endif 592 } 593 594 /************************************************************************* 595 |* 596 |* Stream::SetBufferSize() 597 |* 598 |* Beschreibung STREAM.SDW 599 |* Ersterstellung OV 08.06.94 600 |* Letzte Aenderung OV 08.06.94 601 |* 602 *************************************************************************/ 603 604 void SvStream::SetBufferSize( sal_uInt16 nBufferSize ) 605 { 606 sal_Size nActualFilePos = Tell(); 607 sal_Bool bDontSeek = (sal_Bool)(pRWBuf == 0); 608 609 if( bIsDirty && bIsConsistent && bIsWritable ) // wg. Windows NT: Access denied 610 Flush(); 611 612 if( nBufSize ) 613 { 614 delete[] pRWBuf; 615 nBufFilePos += nBufActualPos; 616 } 617 618 pRWBuf = 0; 619 nBufActualLen = 0; 620 nBufActualPos = 0; 621 nBufSize = nBufferSize; 622 if( nBufSize ) 623 pRWBuf = new sal_uInt8[ nBufSize ]; 624 bIsConsistent = sal_True; 625 pBufPos = pRWBuf; 626 eIOMode = STREAM_IO_DONTKNOW; 627 if( !bDontSeek ) 628 SeekPos( nActualFilePos ); 629 } 630 631 /************************************************************************* 632 |* 633 |* Stream::ClearBuffer() 634 |* 635 |* Beschreibung STREAM.SDW 636 |* Ersterstellung OV 08.06.94 637 |* Letzte Aenderung OV 08.06.94 638 |* 639 *************************************************************************/ 640 641 void SvStream::ClearBuffer() 642 { 643 nBufActualLen = 0; 644 nBufActualPos = 0; 645 nBufFilePos = 0; 646 pBufPos = pRWBuf; 647 bIsDirty = sal_False; 648 bIsConsistent = sal_True; 649 eIOMode = STREAM_IO_DONTKNOW; 650 651 bIsEof = sal_False; 652 } 653 654 /************************************************************************* 655 |* 656 |* Stream::ResetError() 657 |* 658 |* Beschreibung STREAM.SDW 659 |* Ersterstellung OV 08.06.94 660 |* Letzte Aenderung OV 08.06.94 661 |* 662 *************************************************************************/ 663 664 void SvStream::ResetError() 665 { 666 ClearError(); 667 } 668 669 /************************************************************************* 670 |* 671 |* Stream::ReadLine() 672 |* 673 |* Beschreibung STREAM.SDW 674 |* Ersterstellung OV 08.06.94 675 |* Letzte Aenderung OV 08.06.94 676 |* 677 *************************************************************************/ 678 679 sal_Bool SvStream::ReadByteStringLine( ::rtl::OUString& rStr, rtl_TextEncoding eSrcCharSet ) 680 { 681 sal_Bool bRet; 682 ::rtl::OStringBuffer stringBuffer; 683 684 bRet = ReadLine( stringBuffer ); 685 rStr = ::rtl::OStringToOUString( stringBuffer.makeStringAndClear(), eSrcCharSet ); 686 return bRet; 687 } 688 689 sal_Bool SvStream::ReadByteStringLine( String& rStr, rtl_TextEncoding eSrcCharSet ) 690 { 691 sal_Bool bRet; 692 ByteString aStr; 693 694 bRet = ReadLine(aStr); 695 rStr = UniString( aStr, eSrcCharSet ); 696 return bRet; 697 } 698 699 sal_Bool SvStream::ReadLine( ::rtl::OStringBuffer& rStr ) 700 { 701 sal_Char buf[256+1]; 702 sal_Bool bEnd = sal_False; 703 sal_Size nOldFilePos = Tell(); 704 sal_Char c = 0; 705 sal_Size nTotalLen = 0; 706 707 rStr.setLength( 0 ); 708 while( !bEnd && !GetError() ) // !!! do not test for EOF, 709 // !!! because we read in blocks 710 { 711 sal_uInt16 nLen = (sal_uInt16)Read( buf, sizeof(buf)-1 ); 712 if ( !nLen ) 713 { 714 if ( rStr.getLength() == 0 ) 715 { 716 // the very first block read failed -> abort 717 bIsEof = sal_True; 718 return sal_False; 719 } 720 else 721 break; 722 } 723 724 sal_uInt16 j, n; 725 for( j = n = 0; j < nLen ; ++j ) 726 { 727 c = buf[j]; 728 if ( c == '\n' || c == '\r' ) 729 { 730 bEnd = sal_True; 731 break; 732 } 733 // erAck 26.02.01: Old behavior was no special treatment of '\0' 734 // character here, but a following rStr+=c did ignore it. Is this 735 // really intended? Or should a '\0' better terminate a line? 736 // The nOldFilePos stuff wasn't correct then anyways. 737 if ( c ) 738 { 739 if ( n < j ) 740 buf[n] = c; 741 ++n; 742 } 743 } 744 if ( n ) 745 rStr.append( buf, n ); 746 nTotalLen += j; 747 } 748 749 if ( !bEnd && !GetError() && rStr.getLength() ) 750 bEnd = sal_True; 751 752 nOldFilePos += nTotalLen; 753 if( Tell() > nOldFilePos ) 754 nOldFilePos++; 755 Seek( nOldFilePos ); // seek because of the above BlockRead! 756 757 if ( bEnd && (c=='\r' || c=='\n') ) // Special treatment of DOS files 758 { 759 char cTemp; 760 sal_Size nLen = Read((char*)&cTemp , sizeof(cTemp) ); 761 if ( nLen ) { 762 if( cTemp == c || (cTemp != '\n' && cTemp != '\r') ) 763 Seek( nOldFilePos ); 764 } 765 } 766 767 if ( bEnd ) 768 bIsEof = sal_False; 769 return bEnd; 770 } 771 772 sal_Bool SvStream::ReadLine( ByteString& rStr ) 773 { 774 sal_Char buf[256+1]; 775 sal_Bool bEnd = sal_False; 776 sal_Size nOldFilePos = Tell(); 777 sal_Char c = 0; 778 sal_Size nTotalLen = 0; 779 780 rStr.Erase(); 781 while( !bEnd && !GetError() ) // !!! nicht auf EOF testen, 782 // !!! weil wir blockweise 783 // !!! lesen 784 { 785 sal_uInt16 nLen = (sal_uInt16)Read( buf, sizeof(buf)-1 ); 786 if ( !nLen ) 787 { 788 if ( rStr.Len() == 0 ) 789 { 790 // der allererste Blockread hat fehlgeschlagen -> Abflug 791 bIsEof = sal_True; 792 return sal_False; 793 } 794 else 795 break; 796 } 797 798 sal_uInt16 j, n; 799 for( j = n = 0; j < nLen ; ++j ) 800 { 801 c = buf[j]; 802 if ( c == '\n' || c == '\r' ) 803 { 804 bEnd = sal_True; 805 break; 806 } 807 // erAck 26.02.01: Old behavior was no special treatment of '\0' 808 // character here, but a following rStr+=c did ignore it. Is this 809 // really intended? Or should a '\0' better terminate a line? 810 // The nOldFilePos stuff wasn't correct then anyways. 811 if ( c ) 812 { 813 if ( n < j ) 814 buf[n] = c; 815 ++n; 816 } 817 } 818 if ( n ) 819 rStr.Append( buf, n ); 820 nTotalLen += j; 821 } 822 823 if ( !bEnd && !GetError() && rStr.Len() ) 824 bEnd = sal_True; 825 826 nOldFilePos += nTotalLen; 827 if( Tell() > nOldFilePos ) 828 nOldFilePos++; 829 Seek( nOldFilePos ); // seeken wg. obigem BlockRead! 830 831 if ( bEnd && (c=='\r' || c=='\n') ) // Sonderbehandlung DOS-Dateien 832 { 833 char cTemp; 834 sal_Size nLen = Read((char*)&cTemp , sizeof(cTemp) ); 835 if ( nLen ) { 836 if( cTemp == c || (cTemp != '\n' && cTemp != '\r') ) 837 Seek( nOldFilePos ); 838 } 839 } 840 841 if ( bEnd ) 842 bIsEof = sal_False; 843 return bEnd; 844 } 845 846 sal_Bool SvStream::ReadUniStringLine( String& rStr ) 847 { 848 sal_Unicode buf[256+1]; 849 sal_Bool bEnd = sal_False; 850 sal_Size nOldFilePos = Tell(); 851 sal_Unicode c = 0; 852 sal_Size nTotalLen = 0; 853 854 DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "ReadUniStringLine: swapping sizeof(sal_Unicode) not implemented" ); 855 856 rStr.Erase(); 857 while( !bEnd && !GetError() ) // !!! nicht auf EOF testen, 858 // !!! weil wir blockweise 859 // !!! lesen 860 { 861 sal_uInt16 nLen = (sal_uInt16)Read( (char*)buf, sizeof(buf)-sizeof(sal_Unicode) ); 862 nLen /= sizeof(sal_Unicode); 863 if ( !nLen ) 864 { 865 if ( rStr.Len() == 0 ) 866 { 867 // der allererste Blockread hat fehlgeschlagen -> Abflug 868 bIsEof = sal_True; 869 return sal_False; 870 } 871 else 872 break; 873 } 874 875 sal_uInt16 j, n; 876 for( j = n = 0; j < nLen ; ++j ) 877 { 878 if ( bSwap ) 879 SwapUShort( buf[n] ); 880 c = buf[j]; 881 if ( c == '\n' || c == '\r' ) 882 { 883 bEnd = sal_True; 884 break; 885 } 886 // erAck 26.02.01: Old behavior was no special treatment of '\0' 887 // character here, but a following rStr+=c did ignore it. Is this 888 // really intended? Or should a '\0' better terminate a line? 889 // The nOldFilePos stuff wasn't correct then anyways. 890 if ( c ) 891 { 892 if ( n < j ) 893 buf[n] = c; 894 ++n; 895 } 896 } 897 if ( n ) 898 rStr.Append( buf, n ); 899 nTotalLen += j; 900 } 901 902 if ( !bEnd && !GetError() && rStr.Len() ) 903 bEnd = sal_True; 904 905 nOldFilePos += nTotalLen * sizeof(sal_Unicode); 906 if( Tell() > nOldFilePos ) 907 nOldFilePos += sizeof(sal_Unicode); 908 Seek( nOldFilePos ); // seeken wg. obigem BlockRead! 909 910 if ( bEnd && (c=='\r' || c=='\n') ) // Sonderbehandlung DOS-Dateien 911 { 912 sal_Unicode cTemp; 913 Read( (char*)&cTemp, sizeof(cTemp) ); 914 if ( bSwap ) 915 SwapUShort( cTemp ); 916 if( cTemp == c || (cTemp != '\n' && cTemp != '\r') ) 917 Seek( nOldFilePos ); 918 } 919 920 if ( bEnd ) 921 bIsEof = sal_False; 922 return bEnd; 923 } 924 925 sal_Bool SvStream::ReadUniOrByteStringLine( String& rStr, rtl_TextEncoding eSrcCharSet ) 926 { 927 if ( eSrcCharSet == RTL_TEXTENCODING_UNICODE ) 928 return ReadUniStringLine( rStr ); 929 else 930 return ReadByteStringLine( rStr, eSrcCharSet ); 931 } 932 933 /************************************************************************* 934 |* 935 |* Stream::ReadCString 936 |* 937 *************************************************************************/ 938 939 sal_Bool SvStream::ReadCString( ByteString& rStr ) 940 { 941 if( rStr.Len() ) 942 rStr.Erase(); 943 944 sal_Char buf[ 256 + 1 ]; 945 sal_Bool bEnd = sal_False; 946 sal_Size nFilePos = Tell(); 947 948 while( !bEnd && !GetError() ) 949 { 950 sal_uInt16 nLen = (sal_uInt16)Read( buf, sizeof(buf)-1 ); 951 sal_uInt16 nReallyRead = nLen; 952 if( !nLen ) 953 break; 954 955 const sal_Char* pPtr = buf; 956 while( *pPtr && nLen ) 957 ++pPtr, --nLen; 958 959 bEnd = ( nReallyRead < sizeof(buf)-1 ) // read less than attempted to read 960 || ( ( nLen > 0 ) // OR it is inside the block we read 961 && ( 0 == *pPtr ) // AND found a string terminator 962 ); 963 964 rStr.Append( buf, ::sal::static_int_cast< xub_StrLen >( pPtr - buf ) ); 965 } 966 967 nFilePos += rStr.Len(); 968 if( Tell() > nFilePos ) 969 nFilePos++; 970 Seek( nFilePos ); // seeken wg. obigem BlockRead! 971 return bEnd; 972 } 973 974 sal_Bool SvStream::ReadCString( String& rStr, rtl_TextEncoding eToEncode ) 975 { 976 ByteString sStr; 977 sal_Bool bRet = ReadCString( sStr ); 978 rStr = String( sStr, eToEncode ); 979 return bRet; 980 } 981 982 983 /************************************************************************* 984 |* 985 |* Stream::WriteUnicodeText() 986 |* 987 *************************************************************************/ 988 989 sal_Bool SvStream::WriteUnicodeText( const String& rStr ) 990 { 991 DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "WriteUnicodeText: swapping sizeof(sal_Unicode) not implemented" ); 992 if ( bSwap ) 993 { 994 xub_StrLen nLen = rStr.Len(); 995 sal_Unicode aBuf[384]; 996 sal_Unicode* const pTmp = ( nLen > 384 ? new sal_Unicode[nLen] : aBuf); 997 memcpy( pTmp, rStr.GetBuffer(), nLen * sizeof(sal_Unicode) ); 998 sal_Unicode* p = pTmp; 999 const sal_Unicode* const pStop = pTmp + nLen; 1000 while ( p < pStop ) 1001 { 1002 SwapUShort( *p ); 1003 p++; 1004 } 1005 Write( (char*)pTmp, nLen * sizeof(sal_Unicode) ); 1006 if ( pTmp != aBuf ) 1007 delete [] pTmp; 1008 } 1009 else 1010 Write( (char*)rStr.GetBuffer(), rStr.Len() * sizeof(sal_Unicode) ); 1011 return nError == SVSTREAM_OK; 1012 } 1013 1014 sal_Bool SvStream::WriteUnicodeOrByteText( const String& rStr, rtl_TextEncoding eDestCharSet ) 1015 { 1016 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE ) 1017 return WriteUnicodeText( rStr ); 1018 else 1019 { 1020 ByteString aStr( rStr, eDestCharSet ); 1021 Write( aStr.GetBuffer(), aStr.Len() ); 1022 return nError == SVSTREAM_OK; 1023 } 1024 } 1025 1026 /************************************************************************* 1027 |* 1028 |* Stream::WriteLine() 1029 |* 1030 |* Beschreibung STREAM.SDW 1031 |* Ersterstellung OV 08.06.94 1032 |* Letzte Aenderung OV 08.06.94 1033 |* 1034 *************************************************************************/ 1035 1036 sal_Bool SvStream::WriteByteStringLine( const String& rStr, rtl_TextEncoding eDestCharSet ) 1037 { 1038 return WriteLine( ByteString( rStr, eDestCharSet ) ); 1039 } 1040 1041 sal_Bool SvStream::WriteLine( const ByteString& rStr ) 1042 { 1043 Write( rStr.GetBuffer(), rStr.Len() ); 1044 endl(*this); 1045 return nError == SVSTREAM_OK; 1046 } 1047 1048 sal_Bool SvStream::WriteUniStringLine( const String& rStr ) 1049 { 1050 WriteUnicodeText( rStr ); 1051 endlu(*this); 1052 return nError == SVSTREAM_OK; 1053 } 1054 1055 sal_Bool SvStream::WriteUniOrByteStringLine( const String& rStr, rtl_TextEncoding eDestCharSet ) 1056 { 1057 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE ) 1058 return WriteUniStringLine( rStr ); 1059 else 1060 return WriteByteStringLine( rStr, eDestCharSet ); 1061 } 1062 1063 /************************************************************************* 1064 |* 1065 |* Stream::WriteLines() 1066 |* 1067 |* Beschreibung STREAM.SDW 1068 |* Ersterstellung OV 17.07.95 1069 |* Letzte Aenderung OV 17.07.95 1070 |* 1071 *************************************************************************/ 1072 1073 sal_Bool SvStream::WriteByteStringLines( const String& rStr, rtl_TextEncoding eDestCharSet ) 1074 { 1075 return WriteLines( ByteString( rStr, eDestCharSet ) ); 1076 } 1077 1078 sal_Bool SvStream::WriteLines( const ByteString& rStr ) 1079 { 1080 ByteString aStr( rStr ); 1081 aStr.ConvertLineEnd( eLineDelimiter ); 1082 Write( aStr.GetBuffer(), aStr.Len() ); 1083 endl( *this ); 1084 return (sal_Bool)(nError == SVSTREAM_OK); 1085 } 1086 1087 sal_Bool SvStream::WriteUniStringLines( const String& rStr ) 1088 { 1089 String aStr( rStr ); 1090 aStr.ConvertLineEnd( eLineDelimiter ); 1091 WriteUniStringLine( aStr ); 1092 return nError == SVSTREAM_OK; 1093 } 1094 1095 sal_Bool SvStream::WriteUniOrByteStringLines( const String& rStr, rtl_TextEncoding eDestCharSet ) 1096 { 1097 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE ) 1098 return WriteUniStringLines( rStr ); 1099 else 1100 return WriteByteStringLines( rStr, eDestCharSet ); 1101 } 1102 1103 /************************************************************************* 1104 |* 1105 |* Stream::WriteUniOrByteChar() 1106 |* 1107 *************************************************************************/ 1108 1109 sal_Bool SvStream::WriteUniOrByteChar( sal_Unicode ch, rtl_TextEncoding eDestCharSet ) 1110 { 1111 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE ) 1112 *this << ch; 1113 else 1114 { 1115 ByteString aStr( ch, eDestCharSet ); 1116 Write( aStr.GetBuffer(), aStr.Len() ); 1117 } 1118 return nError == SVSTREAM_OK; 1119 } 1120 1121 /************************************************************************* 1122 |* 1123 |* Stream::StartWritingUnicodeText() 1124 |* 1125 *************************************************************************/ 1126 1127 sal_Bool SvStream::StartWritingUnicodeText() 1128 { 1129 SetEndianSwap( sal_False ); // write native format 1130 // BOM, Byte Order Mark, U+FEFF, see 1131 // http://www.unicode.org/faq/utf_bom.html#BOM 1132 // Upon read: 0xfeff(-257) => no swap; 0xfffe(-2) => swap 1133 *this << sal_uInt16( 0xfeff ); 1134 return nError == SVSTREAM_OK; 1135 } 1136 1137 /************************************************************************* 1138 |* 1139 |* Stream::StartReadingUnicodeText() 1140 |* 1141 *************************************************************************/ 1142 1143 sal_Bool SvStream::StartReadingUnicodeText( rtl_TextEncoding eReadBomCharSet ) 1144 { 1145 if (!( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW || 1146 eReadBomCharSet == RTL_TEXTENCODING_UNICODE || 1147 eReadBomCharSet == RTL_TEXTENCODING_UTF8)) 1148 return sal_True; // nothing to read 1149 1150 bool bTryUtf8 = false; 1151 sal_uInt16 nFlag; 1152 sal_sSize nBack = sizeof(nFlag); 1153 *this >> nFlag; 1154 switch ( nFlag ) 1155 { 1156 case 0xfeff : 1157 // native UTF-16 1158 if ( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW || 1159 eReadBomCharSet == RTL_TEXTENCODING_UNICODE) 1160 nBack = 0; 1161 break; 1162 case 0xfffe : 1163 // swapped UTF-16 1164 if ( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW || 1165 eReadBomCharSet == RTL_TEXTENCODING_UNICODE) 1166 { 1167 SetEndianSwap( !bSwap ); 1168 nBack = 0; 1169 } 1170 break; 1171 case 0xefbb : 1172 if (nNumberFormatInt == NUMBERFORMAT_INT_BIGENDIAN && 1173 (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW || 1174 eReadBomCharSet == RTL_TEXTENCODING_UTF8)) 1175 bTryUtf8 = true; 1176 break; 1177 case 0xbbef : 1178 if (nNumberFormatInt == NUMBERFORMAT_INT_LITTLEENDIAN && 1179 (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW || 1180 eReadBomCharSet == RTL_TEXTENCODING_UTF8)) 1181 bTryUtf8 = true; 1182 break; 1183 default: 1184 ; // nothing 1185 } 1186 if (bTryUtf8) 1187 { 1188 sal_uChar nChar; 1189 nBack += sizeof(nChar); 1190 *this >> nChar; 1191 if (nChar == 0xbf) 1192 nBack = 0; // it is UTF-8 1193 } 1194 if (nBack) 1195 SeekRel( -nBack ); // no BOM, pure data 1196 return nError == SVSTREAM_OK; 1197 } 1198 1199 /************************************************************************* 1200 |* 1201 |* Stream::ReadCsvLine() 1202 |* 1203 *************************************************************************/ 1204 1205 // Precondition: pStr is guaranteed to be non-NULL and points to a 0-terminated 1206 // array. 1207 inline const sal_Unicode* lcl_UnicodeStrChr( const sal_Unicode* pStr, 1208 sal_Unicode c ) 1209 { 1210 while (*pStr) 1211 { 1212 if (*pStr == c) 1213 return pStr; 1214 ++pStr; 1215 } 1216 return 0; 1217 } 1218 1219 sal_Bool SvStream::ReadCsvLine( String& rStr, sal_Bool bEmbeddedLineBreak, 1220 const String& rFieldSeparators, sal_Unicode cFieldQuote, 1221 sal_Bool bAllowBackslashEscape) 1222 { 1223 ReadUniOrByteStringLine( rStr); 1224 1225 if (bEmbeddedLineBreak) 1226 { 1227 const sal_Unicode* pSeps = rFieldSeparators.GetBuffer(); 1228 xub_StrLen nLastOffset = 0; 1229 bool isQuoted = false; 1230 bool isFieldStarting = true; 1231 while (!IsEof() && rStr.Len() < STRING_MAXLEN) 1232 { 1233 bool wasQuote = false; 1234 bool bBackslashEscaped = false; 1235 const sal_Unicode *p; 1236 p = rStr.GetBuffer(); 1237 p += nLastOffset; 1238 while (*p) 1239 { 1240 if (isQuoted) 1241 { 1242 if (*p == cFieldQuote && !bBackslashEscaped) 1243 wasQuote = !wasQuote; 1244 else 1245 { 1246 if (bAllowBackslashEscape) 1247 { 1248 if (*p == '\\') 1249 bBackslashEscaped = !bBackslashEscaped; 1250 else 1251 bBackslashEscaped = false; 1252 } 1253 if (wasQuote) 1254 { 1255 wasQuote = false; 1256 isQuoted = false; 1257 if (lcl_UnicodeStrChr( pSeps, *p )) 1258 isFieldStarting = true; 1259 } 1260 } 1261 } 1262 else 1263 { 1264 if (isFieldStarting) 1265 { 1266 isFieldStarting = false; 1267 if (*p == cFieldQuote) 1268 isQuoted = true; 1269 else if (lcl_UnicodeStrChr( pSeps, *p )) 1270 isFieldStarting = true; 1271 } 1272 else if (lcl_UnicodeStrChr( pSeps, *p )) 1273 isFieldStarting = true; 1274 } 1275 ++p; 1276 } 1277 1278 if (wasQuote) 1279 isQuoted = false; 1280 1281 if (isQuoted) 1282 { 1283 nLastOffset = rStr.Len(); 1284 String aNext; 1285 ReadUniOrByteStringLine( aNext); 1286 rStr += sal_Unicode(_LF); 1287 rStr += aNext; 1288 } 1289 else 1290 break; 1291 } 1292 } 1293 return nError == SVSTREAM_OK; 1294 } 1295 1296 /************************************************************************* 1297 |* 1298 |* Stream::SeekRel() 1299 |* 1300 |* Beschreibung STREAM.SDW 1301 |* Ersterstellung OV 08.06.94 1302 |* Letzte Aenderung OV 08.06.94 1303 |* 1304 *************************************************************************/ 1305 1306 sal_Size SvStream::SeekRel( sal_sSize nPos ) 1307 { 1308 sal_Size nActualPos = Tell(); 1309 1310 if ( nPos >= 0 ) 1311 { 1312 if ( SAL_MAX_SIZE - nActualPos > (sal_Size)nPos ) 1313 nActualPos += nPos; 1314 } 1315 else 1316 { 1317 sal_Size nAbsPos = (sal_Size)-nPos; 1318 if ( nActualPos >= nAbsPos ) 1319 nActualPos -= nAbsPos; 1320 } 1321 1322 pBufPos = pRWBuf + nActualPos; 1323 return Seek( nActualPos ); 1324 } 1325 1326 /************************************************************************* 1327 |* 1328 |* Stream::operator>>() 1329 |* 1330 |* Beschreibung STREAM.SDW 1331 |* Ersterstellung OV 08.06.94 1332 |* Letzte Aenderung OV 08.06.94 1333 |* 1334 *************************************************************************/ 1335 1336 SvStream& SvStream::operator >> ( sal_uInt16& r ) 1337 { 1338 READNUMBER_WITHOUT_SWAP(sal_uInt16,r) 1339 if( bSwap ) 1340 SwapUShort(r); 1341 return *this; 1342 } 1343 1344 SvStream& SvStream::operator>> ( sal_uInt32& r ) 1345 { 1346 READNUMBER_WITHOUT_SWAP(sal_uInt32,r) 1347 if( bSwap ) 1348 SwapULong(r); 1349 return *this; 1350 } 1351 1352 SvStream& SvStream::operator >> ( long& r ) 1353 { 1354 #if(SAL_TYPES_SIZEOFLONG != 4) 1355 int tmp = r; 1356 *this >> tmp; 1357 r = tmp; 1358 #else 1359 READNUMBER_WITHOUT_SWAP(long,r) 1360 if( bSwap ) 1361 SwapLong(r); 1362 #endif 1363 return *this; 1364 } 1365 1366 SvStream& SvStream::operator >> ( short& r ) 1367 { 1368 READNUMBER_WITHOUT_SWAP(short,r) 1369 if( bSwap ) 1370 SwapShort(r); 1371 return *this; 1372 } 1373 1374 SvStream& SvStream::operator >> ( int& r ) 1375 { 1376 READNUMBER_WITHOUT_SWAP(int,r) 1377 if( bSwap ) 1378 SwapLongInt(r); 1379 return *this; 1380 } 1381 1382 SvStream& SvStream::operator>>( signed char& r ) 1383 { 1384 if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && 1385 sizeof(signed char) <= nBufFree ) 1386 { 1387 r = *pBufPos; 1388 nBufActualPos += sizeof(signed char); 1389 pBufPos += sizeof(signed char); 1390 nBufFree -= sizeof(signed char); 1391 } 1392 else 1393 Read( (char*)&r, sizeof(signed char) ); 1394 return *this; 1395 } 1396 1397 // Sonderbehandlung fuer Chars wegen PutBack 1398 1399 SvStream& SvStream::operator>>( char& r ) 1400 { 1401 if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && 1402 sizeof(char) <= nBufFree ) 1403 { 1404 r = *pBufPos; 1405 nBufActualPos += sizeof(char); 1406 pBufPos += sizeof(char); 1407 nBufFree -= sizeof(char); 1408 } 1409 else 1410 Read( (char*)&r, sizeof(char) ); 1411 return *this; 1412 } 1413 1414 SvStream& SvStream::operator>>( unsigned char& r ) 1415 { 1416 if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && 1417 sizeof(char) <= nBufFree ) 1418 { 1419 r = *pBufPos; 1420 nBufActualPos += sizeof(char); 1421 pBufPos += sizeof(char); 1422 nBufFree -= sizeof(char); 1423 } 1424 else 1425 Read( (char*)&r, sizeof(char) ); 1426 return *this; 1427 } 1428 1429 SvStream& SvStream::operator>>( float& r ) 1430 { 1431 // Read( (char*)&r, sizeof(float) ); 1432 READNUMBER_WITHOUT_SWAP(float,r) 1433 #if defined UNX 1434 if( bSwap ) 1435 SwapFloat(r); 1436 #endif 1437 return *this; 1438 } 1439 1440 SvStream& SvStream::operator>>( double& r ) 1441 { 1442 // Read( (char*)&r, sizeof(double) ); 1443 READNUMBER_WITHOUT_SWAP(double,r) 1444 #if defined UNX 1445 if( bSwap ) 1446 SwapDouble(r); 1447 #endif 1448 return *this; 1449 } 1450 1451 SvStream& SvStream::operator>> ( SvStream& rStream ) 1452 { 1453 const sal_uInt32 cBufLen = 0x8000; 1454 char* pBuf = new char[ cBufLen ]; 1455 1456 sal_uInt32 nCount; 1457 do { 1458 nCount = Read( pBuf, cBufLen ); 1459 rStream.Write( pBuf, nCount ); 1460 } while( nCount == cBufLen ); 1461 1462 delete[] pBuf; 1463 return *this; 1464 } 1465 1466 /************************************************************************* 1467 |* 1468 |* Stream::operator<<() 1469 |* 1470 |* Beschreibung STREAM.SDW 1471 |* Ersterstellung OV 08.06.94 1472 |* Letzte Aenderung OV 08.06.94 1473 |* 1474 *************************************************************************/ 1475 1476 SvStream& SvStream::operator<< ( sal_uInt16 v ) 1477 { 1478 if( bSwap ) 1479 SwapUShort(v); 1480 WRITENUMBER_WITHOUT_SWAP(sal_uInt16,v) 1481 return *this; 1482 } 1483 1484 SvStream& SvStream::operator<< ( sal_uInt32 v ) 1485 { 1486 if( bSwap ) 1487 SwapULong(v); 1488 WRITENUMBER_WITHOUT_SWAP(sal_uInt32,v) 1489 return *this; 1490 } 1491 1492 SvStream& SvStream::operator<< ( long v ) 1493 { 1494 #if(SAL_TYPES_SIZEOFLONG != 4) 1495 int tmp = v; 1496 *this << tmp; 1497 #else 1498 if( bSwap ) 1499 SwapLong(v); 1500 WRITENUMBER_WITHOUT_SWAP(long,v) 1501 #endif 1502 return *this; 1503 } 1504 1505 SvStream& SvStream::operator<< ( short v ) 1506 { 1507 if( bSwap ) 1508 SwapShort(v); 1509 WRITENUMBER_WITHOUT_SWAP(short,v) 1510 return *this; 1511 } 1512 1513 SvStream& SvStream::operator<<( int v ) 1514 { 1515 if( bSwap ) 1516 SwapLongInt( v ); 1517 WRITENUMBER_WITHOUT_SWAP(int,v) 1518 return *this; 1519 } 1520 1521 SvStream& SvStream::operator<< ( signed char v ) 1522 { 1523 //SDO 1524 int tmp = eIOMode; 1525 if(tmp == STREAM_IO_WRITE && sizeof(signed char) <= nBufFree ) 1526 { 1527 *pBufPos = v; 1528 pBufPos++; // sizeof(char); 1529 nBufActualPos++; 1530 if( nBufActualPos > nBufActualLen ) // Append ? 1531 nBufActualLen = nBufActualPos; 1532 nBufFree--; // = sizeof(char); 1533 bIsDirty = sal_True; 1534 } 1535 else 1536 Write( (char*)&v, sizeof(signed char) ); 1537 return *this; 1538 } 1539 1540 // Sonderbehandlung fuer chars wegen PutBack 1541 1542 SvStream& SvStream::operator<< ( char v ) 1543 { 1544 //SDO 1545 int tmp = eIOMode; 1546 if(tmp == STREAM_IO_WRITE && sizeof(char) <= nBufFree ) 1547 { 1548 *pBufPos = v; 1549 pBufPos++; // sizeof(char); 1550 nBufActualPos++; 1551 if( nBufActualPos > nBufActualLen ) // Append ? 1552 nBufActualLen = nBufActualPos; 1553 nBufFree--; // = sizeof(char); 1554 bIsDirty = sal_True; 1555 } 1556 else 1557 Write( (char*)&v, sizeof(char) ); 1558 return *this; 1559 } 1560 1561 SvStream& SvStream::operator<< ( unsigned char v ) 1562 { 1563 //SDO 1564 int tmp = eIOMode; 1565 if(tmp == STREAM_IO_WRITE && sizeof(char) <= nBufFree ) 1566 { 1567 *(unsigned char*)pBufPos = v; 1568 pBufPos++; // = sizeof(char); 1569 nBufActualPos++; // = sizeof(char); 1570 if( nBufActualPos > nBufActualLen ) // Append ? 1571 nBufActualLen = nBufActualPos; 1572 nBufFree--; 1573 bIsDirty = sal_True; 1574 } 1575 else 1576 Write( (char*)&v, sizeof(char) ); 1577 return *this; 1578 } 1579 1580 SvStream& SvStream::operator<< ( float v ) 1581 { 1582 #ifdef UNX 1583 if( bSwap ) 1584 SwapFloat(v); 1585 #endif 1586 WRITENUMBER_WITHOUT_SWAP(float,v) 1587 return *this; 1588 } 1589 1590 SvStream& SvStream::operator<< ( const double& r ) 1591 { 1592 // Write( (char*)&r, sizeof( double ) ); 1593 #if defined UNX 1594 if( bSwap ) 1595 { 1596 double nHelp = r; 1597 SwapDouble(nHelp); 1598 WRITENUMBER_WITHOUT_SWAP(double,nHelp) 1599 return *this; 1600 } 1601 else 1602 #endif 1603 WRITENUMBER_WITHOUT_SWAP(double,r) 1604 1605 return *this; 1606 } 1607 1608 SvStream& SvStream::operator<< ( const char* pBuf ) 1609 { 1610 Write( pBuf, strlen( pBuf ) ); 1611 return *this; 1612 } 1613 1614 SvStream& SvStream::operator<< ( const unsigned char* pBuf ) 1615 { 1616 Write( (char*)pBuf, strlen( (char*)pBuf ) ); 1617 return *this; 1618 } 1619 1620 SvStream& SvStream::operator<< ( SvStream& rStream ) 1621 { 1622 const sal_uInt32 cBufLen = 0x8000; 1623 char* pBuf = new char[ cBufLen ]; 1624 sal_uInt32 nCount; 1625 do { 1626 nCount = rStream.Read( pBuf, cBufLen ); 1627 Write( pBuf, nCount ); 1628 } while( nCount == cBufLen ); 1629 1630 delete[] pBuf; 1631 return *this; 1632 } 1633 1634 // ----------------------------------------------------------------------- 1635 1636 SvStream& SvStream::ReadByteString( UniString& rStr, rtl_TextEncoding eSrcCharSet ) 1637 { 1638 // read UTF-16 string directly from stream ? 1639 if (eSrcCharSet == RTL_TEXTENCODING_UNICODE) 1640 { 1641 sal_uInt32 nLen; 1642 operator>> (nLen); 1643 if (nLen) 1644 { 1645 if (nLen > STRING_MAXLEN) { 1646 SetError(SVSTREAM_GENERALERROR); 1647 return *this; 1648 } 1649 sal_Unicode *pStr = rStr.AllocBuffer( 1650 static_cast< xub_StrLen >(nLen)); 1651 BOOST_STATIC_ASSERT(STRING_MAXLEN <= SAL_MAX_SIZE / 2); 1652 Read( pStr, nLen << 1 ); 1653 1654 if (bSwap) 1655 for (sal_Unicode *pEnd = pStr + nLen; pStr < pEnd; pStr++) 1656 SwapUShort(*pStr); 1657 } 1658 else 1659 rStr.Erase(); 1660 1661 return *this; 1662 } 1663 1664 ByteString aStr; 1665 ReadByteString( aStr ); 1666 rStr = UniString( aStr, eSrcCharSet ); 1667 return *this; 1668 } 1669 1670 // ----------------------------------------------------------------------- 1671 1672 SvStream& SvStream::ReadByteString( ByteString& rStr ) 1673 { 1674 sal_uInt16 nLen = 0; 1675 operator>>( nLen ); 1676 if( nLen ) 1677 { 1678 char* pTmp = rStr.AllocBuffer( nLen ); 1679 nLen = (sal_uInt16)Read( pTmp, nLen ); 1680 } 1681 else 1682 rStr.Erase(); 1683 return *this; 1684 } 1685 1686 // ----------------------------------------------------------------------- 1687 1688 SvStream& SvStream::WriteByteString( const UniString& rStr, rtl_TextEncoding eDestCharSet ) 1689 { 1690 // write UTF-16 string directly into stream ? 1691 if (eDestCharSet == RTL_TEXTENCODING_UNICODE) 1692 { 1693 sal_uInt32 nLen = rStr.Len(); 1694 operator<< (nLen); 1695 if (nLen) 1696 { 1697 if (bSwap) 1698 { 1699 const sal_Unicode *pStr = rStr.GetBuffer(); 1700 const sal_Unicode *pEnd = pStr + nLen; 1701 1702 for (; pStr < pEnd; pStr++) 1703 { 1704 sal_Unicode c = *pStr; 1705 SwapUShort(c); 1706 WRITENUMBER_WITHOUT_SWAP(sal_uInt16,c) 1707 } 1708 } 1709 else 1710 Write( rStr.GetBuffer(), nLen << 1 ); 1711 } 1712 1713 return *this; 1714 } 1715 1716 return WriteByteString(ByteString( rStr, eDestCharSet )); 1717 } 1718 1719 // ----------------------------------------------------------------------- 1720 1721 SvStream& SvStream::WriteByteString( const ByteString& rStr) 1722 { 1723 sal_uInt16 nLen = rStr.Len(); 1724 operator<< ( nLen ); 1725 if( nLen != 0 ) 1726 Write( rStr.GetBuffer(), nLen ); 1727 return *this; 1728 } 1729 1730 /************************************************************************* 1731 |* 1732 |* Stream::Read() 1733 |* 1734 |* Beschreibung STREAM.SDW 1735 |* Ersterstellung OV 08.06.94 1736 |* Letzte Aenderung OV 08.06.94 1737 |* 1738 *************************************************************************/ 1739 1740 sal_Size SvStream::Read( void* pData, sal_Size nCount ) 1741 { 1742 sal_Size nSaveCount = nCount; 1743 if( !bIsConsistent ) 1744 RefreshBuffer(); 1745 1746 if( !pRWBuf ) 1747 { 1748 nCount = GetData( (char*)pData,nCount); 1749 if( nCryptMask ) 1750 EncryptBuffer(pData, nCount); 1751 nBufFilePos += nCount; 1752 } 1753 else 1754 { 1755 // ist Block komplett im Puffer 1756 eIOMode = STREAM_IO_READ; 1757 if( nCount <= (sal_Size)(nBufActualLen - nBufActualPos ) ) 1758 { 1759 // Ja! 1760 memcpy(pData, pBufPos, (size_t) nCount); 1761 nBufActualPos = nBufActualPos + (sal_uInt16)nCount; 1762 pBufPos += nCount; 1763 nBufFree = nBufFree - (sal_uInt16)nCount; 1764 } 1765 else 1766 { 1767 if( bIsDirty ) // Flushen ? 1768 { 1769 SeekPos( nBufFilePos ); 1770 if( nCryptMask ) 1771 CryptAndWriteBuffer(pRWBuf, nBufActualLen); 1772 else 1773 PutData( pRWBuf, nBufActualLen ); 1774 bIsDirty = sal_False; 1775 } 1776 1777 // passt der Datenblock in den Puffer ? 1778 if( nCount > nBufSize ) 1779 { 1780 // Nein! Deshalb ohne Umweg ueber den Puffer direkt 1781 // in den Zielbereich einlesen 1782 1783 eIOMode = STREAM_IO_DONTKNOW; 1784 1785 SeekPos( nBufFilePos + nBufActualPos ); 1786 nBufActualLen = 0; 1787 pBufPos = pRWBuf; 1788 nCount = GetData( (char*)pData, nCount ); 1789 if( nCryptMask ) 1790 EncryptBuffer(pData, nCount); 1791 nBufFilePos += nCount; 1792 nBufFilePos += nBufActualPos; 1793 nBufActualPos = 0; 1794 } 1795 else 1796 { 1797 // Der Datenblock passt komplett in den Puffer. Deshalb 1798 // Puffer fuellen und dann die angeforderten Daten in den 1799 // Zielbereich kopieren. 1800 1801 nBufFilePos += nBufActualPos; 1802 SeekPos( nBufFilePos ); 1803 1804 // TODO: Typecast vor GetData, sal_uInt16 nCountTmp 1805 sal_Size nCountTmp = GetData( pRWBuf, nBufSize ); 1806 if( nCryptMask ) 1807 EncryptBuffer(pRWBuf, nCountTmp); 1808 nBufActualLen = (sal_uInt16)nCountTmp; 1809 if( nCount > nCountTmp ) 1810 { 1811 nCount = nCountTmp; // zurueckstutzen, Eof siehe unten 1812 } 1813 memcpy( pData, pRWBuf, (size_t)nCount ); 1814 nBufActualPos = (sal_uInt16)nCount; 1815 pBufPos = pRWBuf + nCount; 1816 } 1817 } 1818 } 1819 bIsEof = sal_False; 1820 nBufFree = nBufActualLen - nBufActualPos; 1821 if( nCount != nSaveCount && nError != ERRCODE_IO_PENDING ) 1822 bIsEof = sal_True; 1823 if( nCount == nSaveCount && nError == ERRCODE_IO_PENDING ) 1824 nError = ERRCODE_NONE; 1825 return nCount; 1826 } 1827 1828 /************************************************************************* 1829 |* 1830 |* Stream::Write() 1831 |* 1832 |* Beschreibung STREAM.SDW 1833 |* Ersterstellung OV 08.06.94 1834 |* Letzte Aenderung OV 08.06.94 1835 |* 1836 *************************************************************************/ 1837 1838 sal_Size SvStream::Write( const void* pData, sal_Size nCount ) 1839 { 1840 if( !nCount ) 1841 return 0; 1842 if( !bIsWritable ) 1843 { 1844 SetError( ERRCODE_IO_CANTWRITE ); 1845 return 0; 1846 } 1847 if( !bIsConsistent ) 1848 RefreshBuffer(); // Aenderungen des Puffers durch PutBack loeschen 1849 1850 if( !pRWBuf ) 1851 { 1852 if( nCryptMask ) 1853 nCount = CryptAndWriteBuffer( pData, nCount ); 1854 else 1855 nCount = PutData( (char*)pData, nCount ); 1856 nBufFilePos += nCount; 1857 return nCount; 1858 } 1859 1860 eIOMode = STREAM_IO_WRITE; 1861 if( nCount <= (sal_Size)(nBufSize - nBufActualPos) ) 1862 { 1863 memcpy( pBufPos, pData, (size_t)nCount ); 1864 nBufActualPos = nBufActualPos + (sal_uInt16)nCount; 1865 // wurde der Puffer erweitert ? 1866 if( nBufActualPos > nBufActualLen ) 1867 nBufActualLen = nBufActualPos; 1868 1869 pBufPos += nCount; 1870 bIsDirty = sal_True; 1871 } 1872 else 1873 { 1874 // Flushen ? 1875 if( bIsDirty ) 1876 { 1877 SeekPos( nBufFilePos ); 1878 if( nCryptMask ) 1879 CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen ); 1880 else 1881 PutData( pRWBuf, nBufActualLen ); 1882 bIsDirty = sal_False; 1883 } 1884 1885 // passt der Block in den Puffer ? 1886 if( nCount > nBufSize ) 1887 { 1888 eIOMode = STREAM_IO_DONTKNOW; 1889 nBufFilePos += nBufActualPos; 1890 nBufActualLen = 0; 1891 nBufActualPos = 0; 1892 pBufPos = pRWBuf; 1893 SeekPos( nBufFilePos ); 1894 if( nCryptMask ) 1895 nCount = CryptAndWriteBuffer( pData, nCount ); 1896 else 1897 nCount = PutData( (char*)pData, nCount ); 1898 nBufFilePos += nCount; 1899 } 1900 else 1901 { 1902 // Block in Puffer stellen 1903 memcpy( pRWBuf, pData, (size_t)nCount ); 1904 1905 // Reihenfolge! 1906 nBufFilePos += nBufActualPos; 1907 nBufActualPos = (sal_uInt16)nCount; 1908 pBufPos = pRWBuf + nCount; 1909 nBufActualLen = (sal_uInt16)nCount; 1910 bIsDirty = sal_True; 1911 } 1912 } 1913 nBufFree = nBufSize - nBufActualPos; 1914 return nCount; 1915 } 1916 1917 1918 /************************************************************************* 1919 |* 1920 |* Stream::Seek() 1921 |* 1922 |* Beschreibung STREAM.SDW 1923 |* Ersterstellung OV 08.06.94 1924 |* Letzte Aenderung OV 08.06.94 1925 |* 1926 *************************************************************************/ 1927 1928 sal_Size SvStream::Seek( sal_Size nFilePos ) 1929 { 1930 eIOMode = STREAM_IO_DONTKNOW; 1931 1932 bIsEof = sal_False; 1933 if( !pRWBuf ) 1934 { 1935 nBufFilePos = SeekPos( nFilePos ); 1936 DBG_ASSERT(Tell()==nBufFilePos,"Out Of Sync!"); 1937 return nBufFilePos; 1938 } 1939 1940 // Ist Position im Puffer ? 1941 if( nFilePos >= nBufFilePos && nFilePos <= (nBufFilePos + nBufActualLen)) 1942 { 1943 nBufActualPos = (sal_uInt16)(nFilePos - nBufFilePos); 1944 pBufPos = pRWBuf + nBufActualPos; 1945 // nBufFree korrigieren, damit wir nicht von einem 1946 // PutBack (ignoriert den StreamMode) getoetet werden 1947 nBufFree = nBufActualLen - nBufActualPos; 1948 } 1949 else 1950 { 1951 if( bIsDirty && bIsConsistent) 1952 { 1953 SeekPos( nBufFilePos ); 1954 if( nCryptMask ) 1955 CryptAndWriteBuffer( pRWBuf, nBufActualLen ); 1956 else 1957 PutData( pRWBuf, nBufActualLen ); 1958 bIsDirty = sal_False; 1959 } 1960 nBufActualLen = 0; 1961 nBufActualPos = 0; 1962 pBufPos = pRWBuf; 1963 nBufFilePos = SeekPos( nFilePos ); 1964 } 1965 #ifdef OV_DEBUG 1966 { 1967 sal_Size nDebugTemp = nBufFilePos + nBufActualPos; 1968 DBG_ASSERT(Tell()==nDebugTemp,"Sync?"); 1969 } 1970 #endif 1971 return nBufFilePos + nBufActualPos; 1972 } 1973 1974 /************************************************************************* 1975 |* 1976 |* Stream::Flush() 1977 |* 1978 |* Beschreibung STREAM.SDW 1979 |* Ersterstellung OV 08.06.94 1980 |* Letzte Aenderung OV 08.06.94 1981 |* 1982 *************************************************************************/ 1983 1984 void SvStream::Flush() 1985 { 1986 if( bIsDirty && bIsConsistent ) 1987 { 1988 SeekPos( nBufFilePos ); 1989 if( nCryptMask ) 1990 CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen ); 1991 else 1992 if( PutData( pRWBuf, nBufActualLen ) != nBufActualLen ) 1993 SetError( SVSTREAM_WRITE_ERROR ); 1994 bIsDirty = sal_False; 1995 } 1996 if( bIsWritable ) 1997 FlushData(); 1998 } 1999 2000 2001 /************************************************************************* 2002 |* 2003 |* Stream::PutBack() 2004 |* 2005 |* Beschreibung STREAM.SDW 2006 |* Ersterstellung OV 01.08.94 2007 |* Letzte Aenderung OV 01.08.94 2008 |* 2009 *************************************************************************/ 2010 2011 /* 2012 4 Faelle : 2013 2014 1. Datenzeiger steht mitten im Puffer (nBufActualPos >= 1) 2015 2. Datenzeiger auf Position 0, Puffer ist voll 2016 3. Datenzeiger auf Position 0, Puffer ist teilweise gefuellt 2017 4. Datenzeiger auf Position 0, Puffer ist leer -> Fehler! 2018 */ 2019 2020 SvStream& SvStream::PutBack( char aCh ) 2021 { 2022 // wenn kein Buffer oder Zurueckscrollen nicht moeglich -> Fehler 2023 if( !pRWBuf || !nBufActualLen || ( !nBufActualPos && !nBufFilePos ) ) 2024 { 2025 // 4. Fall 2026 SetError( SVSTREAM_GENERALERROR ); 2027 return *this; 2028 } 2029 2030 // Flush() (Phys. Flushen aber nicht notwendig, deshalb selbst schreiben) 2031 if( bIsConsistent && bIsDirty ) 2032 { 2033 SeekPos( nBufFilePos ); 2034 if( nCryptMask ) 2035 CryptAndWriteBuffer( pRWBuf, nBufActualLen ); 2036 else 2037 PutData( pRWBuf, nBufActualLen ); 2038 bIsDirty = sal_False; 2039 } 2040 bIsConsistent = sal_False; // Puffer enthaelt jetzt TRASH 2041 if( nBufActualPos ) 2042 { 2043 // 1. Fall 2044 nBufActualPos--; 2045 pBufPos--; 2046 *pBufPos = aCh; 2047 nBufFree++; 2048 } 2049 else // Puffer muss verschoben werden 2050 { 2051 // Ist Puffer am Anschlag ? 2052 if( nBufSize == nBufActualLen ) 2053 { 2054 // 2. Fall 2055 memmove( pRWBuf+1, pRWBuf, nBufSize-1 ); 2056 // nBufFree behaelt den Wert! 2057 } 2058 else 2059 { 2060 // 3. Fall -> Puffer vergroessern 2061 memmove( pRWBuf+1, pRWBuf, (sal_uInt16)nBufActualLen ); 2062 nBufActualLen++; 2063 nBufFree++; 2064 } 2065 nBufFilePos--; 2066 *pRWBuf = aCh; 2067 } 2068 eIOMode = STREAM_IO_DONTKNOW; 2069 bIsEof = sal_False; 2070 return *this; 2071 } 2072 2073 /************************************************************************* 2074 |* 2075 |* Stream::EatWhite() 2076 |* 2077 |* Beschreibung STREAM.SDW 2078 |* Ersterstellung OV 01.08.94 2079 |* Letzte Aenderung OV 01.08.94 2080 |* 2081 *************************************************************************/ 2082 2083 void SvStream::EatWhite() 2084 { 2085 char aCh; 2086 Read(&aCh, sizeof(char) ); 2087 while( !bIsEof && isspace((int)aCh) ) //( aCh == ' ' || aCh == '\t' ) ) 2088 Read(&aCh, sizeof(char) ); 2089 if( !bIsEof ) // konnte das letzte Char gelesen werden ? 2090 SeekRel( -1L ); 2091 } 2092 2093 /************************************************************************* 2094 |* 2095 |* Stream::RefreshBuffer() 2096 |* 2097 |* Beschreibung STREAM.SDW 2098 |* Ersterstellung OV 01.08.94 2099 |* Letzte Aenderung OV 01.08.94 2100 |* 2101 *************************************************************************/ 2102 2103 void SvStream::RefreshBuffer() 2104 { 2105 if( bIsDirty && bIsConsistent ) 2106 { 2107 SeekPos( nBufFilePos ); 2108 if( nCryptMask ) 2109 CryptAndWriteBuffer( pRWBuf, (sal_Size)nBufActualLen ); 2110 else 2111 PutData( pRWBuf, nBufActualLen ); 2112 bIsDirty = sal_False; 2113 } 2114 SeekPos( nBufFilePos ); 2115 nBufActualLen = (sal_uInt16)GetData( pRWBuf, nBufSize ); 2116 if( nBufActualLen && nError == ERRCODE_IO_PENDING ) 2117 nError = ERRCODE_NONE; 2118 if( nCryptMask ) 2119 EncryptBuffer(pRWBuf, (sal_Size)nBufActualLen); 2120 bIsConsistent = sal_True; 2121 eIOMode = STREAM_IO_DONTKNOW; 2122 } 2123 2124 2125 /************************************************************************* 2126 |* 2127 |* Stream::CreateFormatString() 2128 |* 2129 |* Beschreibung Baut Formatstring zusammen 2130 |* Ersterstellung OV 08.06.94 2131 |* Letzte Aenderung OV 08.06.94 2132 |* 2133 *************************************************************************/ 2134 2135 void SvStream::CreateFormatString() 2136 { 2137 aFormatString = '%'; 2138 nPrintfParams = SPECIAL_PARAM_NONE; 2139 2140 if( nJustification ) 2141 { 2142 aFormatString += '-'; 2143 } 2144 2145 if( nWidth ) 2146 { 2147 if( cFiller != ' ' ) 2148 aFormatString += '0'; 2149 aFormatString += '*'; 2150 nPrintfParams = SPECIAL_PARAM_WIDTH; 2151 } 2152 2153 if( nPrecision ) 2154 { 2155 aFormatString += ".*"; 2156 if( nWidth ) 2157 nPrintfParams = SPECIAL_PARAM_BOTH; 2158 else 2159 nPrintfParams = SPECIAL_PARAM_PRECISION; 2160 } 2161 } 2162 2163 /************************************************************************* 2164 |* 2165 |* Stream::ReadNumber() 2166 |* 2167 |* Beschreibung STREAM.SDW 2168 |* Ersterstellung OV 08.06.94 2169 |* Letzte Aenderung OV 08.06.94 2170 |* 2171 *************************************************************************/ 2172 2173 #define BUFSIZE_LONG 21 // log( 2 hoch 64 ) + 1 2174 2175 SvStream& SvStream::ReadNumber( long& rLong ) 2176 { 2177 EatWhite(); 2178 if( bIsEof || nError ) 2179 { 2180 SetError( SVSTREAM_GENERALERROR ); 2181 return *this; 2182 } 2183 sal_Size nFPtr = Tell(); 2184 char buf[ BUFSIZE_LONG ]; 2185 memset( buf, 0, BUFSIZE_LONG ); 2186 sal_Size nTemp = Read( buf, BUFSIZE_LONG-1 ); 2187 if( !nTemp || nError ) 2188 { 2189 SetError( SVSTREAM_GENERALERROR ); 2190 return *this; 2191 } 2192 char *pEndPtr; 2193 rLong = strtol( buf, &pEndPtr, (int)nRadix ); 2194 nFPtr += ( (sal_Size)pEndPtr - (sal_Size)(&(buf[0])) ); 2195 Seek( nFPtr ); 2196 bIsEof = sal_False; 2197 return *this; 2198 } 2199 2200 SvStream& SvStream::ReadNumber( sal_uInt32& rUInt32 ) 2201 { 2202 EatWhite(); 2203 if( bIsEof || nError ) 2204 { 2205 SetError( SVSTREAM_GENERALERROR ); 2206 return *this; 2207 } 2208 sal_Size nFPtr = Tell(); 2209 char buf[ BUFSIZE_LONG ]; 2210 memset( buf, 0, BUFSIZE_LONG ); 2211 sal_Size nTemp = Read( buf, BUFSIZE_LONG-1 ); 2212 if( !nTemp || nError ) 2213 { 2214 SetError( SVSTREAM_GENERALERROR ); 2215 return *this; 2216 } 2217 char *pEndPtr; 2218 rUInt32 = strtoul( buf, &pEndPtr, (int)nRadix ); 2219 nFPtr += ( (sal_uIntPtr)pEndPtr - (sal_uIntPtr)buf ); 2220 Seek( nFPtr ); 2221 bIsEof = sal_False; 2222 return *this; 2223 } 2224 2225 SvStream& SvStream::ReadNumber( double& rDouble ) 2226 { 2227 EatWhite(); 2228 if( bIsEof || nError ) 2229 { 2230 SetError( SVSTREAM_GENERALERROR ); 2231 return *this; 2232 } 2233 sal_Size nFPtr = Tell(); 2234 char buf[ BUFSIZE_LONG ]; 2235 memset( buf, 0, BUFSIZE_LONG ); 2236 sal_Size nTemp = Read( buf, BUFSIZE_LONG-1 ); 2237 if( !nTemp || nError ) 2238 { 2239 SetError( SVSTREAM_GENERALERROR ); 2240 return *this; 2241 } 2242 char *pEndPtr; 2243 rDouble = strtod( buf, &pEndPtr ); 2244 nFPtr += ( (sal_Size)pEndPtr - (sal_Size)buf ); 2245 Seek( nFPtr ); 2246 bIsEof = sal_False; 2247 return *this; 2248 } 2249 2250 2251 /************************************************************************* 2252 |* 2253 |* Stream::WriteNumber() 2254 |* 2255 |* Beschreibung STREAM.SDW 2256 |* Ersterstellung OV 08.06.94 2257 |* Letzte Aenderung OV 08.06.94 2258 |* 2259 *************************************************************************/ 2260 2261 SvStream& SvStream::WriteNumber( long nLong ) 2262 { 2263 char buffer[256+12]; 2264 char pType[] = "ld"; // Nicht static! 2265 if( nRadix == 16 ) 2266 pType[1] = 'x'; 2267 else if( nRadix == 8 ) 2268 pType[1] = 'o'; 2269 ByteString aFStr( aFormatString); 2270 aFStr += pType; 2271 int nLen; 2272 switch ( nPrintfParams ) 2273 { 2274 case SPECIAL_PARAM_NONE : 2275 nLen = sprintf( buffer, aFStr.GetBuffer(), nLong ); 2276 break; 2277 case SPECIAL_PARAM_WIDTH : 2278 nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, nLong ); 2279 break; 2280 case SPECIAL_PARAM_PRECISION : 2281 nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision,nLong); 2282 break; 2283 default: 2284 nLen=sprintf(buffer, aFStr.GetBuffer(),nWidth,nPrecision,nLong); 2285 } 2286 Write( buffer, (long)nLen ); 2287 return *this; 2288 } 2289 2290 SvStream& SvStream::WriteNumber( sal_uInt32 nUInt32 ) 2291 { 2292 char buffer[256+12]; 2293 char pType[] = "lu"; // Nicht static! 2294 if( nRadix == 16 ) 2295 pType[1] = 'x'; 2296 else if( nRadix == 8 ) 2297 pType[1] = 'o'; 2298 ByteString aFStr( aFormatString); 2299 aFStr += pType; 2300 int nLen; 2301 switch ( nPrintfParams ) 2302 { 2303 case SPECIAL_PARAM_NONE : 2304 nLen = sprintf( buffer, aFStr.GetBuffer(), nUInt32 ); 2305 break; 2306 case SPECIAL_PARAM_WIDTH : 2307 nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, nUInt32 ); 2308 break; 2309 case SPECIAL_PARAM_PRECISION : 2310 nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision, nUInt32 ); 2311 break; 2312 default: 2313 nLen=sprintf(buffer,aFStr.GetBuffer(),nWidth,nPrecision,nUInt32 ); 2314 } 2315 Write( buffer, (long)nLen ); 2316 return *this; 2317 } 2318 2319 2320 SvStream& SvStream::WriteNumber( const double& rDouble ) 2321 { 2322 char buffer[256+24]; 2323 ByteString aFStr( aFormatString); 2324 aFStr += "lf"; 2325 int nLen; 2326 switch ( nPrintfParams ) 2327 { 2328 case SPECIAL_PARAM_NONE : 2329 nLen = sprintf( buffer, aFStr.GetBuffer(), rDouble ); 2330 break; 2331 case SPECIAL_PARAM_WIDTH : 2332 nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, rDouble ); 2333 break; 2334 case SPECIAL_PARAM_PRECISION : 2335 nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision, rDouble); 2336 break; 2337 default: 2338 nLen=sprintf(buffer, aFStr.GetBuffer(),nWidth,nPrecision,rDouble); 2339 } 2340 Write( buffer, (long)nLen ); 2341 return *this; 2342 } 2343 2344 /************************************************************************* 2345 |* 2346 |* Stream::CryptAndWriteBuffer() 2347 |* 2348 |* Beschreibung Verschluesseln und Schreiben 2349 |* Ersterstellung OV 08.06.94 2350 |* Letzte Aenderung OV 08.06.94 2351 |* 2352 *************************************************************************/ 2353 2354 #define CRYPT_BUFSIZE 1024 2355 2356 sal_Size SvStream::CryptAndWriteBuffer( const void* pStart, sal_Size nLen) 2357 { 2358 unsigned char pTemp[CRYPT_BUFSIZE]; 2359 unsigned char* pDataPtr = (unsigned char*)pStart; 2360 sal_Size nCount = 0; 2361 sal_Size nBufCount; 2362 unsigned char nMask = nCryptMask; 2363 do 2364 { 2365 if( nLen >= CRYPT_BUFSIZE ) 2366 nBufCount = CRYPT_BUFSIZE; 2367 else 2368 nBufCount = nLen; 2369 nLen -= nBufCount; 2370 memcpy( pTemp, pDataPtr, (sal_uInt16)nBufCount ); 2371 // **** Verschluesseln ***** 2372 for ( sal_uInt16 n=0; n < CRYPT_BUFSIZE; n++ ) 2373 { 2374 unsigned char aCh = pTemp[n]; 2375 aCh ^= nMask; 2376 SWAPNIBBLES(aCh) 2377 pTemp[n] = aCh; 2378 } 2379 // ************************* 2380 nCount += PutData( (char*)pTemp, nBufCount ); 2381 pDataPtr += nBufCount; 2382 } 2383 while ( nLen ); 2384 return nCount; 2385 } 2386 2387 /************************************************************************* 2388 |* 2389 |* Stream::EncryptBuffer() 2390 |* 2391 |* Beschreibung Buffer entschluesseln 2392 |* Ersterstellung OV 08.06.94 2393 |* Letzte Aenderung OV 08.06.94 2394 |* 2395 *************************************************************************/ 2396 2397 sal_Bool SvStream::EncryptBuffer(void* pStart, sal_Size nLen) 2398 { 2399 unsigned char* pTemp = (unsigned char*)pStart; 2400 unsigned char nMask = nCryptMask; 2401 2402 for ( sal_Size n=0; n < nLen; n++, pTemp++ ) 2403 { 2404 unsigned char aCh = *pTemp; 2405 SWAPNIBBLES(aCh) 2406 aCh ^= nMask; 2407 *pTemp = aCh; 2408 } 2409 return sal_True; 2410 } 2411 2412 /************************************************************************* 2413 |* 2414 |* Stream::SetKey() 2415 |* 2416 |* Beschreibung STREAM.SDW 2417 |* Ersterstellung OV 08.06.94 2418 |* Letzte Aenderung OV 08.06.94 2419 |* 2420 *************************************************************************/ 2421 2422 unsigned char implGetCryptMask(const sal_Char* pStr, sal_Int32 nLen, long nVersion) 2423 { 2424 unsigned char nCryptMask = 0; 2425 2426 if (!nLen) 2427 return nCryptMask; 2428 2429 if( nVersion <= SOFFICE_FILEFORMAT_31 ) 2430 { 2431 while( nLen ) 2432 { 2433 nCryptMask ^= *pStr; 2434 pStr++; 2435 nLen--; 2436 } 2437 } 2438 else // BugFix #25888# 2439 { 2440 for( sal_uInt16 i = 0; i < nLen; i++ ) { 2441 nCryptMask ^= pStr[i]; 2442 if( nCryptMask & 0x80 ) { 2443 nCryptMask <<= 1; 2444 nCryptMask++; 2445 } 2446 else 2447 nCryptMask <<= 1; 2448 } 2449 } 2450 2451 if( !nCryptMask ) 2452 nCryptMask = 67; 2453 2454 return nCryptMask; 2455 } 2456 2457 void SvStream::SetKey( const ByteString& rKey ) 2458 { 2459 aKey = rKey; 2460 nCryptMask = implGetCryptMask( aKey.GetBuffer(), aKey.Len(), GetVersion() ); 2461 } 2462 2463 /************************************************************************* 2464 |* 2465 |* Stream::SyncSvStream() 2466 |* 2467 |* Beschreibung STREAM.SDW 2468 |* Ersterstellung OV 08.06.94 2469 |* Letzte Aenderung OV 08.06.94 2470 |* 2471 *************************************************************************/ 2472 2473 void SvStream::SyncSvStream( sal_Size nNewStreamPos ) 2474 { 2475 ClearBuffer(); 2476 SvStream::nBufFilePos = nNewStreamPos; 2477 } 2478 2479 /************************************************************************* 2480 |* 2481 |* Stream::SyncSysStream() 2482 |* 2483 |* Beschreibung STREAM.SDW 2484 |* Ersterstellung OV 08.06.94 2485 |* Letzte Aenderung OV 08.06.94 2486 |* 2487 *************************************************************************/ 2488 2489 void SvStream::SyncSysStream() 2490 { 2491 Flush(); 2492 SeekPos( Tell() ); 2493 } 2494 2495 /************************************************************************* 2496 |* 2497 |* Stream::SetStreamSize() 2498 |* 2499 |* Beschreibung STREAM.SDW 2500 |* Ersterstellung OV 08.06.94 2501 |* Letzte Aenderung OV 08.06.94 2502 |* 2503 *************************************************************************/ 2504 2505 sal_Bool SvStream::SetStreamSize( sal_Size nSize ) 2506 { 2507 #ifdef DBG_UTIL 2508 sal_Size nFPos = Tell(); 2509 #endif 2510 sal_uInt16 nBuf = nBufSize; 2511 SetBufferSize( 0 ); 2512 SetSize( nSize ); 2513 SetBufferSize( nBuf ); 2514 DBG_ASSERT(Tell()==nFPos,"SetStreamSize failed"); 2515 return (sal_Bool)(nError == 0); 2516 } 2517 2518 //============================================================================ 2519 2520 void SvStream::AddMark( sal_Size ) 2521 { 2522 } 2523 2524 //============================================================================ 2525 2526 void SvStream::RemoveMark( sal_Size ) 2527 { 2528 } 2529 2530 /************************************************************************* 2531 |* 2532 |* endl() 2533 |* 2534 |* Beschreibung STREAM.SDW 2535 |* Ersterstellung OV 08.06.94 2536 |* Letzte Aenderung TH 13.11.96 2537 |* 2538 *************************************************************************/ 2539 2540 SvStream& endl( SvStream& rStr ) 2541 { 2542 LineEnd eDelim = rStr.GetLineDelimiter(); 2543 if ( eDelim == LINEEND_CR ) 2544 rStr << _CR; 2545 else if( eDelim == LINEEND_LF ) 2546 rStr << _LF; 2547 else 2548 rStr << _CR << _LF; 2549 return rStr; 2550 } 2551 2552 SvStream& endlu( SvStream& rStrm ) 2553 { 2554 switch ( rStrm.GetLineDelimiter() ) 2555 { 2556 case LINEEND_CR : 2557 rStrm << sal_Unicode(_CR); 2558 break; 2559 case LINEEND_LF : 2560 rStrm << sal_Unicode(_LF); 2561 break; 2562 default: 2563 rStrm << sal_Unicode(_CR) << sal_Unicode(_LF); 2564 } 2565 return rStrm; 2566 } 2567 2568 SvStream& endlub( SvStream& rStrm ) 2569 { 2570 if ( rStrm.GetStreamCharSet() == RTL_TEXTENCODING_UNICODE ) 2571 return endlu( rStrm ); 2572 else 2573 return endl( rStrm ); 2574 } 2575 2576 /************************************************************************* 2577 |* 2578 |* SvMemoryStream::SvMemoryStream() 2579 |* 2580 |* Beschreibung STREAM.SDW 2581 |* Ersterstellung OV 20.06.94 2582 |* Letzte Aenderung OV 20.06.94 2583 |* 2584 *************************************************************************/ 2585 2586 SvMemoryStream::SvMemoryStream( void* pBuffer, sal_Size bufSize, 2587 StreamMode eMode ) 2588 { 2589 if( eMode & STREAM_WRITE ) 2590 bIsWritable = sal_True; 2591 else 2592 bIsWritable = sal_False; 2593 nEndOfData = bufSize; 2594 bOwnsData = sal_False; 2595 pBuf = (sal_uInt8 *) pBuffer; 2596 nResize = 0L; 2597 nSize = bufSize; 2598 nPos = 0L; 2599 SetBufferSize( 0 ); 2600 } 2601 2602 /************************************************************************* 2603 |* 2604 |* SvMemoryStream::SvMemoryStream() 2605 |* 2606 |* Beschreibung STREAM.SDW 2607 |* Ersterstellung OV 20.06.94 2608 |* Letzte Aenderung OV 20.06.94 2609 |* 2610 *************************************************************************/ 2611 2612 SvMemoryStream::SvMemoryStream( sal_Size nInitSize, sal_Size nResizeOffset ) 2613 { 2614 bIsWritable = sal_True; 2615 bOwnsData = sal_True; 2616 nEndOfData = 0L; 2617 nResize = nResizeOffset; 2618 nPos = 0; 2619 pBuf = 0; 2620 if( nResize != 0 && nResize < 16 ) 2621 nResize = 16; 2622 if( nInitSize && !AllocateMemory( nInitSize ) ) 2623 { 2624 SetError( SVSTREAM_OUTOFMEMORY ); 2625 nSize = 0; 2626 } 2627 else 2628 nSize = nInitSize; 2629 SetBufferSize( 64 ); 2630 } 2631 2632 /************************************************************************* 2633 |* 2634 |* SvMemoryStream::~SvMemoryStream() 2635 |* 2636 |* Beschreibung STREAM.SDW 2637 |* Ersterstellung OV 20.06.94 2638 |* Letzte Aenderung OV 20.06.94 2639 |* 2640 *************************************************************************/ 2641 2642 SvMemoryStream::~SvMemoryStream() 2643 { 2644 if( pBuf ) 2645 { 2646 if( bOwnsData ) 2647 FreeMemory(); 2648 else 2649 Flush(); 2650 } 2651 } 2652 2653 /************************************************************************* 2654 |* 2655 |* SvMemoryStream::IsA() 2656 |* 2657 |* Beschreibung STREAM.SDW 2658 |* Ersterstellung OV 20.06.94 2659 |* Letzte Aenderung OV 20.06.94 2660 |* 2661 *************************************************************************/ 2662 2663 sal_uInt16 SvMemoryStream::IsA() const 2664 { 2665 return (sal_uInt16)ID_MEMORYSTREAM; 2666 } 2667 2668 /************************************************************************* 2669 |* 2670 |* SvMemoryStream::SetBuffer() 2671 |* 2672 |* Beschreibung STREAM.SDW 2673 |* Ersterstellung OV 20.06.94 2674 |* Letzte Aenderung OV 20.06.94 2675 |* 2676 *************************************************************************/ 2677 2678 void* SvMemoryStream::SetBuffer( void* pNewBuf, sal_Size nCount, 2679 sal_Bool bOwnsDat, sal_Size nEOF ) 2680 { 2681 void* pResult; 2682 SetBufferSize( 0 ); // Buffering in der Basisklasse initialisieren 2683 Seek( 0 ); 2684 if( bOwnsData ) 2685 { 2686 pResult = 0; 2687 if( pNewBuf != pBuf ) 2688 FreeMemory(); 2689 } 2690 else 2691 pResult = pBuf; 2692 2693 pBuf = (sal_uInt8 *) pNewBuf; 2694 nPos = 0; 2695 nSize = nCount; 2696 nResize = 0; 2697 bOwnsData = bOwnsDat; 2698 2699 if( nEOF > nCount ) 2700 nEOF = nCount; 2701 nEndOfData = nEOF; 2702 2703 ResetError(); 2704 2705 DBG_ASSERT( nEndOfData<STREAM_SEEK_TO_END,"Invalid EOF"); 2706 return pResult; 2707 } 2708 2709 /************************************************************************* 2710 |* 2711 |* SvMemoryStream::GetData() 2712 |* 2713 |* Beschreibung STREAM.SDW 2714 |* Ersterstellung OV 20.06.94 2715 |* Letzte Aenderung OV 20.06.94 2716 |* 2717 *************************************************************************/ 2718 2719 sal_Size SvMemoryStream::GetData( void* pData, sal_Size nCount ) 2720 { 2721 sal_Size nMaxCount = nEndOfData-nPos; 2722 if( nCount > nMaxCount ) 2723 nCount = nMaxCount; 2724 memcpy( pData, pBuf+nPos, (size_t)nCount ); 2725 nPos += nCount; 2726 return nCount; 2727 } 2728 2729 /************************************************************************* 2730 |* 2731 |* SvMemoryStream::PutData() 2732 |* 2733 |* Beschreibung STREAM.SDW 2734 |* Ersterstellung OV 20.06.94 2735 |* Letzte Aenderung OV 20.06.94 2736 |* 2737 *************************************************************************/ 2738 2739 sal_Size SvMemoryStream::PutData( const void* pData, sal_Size nCount ) 2740 { 2741 if( GetError() ) 2742 return 0L; 2743 2744 sal_Size nMaxCount = nSize-nPos; 2745 2746 // auf Ueberlauf testen 2747 if( nCount > nMaxCount ) 2748 { 2749 if( nResize == 0 ) 2750 { 2751 // soviel wie moeglich rueberschaufeln 2752 nCount = nMaxCount; 2753 SetError( SVSTREAM_OUTOFMEMORY ); 2754 } 2755 else 2756 { 2757 long nNewResize; 2758 if( nSize && nSize > nResize ) 2759 nNewResize = nSize; 2760 else 2761 nNewResize = nResize; 2762 2763 if( (nCount-nMaxCount) < nResize ) 2764 { 2765 // fehlender Speicher ist kleiner als Resize-Offset, 2766 // deshalb um Resize-Offset vergroessern 2767 if( !ReAllocateMemory( nNewResize) ) 2768 { 2769 nCount = 0; 2770 SetError( SVSTREAM_WRITE_ERROR ); 2771 } 2772 } 2773 else 2774 { 2775 // fehlender Speicher ist groesser als Resize-Offset 2776 // deshalb um Differenz+ResizeOffset vergroessern 2777 if( !ReAllocateMemory( nCount-nMaxCount+nNewResize ) ) 2778 { 2779 nCount = 0; 2780 SetError( SVSTREAM_WRITE_ERROR ); 2781 } 2782 } 2783 } 2784 } 2785 DBG_ASSERT(pBuf,"Possibly Reallocate failed"); 2786 memcpy( pBuf+nPos, pData, (size_t)nCount); 2787 2788 nPos += nCount; 2789 if( nPos > nEndOfData ) 2790 nEndOfData = nPos; 2791 return nCount; 2792 } 2793 2794 /************************************************************************* 2795 |* 2796 |* SvMemoryStream::SeekPos() 2797 |* 2798 |* Beschreibung STREAM.SDW 2799 |* Ersterstellung OV 20.06.94 2800 |* Letzte Aenderung OV 20.06.94 2801 |* 2802 *************************************************************************/ 2803 2804 // nEndOfData: Erste Position im Stream, die nicht gelesen werden darf 2805 // nSize: Groesse des allozierten Speichers 2806 2807 sal_Size SvMemoryStream::SeekPos( sal_Size nNewPos ) 2808 { 2809 if( nNewPos < nEndOfData ) 2810 nPos = nNewPos; 2811 else if( nNewPos == STREAM_SEEK_TO_END ) 2812 nPos = nEndOfData; 2813 else 2814 { 2815 if( nNewPos >= nSize ) // muss Buffer vergroessert werden ? 2816 { 2817 if( nResize ) // ist vergroeseern erlaubt ? 2818 { 2819 long nDiff = (long)(nNewPos - nSize + 1); 2820 nDiff += (long)nResize; 2821 ReAllocateMemory( nDiff ); 2822 nPos = nNewPos; 2823 nEndOfData = nNewPos; 2824 } 2825 else // vergroessern ist nicht erlaubt -> ans Ende setzen 2826 { 2827 // SetError( SVSTREAM_OUTOFMEMORY ); 2828 nPos = nEndOfData; 2829 } 2830 } 2831 else // gueltigen Bereich innerhalb des Buffers vergroessern 2832 { 2833 nPos = nNewPos; 2834 nEndOfData = nNewPos; 2835 } 2836 } 2837 return nPos; 2838 } 2839 2840 /************************************************************************* 2841 |* 2842 |* SvMemoryStream::FlushData() 2843 |* 2844 |* Beschreibung STREAM.SDW 2845 |* Ersterstellung OV 20.06.94 2846 |* Letzte Aenderung OV 20.06.94 2847 |* 2848 *************************************************************************/ 2849 2850 void SvMemoryStream::FlushData() 2851 { 2852 } 2853 2854 /************************************************************************* 2855 |* 2856 |* SvMemoryStream::ResetError() 2857 |* 2858 |* Beschreibung STREAM.SDW 2859 |* Ersterstellung OV 20.06.94 2860 |* Letzte Aenderung OV 20.06.94 2861 |* 2862 *************************************************************************/ 2863 2864 void SvMemoryStream::ResetError() 2865 { 2866 SvStream::ClearError(); 2867 } 2868 2869 /************************************************************************* 2870 |* 2871 |* SvMemoryStream::AllocateMemory() 2872 |* 2873 |* Beschreibung STREAM.SDW 2874 |* Ersterstellung OV 20.06.94 2875 |* Letzte Aenderung OV 20.06.94 2876 |* 2877 *************************************************************************/ 2878 2879 sal_Bool SvMemoryStream::AllocateMemory( sal_Size nNewSize ) 2880 { 2881 pBuf = new sal_uInt8[nNewSize]; 2882 return( pBuf != 0 ); 2883 } 2884 2885 /************************************************************************* 2886 |* 2887 |* SvMemoryStream::ReAllocateMemory() (Bozo-Algorithmus) 2888 |* 2889 |* Beschreibung STREAM.SDW 2890 |* Ersterstellung OV 20.06.94 2891 |* Letzte Aenderung OV 20.06.94 2892 |* 2893 *************************************************************************/ 2894 2895 sal_Bool SvMemoryStream::ReAllocateMemory( long nDiff ) 2896 { 2897 sal_Bool bRetVal = sal_False; 2898 long nTemp = (long)nSize; 2899 nTemp += nDiff; 2900 sal_Size nNewSize = (sal_Size)nTemp; 2901 2902 if( nNewSize ) 2903 { 2904 sal_uInt8* pNewBuf = new sal_uInt8[nNewSize]; 2905 2906 if( pNewBuf ) 2907 { 2908 bRetVal = sal_True; // Success! 2909 if( nNewSize < nSize ) // Verkleinern ? 2910 { 2911 memcpy( pNewBuf, pBuf, (size_t)nNewSize ); 2912 if( nPos > nNewSize ) 2913 nPos = 0L; 2914 if( nEndOfData >= nNewSize ) 2915 nEndOfData = nNewSize-1L; 2916 } 2917 else 2918 { 2919 memcpy( pNewBuf, pBuf, (size_t)nSize ); 2920 } 2921 2922 FreeMemory(); 2923 2924 pBuf = pNewBuf; 2925 nSize = nNewSize; 2926 } 2927 } 2928 else 2929 { 2930 bRetVal = sal_True; 2931 FreeMemory(); 2932 pBuf = 0; 2933 nSize = 0; 2934 nEndOfData = 0; 2935 nPos = 0; 2936 } 2937 2938 return bRetVal; 2939 } 2940 2941 void SvMemoryStream::FreeMemory() 2942 { 2943 delete[] pBuf; 2944 } 2945 2946 /************************************************************************* 2947 |* 2948 |* SvMemoryStream::SwitchBuffer() 2949 |* 2950 |* Beschreibung STREAM.SDW 2951 |* Ersterstellung OV 26.07.94 2952 |* Letzte Aenderung OV 26.07.94 2953 |* 2954 *************************************************************************/ 2955 2956 void* SvMemoryStream::SwitchBuffer( sal_Size nInitSize, sal_Size nResizeOffset) 2957 { 2958 Flush(); 2959 if( !bOwnsData ) 2960 return 0; 2961 Seek( STREAM_SEEK_TO_BEGIN ); 2962 2963 void* pRetVal = pBuf; 2964 pBuf = 0; 2965 nEndOfData = 0L; 2966 nResize = nResizeOffset; 2967 nPos = 0; 2968 2969 if( nResize != 0 && nResize < 16 ) 2970 nResize = 16; 2971 2972 ResetError(); 2973 2974 if( nInitSize && !AllocateMemory(nInitSize) ) 2975 { 2976 SetError( SVSTREAM_OUTOFMEMORY ); 2977 nSize = 0; 2978 } 2979 else 2980 nSize = nInitSize; 2981 2982 SetBufferSize( 64 ); 2983 return pRetVal; 2984 } 2985 2986 void SvMemoryStream::SetSize( sal_Size nNewSize ) 2987 { 2988 long nDiff = (long)nNewSize - (long)nSize; 2989 ReAllocateMemory( nDiff ); 2990 } 2991 2992 TYPEINIT0 ( SvDataCopyStream ) 2993 2994 void SvDataCopyStream::Assign( const SvDataCopyStream& ) 2995 { 2996 } 2997