include/c++/stl/stl/_istream.h

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18 #ifndef _STLP_INTERNAL_ISTREAM
  19 #define _STLP_INTERNAL_ISTREAM
  20
  21 // this block is included by _ostream.h, we include it here to lower #include level
  22 #if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
  23 #  include <stl/_cwchar.h>
  24 #endif
  25
  26 #ifndef _STLP_INTERNAL_IOS_H
  27 #  include <stl/_ios.h>                  // For basic_ios<>.  Includes <iosfwd>.
  28 #endif
  29
  30 #ifndef _STLP_INTERNAL_OSTREAM_H
  31 #  include <stl/_ostream.h>              // Needed as a base class of basic_iostream.
  32 #endif
  33
  34 #ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
  35 #  include <stl/_istreambuf_iterator.h>
  36 #endif
  37
  38 #include <stl/_ctraits_fns.h>    // Helper functions that allow char traits
  39                                 // to be used as function objects.
  40 _STLP_BEGIN_NAMESPACE
  41
  42 #if defined (_STLP_USE_TEMPLATE_EXPORT)
  43 template <class _CharT, class _Traits>
  44 class _Isentry;
  45 #endif
  46
  47 struct _No_Skip_WS {};        // Dummy class used by sentry.
  48
  49 template <class _CharT, class _Traits>
  50 bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr);
  51 template <class _CharT, class _Traits>
  52 bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr);
  53
  54 //----------------------------------------------------------------------
  55 // Class basic_istream, a class that performs formatted input through
  56 // a stream buffer.
  57
  58 // The second template parameter, _Traits, defaults to char_traits<_CharT>.
  59 // The default is declared in header <iosfwd>, and it isn't declared here
  60 // because C++ language rules do not allow it to be declared twice.
  61
  62 template <class _CharT, class _Traits>
  63 class basic_istream : virtual public basic_ios<_CharT, _Traits> {
  64   typedef basic_istream<_CharT, _Traits> _Self;
  65
  66 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
  67   //explicitely defined as private to avoid warnings:
  68   basic_istream(_Self const&);
  69   _Self& operator = (_Self const&);
  70 #endif
  71
  72 public:
  73                          // Types
  74   typedef _CharT                     char_type;
  75   typedef typename _Traits::int_type int_type;
  76   typedef typename _Traits::pos_type pos_type;
  77   typedef typename _Traits::off_type off_type;
  78   typedef _Traits                    traits_type;
  79   typedef basic_ios<_CharT, _Traits>     _Basic_ios;
  80
  81   typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&);
  82   typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&);
  83   typedef _Self& (_STLP_CALL *__istream_fn)(_Self&);
  84
  85 public:                         // Constructor and destructor.
  86   explicit basic_istream(basic_streambuf<_CharT, _Traits>* __buf) :
  87     basic_ios<_CharT, _Traits>(), _M_gcount(0) {
  88     this->init(__buf);
  89   }
  90   ~basic_istream() {};
  91
  92 public:                         // Nested sentry class.
  93
  94 public:                         // Hooks for manipulators.  The arguments are
  95                                 // function pointers.
  96   _Self& operator>> (__istream_fn __f) { return __f(*this); }
  97   _Self& operator>> (__ios_fn __f) {  __f(*this); return *this; }
  98   _Self& operator>> (__ios_base_fn __f) { __f(*this); return *this; }
  99
 100 public:                         // Formatted input of numbers.
 101   _Self& operator>> (short& __val);
 102   _Self& operator>> (int& __val);
 103   _Self& operator>> (unsigned short& __val);
 104   _Self& operator>> (unsigned int& __val);
 105   _Self& operator>> (long& __val);
 106   _Self& operator>> (unsigned long& __val);
 107 #ifdef _STLP_LONG_LONG
 108   _Self& operator>> (_STLP_LONG_LONG& __val);
 109   _Self& operator>> (unsigned _STLP_LONG_LONG& __val);
 110 #endif
 111   _Self& operator>> (float& __val);
 112   _Self& operator>> (double& __val);
 113 # ifndef _STLP_NO_LONG_DOUBLE
 114   _Self& operator>> (long double& __val);
 115 # endif
 116 # ifndef _STLP_NO_BOOL
 117   _Self& operator>> (bool& __val);
 118 # endif
 119   _Self& operator>> (void*& __val);
 120
 121 public:                         // Copying characters into a streambuf.
 122   _Self& operator>>(basic_streambuf<_CharT, _Traits>*);
 123
 124 public:                         // Unformatted input.
 125   streamsize gcount() const { return _M_gcount; }
 126   int_type peek();
 127
 128 public:                         // get() for single characters
 129   int_type get();
 130   _Self& get(char_type& __c);
 131
 132 public:                         // get() for character arrays.
 133   _Self& get(char_type* __s, streamsize __n, char_type __delim);
 134   _Self& get(char_type* __s, streamsize __n)
 135     { return get(__s, __n, this->widen('\n')); }
 136
 137 public:                         // get() for streambufs
 138   _Self& get(basic_streambuf<_CharT, _Traits>& __buf,
 139                      char_type __delim);
 140   _Self& get(basic_streambuf<_CharT, _Traits>& __buf)
 141     { return get(__buf, this->widen('\n')); }
 142
 143 public:                         // getline()
 144   _Self& getline(char_type* __s, streamsize __n, char_type delim);
 145   _Self& getline(char_type* __s, streamsize __n)
 146     { return getline(__s, __n, this->widen('\n')); }
 147
 148 public:                         // read(), readsome(), ignore()
 149   _Self& ignore();
 150   _Self& ignore(streamsize __n);
 151 #if (defined (_STLP_MSVC) && _STLP_MSVC < 1200)
 152   inline
 153 #endif
 154   _Self& ignore(streamsize __n, int_type __delim);
 155
 156   _Self& read(char_type* __s, streamsize __n);
 157   streamsize readsome(char_type* __s, streamsize __n);
 158
 159 public:                         // putback
 160   _Self& putback(char_type __c);
 161   _Self& unget();
 162
 163 public:                         // Positioning and buffer control.
 164   int sync();
 165
 166   pos_type tellg();
 167   _Self& seekg(pos_type __pos);
 168   _Self& seekg(off_type, ios_base::seekdir);
 169
 170 public:                         // Helper functions for non-member extractors.
 171   void _M_formatted_get(_CharT& __c);
 172   void _M_formatted_get(_CharT* __s);
 173   void _M_skip_whitespace(bool __set_failbit);
 174
 175 private:                        // Number of characters extracted by the
 176   streamsize _M_gcount;         // most recent unformatted input function.
 177
 178 public:
 179
 180 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 181   // If we are using DLL specs, we have not to use inner classes
 182   // end class declaration here
 183   typedef _Isentry<_CharT, _Traits>      sentry;
 184 };
 185 #  define sentry _Isentry
 186 template <class _CharT, class _Traits>
 187 class _Isentry {
 188   typedef _Isentry<_CharT, _Traits> _Self;
 189 # else
 190   class sentry {
 191     typedef sentry _Self;
 192 #endif
 193
 194   private:
 195     const bool _M_ok;
 196     //    basic_streambuf<_CharT, _Traits>* _M_buf;
 197
 198   public:
 199     typedef _Traits traits_type;
 200
 201     explicit sentry(basic_istream<_CharT, _Traits>& __istr,
 202                     bool __noskipws = false) :
 203       _M_ok((__noskipws || !(__istr.flags() & ios_base::skipws)) ? _M_init_noskip(__istr) : _M_init_skip(__istr) )
 204       /* , _M_buf(__istr.rdbuf()) */
 205       {}
 206
 207     // Calling this constructor is the same as calling the previous one with
 208     // __noskipws = true, except that it doesn't require a runtime test.
 209     sentry(basic_istream<_CharT, _Traits>& __istr, _No_Skip_WS) : /* _M_buf(__istr.rdbuf()), */
 210       _M_ok(_M_init_noskip(__istr)) {}
 211
 212     ~sentry() {}
 213
 214     operator bool() const { return _M_ok; }
 215
 216   private:                        // Disable assignment and copy constructor.
 217     //Implementation is here only to avoid warning with some compilers.
 218     sentry(const _Self&) : _M_ok(false) {}
 219     _Self& operator=(const _Self&) { return *this; }
 220   };
 221
 222 # if defined (_STLP_USE_TEMPLATE_EXPORT)
 223 #  undef sentry
 224 # else
 225   // close basic_istream class definition here
 226 };
 227 # endif
 228
 229 # if defined (_STLP_USE_TEMPLATE_EXPORT)
 230 _STLP_EXPORT_TEMPLATE_CLASS _Isentry<char, char_traits<char> >;
 231 _STLP_EXPORT_TEMPLATE_CLASS basic_istream<char, char_traits<char> >;
 232 #  if ! defined (_STLP_NO_WCHAR_T)
 233 _STLP_EXPORT_TEMPLATE_CLASS _Isentry<wchar_t, char_traits<wchar_t> >;
 234 _STLP_EXPORT_TEMPLATE_CLASS basic_istream<wchar_t, char_traits<wchar_t> >;
 235 #  endif
 236 # endif /* _STLP_USE_TEMPLATE_EXPORT */
 237
 238 // Non-member character and string extractor functions.
 239 template <class _CharT, class _Traits>
 240 inline basic_istream<_CharT, _Traits>& _STLP_CALL
 241 operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT& __c) {
 242   __in_str._M_formatted_get(__c);
 243   return __in_str;
 244 }
 245
 246 template <class _Traits>
 247 inline basic_istream<char, _Traits>& _STLP_CALL
 248 operator>>(basic_istream<char, _Traits>& __in_str, unsigned char& __c) {
 249   __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
 250   return __in_str;
 251 }
 252
 253 template <class _Traits>
 254 inline basic_istream<char, _Traits>& _STLP_CALL
 255 operator>>(basic_istream<char, _Traits>& __in_str, signed char& __c) {
 256   __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
 257   return __in_str;
 258 }
 259
 260 template <class _CharT, class _Traits>
 261 inline basic_istream<_CharT, _Traits>& _STLP_CALL
 262 operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT* __s) {
 263   __in_str._M_formatted_get(__s);
 264   return __in_str;
 265 }
 266
 267 template <class _Traits>
 268 inline basic_istream<char, _Traits>& _STLP_CALL
 269 operator>>(basic_istream<char, _Traits>& __in_str, unsigned char* __s) {
 270   __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
 271   return __in_str;
 272 }
 273
 274 template <class _Traits>
 275 inline basic_istream<char, _Traits>& _STLP_CALL
 276 operator>>(basic_istream<char, _Traits>& __in_str, signed char* __s) {
 277   __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
 278   return __in_str;
 279 }
 280
 281 //----------------------------------------------------------------------
 282 // istream manipulator.
 283 template <class _CharT, class _Traits>
 284 basic_istream<_CharT, _Traits>& _STLP_CALL
 285 ws(basic_istream<_CharT, _Traits>& __istr) {
 286   if (!__istr.eof()) {
 287     typedef typename basic_istream<_CharT, _Traits>::sentry      _Sentry;
 288     _Sentry __sentry(__istr, _No_Skip_WS()); // Don't skip whitespace.
 289     if (__sentry)
 290       __istr._M_skip_whitespace(false);
 291   }
 292   return __istr;
 293 }
 294
 295 // Helper functions for istream<>::sentry constructor.
 296 template <class _CharT, class _Traits>
 297 inline bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr) {
 298   if (__istr.good()) {
 299     if (__istr.tie())
 300       __istr.tie()->flush();
 301
 302     __istr._M_skip_whitespace(true);
 303   }
 304
 305   if (!__istr.good()) {
 306     __istr.setstate(ios_base::failbit);
 307     return false;
 308   } else
 309     return true;
 310 }
 311
 312 template <class _CharT, class _Traits>
 313 inline bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr) {
 314   if (__istr.good()) {
 315     if (__istr.tie())
 316       __istr.tie()->flush();
 317
 318     if (!__istr.rdbuf())
 319       __istr.setstate(ios_base::badbit);
 320   }
 321   else
 322     __istr.setstate(ios_base::failbit);
 323   return __istr.good();
 324 }
 325
 326 //----------------------------------------------------------------------
 327 // Class iostream.
 328 template <class _CharT, class _Traits>
 329 class basic_iostream
 330   : public basic_istream<_CharT, _Traits>,
 331     public basic_ostream<_CharT, _Traits>
 332 {
 333 public:
 334   typedef basic_ios<_CharT, _Traits> _Basic_ios;
 335
 336   explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __buf);
 337   virtual ~basic_iostream();
 338 };
 339
 340 # if defined (_STLP_USE_TEMPLATE_EXPORT)
 341 _STLP_EXPORT_TEMPLATE_CLASS basic_iostream<char, char_traits<char> >;
 342
 343 #  if ! defined (_STLP_NO_WCHAR_T)
 344 _STLP_EXPORT_TEMPLATE_CLASS basic_iostream<wchar_t, char_traits<wchar_t> >;
 345 #  endif
 346 # endif /* _STLP_USE_TEMPLATE_EXPORT */
 347
 348 template <class _CharT, class _Traits>
 349 basic_streambuf<_CharT, _Traits>* _STLP_CALL _M_get_istreambuf(basic_istream<_CharT, _Traits>& __istr)
 350 { return __istr.rdbuf(); }
 351
 352 _STLP_END_NAMESPACE
 353
 354 #if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
 355 #  include <stl/_istream.c>
 356 #endif
 357
 358 #endif /* _STLP_INTERNAL_ISTREAM */
 359
 360 // Local Variables:
 361 // mode:C++
 362 // End: