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/objstrm.h"
  42 #include "wx/textfile.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     // there is nothing to destroy anyhow
  73     m_destroybuf = FALSE;
  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 = m_stream->OnSysTell();
 617     if ( pos == wxInvalidOffset )
 618         return wxInvalidOffset;
 619
 620     pos += GetIntPosition();
 621
 622     if ( m_mode == read && m_flushable )
 623         pos -= GetLastAccess();
 624
 625     return pos;
 626 }
 627
 628 // ----------------------------------------------------------------------------
 629 // wxStreamBase
 630 // ----------------------------------------------------------------------------
 631
 632 wxStreamBase::wxStreamBase()
 633 {
 634     m_lasterror = wxStream_NOERROR;
 635     m_lastcount = 0;
 636 }
 637
 638 wxStreamBase::~wxStreamBase()
 639 {
 640 }
 641
 642 off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 643 {
 644     return wxInvalidOffset;
 645 }
 646
 647 off_t wxStreamBase::OnSysTell() const
 648 {
 649     return wxInvalidOffset;
 650 }
 651
 652 // ----------------------------------------------------------------------------
 653 // wxInputStream
 654 // ----------------------------------------------------------------------------
 655
 656 wxInputStream::wxInputStream()
 657 {
 658     m_wback = NULL;
 659     m_wbacksize =
 660     m_wbackcur = 0;
 661 }
 662
 663 wxInputStream::~wxInputStream()
 664 {
 665     free(m_wback);
 666 }
 667
 668 size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
 669                                 size_t WXUNUSED(bufsize))
 670 {
 671     return 0;
 672 }
 673
 674 bool wxInputStream::Eof() const
 675 {
 676     wxInputStream *self = wxConstCast(this, wxInputStream);
 677
 678     char c;
 679     self->Read(&c, 1);
 680
 681     // some streams can know that they're at EOF before actually trying to
 682     // read beyond the end of stream (e.g. files) while others have no way of
 683     // knowing it, so to provide the same behaviour in all cases we only
 684     // return TRUE from here if the character really couldn't be read
 685     if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )
 686     {
 687         return TRUE;
 688     }
 689
 690     self->Ungetch(c);
 691
 692     return FALSE;
 693 }
 694
 695 char *wxInputStream::AllocSpaceWBack(size_t needed_size)
 696 {
 697     // get number of bytes left from previous wback buffer
 698     size_t toget = m_wbacksize - m_wbackcur;
 699
 700     // allocate a buffer large enough to hold prev + new data
 701     char *temp_b = (char *)malloc(needed_size + toget);
 702
 703     if (!temp_b)
 704         return NULL;
 705
 706     /* copy previous data (and free old buffer) if needed */
 707     if (m_wback)
 708     {
 709         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
 710         free(m_wback);
 711     }
 712
 713     /* done */
 714     m_wback = temp_b;
 715     m_wbackcur = 0;
 716     m_wbacksize = needed_size + toget;
 717
 718     return m_wback;
 719 }
 720
 721 size_t wxInputStream::GetWBack(void *buf, size_t bsize)
 722 {
 723     size_t toget = m_wbacksize-m_wbackcur;
 724
 725     if (!m_wback)
 726         return 0;
 727
 728     if (bsize < toget)
 729        toget = bsize;
 730
 731     memcpy(buf, (m_wback+m_wbackcur), toget);
 732
 733     m_wbackcur += toget;
 734     if (m_wbackcur == m_wbacksize)
 735     {
 736         free(m_wback);
 737         m_wback = NULL;
 738         m_wbacksize = 0;
 739         m_wbackcur = 0;
 740     }
 741
 742     return toget;
 743 }
 744
 745 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 746 {
 747     char *ptrback = AllocSpaceWBack(bufsize);
 748     if (!ptrback)
 749         return 0;
 750
 751     memcpy(ptrback, buf, bufsize);
 752     return bufsize;
 753 }
 754
 755 bool wxInputStream::Ungetch(char c)
 756 {
 757     void *ptrback = AllocSpaceWBack(1);
 758     if (!ptrback)
 759         return FALSE;
 760
 761     *(char *)ptrback = c;
 762     return TRUE;
 763 }
 764
 765 char wxInputStream::GetC()
 766 {
 767     char c;
 768     Read(&c, 1);
 769     return c;
 770 }
 771
 772 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 773 {
 774     size_t retsize = GetWBack(buf, size);
 775     if (retsize == size)
 776     {
 777         m_lastcount = size;
 778         m_lasterror = wxStream_NOERROR;
 779         return *this;
 780     }
 781     size -= retsize;
 782     buf = (char *)buf + retsize;
 783
 784     m_lastcount = OnSysRead(buf, size) + retsize;
 785     return *this;
 786 }
 787
 788 char wxInputStream::Peek()
 789 {
 790     char c;
 791     Read(&c, 1);
 792     if (m_lasterror == wxStream_NOERROR)
 793     {
 794         Ungetch(c);
 795         return c;
 796     }
 797
 798     return 0;
 799 }
 800
 801 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 802 {
 803     char buf[BUF_TEMP_SIZE];
 804     size_t bytes_read = BUF_TEMP_SIZE;
 805
 806     while (bytes_read == BUF_TEMP_SIZE)
 807     {
 808         bytes_read = Read(buf, bytes_read).LastRead();
 809         bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
 810     }
 811     return *this;
 812 }
 813
 814 off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 815 {
 816     /* Should be check and improve, just to remove a slight bug !
 817        I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */
 818     if (m_lasterror==wxSTREAM_EOF)
 819         m_lasterror=wxSTREAM_NOERROR;
 820
 821     /* A call to SeekI() will automatically invalidate any previous call
 822        to Ungetch(), otherwise it would be possible to SeekI() to one
 823        one position, unread some bytes there, SeekI() to another position
 824        and the data would be corrupted.
 825
 826        GRG: Could add code here to try to navigate within the wback
 827        buffer if possible, but is it really needed? It would only work
 828        when seeking in wxFromCurrent mode, else it would invalidate
 829        anyway...
 830      */
 831     if (m_wback)
 832     {
 833         free(m_wback);
 834         m_wback = NULL;
 835         m_wbacksize = 0;
 836         m_wbackcur = 0;
 837     }
 838
 839     return OnSysSeek(pos, mode);
 840 }
 841
 842 off_t wxInputStream::TellI() const
 843 {
 844     /* GRG: Changed to make it compatible with the wback buffer */
 845     off_t pos = OnSysTell();
 846
 847     if (pos != wxInvalidOffset)
 848         pos -= (m_wbacksize - m_wbackcur);
 849
 850     return pos;
 851 }
 852
 853 // --------------------
 854 // Overloaded operators
 855 // --------------------
 856
 857 #if wxUSE_SERIAL
 858 wxInputStream& wxInputStream::operator>>(wxObject *& obj)
 859 {
 860     wxObjectInputStream obj_s(*this);
 861     obj = obj_s.LoadObject();
 862     return *this;
 863 }
 864 #endif // wxUSE_SERIAL
 865
 866
 867 // ----------------------------------------------------------------------------
 868 // wxOutputStream
 869 // ----------------------------------------------------------------------------
 870
 871 wxOutputStream::wxOutputStream()
 872 {
 873 }
 874
 875 wxOutputStream::~wxOutputStream()
 876 {
 877 }
 878
 879 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
 880                                   size_t WXUNUSED(bufsize))
 881 {
 882     return 0;
 883 }
 884
 885 void wxOutputStream::PutC(char c)
 886 {
 887     Write(&c, 1);
 888 }
 889
 890 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 891 {
 892     m_lastcount = OnSysWrite(buffer, size);
 893     return *this;
 894 }
 895
 896 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
 897 {
 898     stream_in.Read(*this);
 899     return *this;
 900 }
 901
 902 off_t wxOutputStream::TellO() const
 903 {
 904     return OnSysTell();
 905 }
 906
 907 off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
 908 {
 909     return OnSysSeek(pos, mode);
 910 }
 911
 912 void wxOutputStream::Sync()
 913 {
 914 }
 915
 916 #if wxUSE_SERIAL
 917 wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
 918 {
 919     wxObjectOutputStream obj_s(*this);
 920     obj_s.SaveObject(obj);
 921     return *this;
 922 }
 923 #endif // wxUSE_SERIAL
 924
 925 // ----------------------------------------------------------------------------
 926 // wxCountingOutputStream
 927 // ----------------------------------------------------------------------------
 928
 929 wxCountingOutputStream::wxCountingOutputStream ()
 930 {
 931      m_currentPos = 0;
 932 }
 933
 934 size_t wxCountingOutputStream::GetSize() const
 935 {
 936     return m_lastcount;
 937 }
 938
 939 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
 940                                           size_t size)
 941 {
 942     m_currentPos += size;
 943     if (m_currentPos > m_lastcount)
 944         m_lastcount = m_currentPos;
 945
 946     return m_currentPos;
 947 }
 948
 949 off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
 950 {
 951     switch ( mode )
 952     {
 953         case wxFromStart:
 954             m_currentPos = pos;
 955             break;
 956
 957         case wxFromEnd:
 958             m_currentPos = m_lastcount + pos;
 959             break;
 960
 961         case wxFromCurrent:
 962             m_currentPos += pos;
 963             break;
 964
 965         default:
 966             wxFAIL_MSG( _T("invalid seek mode") );
 967             return wxInvalidOffset;
 968     }
 969
 970     if (m_currentPos > m_lastcount)
 971         m_lastcount = m_currentPos;
 972
 973     return m_currentPos;
 974 }
 975
 976 off_t wxCountingOutputStream::OnSysTell() const
 977 {
 978     return m_currentPos;
 979 }
 980
 981 // ----------------------------------------------------------------------------
 982 // wxFilterInputStream
 983 // ----------------------------------------------------------------------------
 984
 985 wxFilterInputStream::wxFilterInputStream()
 986 {
 987     m_parent_i_stream = NULL;
 988 }
 989
 990 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 991 {
 992     m_parent_i_stream = &stream;
 993 }
 994
 995 wxFilterInputStream::~wxFilterInputStream()
 996 {
 997 }
 998
 999 // ----------------------------------------------------------------------------
