home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / libg++-2.6.2.lha / libg++-2.6.2 / libio / iostream.cc < prev    next >
C/C++ Source or Header  |  1994-11-05  |  18KB  |  819 lines
  1. /* This is part of libio/iostream, providing -*- C++ -*- input/output.
  2. Copyright (C) 1993 Free Software Foundation
  3.  
  4. This file is part of the GNU IO Library.  This library is free
  5. software; you can redistribute it and/or modify it under the
  6. terms of the GNU General Public License as published by the
  7. Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This library is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with GNU CC; see the file COPYING.  If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. As a special exception, if you link this library with files
  20. compiled with a GNU compiler to produce an executable, this does not cause
  21. the resulting executable to be covered by the GNU General Public License.
  22. This exception does not however invalidate any other reasons why
  23. the executable file might be covered by the GNU General Public License. */
  24.  
  25. /* Written by Per Bothner (bothner@cygnus.com). */
  26.  
  27. #ifdef __GNUC__
  28. #pragma implementation
  29. #endif
  30. #define _STREAM_COMPAT
  31. #include <iostream.h>
  32. #include "libioP.h"
  33. #include <stdio.h>  /* Needed for sprintf */
  34. #include <ctype.h>
  35. #include <string.h>
  36. #include <limits.h>
  37. #include "floatio.h"
  38.  
  39. #define    BUF        (MAXEXP+MAXFRACT+1)    /* + decimal point */
  40.  
  41. //#define isspace(ch) ((ch)==' ' || (ch)=='\t' || (ch)=='\n')
  42.  
  43. istream::istream(streambuf *sb, ostream* tied)
  44. {
  45.   init (sb, tied);
  46.   _gcount = 0;
  47. }
  48.  
  49. int skip_ws(streambuf* sb)
  50. {
  51.     int ch;
  52.     for (;;) {
  53.     ch = sb->sbumpc();
  54.     if (ch == EOF || !isspace(ch))
  55.         return ch;
  56.     }
  57. }
  58.  
  59. istream& istream::get(char& c)
  60. {
  61.     if (ipfx1()) {
  62.     int ch = _strbuf->sbumpc();
  63.     if (ch == EOF) {
  64.       set(ios::eofbit|ios::failbit);
  65.       _gcount = 0;
  66.     }
  67.     else {
  68.       c = (char)ch;
  69.       _gcount = 1;
  70.     }
  71.     }
  72.     else
  73.       _gcount = 0;
  74.     return *this;
  75. }
  76.  
  77. int istream::peek()
  78. {
  79.   if (!good())
  80.     return EOF;
  81.   if (_tie && rdbuf()->in_avail() == 0)
  82.     _tie->flush();
  83.   int ch = _strbuf->sgetc();
  84.   if (ch == EOF)
  85.     set(ios::eofbit);
  86.   return ch;
  87. }
  88.  
  89. istream& istream::ignore(int n /* = 1 */, int delim /* = EOF */)
  90. {
  91.     _gcount = 0;
  92.     if (ipfx1()) {
  93.     register streambuf* sb = _strbuf;
  94.     if (delim == EOF) {
  95.         _gcount = sb->ignore(n);
  96.         return *this;
  97.     }
  98.     for (;;) {
  99. #if 0
  100.         if (n != MAXINT) // FIXME
  101. #endif
  102.         if (--n < 0)
  103.         break;
  104.         int ch = sb->sbumpc();
  105.         if (ch == EOF) {
  106.         set(ios::eofbit|ios::failbit);
  107.         break;
  108.         }
  109.         _gcount++;
  110.         if (ch == delim)
  111.         break;
  112.     }
  113.     }
  114.     return *this;
  115. }
  116.  
  117. istream& istream::read(char *s, int n)
  118. {
  119.     if (ipfx1()) {
  120.     _gcount = _strbuf->sgetn(s, n);
  121.     if (_gcount != n)
  122.         set(ios::failbit|ios::eofbit);
  123.     }
  124.     else
  125.       _gcount = 0;
  126.     return *this;
  127. }
  128.  
  129. istream& istream::seekg(streampos pos)
  130. {
  131.     pos = _strbuf->sseekpos(pos, ios::in);
  132.     if (pos == streampos(EOF))
  133.     set(ios::badbit);
  134.     return *this;
  135. }
  136.  
  137. istream& istream::seekg(streamoff off, _seek_dir dir)
  138. {
  139.   streampos pos
  140.     = _IO_seekoff (_strbuf, off,
  141.            (_IO_seekflags)
  142.            ((int)dir | _IO_seek_not_out | _IO_seek_pos_ignored));
  143.   if (pos == streampos(EOF))
  144.     set(ios::badbit);
  145.   return *this;
  146. }
  147.  
  148. streampos istream::tellg()
  149. {
  150. #if 0
  151.     streampos pos = _strbuf->sseekoff(0, ios::cur, ios::in);
  152. #else
  153.     streampos pos
  154.       = _IO_seekoff (_strbuf, 0,
  155.              (_IO_seekflags)(_IO_seek_cur | _IO_seek_not_out));
  156. #endif
  157.     if (pos == streampos(EOF))
  158.     set(ios::badbit);
  159.     return pos;
  160. }
  161.  
  162. istream& istream::operator>>(char& c)
  163. {
  164.     if (ipfx0()) {
  165.     int ch = _strbuf->sbumpc();
  166.     if (ch == EOF)
  167.         set(ios::eofbit|ios::failbit);
  168.     else
  169.         c = (char)ch;
  170.     }
  171.     return *this;
  172. }
  173.  
  174. istream& istream::operator>>(char* ptr)
  175. {
  176.   register char *p = ptr;
  177.   int w = width(0);
  178.   if (ipfx0()) {
  179.     register streambuf* sb = _strbuf;
  180.     for (;;)
  181.       {
  182.     int ch = sb->sbumpc();
  183.     if (ch == EOF)
  184.       {
  185.         set(p == ptr ? (ios::eofbit|ios::failbit) : (ios::eofbit));
  186.         break;
  187.       }
  188.     else if (isspace(ch))
  189.       {
  190.         sb->sputbackc(ch);
  191.         break;
  192.       }
  193.     else if (w == 1)
  194.       {
  195.         set(ios::failbit);
  196.         sb->sputbackc(ch);
  197.         break;
  198.       }
  199.     else *p++ = ch;
  200.     w--;
  201.       }
  202.   }
  203.   *p = '\0';
  204.   return *this;
  205. }
  206.  
  207. #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
  208. #define LONGEST long long
  209. #else
  210. #define LONGEST long
  211. #endif
  212.  
  213. static int read_int(istream& stream, unsigned LONGEST& val, int& neg)
  214. {
  215.     if (!stream.ipfx0())
  216.       return 0;
  217.     register streambuf* sb = stream.rdbuf();
  218.     int base = 10;
  219.     int ndigits = 0;
  220.     register int ch = skip_ws(sb);
  221.     if (ch == EOF)
  222.     goto eof_fail;
  223.     neg = 0;
  224.     if (ch == '+') {
  225.     ch = skip_ws(sb);
  226.     }
  227.     else if (ch == '-') {
  228.     neg = 1;
  229.     ch = skip_ws(sb);
  230.     }
  231.     if (ch == EOF) goto eof_fail;
  232.     if (!(stream.flags() & ios::basefield)) {
  233.     if (ch == '0') {
  234.         ch = sb->sbumpc();
  235.         if (ch == EOF) {
  236.         val = 0;
  237.         return 1;
  238.         }
  239.         if (ch == 'x' || ch == 'X') {
  240.         base = 16;
  241.         ch = sb->sbumpc();
  242.         if (ch == EOF) goto eof_fail;
  243.         }
  244.         else {
  245.         sb->sputbackc(ch);
  246.         base = 8;
  247.         ch = '0';
  248.         }
  249.     }
  250.     }
  251.     else if ((stream.flags() & ios::basefield) == ios::hex)
  252.     base = 16;
  253.     else if ((stream.flags() & ios::basefield) == ios::oct)
  254.     base = 8;
  255.     val = 0;
  256.     for (;;) {
  257.     if (ch == EOF)
  258.         break;
  259.     int digit;
  260.     if (ch >= '0' && ch <= '9')
  261.         digit = ch - '0';
  262.     else if (ch >= 'A' && ch <= 'F')
  263.         digit = ch - 'A' + 10;
  264.     else if (ch >= 'a' && ch <= 'f')
  265.         digit = ch - 'a' + 10;
  266.     else
  267.         digit = 999;
  268.     if (digit >= base) {
  269.         sb->sputbackc(ch);
  270.         if (ndigits == 0)
  271.         goto fail;
  272.         else
  273.         return 1;
  274.     }
  275.     ndigits++;
  276.     val = base * val + digit;
  277.     ch = sb->sbumpc();
  278.     }
  279.     return 1;
  280.   fail:
  281.     stream.set(ios::failbit);
  282.     return 0;
  283.   eof_fail:
  284.     stream.set(ios::failbit|ios::eofbit);
  285.     return 0;
  286. }
  287.  
  288. #define READ_INT(TYPE) \
  289. istream& istream::operator>>(TYPE& i)\
  290. {\
  291.     unsigned LONGEST val; int neg;\
  292.     if (read_int(*this, val, neg)) {\
  293.     if (neg) val = -val;\
  294.     i = (TYPE)val;\
  295.     }\
  296.     return *this;\
  297. }
  298.  
  299. READ_INT(short)
  300. READ_INT(unsigned short)
  301. READ_INT(int)
  302. READ_INT(unsigned int)
  303. READ_INT(long)
  304. READ_INT(unsigned long)
  305. #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
  306. READ_INT(long long)
  307. READ_INT(unsigned long long)
  308. #endif
  309. #if _G_HAVE_BOOL
  310. READ_INT(bool)
  311. #endif
  312.  
  313. istream& istream::operator>>(long double& x)
  314. {
  315.     if (ipfx0())
  316.     scan("%lg", &x);
  317.     return *this;
  318. }
  319.  
  320. istream& istream::operator>>(double& x)
  321. {
  322.     if (ipfx0())
  323.     scan("%lg", &x);
  324.     return *this;
  325. }
  326.  
  327. istream& istream::operator>>(float& x)
  328. {
  329.     if (ipfx0())
  330.     scan("%g", &x);
  331.     return *this;
  332. }
  333.  
  334. istream& istream::operator>>(register streambuf* sbuf)
  335. {
  336.     if (ipfx0()) {
  337.     register streambuf* inbuf = rdbuf();
  338.     // FIXME: Should optimize!
  339.     for (;;) {
  340.         register int ch = inbuf->sbumpc();
  341.         if (ch == EOF) {
  342.         set(ios::eofbit);
  343.         break;
  344.         }
  345.         if (sbuf->sputc(ch) == EOF) {
  346.         set(ios::failbit);
  347.         break;
  348.         }
  349.     }
  350.     }
  351.     return *this;
  352. }
  353.  
  354. ostream& ostream::operator<<(char c)
  355. {
  356.     if (opfx()) {
  357. #if 1
  358.     // This is what the cfront implementation does.
  359.     if (_strbuf->sputc(c) == EOF)
  360.       goto failed;
  361. #else
  362.     // This is what cfront documentation and current ANSI drafts say.
  363.     int w = width(0);
  364.     char fill_char = fill();
  365.     register int padding = w > 0 ? w - 1 : 0;
  366.     register streambuf *sb = _strbuf;
  367.     if (!(flags() & ios::left) && padding) // Default adjustment.
  368.         if (_IO_padn(sb, fill_char, padding) < padding)
  369.           goto failed;
  370.     if (sb->sputc(c) == EOF)
  371.       goto failed;
  372.     if (flags() & ios::left && padding) // Left adjustment.
  373.         if (_IO_padn(sb, fill_char, padding) < padding)
  374.           goto failed;
  375. #endif
  376.     osfx();
  377.     }
  378.     return *this;
  379.   failed:
  380.     set(ios::badbit);
  381.     osfx();
  382.     return *this;
  383. }
  384.  
  385. /* Write VAL on STREAM.
  386.    If SIGN<0, val is the absolute value of a negative number.
  387.    If SIGN>0, val is a signed non-negative number.
  388.    If SIGN==0, val is unsigned. */
  389.  
  390. static void write_int(ostream& stream, unsigned LONGEST val, int sign)
  391. {
  392. #define WRITE_BUF_SIZE (10 + sizeof(unsigned LONGEST) * 3)
  393.     char buf[WRITE_BUF_SIZE];
  394.     register char *buf_ptr = buf+WRITE_BUF_SIZE; // End of buf.
  395.     char