src/common/stream.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/stream.cpp
   3 // Purpose:     wxStream base classes
   4 // Author:      Guilhem Lavaux
   5 // Modified by: VZ (23.11.00) to fix realloc()ing new[]ed memory,
   6 //                            general code review
   7 // Created:     11/07/98
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) Guilhem Lavaux
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #if wxUSE_STREAMS
  29
  30 #include "wx/stream.h"
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/log.h"
  34 #endif
  35
  36 #include <ctype.h>
  37 #include "wx/datstrm.h"
  38 #include "wx/textfile.h"
  39 #include "wx/scopeguard.h"
  40
  41 // ----------------------------------------------------------------------------
  42 // constants
  43 // ----------------------------------------------------------------------------
  44
  45 // the temporary buffer size used when copying from stream to stream
  46 #define BUF_TEMP_SIZE 4096
  47
  48 // ============================================================================
  49 // implementation
  50 // ============================================================================
  51
  52 // ----------------------------------------------------------------------------
  53 // wxStreamBuffer
  54 // ----------------------------------------------------------------------------
  55
  56 void wxStreamBuffer::SetError(wxStreamError err)
  57 {
  58    if ( m_stream && m_stream->m_lasterror == wxSTREAM_NO_ERROR )
  59        m_stream->m_lasterror = err;
  60 }
  61
  62 void wxStreamBuffer::InitBuffer()
  63 {
  64     m_buffer_start =
  65     m_buffer_end =
  66     m_buffer_pos = NULL;
  67
  68     // if we are going to allocate the buffer, we should free it later as well
  69     m_destroybuf = true;
  70 }
  71
  72 void wxStreamBuffer::Init()
  73 {
  74     InitBuffer();
  75
  76     m_fixed = true;
  77 }
  78
  79 void wxStreamBuffer::InitWithStream(wxStreamBase& stream, BufMode mode)
  80 {
  81     Init();
  82
  83     m_stream = &stream;
  84     m_mode = mode;
  85
  86     m_flushable = true;
  87 }
  88
  89 wxStreamBuffer::wxStreamBuffer(BufMode mode)
  90 {
  91     Init();
  92
  93     m_stream = NULL;
  94     m_mode = mode;
  95
  96     m_flushable = false;
  97 }
  98
  99 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 100 {
 101     // doing this has big chances to lead to a crash when the source buffer is
 102     // destroyed (otherwise assume the caller knows what he does)
 103     wxASSERT_MSG( !buffer.m_destroybuf,
 104                   wxT("it's a bad idea to copy this buffer") );
 105
 106     m_buffer_start = buffer.m_buffer_start;
 107     m_buffer_end = buffer.m_buffer_end;
 108     m_buffer_pos = buffer.m_buffer_pos;
 109     m_fixed = buffer.m_fixed;
 110     m_flushable = buffer.m_flushable;
 111     m_stream = buffer.m_stream;
 112     m_mode = buffer.m_mode;
 113     m_destroybuf = false;
 114 }
 115
 116 void wxStreamBuffer::FreeBuffer()
 117 {
 118     if ( m_destroybuf )
 119     {
 120         free(m_buffer_start);
 121         m_buffer_start = NULL;
 122     }
 123 }
 124
 125 wxStreamBuffer::~wxStreamBuffer()
 126 {
 127     FreeBuffer();
 128 }
 129
 130 wxInputStream *wxStreamBuffer::GetInputStream() const
 131 {
 132     return m_mode == write ? NULL : (wxInputStream *)m_stream;
 133 }
 134
 135 wxOutputStream *wxStreamBuffer::GetOutputStream() const
 136 {
 137     return m_mode == read ? NULL : (wxOutputStream *)m_stream;
 138 }
 139
 140 void wxStreamBuffer::SetBufferIO(void *buffer_start,
 141                                  void *buffer_end,
 142                                  bool takeOwnership)
 143 {
 144     SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start,
 145                 takeOwnership);
 146 }
 147
 148 void wxStreamBuffer::SetBufferIO(void *start,
 149                                  size_t len,
 150                                  bool takeOwnership)
 151 {
 152     // start by freeing the old buffer
 153     FreeBuffer();
 154
 155     m_buffer_start = (char *)start;
 156     m_buffer_end   = m_buffer_start + len;
 157
 158     // if we own it, we free it
 159     m_destroybuf = takeOwnership;
 160
 161     ResetBuffer();
 162 }
 163
 164 void wxStreamBuffer::SetBufferIO(size_t bufsize)
 165 {
 166     if ( bufsize )
 167     {
 168         // this will free the old buffer and allocate the new one
 169         SetBufferIO(malloc(bufsize), bufsize, true /* take ownership */);
 170     }
 171     else // no buffer size => no buffer
 172     {
 173         // still free the old one
 174         FreeBuffer();
 175         InitBuffer();
 176     }
 177 }
 178
 179 void wxStreamBuffer::ResetBuffer()
 180 {
 181     if ( m_stream )
 182     {
 183         m_stream->Reset();
 184         m_stream->m_lastcount = 0;
 185     }
 186
 187     m_buffer_pos = m_mode == read && m_flushable
 188                         ? m_buffer_end
 189                         : m_buffer_start;
 190 }
 191
 192 void wxStreamBuffer::Truncate()
 193 {
 194     size_t new_size = m_buffer_pos - m_buffer_start;
 195     if ( m_buffer_pos == m_buffer_end )
 196         return;
 197
 198     if ( !new_size )
 199     {
 200         FreeBuffer();
 201         InitBuffer();
 202         return;
 203     }
 204
 205     char *new_start = (char *)realloc(m_buffer_start, new_size);
 206     wxCHECK_RET( new_size, wxT("shrinking buffer shouldn't fail") );
 207
 208     m_buffer_start = new_start;
 209     m_buffer_end = m_buffer_start + new_size;
 210     m_buffer_pos = m_buffer_end;
 211 }
 212
 213 // fill the buffer with as much data as possible (only for read buffers)
 214 bool wxStreamBuffer::FillBuffer()
 215 {
 216     wxInputStream *inStream = GetInputStream();
 217
 218     // It's legal to have no stream, so we don't complain about it just return false
 219     if ( !inStream )
 220         return false;
 221
 222     size_t count = inStream->OnSysRead(GetBufferStart(), GetBufferSize());
 223     if ( !count )
 224         return false;
 225
 226     m_buffer_end = m_buffer_start + count;
 227     m_buffer_pos = m_buffer_start;
 228
 229     return true;
 230 }
 231
 232 // write the buffer contents to the stream (only for write buffers)
 233 bool wxStreamBuffer::FlushBuffer()
 234 {
 235     wxCHECK_MSG( m_flushable, false, wxT("can't flush this buffer") );
 236
 237     // FIXME: what is this check for? (VZ)
 238     if ( m_buffer_pos == m_buffer_start )
 239         return false;
 240
 241     wxOutputStream *outStream = GetOutputStream();
 242
 243     wxCHECK_MSG( outStream, false, wxT("should have a stream in wxStreamBuffer") );
 244
 245     size_t current = m_buffer_pos - m_buffer_start;
 246     size_t count = outStream->OnSysWrite(m_buffer_start, current);
 247     if ( count != current )
 248         return false;
 249
 250     m_buffer_pos = m_buffer_start;
 251
 252     return true;
 253 }
 254
 255 size_t wxStreamBuffer::GetDataLeft()
 256 {
 257     /* Why is this done? RR. */
 258     if ( m_buffer_pos == m_buffer_end && m_flushable)
 259         FillBuffer();
 260
 261     return GetBytesLeft();
 262 }
 263
 264 // copy up to size bytes from our buffer into the provided one
 265 void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
 266 {
 267     // don't get more bytes than left in the buffer
 268     size_t left = GetBytesLeft();
 269
 270     if ( size > left )
 271         size = left;
 272
 273     memcpy(buffer, m_buffer_pos, size);
 274     m_buffer_pos += size;
 275 }
 276
 277 // copy the contents of the provided buffer into this one
 278 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 279 {
 280     size_t left = GetBytesLeft();
 281
 282     if ( size > left )
 283     {
 284         if ( m_fixed )
 285         {
 286             // we can't realloc the buffer, so just copy what we can
 287             size = left;
 288         }
 289         else // !m_fixed
 290         {
 291             // realloc the buffer to have enough space for the data
 292             if ( m_buffer_pos + size > m_buffer_end )
 293             {
 294                 size_t delta = m_buffer_pos - m_buffer_start;
 295                 size_t new_size = delta + size;
 296
 297                 char *startOld = m_buffer_start;
 298                 m_buffer_start = (char *)realloc(m_buffer_start, new_size);
 299                 if ( !m_buffer_start )
 300                 {
 301                     // don't leak memory if realloc() failed
 302                     m_buffer_start = startOld;
 303
 304                     // what else can we do?
 305                     return;
 306                 }
 307
 308                 // adjust the pointers invalidated by realloc()
 309                 m_buffer_pos = m_buffer_start + delta;
 310                 m_buffer_end = m_buffer_start + new_size;
 311             } // else: the buffer is big enough
 312         }
 313     }
 314
 315     memcpy(m_buffer_pos, buffer, size);
 316     m_buffer_pos += size;
 317 }
 318
 319 void wxStreamBuffer::PutChar(char c)
 320 {
 321     wxOutputStream *outStream = GetOutputStream();
 322
 323     wxCHECK_RET( outStream, wxT("should have a stream in wxStreamBuffer") );
 324
 325     // if we don't have buffer at all, just forward this call to the stream,
 326     if ( !HasBuffer() )
 327     {
 328         outStream->OnSysWrite(&c, sizeof(c));
 329     }
 330     else
 331     {
 332         // otherwise check we have enough space left
 333         if ( !GetDataLeft() && !FlushBuffer() )
 334         {
 335             // we don't
 336             SetError(wxSTREAM_WRITE_ERROR);
 337         }
 338         else
 339         {
 340             PutToBuffer(&c, sizeof(c));
 341             m_stream->m_lastcount = 1;
 342         }
 343     }
 344 }
 345
 346 char wxStreamBuffer::Peek()
 347 {
 348     wxCHECK_MSG( m_stream && HasBuffer(), 0,
 349                  wxT("should have the stream and the buffer in wxStreamBuffer") );
 350
 351     if ( !GetDataLeft() )
 352     {
 353         SetError(wxSTREAM_READ_ERROR);
 354         return 0;
 355     }
 356
 357     char c;
 358     GetFromBuffer(&c, sizeof(c));
 359     m_buffer_pos--;
 360
 361     return c;
 362 }
 363
 364 char wxStreamBuffer::GetChar()
 365 {
 366     wxInputStream *inStream = GetInputStream();
 367
 368     wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
 369
 370     char c;
 371     if ( !HasBuffer() )
 372     {
 373         inStream->OnSysRead(&c, sizeof(c));
 374     }
 375     else
 376     {
 377         if ( !GetDataLeft() )
 378         {
 379             SetError(wxSTREAM_READ_ERROR);
 380             c = 0;
 381         }
 382         else
 383         {
 384             GetFromBuffer(&c, sizeof(c));
 385             m_stream->m_lastcount = 1;
 386         }
 387     }
 388
 389     return c;
 390 }
 391
 392 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 393 {
 394     wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be used") );
 395
 396     /* Clear buffer first */
 397     memset(buffer, 0x00, size);
 398
 399     // lasterror is reset before all new IO calls
 400     if ( m_stream )
 401         m_stream->Reset();
 402
 403     size_t readBytes;
 404     if ( !HasBuffer() )
 405     {
 406         wxInputStream *inStream = GetInputStream();
 407
 408         wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
 409
 410         readBytes = inStream->OnSysRead(buffer, size);
 411     }
 412     else // we have a buffer, use it
 413     {
 414         size_t orig_size = size;
 415
 416         while ( size > 0 )
 417         {
 418             size_t left = GetDataLeft();
 419
 420             // if the requested number of bytes if greater than the buffer
 421             // size, read data in chunks
 422             if ( size > left )
 423             {
 424                 GetFromBuffer(buffer, left);
 425                 size -= left;
 426                 buffer = (char *)buffer + left;
 427
 428                 if ( !FillBuffer() )
 429                 {
 430                     SetError(wxSTREAM_EOF);
 431                     break;
 432                 }
 433             }
 434             else // otherwise just do it in one gulp
 435             {
 436                 GetFromBuffer(buffer, size);
 437                 size = 0;
 438             }
 439         }
 440
 441         readBytes = orig_size - size;
 442     }
 443
 444     if ( m_stream )
 445         m_stream->m_lastcount = readBytes;
 446
 447     return readBytes;
 448 }
 449
 450 // this should really be called "Copy()"
 451 size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 452 {
 453     wxCHECK_MSG( m_mode != write, 0, wxT("can't read from this buffer") );
 454
 455     char buf[BUF_TEMP_SIZE];
 456     size_t nRead,
 457            total = 0;
 458
 459     do
 460     {
 461         nRead = Read(buf, WXSIZEOF(buf));
 462         if ( nRead )
 463         {
 464             nRead = dbuf->Write(buf, nRead);
 465             total += nRead;
 466         }
 467     }
 468     while ( nRead );
 469
 470     return total;
 471 }
 472
 473 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 474 {
 475     wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be send") );
 476
 477     if (m_stream)
 478     {
 479         // lasterror is reset before all new IO calls
 480         m_stream->Reset();
 481     }
 482
 483     size_t ret;
 484
 485     if ( !HasBuffer() && m_fixed )
 486     {
 487         wxOutputStream *outStream = GetOutputStream();
 488
 489         wxCHECK_MSG( outStream, 0, wxT("should have a stream in wxStreamBuffer") );
 490
 491         // no buffer, just forward the call to the stream
 492         ret = outStream->OnSysWrite(buffer, size);
 493     }
 494     else // we [may] have a buffer, use it
 495     {
 496         size_t orig_size = size;
 497
 498         while ( size > 0 )
 499         {
 500             size_t left = GetBytesLeft();
 501
 502             // if the buffer is too large to fit in the stream buffer, split
 503             // it in smaller parts
 504             //
 505             // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
 506             //     we always go to the second case.
 507             //
 508             // FIXME: fine, but if it fails we should (re)try writing it by
 509             //        chunks as this will (hopefully) always work (VZ)
 510
 511             if ( size > left && m_fixed )
 512             {
 513                 PutToBuffer(buffer, left);
 514                 size -= left;
 515                 buffer = (char *)buffer + left;
 516
 517                 if ( !FlushBuffer() )
 518                 {
 519                     SetError(wxSTREAM_WRITE_ERROR);
 520
 521                     break;
 522                 }
 523
 524                 m_buffer_pos = m_buffer_start;
 525             }
 526             else // we can do it in one gulp
 527             {
 528                 PutToBuffer(buffer, size);
 529                 size = 0;
 530             }
 531         }
 532
 533         ret = orig_size - size;
 534     }
 535
 536     if (m_stream)
 537     {
 538         // i am not entirely sure what we do this for
 539         m_stream->m_lastcount = ret;
 540     }
 541
 542     return ret;
 543 }
 544
 545 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
 546 {
 547     wxCHECK_MSG( m_mode != read, 0, wxT("can't write to this buffer") );
 548     wxCHECK_MSG( sbuf->m_mode != write, 0, wxT("can't read from that buffer") );
 549
 550     char buf[BUF_TEMP_SIZE];
 551     size_t nWrite,
 552            total = 0;
 553
 554     do
 555     {
 556         size_t nRead = sbuf->Read(buf, WXSIZEOF(buf));
 557         if ( nRead )
 558         {
 559             nWrite = Write(buf, nRead);
 560             if ( nWrite < nRead )
 561             {
 562                 // put back data we couldn't copy
 563                 wxInputStream *in_stream = (wxInputStream *)sbuf->GetStream();
 564
 565                 in_stream->Ungetch(buf + nWrite, nRead - nWrite);
 566             }
 567
 568             total += nWrite;
 569         }
 570         else
 571         {
 572             nWrite = 0;
 573         }
 574     }
 575     while ( nWrite == WXSIZEOF(buf) );
 576
 577     return total;
 578 }
 579
 580 wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode)
 581 {
 582     wxFileOffset ret_off, diff;
 583
 584     wxFileOffset last_access = GetLastAccess();
 585
 586     if ( !m_flushable )
 587     {
 588         switch (mode)
 589         {
 590             case wxFromStart:
 591                 diff = pos;
 592                 break;
 593
 594             case wxFromCurrent:
 595                 diff = pos + GetIntPosition();
 596                 break;
 597
 598             case wxFromEnd:
 599                 diff = pos + last_access;
 600                 break;
 601
 602             default:
 603                 wxFAIL_MSG( wxT("invalid seek mode") );
 604
 605                 return wxInvalidOffset;
 606         }
 607         if (diff < 0 || diff > last_access)
 608             return wxInvalidOffset;
 609         size_t int_diff = wx_truncate_cast(size_t, diff);
 610         wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
 611         SetIntPosition(int_diff);
 612         return diff;
 613     }
 614
 615     switch ( mode )
 616     {
 617         case wxFromStart:
 618             // We'll try to compute an internal position later ...
 619             ret_off = m_stream->OnSysSeek(pos, wxFromStart);
 620             ResetBuffer();
 621             return ret_off;
 622
 623         case wxFromCurrent:
 624             diff = pos + GetIntPosition();
 625
 626             if ( (diff > last_access) || (diff < 0) )
 627             {
 628                 // We must take into account the fact that we have read
 629                 // something previously.
 630                 ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent);
 631                 ResetBuffer();
 632                 return ret_off;
 633             }
 634             else
 635             {
 636                 size_t int_diff = wx_truncate_cast(size_t, diff);
 637                 wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
 638                 SetIntPosition(int_diff);
 639                 return diff;
 640             }
 641
 642         case wxFromEnd:
 643             // Hard to compute: always seek to the requested position.
 644             ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
 645             ResetBuffer();
 646             return ret_off;
 647     }
 648
 649     return wxInvalidOffset;
 650 }
 651
 652 wxFileOffset wxStreamBuffer::Tell() const
 653 {
 654     wxFileOffset pos;
 655
 656     // ask the stream for position if we have a real one
 657     if ( m_stream )
 658     {
 659         pos = m_stream->OnSysTell();
 660         if ( pos == wxInvalidOffset )
 661             return wxInvalidOffset;
 662     }
 663     else // no associated stream
 664     {
 665         pos = 0;
 666     }
 667
 668     pos += GetIntPosition();
 669
 670     if ( m_mode == read && m_flushable )
 671         pos -= GetLastAccess();
 672
 673     return pos;
 674 }
 675
 676 // ----------------------------------------------------------------------------
 677 // wxStreamBase
 678 // ----------------------------------------------------------------------------
 679
 680 IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
 681
 682 wxStreamBase::wxStreamBase()
 683 {
 684     m_lasterror = wxSTREAM_NO_ERROR;
 685     m_lastcount = 0;
 686 }
 687
 688 wxStreamBase::~wxStreamBase()
 689 {
 690 }
 691
 692 size_t wxStreamBase::GetSize() const
 693 {
 694     wxFileOffset length = GetLength();
 695     if ( length == (wxFileOffset)wxInvalidOffset )
 696         return 0;
 697
 698     const size_t len = wx_truncate_cast(size_t, length);
 699     wxASSERT_MSG( len == length + size_t(0), wxT("large files not supported") );
 700
 701     return len;
 702 }
 703
 704 wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 705 {
 706     return wxInvalidOffset;
 707 }
 708
 709 wxFileOffset wxStreamBase::OnSysTell() const
 710 {
 711     return wxInvalidOffset;
 712 }
 713
 714 // ----------------------------------------------------------------------------
 715 // wxInputStream
 716 // ----------------------------------------------------------------------------
 717
 718 IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
 719
 720 wxInputStream::wxInputStream()
 721 {
 722     m_wback = NULL;
 723     m_wbacksize =
 724     m_wbackcur = 0;
 725 }
 726
 727 wxInputStream::~wxInputStream()
 728 {
 729     free(m_wback);
 730 }
 731
 732 bool wxInputStream::CanRead() const
 733 {
 734     // we don't know if there is anything to read or not and by default we
 735     // prefer to be optimistic and try to read data unless we know for sure
 736     // there is no more of it
 737     return m_lasterror != wxSTREAM_EOF;
 738 }
 739
 740 bool wxInputStream::Eof() const
 741 {
 742     // the only way the base class can know we're at EOF is when we'd already
 743     // tried to read beyond it in which case last error is set accordingly
 744     return GetLastError() == wxSTREAM_EOF;
 745 }
 746
 747 char *wxInputStream::AllocSpaceWBack(size_t needed_size)
 748 {
 749     // get number of bytes left from previous wback buffer
 750     size_t toget = m_wbacksize - m_wbackcur;
 751
 752     // allocate a buffer large enough to hold prev + new data
 753     char *temp_b = (char *)malloc(needed_size + toget);
 754
 755     if (!temp_b)
 756         return NULL;
 757
 758     // copy previous data (and free old buffer) if needed
 759     if (m_wback)
 760     {
 761         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
 762         free(m_wback);
 763     }
 764
 765     // done
 766     m_wback = temp_b;
 767     m_wbackcur = 0;
 768     m_wbacksize = needed_size + toget;
 769
 770     return m_wback;
 771 }
 772
 773 size_t wxInputStream::GetWBack(void *buf, size_t size)
 774 {
 775     wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used") );
 776
 777     /* Clear buffer first */
 778     memset(buf, 0x00, size);
 779
 780     if (!m_wback)
 781         return 0;
 782
 783     // how many bytes do we have in the buffer?
 784     size_t toget = m_wbacksize - m_wbackcur;
 785
 786     if ( size < toget )
 787     {
 788         // we won't read everything
 789         toget = size;
 790     }
 791
 792     // copy the data from the cache
 793     memcpy(buf, m_wback + m_wbackcur, toget);
 794
 795     m_wbackcur += toget;
 796     if ( m_wbackcur == m_wbacksize )
 797     {
 798         // TODO: should we really free it here all the time? maybe keep it?
 799         free(m_wback);
 800         m_wback = NULL;
 801         m_wbacksize = 0;
 802         m_wbackcur = 0;
 803     }
 804
 805     // return the number of bytes copied
 806     return toget;
 807 }
 808
 809 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 810 {
 811     wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used in Ungetch()") );
 812
 813     if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF )
 814     {
 815         // can't operate on this stream until the error is cleared
 816         return 0;
 817     }
 818
 819     char *ptrback = AllocSpaceWBack(bufsize);
 820     if (!ptrback)
 821         return 0;
 822
 823     // Eof() shouldn't return true any longer
 824     if ( m_lasterror == wxSTREAM_EOF )
 825         m_lasterror = wxSTREAM_NO_ERROR;
 826
 827     memcpy(ptrback, buf, bufsize);
 828     return bufsize;
 829 }
 830
 831 bool wxInputStream::Ungetch(char c)
 832 {
 833     return Ungetch(&c, sizeof(c)) != 0;
 834 }
 835
 836 int wxInputStream::GetC()
 837 {
 838     unsigned char c;
 839     Read(&c, sizeof(c));
 840     return LastRead() ? c : wxEOF;
 841 }
 842
 843 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 844 {
 845     wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be read") );
 846
 847     char *p = (char *)buf;
 848     m_lastcount = 0;
 849
 850     size_t read = GetWBack(buf, size);
 851     for ( ;; )
 852     {
 853         size -= read;
 854         m_lastcount += read;
 855         p += read;
 856
 857         if ( !size )
 858         {
 859             // we read the requested amount of data
 860             break;
 861         }
 862
 863         if ( p != buf && !CanRead() )
 864         {
 865             // we have already read something and we would block in OnSysRead()
 866             // now: don't do it but return immediately
 867             break;
 868         }
 869
 870         read = OnSysRead(p, size);
 871         if ( !read )
 872         {
 873             // no more data available
 874             break;
 875         }
 876     }
 877
 878     return *this;
 879 }
 880
 881 char wxInputStream::Peek()
 882 {
 883     char c;
 884     Read(&c, sizeof(c));
 885     if (m_lasterror == wxSTREAM_NO_ERROR)
 886     {
 887         Ungetch(c);
 888         return c;
 889     }
 890
 891     return 0;
 892 }
 893
 894 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 895 {
 896     size_t lastcount = 0;
 897     char buf[BUF_TEMP_SIZE];
 898
 899     for ( ;; )
 900     {
 901         size_t bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
 902         if ( !bytes_read )
 903             break;
 904
 905         if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read )
 906             break;
 907
 908         lastcount += bytes_read;
 909     }
 910
 911     m_lastcount = lastcount;
 912
 913     return *this;
 914 }
 915
 916 wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
 917 {
 918     // RR: This code is duplicated in wxBufferedInputStream. This is
 919     // not really a good design, but buffered stream are different
 920     // from all others in that they handle two stream-related objects:
 921     // the stream buffer and parent stream.
 922
 923     // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
 924     if (m_lasterror==wxSTREAM_EOF)
 925         m_lasterror=wxSTREAM_NO_ERROR;
 926
 927     // avoid unnecessary seek operations (optimization)
 928     wxFileOffset currentPos = TellI(), size = GetLength();
 929     if ((mode == wxFromStart && currentPos == pos) ||
 930         (mode == wxFromCurrent && pos == 0) ||
 931         (mode == wxFromEnd && size != wxInvalidOffset && currentPos == size-pos))
 932         return currentPos;
 933
 934     if (!IsSeekable() && mode == wxFromCurrent && pos > 0)
 935     {
 936         // rather than seeking, we can just read data and discard it;
 937         // this allows to forward-seek also non-seekable streams!
 938         char buf[BUF_TEMP_SIZE];
 939         size_t bytes_read;
 940
 941         // read chunks of BUF_TEMP_SIZE bytes until we reach the new position
 942         for ( ; pos >= BUF_TEMP_SIZE; pos -= bytes_read)
 943         {
 944             bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
 945             if ( m_lasterror != wxSTREAM_NO_ERROR )
 946                 return wxInvalidOffset;
 947
 948             wxASSERT(bytes_read == WXSIZEOF(buf));
 949         }
 950
 951         // read the last 'pos' bytes
 952         bytes_read = Read(buf, (size_t)pos).LastRead();
 953         if ( m_lasterror != wxSTREAM_NO_ERROR )
 954             return wxInvalidOffset;
 955
 956         wxASSERT(bytes_read == (size_t)pos);
 957
 958         // we should now have sought to the right position...
 959         return TellI();
 960     }
 961
 962     /* RR: A call to SeekI() will automatically invalidate any previous
 963        call to Ungetch(), otherwise it would be possible to SeekI() to
 964        one position, unread some bytes there, SeekI() to another position
 965        and the data would be corrupted.
 966
 967        GRG: Could add code here to try to navigate within the wback
 968        buffer if possible, but is it really needed? It would only work
 969        when seeking in wxFromCurrent mode, else it would invalidate
 970        anyway... */
 971
 972     if (m_wback)
 973     {
 974         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
 975
 976         free(m_wback);
 977         m_wback = NULL;
 978         m_wbacksize = 0;
 979         m_wbackcur = 0;
 980     }
 981
 982     return OnSysSeek(pos, mode);
 983 }
 984
 985 wxFileOffset wxInputStream::TellI() const
 986 {
 987     wxFileOffset pos = OnSysTell();
 988
 989     if (pos != wxInvalidOffset)
 990         pos -= (m_wbacksize - m_wbackcur);
 991
 992     return pos;
 993 }
 994
 995
 996 // ----------------------------------------------------------------------------
 997 // wxOutputStream
 998 // ----------------------------------------------------------------------------
 999