1000 // wxFilterOutputStream
1001 // ----------------------------------------------------------------------------
1002
1003 wxFilterOutputStream::wxFilterOutputStream()
1004 {
1005     m_parent_o_stream = NULL;
1006 }
1007
1008 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
1009 {
1010     m_parent_o_stream = &stream;
1011 }
1012
1013 wxFilterOutputStream::~wxFilterOutputStream()
1014 {
1015 }
1016
1017 // ----------------------------------------------------------------------------
1018 // wxBufferedInputStream
1019 // ----------------------------------------------------------------------------
1020
1021 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
1022                                              wxStreamBuffer *buffer)
1023                      : wxFilterInputStream(s)
1024 {
1025     if ( buffer )
1026     {
1027         // use the buffer provided by the user
1028         m_i_streambuf = buffer;
1029     }
1030     else // create a default buffer
1031     {
1032         m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
1033
1034         m_i_streambuf->SetBufferIO(1024);
1035     }
1036 }
1037
1038 wxBufferedInputStream::~wxBufferedInputStream()
1039 {
1040     m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
1041                              wxFromCurrent);
1042
1043     delete m_i_streambuf;
1044 }
1045
1046 char wxBufferedInputStream::Peek()
1047 {
1048     return m_i_streambuf->Peek();
1049 }
1050
1051 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
1052 {
1053     size_t retsize;
1054
1055     retsize = GetWBack(buf, size);
1056     m_lastcount = retsize;
1057     if ( retsize == size )
1058     {
1059         m_lasterror = wxStream_NOERROR;
1060         return *this;
1061     }
1062     size -= retsize;
1063     buf = (char *)buf + retsize;
1064
1065     m_i_streambuf->Read(buf, size);
1066
1067     return *this;
1068 }
1069
1070 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
1071 {
1072     return m_i_streambuf->Seek(pos, mode);
1073 }
1074
1075 off_t wxBufferedInputStream::TellI() const
1076 {
1077     return m_i_streambuf->Tell();
1078 }
1079
1080 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
1081 {
1082     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
1083 }
1084
1085 off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1086 {
1087     return m_parent_i_stream->SeekI(seek, mode);
1088 }
1089
1090 off_t wxBufferedInputStream::OnSysTell() const
1091 {
1092     return m_parent_i_stream->TellI();
1093 }
1094
1095 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
1096 {
1097     wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
1098
1099     delete m_i_streambuf;
1100     m_i_streambuf = buffer;
1101 }
1102
1103 // ----------------------------------------------------------------------------
1104 // wxBufferedOutputStream
1105 // ----------------------------------------------------------------------------
1106
1107 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
1108                                                wxStreamBuffer *buffer)
1109                       : wxFilterOutputStream(s)
1110 {
1111     if ( buffer )
1112     {
1113         m_o_streambuf = buffer;
1114     }
1115     else // create a default one
1116     {
1117         m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
1118
1119         m_o_streambuf->SetBufferIO(1024);
1120     }
1121 }
1122
1123 wxBufferedOutputStream::~wxBufferedOutputStream()
1124 {
1125     Sync();
1126     delete m_o_streambuf;
1127 }
1128
1129 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
1130 {
1131     m_lastcount = 0;
1132     m_o_streambuf->Write(buffer, size);
1133     return *this;
1134 }
1135
1136 off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
1137 {
1138     Sync();
1139     return m_o_streambuf->Seek(pos, mode);
1140 }
1141
1142 off_t wxBufferedOutputStream::TellO() const
1143 {
1144     return m_o_streambuf->Tell();
1145 }
1146
1147 void wxBufferedOutputStream::Sync()
1148 {
1149     m_o_streambuf->FlushBuffer();
1150     m_parent_o_stream->Sync();
1151 }
1152
1153 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
1154 {
1155     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
1156 }
1157
1158 off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1159 {
1160     return m_parent_o_stream->SeekO(seek, mode);
1161 }
1162
1163 off_t wxBufferedOutputStream::OnSysTell() const
1164 {
1165     return m_parent_o_stream->TellO();
1166 }
1167
1168 size_t wxBufferedOutputStream::GetSize() const
1169 {
1170    return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
1171 }
1172
1173 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
1174 {
1175     wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
1176
1177     delete m_o_streambuf;
1178     m_o_streambuf = buffer;
1179 }
1180
1181 // ----------------------------------------------------------------------------
1182 // Some IOManip function
1183 // ----------------------------------------------------------------------------
1184
1185 wxOutputStream& wxEndL(wxOutputStream& stream)
1186 {
1187     static const wxChar *eol = wxTextFile::GetEOL();
1188
1189     return stream.Write(eol, wxStrlen(eol));
1190 }
1191
1192 #endif
1193   // wxUSE_STREAMS