home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c065 / 2.ddi / CLIB2.ZIP / STRMBFN.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-07  |  4.4 KB  |  221 lines
  1. /*-----------------------------------------------------------------------*
  2.  * filename - strmbfn.cpp
  3.  * Class streambuf member functions
  4.  *-----------------------------------------------------------------------*/
  5.  
  6. /*[]------------------------------------------------------------[]*/
  7. /*|                                                              |*/
  8. /*|     Turbo C++ Run Time Library - Version 1.0                 |*/
  9. /*|                                                              |*/
  10. /*|                                                              |*/
  11. /*|     Copyright (c) 1990 by Borland International              |*/
  12. /*|     All Rights Reserved.                                     |*/
  13. /*|                                                              |*/
  14. /*[]------------------------------------------------------------[]*/
  15.  
  16. #undef _BIG_INLINE_
  17. #include <iostream.h>
  18.  
  19. const int streambuf_size = 1024;
  20.  
  21. streambuf::streambuf()
  22. {
  23.     alloc_ = 0;
  24.     unbuf_ = 0;
  25.     base_ = 0;
  26.     pbase_ = 0;
  27.     pptr_ = 0;
  28.     epptr_ = 0;
  29.     gptr_ = 0;
  30.     egptr_ = 0;
  31.     eback_ = 0;
  32.     ebuf_ = 0;
  33. }
  34.  
  35.  
  36. streambuf::streambuf(char* b, int len)
  37. {
  38.     alloc_ = 0;
  39.     unbuf_ = 0;
  40.     base_ = b;
  41.     ebuf_ = (len > 0) ? b + len : b;
  42.     pbase_ = 0;
  43.     pptr_ = 0;
  44.     epptr_ = 0;
  45.     gptr_ = 0;
  46.     egptr_ = 0;
  47.     eback_ = 0;
  48. }
  49.  
  50.  
  51. streambuf::~streambuf()
  52. {
  53.     if( alloc_ )
  54.     delete base_;
  55. }
  56.  
  57.  
  58. int streambuf::doallocate()
  59. {
  60.     char *p = new char[streambuf_size];
  61.     if( ! p )
  62.     return EOF;
  63.     base_ = p;
  64.     ebuf_ = p + streambuf_size;
  65.     alloc_ = 1;
  66.     return 1;
  67. }
  68.  
  69.  
  70. void streambuf::setb(char* b, char* eb, int a)
  71. {
  72.     if( alloc_  &&  base_  &&  base_ != b )
  73.     delete base_;
  74.     base_ = b;
  75.     ebuf_ = ( b && eb && (eb >= b) ) ? eb : b;
  76.     unbuf_ = ! b;
  77.     alloc_ = a && b;
  78. }
  79.  
  80.  
  81. void streambuf::setg(char* eb, char* g, char* eg)
  82. {
  83.     eback_ = (g && eb) ? eb : g;
  84.     gptr_ = g;
  85.     egptr_ = (g && eg && (eg >= g)) ? eg : g;
  86.  }
  87.  
  88.  
  89. void streambuf::setp(char* p, char* ep)
  90. {
  91.     pbase_ = pptr_ = p;
  92.     epptr_ = (p && ep && (ep >= p)) ? ep : p;
  93. }
  94.  
  95.  
  96. streambuf* streambuf::setbuf(signed char* p, int len)
  97. {
  98.     setb((char*)p, (char*)p + len, 0);
  99.     return this;
  100. }
  101.  
  102.  
  103. // obsolete.  included for compatibility with version 1.2 streams
  104. streambuf* streambuf::setbuf(char* p, int len, int offset)
  105. {
  106.     setb(p, p + len, 0);
  107.     setp(p + offset, p + len);
  108.     return this;
  109. }
  110.  
  111.  
  112. // called when sgetn finds not enough chars in the get area
  113. int streambuf::do_sgetn(char* s, int n)
  114. {
  115.     int c, i;
  116.  
  117.     i = in_avail();
  118.     if( i > 0 ) {
  119.     memcpy(s, gptr_, i);
  120.     s += i;
  121.     gbump(i);
  122.     }
  123.     while( i < n  &&  (c = sbumpc()) != EOF ) {
  124.     *s++ = c;
  125.     ++i;
  126.     }
  127.     return i;
  128. }
  129.  
  130.  
  131. // called by sputn when more chars are needed than are in the buffer
  132. int streambuf::do_sputn(const char* s, int n)
  133. {
  134.     int i;
  135.  
  136.     i = (int)(epptr_ - pptr_);
  137.     if( i > 0 ) {
  138.     memcpy(pptr_, s, i);
  139.     s += i;
  140.     pbump(i);
  141.     }
  142.     while( i < n  &&  sputc(*s++) != EOF )
  143.     ++i;
  144.     return i;
  145. }
  146.  
  147.  
  148. // called when snextc doesn't have an available character
  149. int streambuf::do_snextc()
  150. {
  151.     return (underflow() == EOF) ? EOF : (unsigned char) *gptr_;
  152. }
  153.  
  154.  
  155. // streambuf can't do anything about underflow -- no place to get chars
  156. int streambuf::underflow()
  157. {
  158.     if( egptr_ > gptr_ )
  159.     return (unsigned char) *gptr_;
  160.  
  161.     gptr_ = egptr_;
  162.     return EOF;
  163. }
  164.  
  165.  
  166. // streambuf can't do anything about overflow -- no place to put chars
  167. int streambuf::overflow(int)
  168. {
  169.     return EOF;
  170. }
  171.  
  172.  
  173. int streambuf::pbackfail(int)
  174. {
  175.     return EOF;
  176. }
  177.  
  178.  
  179. streampos streambuf::seekoff(streamoff, seek_dir, int)
  180. {
  181.     return EOF;
  182. }
  183.  
  184.  
  185. streampos streambuf::seekpos(streampos pos, int mode)
  186. {
  187.     return seekoff(streamoff(pos), ios::beg, mode);
  188. }
  189.  
  190.  
  191. int streambuf::sync() 
  192. {
  193.      return (in_avail() == 0  &&  out_waiting() == 0) ? 0 : EOF;
  194. }
  195.  
  196.  
  197. /*
  198.  * The following functions are expected to be inline, but just in case
  199.  * they aren't, and they generate a LOT of code, here they are as
  200.  * global closed subroutines.
  201.  */
  202.  
  203. int streambuf::sputn(const char* s, int n)
  204. {
  205.     if( n <= (epptr_ - pptr_) ) {
  206.     memcpy(pptr_, s, n);
  207.     pbump(n);
  208.     return n;
  209.     }
  210.     return do_sputn(s, n);
  211. }
  212.  
  213. int streambuf::sgetn(char* s, int n) {
  214.     if( n <= (egptr_ - gptr_) ) {
  215.     memcpy(s, gptr_, n);
  216.     gbump(n);
  217.     return n;
  218.     }
  219.     return do_sgetn(s, n);
  220. }
  221.