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     if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF )
 767     {
 768         // can't operate on this stream until the error is cleared
 769         return 0;
 770     }
 771
 772     char *ptrback = AllocSpaceWBack(bufsize);
 773     if (!ptrback)
 774         return 0;
 775
 776     // Eof() shouldn't return TRUE any longer
 777     if ( m_lasterror == wxSTREAM_EOF )
 778         m_lasterror = wxSTREAM_NO_ERROR;
 779
 780     memcpy(ptrback, buf, bufsize);
 781     return bufsize;
 782 }
 783
 784 bool wxInputStream::Ungetch(char c)
 785 {
 786     return Ungetch(&c, sizeof(char)) != 0;
 787 }
 788
 789 char wxInputStream::GetC()
 790 {
 791     char c;
 792     Read(&c, 1);
 793     return c;
 794 }
 795
 796 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 797 {
 798     size_t retsize = GetWBack(buf, size);
 799     if (retsize == size)
 800     {
 801         m_lastcount = size;
 802         m_lasterror = wxStream_NOERROR;
 803         return *this;
 804     }
 805     size -= retsize;
 806     buf = (char *)buf + retsize;
 807
 808     m_lastcount = OnSysRead(buf, size) + retsize;
 809     return *this;
 810 }
 811
 812 char wxInputStream::Peek()
 813 {
 814     char c;
 815     Read(&c, 1);
 816     if (m_lasterror == wxStream_NOERROR)
 817     {
 818         Ungetch(c);
 819         return c;
 820     }
 821
 822     return 0;
 823 }
 824
 825 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 826 {
 827     char buf[BUF_TEMP_SIZE];
 828     size_t bytes_read = BUF_TEMP_SIZE;
 829
 830     while (bytes_read == BUF_TEMP_SIZE)
 831     {
 832         bytes_read = Read(buf, bytes_read).LastRead();
 833         bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
 834     }
 835     return *this;
 836 }
 837
 838 off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 839 {
 840     // RR: This code is duplicated in wxBufferedInputStream. This is
 841     // not really a good design, but buffered stream are different
 842     // from all other in that they handle two stream-related objects,
 843     // the stream buffer and parent stream.
 844
 845     // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
 846     if (m_lasterror==wxSTREAM_EOF)
 847         m_lasterror=wxSTREAM_NOERROR;
 848
 849     /* RR: A call to SeekI() will automatically invalidate any previous
 850        call to Ungetch(), otherwise it would be possible to SeekI() to
 851        one position, unread some bytes there, SeekI() to another position
 852        and the data would be corrupted.
 853
 854        GRG: Could add code here to try to navigate within the wback
 855        buffer if possible, but is it really needed? It would only work
 856        when seeking in wxFromCurrent mode, else it would invalidate
 857        anyway... */
 858
 859     if (m_wback)
 860     {
 861         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
 862
 863         free(m_wback);
 864         m_wback = NULL;
 865         m_wbacksize = 0;
 866         m_wbackcur = 0;
 867     }
 868
 869     return OnSysSeek(pos, mode);
 870 }
 871
 872 off_t wxInputStream::TellI() const
 873 {
 874     off_t pos = OnSysTell();
 875
 876     if (pos != wxInvalidOffset)
 877         pos -= (m_wbacksize - m_wbackcur);
 878
 879     return pos;
 880 }
 881
 882
 883 // ----------------------------------------------------------------------------
 884 // wxOutputStream
 885 // ----------------------------------------------------------------------------
 886
 887 wxOutputStream::wxOutputStream()
 888 {
 889 }
 890
 891 wxOutputStream::~wxOutputStream()
 892 {
 893 }
 894
 895 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
 896                                   size_t WXUNUSED(bufsize))
 897 {
 898     return 0;
 899 }
 900
 901 void wxOutputStream::PutC(char c)
 902 {
 903     Write(&c, 1);
 904 }
 905
 906 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 907 {
 908     m_lastcount = OnSysWrite(buffer, size);
 909     return *this;
 910 }
 911
 912 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
 913 {
 914     stream_in.Read(*this);
 915     return *this;
 916 }
 917
 918 off_t wxOutputStream::TellO() const
 919 {
 920     return OnSysTell();
 921 }
 922
 923 off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
 924 {
 925     return OnSysSeek(pos, mode);
 926 }
 927
 928 void wxOutputStream::Sync()
 929 {
 930 }
 931
 932
 933 // ----------------------------------------------------------------------------
 934 // wxCountingOutputStream
 935 // ----------------------------------------------------------------------------
 936
 937 wxCountingOutputStream::wxCountingOutputStream ()
 938 {
 939      m_currentPos = 0;
 940 }
 941
 942 size_t wxCountingOutputStream::GetSize() const
 943 {
 944     return m_lastcount;
 945 }
 946
 947 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
 948                                           size_t size)
 949 {
 950     m_currentPos += size;
 951     if (m_currentPos > m_lastcount)
 952         m_lastcount = m_currentPos;
 953
 954     return m_currentPos;
 955 }
 956
 957 off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
 958 {
 959     switch ( mode )
 960     {
 961         case wxFromStart:
 962             m_currentPos = pos;
 963             break;
 964
 965         case wxFromEnd:
 966             m_currentPos = m_lastcount + pos;
 967             break;
 968
 969         case wxFromCurrent:
 970             m_currentPos += pos;
 971             break;
 972
 973         default:
 974             wxFAIL_MSG( _T("invalid seek mode") );
 975             return wxInvalidOffset;
 976     }
 977
 978     if (m_currentPos > m_lastcount)
 979         m_lastcount = m_currentPos;
 980
 981     return m_currentPos;
 982 }
 983
 984 off_t wxCountingOutputStream::OnSysTell() const
 985 {
 986     return m_currentPos;
 987 }
 988
 989 // ----------------------------------------------------------------------------
 990 // wxFilterInputStream
 991 // ----------------------------------------------------------------------------
 992
 993 wxFilterInputStream::wxFilterInputStream()
 994 {
 995     m_parent_i_stream = NULL;
 996 }
 997
 998 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 999 {
1000     m_parent_i_stream = &stream;
1001 }
1002
1003 wxFilterInputStream::~wxFilterInputStream()
1004 {
1005 }
1006
1007 // ----------------------------------------------------------------------------
1008 // wxFilterOutputStream
1009 // ----------------------------------------------------------------------------
1010
1011 wxFilterOutputStream::wxFilterOutputStream()
1012 {
1013     m_parent_o_stream = NULL;
1014 }
1015
1016 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
1017 {
1018     m_parent_o_stream = &stream;
1019 }
1020
1021 wxFilterOutputStream::~wxFilterOutputStream()
1022 {
1023 }
1024
1025 // ----------------------------------------------------------------------------
1026 // wxBufferedInputStream
1027 // ----------------------------------------------------------------------------
1028
1029 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
1030                                              wxStreamBuffer *buffer)
1031                      : wxFilterInputStream(s)
1032 {
1033     if ( buffer )
1034     {
1035         // use the buffer provided by the user
1036         m_i_streambuf = buffer;
1037     }
1038     else // create a default buffer
1039     {
1040         m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
1041
1042         m_i_streambuf->SetBufferIO(1024);
1043     }
1044 }
1045
1046 wxBufferedInputStream::~wxBufferedInputStream()
1047 {
1048     m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
1049                              wxFromCurrent);
1050
1051     delete m_i_streambuf;
1052 }
1053
1054 char wxBufferedInputStream::Peek()
1055 {
1056     return m_i_streambuf->Peek();
1057 }
1058
1059 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
1060 {
1061     // reset the error flag
1062     m_lasterror = wxStream_NOERROR;
1063
1064     // first read from the already cached data
1065     m_lastcount = GetWBack(buf, size);
1066
1067     // do we have to read anything more?
1068     if ( m_lastcount < size )
1069     {
1070         size -= m_lastcount;
1071         buf = (char *)buf + m_lastcount;
1072
1073         // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
1074         // so save it
1075         size_t countOld = m_lastcount;
1076
1077         m_i_streambuf->Read(buf, size);
1078
1079         m_lastcount += countOld;
1080     }
1081
1082     return *this;
1083 }
1084
1085 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
1086 {
1087     // RR: Look at wxInputStream for comments.
1088
1089     if (m_lasterror==wxSTREAM_EOF)
1090         m_lasterror=wxSTREAM_NOERROR;
1091
1092     if (m_wback)
1093     {
1094         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
1095
1096         free(m_wback);
1097         m_wback = NULL;
1098         m_wbacksize = 0;
1099         m_wbackcur = 0;
1100     }
1101
1102     return m_i_streambuf->Seek(pos, mode);
1103 }
1104
1105 off_t wxBufferedInputStream::TellI() const
1106 {
1107     off_t pos = m_i_streambuf->Tell();
1108
1109     if (pos != wxInvalidOffset)
1110         pos -= (m_wbacksize - m_wbackcur);
1111
1112     return pos;
1113 }
1114
1115 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
1116 {
1117     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
1118 }
1119
1120 off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1121 {
1122     return m_parent_i_stream->SeekI(seek, mode);
1123 }
1124
1125 off_t wxBufferedInputStream::OnSysTell() const
1126 {
1127     return m_parent_i_stream->TellI();
1128 }
1129
1130 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
1131 {
1132     wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
1133
1134     delete m_i_streambuf;
1135     m_i_streambuf = buffer;
1136 }
1137
1138 // ----------------------------------------------------------------------------
1139 // wxBufferedOutputStream
1140 // ----------------------------------------------------------------------------
1141
1142 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
1143                                                wxStreamBuffer *buffer)
1144                       : wxFilterOutputStream(s)
1145 {
1146     if ( buffer )
1147     {
1148         m_o_streambuf = buffer;
1149     }
1150     else // create a default one
1151     {
1152         m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
1153
1154         m_o_streambuf->SetBufferIO(1024);
1155     }
1156 }
1157
1158 wxBufferedOutputStream::~wxBufferedOutputStream()
1159 {
1160     Sync();
1161     delete m_o_streambuf;
1162 }
1163
1164 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
1165 {
1166     m_lastcount = 0;
1167     m_o_streambuf->Write(buffer, size);
1168     return *this;
1169 }
1170
1171 off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
1172 {
1173     Sync();
1174     return m_o_streambuf->Seek(pos, mode);
1175 }
1176
1177 off_t wxBufferedOutputStream::TellO() const
1178 {
1179     return m_o_streambuf->Tell();
1180 }
1181
1182 void wxBufferedOutputStream::Sync()
1183 {
1184     m_o_streambuf->FlushBuffer();
1185     m_parent_o_stream->Sync();
1186 }
1187
1188 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
1189 {
1190     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
1191 }
1192
1193 off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1194 {
1195     return m_parent_o_stream->SeekO(seek, mode);
1196 }
1197
1198 off_t wxBufferedOutputStream::OnSysTell() const
1199 {
1200     return m_parent_o_stream->TellO();
1201 }
1202
1203 size_t wxBufferedOutputStream::GetSize() const
1204 {
1205    return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
1206 }
1207
1208 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
1209 {
1210     wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
1211
1212     delete m_o_streambuf;
1213     m_o_streambuf = buffer;
1214 }
1215
1216 // ----------------------------------------------------------------------------
1217 // Some IOManip function
1218 // ----------------------------------------------------------------------------
1219
1220 wxOutputStream& wxEndL(wxOutputStream& stream)
1221 {
1222     static const wxChar *eol = wxTextFile::GetEOL();
1223
1224     return stream.Write(eol, wxStrlen(eol));
1225 }
1226
1227 #endif
1228   // wxUSE_STREAMS