home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / streambu.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  5.5 KB  |  237 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19. #ifndef _streambuf_h
  20. #ifdef __GNUG__
  21. #pragma once
  22. #pragma interface
  23. #endif
  24. #define _streambuf_h 1
  25.  
  26. /* streambufs. 
  27.    basic streambufs and filebufs are as in Stroustrup, ch 8,
  28.    but the base class contains virtual extensions that allow
  29.    most capabilities of libg++ Files to be used as streambufs
  30.    via `Filebufs'.
  31. */
  32.  
  33. #include <stdio.h>
  34. #include <builtin.h>
  35. #include <xfmodes.h>
  36. #ifdef atarist
  37. #include <bool.h>
  38. #endif
  39.  
  40. // see below for NO_LINE_BUFFER_STREAMBUFS
  41.  
  42. #ifndef BUFSIZE
  43. #ifdef BUFSIZ
  44. #define BUFSIZE BUFSIZ
  45. #else
  46. #define BUFSIZE 1024
  47. #endif
  48. #endif
  49.  
  50. enum open_mode // filebuf open modes
  51. { 
  52.   input=0, 
  53.   output=1, 
  54.   append=2 
  55. #ifdef atarist
  56.   ,
  57.   input_bin =  _atari_bin+input,
  58.   output_bin = _atari_bin+output,
  59.   append_bin = _atari_bin+append,
  60.  
  61.   input_text  = _atari_text+input,
  62.   output_text = _atari_text+output,
  63.   append_text = _atari_text+append
  64. #endif
  65. }; 
  66.  
  67. class streambuf
  68. {
  69. public:
  70.   char*       base;          // start of buffer
  71.   char*       pptr;          // put-pointer (and gptr fence)
  72.   char*       gptr;          // get-pointer
  73.   char*       eptr;          // last valid addr in buffer
  74.  
  75.   char        alloc;         // true if we own freestore alloced buffer
  76.  
  77. #ifdef atarist
  78.   bool        _bin_mode;     // text or bin mode
  79. #endif
  80.  
  81.               streambuf();
  82. #ifdef atarist
  83.               streambuf(char* buf, size_t buflen);
  84. #else
  85.               streambuf(char* buf, int buflen);
  86. #endif
  87.  
  88.   virtual    ~streambuf();
  89.  
  90. #ifdef atarist
  91.   size_t         doallocate();
  92.   size_t         allocate();
  93. #else
  94.   int         doallocate();
  95.   int         allocate();
  96. #endif
  97.  
  98.   int         must_overflow(int ch); // true if should call overflow
  99.  
  100.   virtual int overflow(int c = EOF); // flush -- return EOF if fail
  101.   virtual int underflow();           // fill -- return EOF if fail
  102.  
  103.   int         sgetc();          // get one char (as int) or EOF
  104.   int         snextc();         // get and advance
  105.   void        stossc();         // advance only
  106.  
  107.   int         sputbackc(char);   // unget
  108.  
  109.   int         sputc(int c = EOF); // write one char
  110.  
  111. #ifdef atarist
  112.   virtual streambuf*  setbuf(char* buf, size_t buflen, size_t preloaded_count = 0);
  113. #else
  114.   virtual streambuf*  setbuf(char* buf, int buflen, int preloaded_count = 0);
  115.                                 // (not virtual in AT&T)
  116. #endif
  117.  
  118. // the following aren't in AT&T version:
  119.  
  120.   int         sputs(const char* s);           // write null-terminated str
  121. #ifdef atarist
  122.   int         sputsn(const char* s, size_t len);
  123.   int         _atari_putc(int ch);            // kludge for bin/text modes
  124. #else
  125.   int         sputsn(const char* s, int len); // write len bytes
  126. #endif
  127.  
  128.   virtual const char* name();
  129.  
  130.  
  131.   virtual streambuf*  open(const char* name, open_mode m);
  132.   virtual streambuf*  open(const char* filename, io_mode m, access_mode a);
  133.   virtual streambuf*  open(const char* filename, const char* m);
  134.   virtual streambuf*  open(int  filedesc, io_mode m);
  135.   virtual streambuf*  open(FILE* fileptr);
  136.  
  137.   virtual int         is_open();
  138.   virtual int         close();
  139.  
  140.   virtual void        error();
  141. };
  142.  
  143.  
  144. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  145.  
  146.  
  147. inline int streambuf::must_overflow(int ch)
  148. {
  149. #ifndef NO_LINE_BUFFER_STREAMBUF
  150.   return pptr >= eptr || ch == '\n';
  151. #else
  152.   return pptr >= eptr;
  153. #endif
  154. }
  155.  
  156.  
  157. #ifdef atarist
  158. inline size_t streambuf::allocate()
  159. {
  160.   return (base == 0)? doallocate() : 0; 
  161. }
  162. #else
  163. inline int streambuf::allocate()
  164. {
  165.   return (base == 0)? doallocate() : 0; 
  166. }
  167. #endif
  168.  
  169. inline int streambuf::sgetc()
  170. {
  171. #ifndef atarist
  172.   return (gptr >= pptr)? underflow() : int((unsigned char)(*gptr));
  173. #else
  174.   int ch;
  175.   do {
  176.     ch = ((gptr >= pptr) ? underflow() : int((unsigned char)(*gptr)));
  177.     if ((!_bin_mode) && (ch == '\r'))
  178.       ch = ((++gptr >= pptr) ? underflow() : int((unsigned char)(*gptr)));
  179.   } while ((!_bin_mode) && (ch == '\r'));
  180.   return(ch);
  181. #endif
  182. }
  183.  
  184.  
  185. inline int streambuf::snextc()
  186. {
  187. #ifndef atarist
  188.   ++gptr;
  189.   return (gptr >= pptr)? underflow() : int((unsigned char)(*gptr));
  190. #else
  191.   int ch;
  192.   do {
  193.     ++gptr;
  194.     ch = ((gptr >= pptr) ? underflow() : int((unsigned char)(*gptr)));
  195.   } while ((!_bin_mode) && (ch == '\r'));
  196.   return ch;
  197. #endif
  198. }
  199.  
  200.  
  201. inline void streambuf::stossc()
  202. {
  203.   if (gptr >= pptr) underflow(); else gptr++;
  204. }
  205.  
  206.  
  207. inline int streambuf::sputbackc(char ch)
  208. {
  209.   return (gptr > base)? int((unsigned char)(*--gptr = ch)) : EOF;
  210. }
  211.  
  212. inline int streambuf::sputc(int ch)
  213. {
  214.   return must_overflow(ch)? overflow(ch) : 
  215. #ifdef atarist
  216.                             _atari_putc(ch);
  217. #else
  218.                             int((unsigned char)(*pptr++ = char(ch)));
  219. #endif
  220. }
  221.  
  222. #ifdef atarist
  223.  
  224. inline int streambuf::_atari_putc(int ch)
  225. {
  226.   if ((!_bin_mode) && (ch == '\n'))
  227.     *pptr++ = '\r';
  228.   *pptr++ = ch;
  229.   return(int(ch));
  230. }
  231.  
  232. #endif
  233.  
  234. #endif
  235.  
  236. #endif
  237.