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 license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #ifdef __GNUG__
  22     #pragma implementation "stream.h"
  23 #endif
  24
  25 // For compilers that support precompilation, includes "wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29   #pragma hdrstop
  30 #endif
  31
  32 #ifndef WX_PRECOMP
  33   #include "wx/defs.h"
  34 #endif
  35
  36 #if wxUSE_STREAMS
  37
  38 #include <ctype.h>
  39 #include "wx/stream.h"
  40 #include "wx/datstrm.h"
  41 #include "wx/textfile.h"
  42 #include "wx/log.h"
  43
  44 // ----------------------------------------------------------------------------
  45 // constants
  46 // ----------------------------------------------------------------------------
  47
  48 // the temporary buffer size used when copying from stream to stream
  49 #define BUF_TEMP_SIZE 10000
  50
  51 // ============================================================================
  52 // implementation
  53 // ============================================================================
  54
  55 // ----------------------------------------------------------------------------
  56 // wxStreamBuffer
  57 // ----------------------------------------------------------------------------
  58
  59 void wxStreamBuffer::SetError(wxStreamError err)
  60 {
  61    if ( m_stream->m_lasterror == wxStream_NOERROR )
  62        m_stream->m_lasterror = err;
  63 }
  64
  65 void wxStreamBuffer::InitBuffer()
  66 {
  67     m_buffer_start =
  68     m_buffer_end =
  69     m_buffer_pos = NULL;
  70     m_buffer_size = 0;
  71
  72     // if we are going to allocate the buffer, we should free it later as well
  73     m_destroybuf = TRUE;
  74 }
  75
  76 void wxStreamBuffer::Init()
  77 {
  78     InitBuffer();
  79
  80     m_fixed = TRUE;
  81 }
  82
  83 wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
  84 {
  85     Init();
  86
  87     m_stream = &stream;
  88     m_mode = mode;
  89
  90     m_flushable = TRUE;
  91     m_destroystream = FALSE;
  92 }
  93
  94 wxStreamBuffer::wxStreamBuffer(BufMode mode)
  95 {
  96     Init();
  97
  98     wxASSERT_MSG(mode != read_write, wxT("you have to use the other ctor for read_write mode") );
  99     if ( mode == read )
 100         m_stream = new wxInputStream;
 101     else if ( mode == write)
 102         m_stream = new wxOutputStream;
 103     else
 104         m_stream = NULL;
 105
 106     m_mode = mode;
 107
 108     m_flushable = FALSE;
 109     m_destroystream = TRUE;
 110 }
 111
 112 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 113 {
 114     // doing this has big chances to lead to a crashwhen the source buffer is
 115     // destroyed (otherwise assume the caller knows what he does)
 116     wxASSERT_MSG( !buffer.m_destroybuf && !buffer.m_destroystream,
 117                   _T("it's a bad idea to copy this buffer") );
 118
 119     m_buffer_start = buffer.m_buffer_start;
 120     m_buffer_end = buffer.m_buffer_end;
 121     m_buffer_pos = buffer.m_buffer_pos;
 122     m_buffer_size = buffer.m_buffer_size;
 123     m_fixed = buffer.m_fixed;
 124     m_flushable = buffer.m_flushable;
 125     m_stream = buffer.m_stream;
 126     m_mode = buffer.m_mode;
 127     m_destroybuf = FALSE;
 128     m_destroystream = FALSE;
 129 }
 130
 131 void wxStreamBuffer::FreeBuffer()
 132 {
 133     if ( m_destroybuf )
 134         free(m_buffer_start);
 135 }
 136
 137 wxStreamBuffer::~wxStreamBuffer()
 138 {
 139     FreeBuffer();
 140
 141     if ( m_destroystream )
 142         delete m_stream;
 143 }
 144
 145 wxInputStream *wxStreamBuffer::GetInputStream() const
 146 {
 147     return m_mode == write ? NULL : (wxInputStream *)m_stream;
 148 }
 149
 150 wxOutputStream *wxStreamBuffer::GetOutputStream() const
 151 {
 152     return m_mode == read ? NULL : (wxOutputStream *)m_stream;
 153 }
 154
 155 void wxStreamBuffer::SetBufferIO(void *buffer_start,
 156                                  void *buffer_end,
 157                                  bool takeOwnership)
 158 {
 159     SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start,
 160                 takeOwnership);
 161 }
 162
 163 void wxStreamBuffer::SetBufferIO(void *start,
 164                                  size_t len,
 165                                  bool takeOwnership)
 166 {
 167     // start by freeing the old buffer
 168     FreeBuffer();
 169
 170     m_buffer_start = (char *)start;
 171     m_buffer_end   = m_buffer_start + len;
 172
 173     m_buffer_size = len;
 174
 175     // if we own it, we free it
 176     m_destroybuf = takeOwnership;
 177
 178     ResetBuffer();
 179 }
 180
 181 void wxStreamBuffer::SetBufferIO(size_t bufsize)
 182 {
 183     // start by freeing the old buffer
 184     FreeBuffer();
 185
 186     if ( bufsize )
 187     {
 188         SetBufferIO(malloc(bufsize), bufsize, TRUE /* take ownership */);
 189     }
 190     else // no buffer size => no buffer
 191     {
 192         InitBuffer();
 193     }
 194 }
 195
 196 void wxStreamBuffer::ResetBuffer()
 197 {
 198     wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
 199
 200     m_stream->m_lasterror = wxStream_NOERROR;
 201     m_stream->m_lastcount = 0;
 202     if (m_mode == read && m_flushable)
 203         m_buffer_pos = m_buffer_end;
 204     else
 205         m_buffer_pos = m_buffer_start;
 206 }
 207
 208 // fill the buffer with as much data as possible (only for read buffers)
 209 bool wxStreamBuffer::FillBuffer()
 210 {
 211     wxInputStream *inStream = GetInputStream();
 212
 213     wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );
 214
 215     size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
 216     if ( !count )
 217         return FALSE;
 218
 219     m_buffer_end = m_buffer_start + count;
 220     m_buffer_pos = m_buffer_start;
 221
 222     return TRUE;
 223 }
 224
 225 // write the buffer contents to the stream (only for write buffers)
 226 bool wxStreamBuffer::FlushBuffer()
 227 {
 228     wxCHECK_MSG( m_flushable, FALSE, _T("can't flush this buffer") );
 229
 230     // FIXME: what is this check for? (VZ)
 231     if ( m_buffer_pos == m_buffer_start )
 232         return FALSE;
 233
 234     wxOutputStream *outStream = GetOutputStream();
 235
 236     wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );
 237
 238     size_t current = m_buffer_pos - m_buffer_start;
 239     size_t count = outStream->OnSysWrite(m_buffer_start, current);
 240     if ( count != current )
 241         return FALSE;
 242
 243     m_buffer_pos = m_buffer_start;
 244
 245     return TRUE;
 246 }
 247
 248 size_t wxStreamBuffer::GetDataLeft()
 249 {
 250     /* Why is this done? RR. */
 251     if ( m_buffer_pos == m_buffer_end && m_flushable)
 252         FillBuffer();
 253
 254     return GetBytesLeft();
 255 }
 256
 257 // copy up to size bytes from our buffer into the provided one
 258 void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
 259 {
 260     // don't get more bytes than left in the buffer
 261     size_t left = GetBytesLeft();
 262
 263     if ( size > left )
 264         size = left;
 265
 266     memcpy(buffer, m_buffer_pos, size);
 267     m_buffer_pos += size;
 268 }
 269
 270 // copy the contents of the provided buffer into this one
 271 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 272 {
 273     size_t left = GetBytesLeft();
 274     if ( size > left )
 275     {
 276         if ( m_fixed )
 277         {
 278             // we can't realloc the buffer, so just copy what we can
 279             size = left;
 280         }
 281         else // !m_fixed
 282         {
 283             // realloc the buffer to have enough space for the data
 284             size_t delta = m_buffer_pos - m_buffer_start;
 285
 286             char *startOld = m_buffer_start;
 287             m_buffer_size += size;
 288             m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size);
 289             if ( !m_buffer_start )
 290             {
 291                 // don't leak memory if realloc() failed
 292                 m_buffer_start = startOld;
 293                 m_buffer_size -= size;
 294
 295                 // what else can we do?
 296                 return;
 297             }
 298
 299             // adjust the pointers invalidated by realloc()
 300             m_buffer_pos = m_buffer_start + delta;
 301             m_buffer_end = m_buffer_start + m_buffer_size;
 302         }
 303     }
 304
 305     memcpy(m_buffer_pos, buffer, size);
 306     m_buffer_pos += size;
 307 }
 308
 309 void wxStreamBuffer::PutChar(char c)
 310 {
 311     wxOutputStream *outStream = GetOutputStream();
 312
 313     wxCHECK_RET( outStream, _T("should have a stream in wxStreamBuffer") );
 314
 315     // if we don't have buffer at all, just forward this call to the stream,
 316     if ( !HasBuffer() )
 317     {
 318         outStream->OnSysWrite(&c, 1);
 319     }
 320     else
 321     {
 322         // otherwise check we have enough space left
 323         if ( !GetDataLeft() && !FlushBuffer() )
 324         {
 325             // we don't
 326             SetError(wxStream_WRITE_ERR);
 327         }
 328         else
 329         {
 330             PutToBuffer(&c, 1);
 331             m_stream->m_lastcount = 1;
 332         }
 333     }
 334 }
 335
 336 char wxStreamBuffer::Peek()
 337 {
 338     wxCHECK_MSG( m_stream && HasBuffer(), 0,
 339                  _T("should have the stream and the buffer in wxStreamBuffer") );
 340
 341     if ( !GetDataLeft() )
 342     {
 343         SetError(wxStream_READ_ERR);
 344         return 0;
 345     }
 346
 347     char c;
 348     GetFromBuffer(&c, 1);
 349     m_buffer_pos--;
 350
 351     return c;
 352 }
 353
 354 char wxStreamBuffer::GetChar()
 355 {
 356     wxInputStream *inStream = GetInputStream();
 357
 358     wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
 359
 360     char c;
 361     if ( !HasBuffer() )
 362     {
 363         inStream->OnSysRead(&c, 1);
 364     }
 365     else
 366     {
 367         if ( !GetDataLeft() )
 368         {
 369             SetError(wxStream_READ_ERR);
 370             c = 0;
 371         }
 372         else
 373         {
 374             GetFromBuffer(&c, 1);
 375             m_stream->m_lastcount = 1;
 376         }
 377     }
 378
 379     return c;
 380 }
 381
 382 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 383 {
 384     wxInputStream *inStream = GetInputStream();
 385
 386     wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
 387
 388     // lasterror is reset before all new IO calls
 389     m_stream->m_lasterror = wxStream_NOERROR;
 390
 391     if ( !HasBuffer() )
 392     {
 393         m_stream->m_lastcount = inStream->OnSysRead(buffer, size);
 394     }
 395     else // we have a buffer, use it
 396     {
 397         size_t orig_size = size;
 398
 399         while ( size > 0 )
 400         {
 401             size_t left = GetDataLeft();
 402
 403             // if the requested number of bytes if greater than the buffer
 404             // size, read data in chunks
 405             if ( size > left )
 406             {
 407                 GetFromBuffer(buffer, left);
 408                 size -= left;
 409                 buffer = (char *)buffer + left;
 410
 411                 if ( !FillBuffer() )
 412                 {
 413                     SetError(wxStream_EOF);
 414                     break;
 415                 }
 416             }
 417             else // otherwise just do it in one gulp
 418             {
 419                 GetFromBuffer(buffer, size);
 420                 size = 0;
 421             }
 422         }
 423
 424         m_stream->m_lastcount = orig_size - size;
 425     }
 426
 427     return m_stream->m_lastcount;
 428 }
 429
 430 // this should really be called "Copy()"
 431 size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 432 {
 433     wxCHECK_MSG( m_mode != write, 0, _T("can't read from this buffer") );
 434
 435     char buf[BUF_TEMP_SIZE];
 436     size_t nRead,
 437            total = 0;
 438
 439     do
 440     {
 441         nRead = Read(dbuf, WXSIZEOF(buf));
 442         if ( nRead )
 443         {
 444             nRead = dbuf->Write(buf, nRead);
 445             total += nRead;
 446         }
 447     }
 448     while ( nRead );
 449
 450     return total;
 451 }
 452
 453 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 454 {
 455     wxOutputStream *outStream = GetOutputStream();
 456
 457     wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
 458
 459     // lasterror is reset before all new IO calls
 460     m_stream->m_lasterror = wxStream_NOERROR;
 461
 462     if ( !HasBuffer() && m_fixed )
 463     {
 464         // no buffer, just forward the call to the stream
 465         m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
 466     }
 467     else // we [may] have a buffer, use it
 468     {
 469         size_t orig_size = size;
 470
 471         while ( size > 0 )
 472         {
 473             size_t left = GetBytesLeft();
 474
 475             // if the buffer is too large to fit in the stream buffer, split
 476             // it in smaller parts
 477             //
 478             // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
 479             //     we always go to the second case.
 480             //
 481             // FIXME: fine, but if it fails we should (re)try writing it by
 482             //        chunks as this will (hopefully) always work (VZ)
 483             if ( size > left && m_fixed )
 484             {
 485                 PutToBuffer(buffer, left);
 486                 size -= left;
 487                 buffer = (char *)buffer + left;
 488
 489                 if ( !FlushBuffer() )
 490                 {
 491                     SetError(wxStream_WRITE_ERR);
 492
 493                     break;
 494                 }
 495
 496                 m_buffer_pos = m_buffer_start;
 497             }
 498             else // we can do it in one gulp
 499             {
 500                 PutToBuffer(buffer, size);
 501                 size = 0;
 502             }
 503         }
 504
 505         m_stream->m_lastcount = orig_size - size;
 506     }
 507
 508     return m_stream->m_lastcount;
 509 }
 510
 511 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
 512 {
 513     wxCHECK_MSG( m_mode != read, 0, _T("can't write to this buffer") );
 514     wxCHECK_MSG( sbuf->m_mode != write, 0, _T("can't read from that buffer") );
 515
 516     char buf[BUF_TEMP_SIZE];
 517     size_t nWrite,
 518            total = 0;
 519
 520     do
 521     {
 522         size_t nRead = sbuf->Read(buf, WXSIZEOF(buf));
 523         if ( nRead )
 524         {
 525             nWrite = Write(buf, nRead);
 526             if ( nWrite < nRead )
 527             {
 528                 // put back data we couldn't copy
 529                 wxInputStream *in_stream = (wxInputStream *)sbuf->GetStream();
 530
 531                 in_stream->Ungetch(buf + nWrite, nRead - nWrite);
 532             }
 533
 534             total += nWrite;
 535         }
 536         else
 537         {
 538             nWrite = 0;
 539         }
 540     }
 541     while ( nWrite == WXSIZEOF(buf) );
 542
 543     return total;
 544 }
 545
 546 off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
 547 {
 548     off_t ret_off, diff;
 549
 550     off_t last_access = GetLastAccess();
 551
 552     if ( !m_flushable )
 553     {
 554         switch (mode)
 555         {
 556             case wxFromStart:
 557                 diff = pos;
 558                 break;
 559
 560             case wxFromCurrent:
 561                 diff = pos + GetIntPosition();
 562                 break;
 563
 564             case wxFromEnd:
 565                 diff = pos + last_access;
 566                 break;
 567
 568             default:
 569                 wxFAIL_MSG( _T("invalid seek mode") );
 570
 571                 return wxInvalidOffset;
 572         }
 573         if (diff < 0 || diff > last_access)
 574             return wxInvalidOffset;
 575         SetIntPosition(diff);
 576         return diff;
 577     }
 578
 579     switch ( mode )
 580     {
 581         case wxFromStart:
 582             // We'll try to compute an internal position later ...
 583             ret_off = m_stream->OnSysSeek(pos, wxFromStart);
 584             ResetBuffer();
 585             return ret_off;
 586
 587         case wxFromCurrent:
 588             diff = pos + GetIntPosition();
 589
 590             if ( (diff > last_access) || (diff < 0) )
 591             {
 592                 // We must take into account the fact that we have read
 593                 // something previously.
 594                 ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent);
 595                 ResetBuffer();
 596                 return ret_off;
 597             }
 598             else
 599             {
 600                 SetIntPosition(diff);
 601                 return pos;
 602             }
 603
 604         case wxFromEnd:
 605             // Hard to compute: always seek to the requested position.
 606             ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
 607             ResetBuffer();
 608             return ret_off;
 609     }
 610
 611     return wxInvalidOffset;
 612 }
 613
 614 off_t wxStreamBuffer::Tell() const
 615 {
 616     off_t pos;
 617
 618     // only ask the stream for position if we have a real stream and not a
 619     // dummy one which we created ourselves, otherwise we'd call
 620     // wxStream::OnSysTell() which would always return wxInvalidOffset
 621     if ( !m_destroystream )
 622     {
 623         pos = m_stream->OnSysTell();
 624         if ( pos == wxInvalidOffset )
 625             return wxInvalidOffset;
 626     }
 627     else // no associated stream
 628     {
 629         pos = 0;
 630     }
 631
 632     pos += GetIntPosition();
 633
 634     if ( m_mode == read && m_flushable )
 635         pos -= GetLastAccess();
 636
 637     return pos;
 638 }
 639
 640 // ----------------------------------------------------------------------------
 641 // wxStreamBase
 642 // ----------------------------------------------------------------------------
 643
 644 wxStreamBase::wxStreamBase()
 645 {
 646     m_lasterror = wxStream_NOERROR;
 647     m_lastcount = 0;
 648 }
 649
 650 wxStreamBase::~wxStreamBase()
 651 {
 652 }
 653
 654 off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 655 {
 656     return wxInvalidOffset;
 657 }
 658
 659 off_t wxStreamBase::OnSysTell() const
 660 {
 661     return wxInvalidOffset;
 662 }
 663
 664 // ----------------------------------------------------------------------------
 665 // wxInputStream
 666 // ----------------------------------------------------------------------------
 667
 668 wxInputStream::wxInputStream()
 669 {
 670     m_wback = NULL;
 671     m_wbacksize =
 672     m_wbackcur = 0;
 673 }
 674
 675 wxInputStream::~wxInputStream()
 676 {
 677     free(m_wback);
 678 }
 679
 680 size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
 681                                 size_t WXUNUSED(bufsize))
 682 {
 683     return 0;
 684 }
 685
 686 bool wxInputStream::Eof() const
 687 {
 688     wxInputStream *self = wxConstCast(this, wxInputStream);
 689
 690     char c;
 691     self->Read(&c, 1);
 692
 693     // some streams can know that they're at EOF before actually trying to
 694     // read beyond the end of stream (e.g. files) while others have no way of
 695     // knowing it, so to provide the same behaviour in all cases we only
 696     // return TRUE from here if the character really couldn't be read
 697     if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )
 698     {
 699         return TRUE;
 700     }
 701
 702     self->Ungetch(c);
 703
 704     return FALSE;
 705 }
 706
 707 char *wxInputStream::AllocSpaceWBack(size_t needed_size)
 708 {
 709     // get number of bytes left from previous wback buffer
 710     size_t toget = m_wbacksize - m_wbackcur;
 711
 712     // allocate a buffer large enough to hold prev + new data
 713     char *temp_b = (char *)malloc(needed_size + toget);
 714
 715     if (!temp_b)
 716         return NULL;
 717
 718     // copy previous data (and free old buffer) if needed
 719     if (m_wback)
 720     {
 721         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
 722         free(m_wback);
 723     }
 724
 725     // done
 726     m_wback = temp_b;
 727     m_wbackcur = 0;
 728     m_wbacksize = needed_size + toget;
 729
 730     return m_wback;
 731 }
 732
 733 size_t wxInputStream::GetWBack(void *buf, size_t bsize)
 734 {
 735     if (!m_wback)
 736         return 0;
 737
 738     // how many bytes do we have in the buffer?
 739     size_t toget = m_wbacksize - m_wbackcur;
 740
 741     if ( bsize < toget )
 742     {
 743         // we won't read everything
 744         toget = bsize;
 745     }
 746
 747     // copy the data from the cache
 748     memcpy(buf, m_wback + m_wbackcur, toget);
 749
 750     m_wbackcur += toget;
 751     if ( m_wbackcur == m_wbacksize )
 752     {
 753         // TODO: should we really free it here all the time? maybe keep it?
 754         free(m_wback);
 755         m_wback = NULL;
 756         m_wbacksize = 0;
 757         m_wbackcur = 0;
 758     }
 759
 760     // return the number of bytes copied
 761     return toget;
 762 }
 763
 764 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 765 {
 766     char *ptrback = AllocSpaceWBack(bufsize);
 767     if (!ptrback)
 768         return 0;
 769
 770     memcpy(ptrback, buf, bufsize);
 771     return bufsize;
 772 }
 773
 774 bool wxInputStream::Ungetch(char c)
 775 {
 776     void *ptrback = AllocSpaceWBack(1);
 777     if (!ptrback)
 778         return FALSE;
 779
 780     *(char *)ptrback = c;
 781     return TRUE;
 782 }
 783
 784 char wxInputStream::GetC()
 785 {
 786     char c;
 787     Read(&c, 1);
 788     return c;
 789 }
 790
 791 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 792 {
 793     size_t retsize = GetWBack(buf, size);
 794     if (retsize == size)
 795     {
 796         m_lastcount = size;
 797         m_lasterror = wxStream_NOERROR;
 798         return *this;
 799     }
 800     size -= retsize;
 801     buf = (char *)buf + retsize;
 802
 803     m_lastcount = OnSysRead(buf, size) + retsize;
 804     return *this;
 805 }
 806
 807 char wxInputStream::Peek()
 808 {
 809     char c;
 810     Read(&c, 1);
 811     if (m_lasterror == wxStream_NOERROR)
 812     {
 813         Ungetch(c);
 814         return c;
 815     }
 816
 817     return 0;
 818 }
 819
 820 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 821 {
 822     char buf[BUF_TEMP_SIZE];
 823     size_t bytes_read = BUF_TEMP_SIZE;
 824
 825     while (bytes_read == BUF_TEMP_SIZE)
 826     {
 827         bytes_read = Read(buf, bytes_read).LastRead();
 828         bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
 829     }
 830     return *this;
 831 }
 832
 833 off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 834 {
 835     // RR: This code is duplicated in wxBufferedInputStream. This is
 836     // not really a good design, but buffered stream are different
 837     // from all other in that they handle two stream-related objects,
 838     // the stream buffer and parent stream.
 839
 840     // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
 841     if (m_lasterror==wxSTREAM_EOF)
 842         m_lasterror=wxSTREAM_NOERROR;
 843
 844     /* RR: A call to SeekI() will automatically invalidate any previous
 845        call to Ungetch(), otherwise it would be possible to SeekI() to
 846        one position, unread some bytes there, SeekI() to another position
 847        and the data would be corrupted.
 848
 849        GRG: Could add code here to try to navigate within the wback
 850        buffer if possible, but is it really needed? It would only work
 851        when seeking in wxFromCurrent mode, else it would invalidate
 852        anyway... */
 853
 854     if (m_wback)
 855     {
 856         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
 857
 858         free(m_wback);
 859         m_wback = NULL;
 860         m_wbacksize = 0;
 861         m_wbackcur = 0;
 862     }
 863
 864     return OnSysSeek(pos, mode);
 865 }
 866
 867 off_t wxInputStream::TellI() const
 868 {
 869     off_t pos = OnSysTell();
 870
 871     if (pos != wxInvalidOffset)
 872         pos -= (m_wbacksize - m_wbackcur);
 873
 874     return pos;
 875 }
 876
 877
 878 // ----------------------------------------------------------------------------
 879 // wxOutputStream
 880 // ----------------------------------------------------------------------------
 881
 882 wxOutputStream::wxOutputStream()
 883 {
 884 }
 885
 886 wxOutputStream::~wxOutputStream()
 887 {
 888 }
 889
 890 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
 891                                   size_t WXUNUSED(bufsize))
 892 {
 893     return 0;
 894 }
 895
 896 void wxOutputStream::PutC(char c)
 897 {
 898     Write(&c, 1);
 899 }
 900
 901 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 902 {
 903     m_lastcount = OnSysWrite(buffer, size);
 904     return *this;
 905 }
 906
 907 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
 908 {
 909     stream_in.Read(*this);
 910     return *this;
 911 }
 912
 913 off_t wxOutputStream::TellO() const
 914 {
 915     return OnSysTell();
 916 }
 917
 918 off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
 919 {
 920     return OnSysSeek(pos, mode);
 921 }
 922
 923 void wxOutputStream::Sync()
 924 {
 925 }
 926
 927
 928 // ----------------------------------------------------------------------------
 929 // wxCountingOutputStream
 930 // ----------------------------------------------------------------------------
 931
 932 wxCountingOutputStream::wxCountingOutputStream ()
 933 {
 934      m_currentPos = 0;
 935 }
 936
 937 size_t wxCountingOutputStream::GetSize() const
 938 {
 939     return m_lastcount;
 940 }
 941
 942 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
 943                                           size_t size)
 944 {
 945     m_currentPos += size;
 946     if (m_currentPos > m_lastcount)
 947         m_lastcount = m_currentPos;
 948
 949     return m_currentPos;
 950 }
 951
 952 off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
 953 {
 954     switch ( mode )
 955     {
 956         case wxFromStart:
 957             m_currentPos = pos;
 958             break;
 959
 960         case wxFromEnd:
 961             m_currentPos = m_lastcount + pos;
 962             break;
 963
 964         case wxFromCurrent:
 965             m_currentPos += pos;
 966             break;
 967
 968         default:
 969             wxFAIL_MSG( _T("invalid seek mode") );
 970             return wxInvalidOffset;
 971     }
 972
 973     if (m_currentPos > m_lastcount)
 974         m_lastcount = m_currentPos;
 975
 976     return m_currentPos;
 977 }
 978
 979 off_t wxCountingOutputStream::OnSysTell() const
 980 {
 981     return m_currentPos;
 982 }
 983
 984 // ----------------------------------------------------------------------------
 985 // wxFilterInputStream
 986 // ----------------------------------------------------------------------------
 987
 988 wxFilterInputStream::wxFilterInputStream()
 989 {
 990     m_parent_i_stream = NULL;
 991 }
 992
 993 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 994 {
 995     m_parent_i_stream = &stream;
 996 }
 997
 998 wxFilterInputStream::~wxFilterInputStream()
 999 {
1000 }
1001
1002 // ----------------------------------------------------------------------------
1003 // wxFilterOutputStream
1004 // ----------------------------------------------------------------------------
1005
1006 wxFilterOutputStream::wxFilterOutputStream()
1007 {
1008     m_parent_o_stream = NULL;
1009 }
1010
1011 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
1012 {
1013     m_parent_o_stream = &stream;
1014 }
1015
1016 wxFilterOutputStream::~wxFilterOutputStream()
1017 {
1018 }
1019
1020 // ----------------------------------------------------------------------------
1021 // wxBufferedInputStream
1022 // ----------------------------------------------------------------------------
1023
1024 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
1025                                              wxStreamBuffer *buffer)
1026                      : wxFilterInputStream(s)
1027 {
1028     if ( buffer )
1029     {
1030         // use the buffer provided by the user
1031         m_i_streambuf = buffer;
1032     }
1033     else // create a default buffer
1034     {
1035         m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
1036
1037         m_i_streambuf->SetBufferIO(1024);
1038     }
1039 }
1040
1041 wxBufferedInputStream::~wxBufferedInputStream()
1042 {
1043     m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
1044                              wxFromCurrent);
1045
1046     delete m_i_streambuf;
1047 }
1048
1049 char wxBufferedInputStream::Peek()
1050 {
1051     return m_i_streambuf->Peek();
1052 }
1053
1054 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
1055 {
1056     // reset the error flag
1057     m_lasterror = wxStream_NOERROR;
1058
1059     // first read from the already cached data
1060     m_lastcount = GetWBack(buf, size);
1061
1062     // do we have to read anything more?
1063     if ( m_lastcount < size )
1064     {
1065         size -= m_lastcount;
1066         buf = (char *)buf + m_lastcount;
1067
1068         // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
1069         // so save it
1070         size_t countOld = m_lastcount;
1071
1072         m_i_streambuf->Read(buf, size);
1073
1074         m_lastcount += countOld;
1075     }
1076
1077     return *this;
1078 }
1079
1080 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
1081 {
1082     // RR: Look at wxInputStream for comments.
1083
1084     if (m_lasterror==wxSTREAM_EOF)
1085         m_lasterror=wxSTREAM_NOERROR;
1086
1087     if (m_wback)
1088     {
1089         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
1090
1091         free(m_wback);
1092         m_wback = NULL;
1093         m_wbacksize = 0;
1094         m_wbackcur = 0;
1095     }
1096
1097     return m_i_streambuf->Seek(pos, mode);
1098 }
1099
1100 off_t wxBufferedInputStream::TellI() const
1101 {
1102     off_t pos = m_i_streambuf->Tell();
1103
1104     if (pos != wxInvalidOffset)
1105         pos -= (m_wbacksize - m_wbackcur);
1106
1107     return pos;
1108 }
1109
1110 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
1111 {
1112     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
1113 }
1114
1115 off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1116 {
1117     return m_parent_i_stream->SeekI(seek, mode);
1118 }
1119
1120 off_t wxBufferedInputStream::OnSysTell() const
1121 {
1122     return m_parent_i_stream->TellI();
1123 }
1124
1125 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
1126 {
1127     wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
1128
1129     delete m_i_streambuf;
1130     m_i_streambuf = buffer;
1131 }
1132
1133 // ----------------------------------------------------------------------------
1134 // wxBufferedOutputStream
1135 // ----------------------------------------------------------------------------
1136
1137 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
1138                                                wxStreamBuffer *buffer)
1139                       : wxFilterOutputStream(s)
1140 {
1141     if ( buffer )
1142     {
1143         m_o_streambuf = buffer;
1144     }
1145     else // create a default one
1146     {
1147         m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
1148
1149         m_o_streambuf->SetBufferIO(1024);
1150     }
1151 }
1152
1153 wxBufferedOutputStream::~wxBufferedOutputStream()
1154 {
1155     Sync();
1156     delete m_o_streambuf;
1157 }
1158
1159 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
1160 {
1161     m_lastcount = 0;
1162     m_o_streambuf->Write(buffer, size);
1163     return *this;
1164 }
1165
1166 off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
1167 {
1168     Sync();
1169     return m_o_streambuf->Seek(pos, mode);
1170 }
1171
1172 off_t wxBufferedOutputStream::TellO() const
1173 {
1174     return m_o_streambuf->Tell();
1175 }
1176
1177 void wxBufferedOutputStream::Sync()
1178 {
1179     m_o_streambuf->FlushBuffer();
1180     m_parent_o_stream->Sync();
1181 }
1182
1183 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
1184 {
1185     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
1186 }
1187
1188 off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1189 {
1190     return m_parent_o_stream->SeekO(seek, mode);
1191 }
1192
1193 off_t wxBufferedOutputStream::OnSysTell() const
1194 {
1195     return m_parent_o_stream->TellO();
1196 }
1197
1198 size_t wxBufferedOutputStream::GetSize() const
1199 {
1200    return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
1201 }
1202
1203 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
1204 {
1205     wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
1206
1207     delete m_o_streambuf;
1208     m_o_streambuf = buffer;
1209 }
1210
1211 // ----------------------------------------------------------------------------
1212 // Some IOManip function
1213 // ----------------------------------------------------------------------------
1214
1215 wxOutputStream& wxEndL(wxOutputStream& stream)
1216 {
1217     static const wxChar *eol = wxTextFile::GetEOL();
1218
1219     return stream.Write(eol, wxStrlen(eol));
1220 }
1221
1222 #endif
1223   // wxUSE_STREAMS