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