1000 IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
1001
1002 wxOutputStream::wxOutputStream()
1003 {
1004 }
1005
1006 wxOutputStream::~wxOutputStream()
1007 {
1008 }
1009
1010 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
1011                                   size_t WXUNUSED(bufsize))
1012 {
1013     return 0;
1014 }
1015
1016 void wxOutputStream::PutC(char c)
1017 {
1018     Write(&c, sizeof(c));
1019 }
1020
1021 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
1022 {
1023     m_lastcount = OnSysWrite(buffer, size);
1024     return *this;
1025 }
1026
1027 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
1028 {
1029     stream_in.Read(*this);
1030     return *this;
1031 }
1032
1033 wxFileOffset wxOutputStream::TellO() const
1034 {
1035     return OnSysTell();
1036 }
1037
1038 wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
1039 {
1040     return OnSysSeek(pos, mode);
1041 }
1042
1043 void wxOutputStream::Sync()
1044 {
1045 }
1046
1047
1048 // ----------------------------------------------------------------------------
1049 // wxCountingOutputStream
1050 // ----------------------------------------------------------------------------
1051
1052 IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
1053
1054 wxCountingOutputStream::wxCountingOutputStream ()
1055 {
1056      m_currentPos = 0;
1057 }
1058
1059 wxFileOffset wxCountingOutputStream::GetLength() const
1060 {
1061     return m_lastcount;
1062 }
1063
1064 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
1065                                           size_t size)
1066 {
1067     m_currentPos += size;
1068     if (m_currentPos > m_lastcount)
1069         m_lastcount = m_currentPos;
1070
1071     return m_currentPos;
1072 }
1073
1074 wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
1075 {
1076     ssize_t new_pos = wx_truncate_cast(ssize_t, pos);
1077
1078     switch ( mode )
1079     {
1080         case wxFromStart:
1081             wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") );
1082             break;
1083
1084         case wxFromEnd:
1085             new_pos = m_lastcount + new_pos;
1086             wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") );
1087             break;
1088
1089         case wxFromCurrent:
1090             new_pos = m_currentPos + new_pos;
1091             wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") );
1092             break;
1093
1094         default:
1095             wxFAIL_MSG( wxT("invalid seek mode") );
1096             return wxInvalidOffset;
1097     }
1098
1099     m_currentPos = new_pos;
1100
1101     if (m_currentPos > m_lastcount)
1102         m_lastcount = m_currentPos;
1103
1104     return m_currentPos;
1105 }
1106
1107 wxFileOffset wxCountingOutputStream::OnSysTell() const
1108 {
1109     return m_currentPos;
1110 }
1111
1112 // ----------------------------------------------------------------------------
1113 // wxFilterInputStream
1114 // ----------------------------------------------------------------------------
1115
1116 IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
1117
1118 wxFilterInputStream::wxFilterInputStream()
1119  :  m_parent_i_stream(NULL),
1120     m_owns(false)
1121 {
1122 }
1123
1124 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
1125  :  m_parent_i_stream(&stream),
1126     m_owns(false)
1127 {
1128 }
1129
1130 wxFilterInputStream::wxFilterInputStream(wxInputStream *stream)
1131  :  m_parent_i_stream(stream),
1132     m_owns(true)
1133 {
1134 }
1135
1136 wxFilterInputStream::~wxFilterInputStream()
1137 {
1138     if (m_owns)
1139         delete m_parent_i_stream;
1140 }
1141
1142 // ----------------------------------------------------------------------------
1143 // wxFilterOutputStream
1144 // ----------------------------------------------------------------------------
1145
1146 IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream)
1147
1148 wxFilterOutputStream::wxFilterOutputStream()
1149  :  m_parent_o_stream(NULL),
1150     m_owns(false)
1151 {
1152 }
1153
1154 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
1155  :  m_parent_o_stream(&stream),
1156     m_owns(false)
1157 {
1158 }
1159
1160 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream)
1161  :  m_parent_o_stream(stream),
1162     m_owns(true)
1163 {
1164 }
1165
1166 bool wxFilterOutputStream::Close()
1167 {
1168     if (m_parent_o_stream && m_owns)
1169         return m_parent_o_stream->Close();
1170     else
1171         return true;
1172 }
1173
1174 wxFilterOutputStream::~wxFilterOutputStream()
1175 {
1176     if (m_owns)
1177         delete m_parent_o_stream;
1178 }
1179
1180 // ----------------------------------------------------------------------------
1181 // wxFilterClassFactoryBase
1182 // ----------------------------------------------------------------------------
1183
1184 IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactoryBase, wxObject)
1185
1186 wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const
1187 {
1188     return location.substr(0, FindExtension(location));
1189 }
1190
1191 wxString::size_type wxFilterClassFactoryBase::FindExtension(
1192         const wxString& location) const
1193 {
1194     for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++)
1195     {
1196         if ( location.EndsWith(*p) )
1197             return location.length() - wxStrlen(*p);
1198     }
1199
1200     return wxString::npos;
1201 }
1202
1203 bool wxFilterClassFactoryBase::CanHandle(const wxString& protocol,
1204                                          wxStreamProtocolType type) const
1205 {
1206     if (type == wxSTREAM_FILEEXT)
1207         return FindExtension(protocol) != wxString::npos;
1208     else
1209         for (const wxChar *const *p = GetProtocols(type); *p; p++)
1210             if (protocol == *p)
1211                 return true;
1212
1213     return false;
1214 }
1215
1216 // ----------------------------------------------------------------------------
1217 // wxFilterClassFactory
1218 // ----------------------------------------------------------------------------
1219
1220 IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactory, wxFilterClassFactoryBase)
1221
1222 wxFilterClassFactory *wxFilterClassFactory::sm_first = NULL;
1223
1224 void wxFilterClassFactory::Remove()
1225 {
1226     if (m_next != this)
1227     {
1228         wxFilterClassFactory **pp = &sm_first;
1229
1230         while (*pp != this)
1231             pp = &(*pp)->m_next;
1232
1233         *pp = m_next;
1234
1235         m_next = this;
1236     }
1237 }
1238
1239 // ----------------------------------------------------------------------------
1240 // wxBufferedInputStream
1241 // ----------------------------------------------------------------------------
1242
1243 namespace
1244 {
1245
1246 // helper function used for initializing the buffer used by
1247 // wxBufferedInput/OutputStream: it simply returns the provided buffer if it's
1248 // not NULL or creates a buffer of the given size otherwise
1249 template <typename T>
1250 wxStreamBuffer *
1251 CreateBufferIfNeeded(T& stream, wxStreamBuffer *buffer, size_t bufsize = 1024)
1252 {
1253     return buffer ? buffer : new wxStreamBuffer(bufsize, stream);
1254 }
1255
1256 } // anonymous namespace
1257
1258 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
1259                                              wxStreamBuffer *buffer)
1260                      : wxFilterInputStream(stream)
1261 {
1262     m_i_streambuf = CreateBufferIfNeeded(*this, buffer);
1263 }
1264
1265 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
1266                                              size_t bufsize)
1267                      : wxFilterInputStream(stream)
1268 {
1269     m_i_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
1270 }
1271
1272 wxBufferedInputStream::~wxBufferedInputStream()
1273 {
1274     m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(),
1275                              wxFromCurrent);
1276
1277     delete m_i_streambuf;
1278 }
1279
1280 char wxBufferedInputStream::Peek()
1281 {
1282     return m_i_streambuf->Peek();
1283 }
1284
1285 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
1286 {
1287     // reset the error flag
1288     Reset();
1289
1290     // first read from the already cached data
1291     m_lastcount = GetWBack(buf, size);
1292
1293     // do we have to read anything more?
1294     if ( m_lastcount < size )
1295     {
1296         size -= m_lastcount;
1297         buf = (char *)buf + m_lastcount;
1298
1299         // the call to wxStreamBuffer::Read() below may reset our m_lastcount
1300         // (but it also may not do it if the buffer is associated to another
1301         // existing stream and wasn't created by us), so save it
1302         size_t countOld = m_lastcount;
1303
1304         // the new count of the bytes read is the count of bytes read this time
1305         m_lastcount = m_i_streambuf->Read(buf, size);
1306
1307         // plus those we had read before
1308         m_lastcount += countOld;
1309     }
1310
1311     return *this;
1312 }
1313
1314 wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
1315 {
1316     // RR: Look at wxInputStream for comments.
1317
1318     if (m_lasterror==wxSTREAM_EOF)
1319         Reset();
1320
1321     if (m_wback)
1322     {
1323         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
1324
1325         free(m_wback);
1326         m_wback = NULL;
1327         m_wbacksize = 0;
1328         m_wbackcur = 0;
1329     }
1330
1331     return m_i_streambuf->Seek(pos, mode);
1332 }
1333
1334 wxFileOffset wxBufferedInputStream::TellI() const
1335 {
1336     wxFileOffset pos = m_i_streambuf->Tell();
1337
1338     if (pos != wxInvalidOffset)
1339         pos -= (m_wbacksize - m_wbackcur);
1340
1341     return pos;
1342 }
1343
1344 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
1345 {
1346     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
1347 }
1348
1349 wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
1350 {
1351     return m_parent_i_stream->SeekI(seek, mode);
1352 }
1353
1354 wxFileOffset wxBufferedInputStream::OnSysTell() const
1355 {
1356     return m_parent_i_stream->TellI();
1357 }
1358
1359 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
1360 {
1361     wxCHECK_RET( buffer, wxT("wxBufferedInputStream needs buffer") );
1362
1363     delete m_i_streambuf;
1364     m_i_streambuf = buffer;
1365 }
1366
1367 // ----------------------------------------------------------------------------
1368 // wxBufferedOutputStream
1369 // ----------------------------------------------------------------------------
1370
1371 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
1372                                                wxStreamBuffer *buffer)
1373                       : wxFilterOutputStream(stream)
1374 {
1375     m_o_streambuf = CreateBufferIfNeeded(*this, buffer);
1376 }
1377
1378 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
1379                                                size_t bufsize)
1380                       : wxFilterOutputStream(stream)
1381 {
1382     m_o_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
1383 }
1384
1385 wxBufferedOutputStream::~wxBufferedOutputStream()
1386 {
1387     Sync();
1388     delete m_o_streambuf;
1389 }
1390
1391 bool wxBufferedOutputStream::Close()
1392 {
1393     Sync();
1394     return IsOk();
1395 }
1396
1397
1398 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
1399 {
1400     m_lastcount = 0;
1401     m_o_streambuf->Write(buffer, size);
1402     return *this;
1403 }
1404
1405 wxFileOffset wxBufferedOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
1406 {
1407     Sync();
1408     return m_o_streambuf->Seek(pos, mode);
1409 }
1410
1411 wxFileOffset wxBufferedOutputStream::TellO() const
1412 {
1413     return m_o_streambuf->Tell();
1414 }
1415
1416 void wxBufferedOutputStream::Sync()
1417 {
1418     m_o_streambuf->FlushBuffer();
1419     m_parent_o_stream->Sync();
1420 }
1421
1422 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
1423 {
1424     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
1425 }
1426
1427 wxFileOffset wxBufferedOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
1428 {
1429     return m_parent_o_stream->SeekO(seek, mode);
1430 }
1431
1432 wxFileOffset wxBufferedOutputStream::OnSysTell() const
1433 {
1434     return m_parent_o_stream->TellO();
1435 }
1436
1437 wxFileOffset wxBufferedOutputStream::GetLength() const
1438 {
1439    return m_parent_o_stream->GetLength() + m_o_streambuf->GetIntPosition();
1440 }
1441
1442 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
1443 {
1444     wxCHECK_RET( buffer, wxT("wxBufferedOutputStream needs buffer") );
1445
1446     delete m_o_streambuf;
1447     m_o_streambuf = buffer;
1448 }
1449
1450 // ---------------------------------------------------------------------------
1451 // wxWrapperInputStream implementation
1452 // ---------------------------------------------------------------------------
1453
1454 wxWrapperInputStream::wxWrapperInputStream()
1455 {
1456     m_lasterror = wxSTREAM_READ_ERROR;
1457 }
1458
1459 wxWrapperInputStream::wxWrapperInputStream(wxInputStream& stream)
1460     : wxFilterInputStream(stream)
1461 {
1462     SynchronizeLastError();
1463 }
1464
1465 wxWrapperInputStream::wxWrapperInputStream(wxInputStream *stream)
1466     : wxFilterInputStream(stream)
1467 {
1468     if ( m_parent_i_stream )
1469         SynchronizeLastError();
1470     else
1471         m_lasterror = wxSTREAM_READ_ERROR;
1472 }
1473
1474 void wxWrapperInputStream::InitParentStream(wxInputStream& stream)
1475 {
1476     wxCHECK_RET( !m_parent_i_stream, "Can't init parent stream twice" );
1477
1478     m_parent_i_stream = &stream;
1479
1480     SynchronizeLastError();
1481 }
1482
1483 void wxWrapperInputStream::InitParentStream(wxInputStream* stream)
1484 {
1485     wxCHECK_RET( !m_parent_i_stream, "Can't init parent stream twice" );
1486
1487     m_parent_i_stream = stream;
1488
1489     if ( m_parent_i_stream )
1490     {
1491         m_owns = true;
1492
1493         SynchronizeLastError();
1494     }
1495 }
1496
1497 wxFileOffset wxWrapperInputStream::GetLength() const
1498 {
1499     wxCHECK_MSG(m_parent_i_stream, wxInvalidOffset, "Stream not valid");
1500
1501     wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError);
1502     return m_parent_i_stream->GetLength();
1503 }
1504
1505 bool wxWrapperInputStream::IsSeekable() const
1506 {
1507     wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid");
1508     return m_parent_i_stream->IsSeekable();
1509 }
1510
1511 size_t wxWrapperInputStream::OnSysRead(void *buffer, size_t size)
1512 {
1513     wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid");
1514
1515     wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError);
1516
1517     m_parent_i_stream->Read(buffer, size);
1518     return m_parent_i_stream->LastRead();
1519 }
1520
1521 wxFileOffset wxWrapperInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
1522 {
1523     wxCHECK_MSG(IsSeekable(), false, "Stream not seekable");
1524
1525     wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError);
1526     return m_parent_i_stream->SeekI (pos, mode);
1527 }
1528
1529 wxFileOffset wxWrapperInputStream::OnSysTell() const
1530 {
1531     wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid");
1532
1533     wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError);
1534     return m_parent_i_stream->TellI();
1535 }
1536
1537 // ----------------------------------------------------------------------------
1538 // Some IOManip function
1539 // ----------------------------------------------------------------------------
1540
1541 wxOutputStream& wxEndL(wxOutputStream& stream)
1542 {
1543     static const wxChar *eol = wxTextFile::GetEOL();
1544
1545     return stream.Write(eol, wxStrlen(eol));
1546 }
1547
1548 #endif // wxUSE_STREAMS