mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 05:08:39 +00:00
360 lines
12 KiB
C++
360 lines
12 KiB
C++
/*
|
|
* 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 <stl/_cwchar.h>
|
|
#endif
|
|
|
|
#ifndef _STLP_INTERNAL_IOS_H
|
|
# include <stl/_ios.h> // For basic_ios<>. Includes <iosfwd>.
|
|
#endif
|
|
|
|
#ifndef _STLP_INTERNAL_OSTREAM_H
|
|
# include <stl/_ostream.h> // Needed as a base class of basic_iostream.
|
|
#endif
|
|
|
|
#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
|
|
# include <stl/_istreambuf_iterator.h>
|
|
#endif
|
|
|
|
#include <stl/_ctraits_fns.h> // Helper functions that allow char traits
|
|
// to be used as function objects.
|
|
_STLP_BEGIN_NAMESPACE
|
|
|
|
#if defined (_STLP_USE_TEMPLATE_EXPORT)
|
|
template <class _CharT, class _Traits>
|
|
class _Isentry;
|
|
#endif
|
|
|
|
struct _No_Skip_WS {}; // Dummy class used by sentry.
|
|
|
|
template <class _CharT, class _Traits>
|
|
bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr);
|
|
template <class _CharT, class _Traits>
|
|
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 <iosfwd>, and it isn't declared here
|
|
// because C++ language rules do not allow it to be declared twice.
|
|
|
|
template <class _CharT, class _Traits>
|
|
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);
|
|
_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 _CharT, class _Traits>
|
|
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<char, char_traits<char> >;
|
|
_STLP_EXPORT_TEMPLATE_CLASS basic_istream<char, char_traits<char> >;
|
|
# if ! defined (_STLP_NO_WCHAR_T)
|
|
_STLP_EXPORT_TEMPLATE_CLASS _Isentry<wchar_t, char_traits<wchar_t> >;
|
|
_STLP_EXPORT_TEMPLATE_CLASS basic_istream<wchar_t, char_traits<wchar_t> >;
|
|
# endif
|
|
# endif /* _STLP_USE_TEMPLATE_EXPORT */
|
|
|
|
// Non-member character and string extractor functions.
|
|
template <class _CharT, class _Traits>
|
|
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 <class _Traits>
|
|
inline basic_istream<char, _Traits>& _STLP_CALL
|
|
operator>>(basic_istream<char, _Traits>& __in_str, unsigned char& __c) {
|
|
__in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
|
|
return __in_str;
|
|
}
|
|
|
|
template <class _Traits>
|
|
inline basic_istream<char, _Traits>& _STLP_CALL
|
|
operator>>(basic_istream<char, _Traits>& __in_str, signed char& __c) {
|
|
__in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
|
|
return __in_str;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
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 <class _Traits>
|
|
inline basic_istream<char, _Traits>& _STLP_CALL
|
|
operator>>(basic_istream<char, _Traits>& __in_str, unsigned char* __s) {
|
|
__in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
|
|
return __in_str;
|
|
}
|
|
|
|
template <class _Traits>
|
|
inline basic_istream<char, _Traits>& _STLP_CALL
|
|
operator>>(basic_istream<char, _Traits>& __in_str, signed char* __s) {
|
|
__in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
|
|
return __in_str;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// istream manipulator.
|
|
template <class _CharT, class _Traits>
|
|
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 <class _CharT, class _Traits>
|
|
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 <class _CharT, class _Traits>
|
|
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 _CharT, class _Traits>
|
|
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<char, char_traits<char> >;
|
|
|
|
# if ! defined (_STLP_NO_WCHAR_T)
|
|
_STLP_EXPORT_TEMPLATE_CLASS basic_iostream<wchar_t, char_traits<wchar_t> >;
|
|
# endif
|
|
# endif /* _STLP_USE_TEMPLATE_EXPORT */
|
|
|
|
template <class _CharT, class _Traits>
|
|
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 <stl/_istream.c>
|
|
#endif
|
|
|
|
#endif /* _STLP_INTERNAL_ISTREAM */
|
|
|
|
// Local Variables:
|
|
// mode:C++
|
|
// End:
|