X-Git-Url: http://git.buserror.net/cgi-bin/gitweb.cgi?p=polintos%2Fscott%2Fpriv.git;a=blobdiff_plain;f=include%2Fc%2B%2B%2Fstl%2Fstl%2F_istream.h;fp=include%2Fc%2B%2B%2Fstl%2Fstl%2F_istream.h;h=9292cce20acec1feafc547a9b68e046f3f40c8be;hp=0000000000000000000000000000000000000000;hb=173d8903eb9d51a4ea7d7fa3e52dc86c9bb6d4f1;hpb=b024710fe2b60cd4a42a8993b61333d6cdb56ca3 diff --git a/include/c++/stl/stl/_istream.h b/include/c++/stl/stl/_istream.h new file mode 100644 index 0000000..9292cce --- /dev/null +++ b/include/c++/stl/stl/_istream.h @@ -0,0 +1,362 @@ +/* + * Copyright (c) 1999 + * Silicon Graphics Computer Systems, Inc. + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ +#ifndef _STLP_INTERNAL_ISTREAM +#define _STLP_INTERNAL_ISTREAM + +// this block is included by _ostream.h, we include it here to lower #include level +#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR) +# include +#endif + +#ifndef _STLP_INTERNAL_IOS_H +# include // For basic_ios<>. Includes . +#endif + +#ifndef _STLP_INTERNAL_OSTREAM_H +# include // Needed as a base class of basic_iostream. +#endif + +#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H +# include +#endif + +#include // Helper functions that allow char traits + // to be used as function objects. +_STLP_BEGIN_NAMESPACE + +#if defined (_STLP_USE_TEMPLATE_EXPORT) +template +class _Isentry; +#endif + +struct _No_Skip_WS {}; // Dummy class used by sentry. + +template +bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr); +template +bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr); + +//---------------------------------------------------------------------- +// Class basic_istream, a class that performs formatted input through +// a stream buffer. + +// The second template parameter, _Traits, defaults to char_traits<_CharT>. +// The default is declared in header , and it isn't declared here +// because C++ language rules do not allow it to be declared twice. + +template +class basic_istream : virtual public basic_ios<_CharT, _Traits> { + typedef basic_istream<_CharT, _Traits> _Self; + +#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310) + //explicitely defined as private to avoid warnings: + basic_istream(_Self const&); + _Self& operator = (_Self const&); +#endif + +public: + // Types + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + typedef basic_ios<_CharT, _Traits> _Basic_ios; + + typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&); + typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&); + typedef _Self& (_STLP_CALL *__istream_fn)(_Self&); + +public: // Constructor and destructor. + explicit basic_istream(basic_streambuf<_CharT, _Traits>* __buf) : + basic_ios<_CharT, _Traits>(), _M_gcount(0) { + this->init(__buf); + } + ~basic_istream() {}; + +public: // Nested sentry class. + +public: // Hooks for manipulators. The arguments are + // function pointers. + _Self& operator>> (__istream_fn __f) { return __f(*this); } + _Self& operator>> (__ios_fn __f) { __f(*this); return *this; } + _Self& operator>> (__ios_base_fn __f) { __f(*this); return *this; } + +public: // Formatted input of numbers. + _Self& operator>> (short& __val); + _Self& operator>> (int& __val); + _Self& operator>> (unsigned short& __val); + _Self& operator>> (unsigned int& __val); + _Self& operator>> (long& __val); + _Self& operator>> (unsigned long& __val); +#ifdef _STLP_LONG_LONG + _Self& operator>> (_STLP_LONG_LONG& __val); + _Self& operator>> (unsigned _STLP_LONG_LONG& __val); +#endif + _Self& operator>> (float& __val); + _Self& operator>> (double& __val); +# ifndef _STLP_NO_LONG_DOUBLE + _Self& operator>> (long double& __val); +# endif +# ifndef _STLP_NO_BOOL + _Self& operator>> (bool& __val); +# endif + _Self& operator>> (void*& __val); + +public: // Copying characters into a streambuf. + _Self& operator>>(basic_streambuf<_CharT, _Traits>*); + +public: // Unformatted input. + streamsize gcount() const { return _M_gcount; } + int_type peek(); + +public: // get() for single characters + int_type get(); + _Self& get(char_type& __c); + +public: // get() for character arrays. + _Self& get(char_type* __s, streamsize __n, char_type __delim); + _Self& get(char_type* __s, streamsize __n) + { return get(__s, __n, this->widen('\n')); } + +public: // get() for streambufs + _Self& get(basic_streambuf<_CharT, _Traits>& __buf, + char_type __delim); + _Self& get(basic_streambuf<_CharT, _Traits>& __buf) + { return get(__buf, this->widen('\n')); } + +public: // getline() + _Self& getline(char_type* __s, streamsize __n, char_type delim); + _Self& getline(char_type* __s, streamsize __n) + { return getline(__s, __n, this->widen('\n')); } + +public: // read(), readsome(), ignore() + _Self& ignore(); + _Self& ignore(streamsize __n); +#if (defined (_STLP_MSVC) && _STLP_MSVC < 1200) + inline +#endif + _Self& ignore(streamsize __n, int_type __delim); + + _Self& read(char_type* __s, streamsize __n); + streamsize readsome(char_type* __s, streamsize __n); + +public: // putback + _Self& putback(char_type __c); + _Self& unget(); + +public: // Positioning and buffer control. + int sync(); + + pos_type tellg(); + _Self& seekg(pos_type __pos); + _Self& seekg(off_type, ios_base::seekdir); + +public: // Helper functions for non-member extractors. + void _M_formatted_get(_CharT& __c); + void _M_formatted_get(_CharT* __s); + void _M_skip_whitespace(bool __set_failbit); + +private: // Number of characters extracted by the + streamsize _M_gcount; // most recent unformatted input function. + +public: + +#if defined (_STLP_USE_TEMPLATE_EXPORT) + // If we are using DLL specs, we have not to use inner classes + // end class declaration here + typedef _Isentry<_CharT, _Traits> sentry; +}; +# define sentry _Isentry +template +class _Isentry { + typedef _Isentry<_CharT, _Traits> _Self; +# else + class sentry { + typedef sentry _Self; +#endif + + private: + const bool _M_ok; + // basic_streambuf<_CharT, _Traits>* _M_buf; + + public: + typedef _Traits traits_type; + + explicit sentry(basic_istream<_CharT, _Traits>& __istr, + bool __noskipws = false) : + _M_ok((__noskipws || !(__istr.flags() & ios_base::skipws)) ? _M_init_noskip(__istr) : _M_init_skip(__istr) ) + /* , _M_buf(__istr.rdbuf()) */ + {} + + // Calling this constructor is the same as calling the previous one with + // __noskipws = true, except that it doesn't require a runtime test. + sentry(basic_istream<_CharT, _Traits>& __istr, _No_Skip_WS) : /* _M_buf(__istr.rdbuf()), */ + _M_ok(_M_init_noskip(__istr)) {} + + ~sentry() {} + + operator bool() const { return _M_ok; } + + private: // Disable assignment and copy constructor. + //Implementation is here only to avoid warning with some compilers. + sentry(const _Self&) : _M_ok(false) {} + _Self& operator=(const _Self&) { return *this; } + }; + +# if defined (_STLP_USE_TEMPLATE_EXPORT) +# undef sentry +# else + // close basic_istream class definition here +}; +# endif + +# if defined (_STLP_USE_TEMPLATE_EXPORT) +_STLP_EXPORT_TEMPLATE_CLASS _Isentry >; +_STLP_EXPORT_TEMPLATE_CLASS basic_istream >; +# if ! defined (_STLP_NO_WCHAR_T) +_STLP_EXPORT_TEMPLATE_CLASS _Isentry >; +_STLP_EXPORT_TEMPLATE_CLASS basic_istream >; +# endif +# endif /* _STLP_USE_TEMPLATE_EXPORT */ + +// Non-member character and string extractor functions. +template +inline basic_istream<_CharT, _Traits>& _STLP_CALL +operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT& __c) { + __in_str._M_formatted_get(__c); + return __in_str; +} + +template +inline basic_istream& _STLP_CALL +operator>>(basic_istream& __in_str, unsigned char& __c) { + __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c)); + return __in_str; +} + +template +inline basic_istream& _STLP_CALL +operator>>(basic_istream& __in_str, signed char& __c) { + __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c)); + return __in_str; +} + +template +inline basic_istream<_CharT, _Traits>& _STLP_CALL +operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT* __s) { + __in_str._M_formatted_get(__s); + return __in_str; +} + +template +inline basic_istream& _STLP_CALL +operator>>(basic_istream& __in_str, unsigned char* __s) { + __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s)); + return __in_str; +} + +template +inline basic_istream& _STLP_CALL +operator>>(basic_istream& __in_str, signed char* __s) { + __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s)); + return __in_str; +} + +//---------------------------------------------------------------------- +// istream manipulator. +template +basic_istream<_CharT, _Traits>& _STLP_CALL +ws(basic_istream<_CharT, _Traits>& __istr) { + if (!__istr.eof()) { + typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry; + _Sentry __sentry(__istr, _No_Skip_WS()); // Don't skip whitespace. + if (__sentry) + __istr._M_skip_whitespace(false); + } + return __istr; +} + +// Helper functions for istream<>::sentry constructor. +template +inline bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr) { + if (__istr.good()) { + if (__istr.tie()) + __istr.tie()->flush(); + + __istr._M_skip_whitespace(true); + } + + if (!__istr.good()) { + __istr.setstate(ios_base::failbit); + return false; + } else + return true; +} + +template +inline bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr) { + if (__istr.good()) { + if (__istr.tie()) + __istr.tie()->flush(); + + if (!__istr.rdbuf()) + __istr.setstate(ios_base::badbit); + } + else + __istr.setstate(ios_base::failbit); + return __istr.good(); +} + +//---------------------------------------------------------------------- +// Class iostream. +template +class basic_iostream + : public basic_istream<_CharT, _Traits>, + public basic_ostream<_CharT, _Traits> +{ +public: + typedef basic_ios<_CharT, _Traits> _Basic_ios; + + explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __buf); + virtual ~basic_iostream(); +}; + +# if defined (_STLP_USE_TEMPLATE_EXPORT) +_STLP_EXPORT_TEMPLATE_CLASS basic_iostream >; + +# if ! defined (_STLP_NO_WCHAR_T) +_STLP_EXPORT_TEMPLATE_CLASS basic_iostream >; +# endif +# endif /* _STLP_USE_TEMPLATE_EXPORT */ + +template +basic_streambuf<_CharT, _Traits>* _STLP_CALL _M_get_istreambuf(basic_istream<_CharT, _Traits>& __istr) +{ return __istr.rdbuf(); } + +_STLP_END_NAMESPACE + +#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION) +# include +#endif + +#endif /* _STLP_INTERNAL_ISTREAM */ + +// Local Variables: +// mode:C++ +// End: