602 lines
18 KiB
Plaintext
602 lines
18 KiB
Plaintext
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
|
|
|
This file is part of the uClibc C++ Library. This library is free
|
|
software; you can redistribute it and/or modify it under the
|
|
terms of the GNU General Public License as published by the
|
|
Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this library; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
USA.
|
|
*/
|
|
|
|
#include <ios>
|
|
#include <cctype>
|
|
#include <streambuf>
|
|
#include <istream_helpers>
|
|
#include <ostream>
|
|
|
|
#ifndef __STD_HEADER_ISTREAM
|
|
#define __STD_HEADER_ISTREAM 1
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
namespace std{
|
|
|
|
typedef basic_istream<char> istream;
|
|
|
|
#ifdef __UCLIBCXX_HAS_WCHAR__
|
|
typedef basic_istream<wchar_t> wistream;
|
|
#endif
|
|
|
|
template <class charT, class traits> basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
|
|
|
|
template <class charT, class traits> class _UCXXEXPORT basic_istream :
|
|
virtual public basic_ios<charT,traits>
|
|
{
|
|
public:
|
|
|
|
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 basic_streambuf<charT,traits> streambuf_type;
|
|
typedef traits traits_type;
|
|
|
|
explicit basic_istream(basic_streambuf<charT,traits>* sb)
|
|
: basic_ios<charT, traits>(sb), count_last_ufmt_input(0)
|
|
{
|
|
basic_ios<charT, traits>::init(sb);
|
|
}
|
|
virtual ~basic_istream() { }
|
|
|
|
class sentry;
|
|
|
|
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
|
|
basic_istream<charT,traits>& operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
|
|
basic_istream<charT,traits>& operator>>(ios_base& (*pf)(ios_base&));
|
|
basic_istream<charT,traits>& operator>>(bool& n);
|
|
basic_istream<charT,traits>& operator>>(short& n);
|
|
basic_istream<charT,traits>& operator>>(unsigned short& n);
|
|
basic_istream<charT,traits>& operator>>(int& n);
|
|
basic_istream<charT,traits>& operator>>(unsigned int& n);
|
|
basic_istream<charT,traits>& operator>>(long& n);
|
|
basic_istream<charT,traits>& operator>>(unsigned long& n);
|
|
basic_istream<charT,traits>& operator>>(void*& p);
|
|
basic_istream<charT,traits>& operator>>(basic_streambuf<char_type,traits>* sb);
|
|
|
|
#ifdef __UCLIBCXX_HAS_FLOATS__
|
|
basic_istream<charT,traits>& operator>>(float& f);
|
|
basic_istream<charT,traits>& operator>>(double& f);
|
|
basic_istream<charT,traits>& operator>>(long double& f);
|
|
#endif
|
|
|
|
_UCXXEXPORT streamsize gcount() const{
|
|
return count_last_ufmt_input;
|
|
}
|
|
|
|
_UCXXEXPORT int_type get(); //below
|
|
_UCXXEXPORT basic_istream<charT,traits>& get(char_type& c); //Below
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n){
|
|
return get(s, n, basic_ios<charT,traits>::widen('\n'));
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n, char_type delim){
|
|
sentry(*this, true);
|
|
streamsize i = 0;
|
|
int_type c;
|
|
for(i=0;i<n-1;++i){
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
if(c == traits::eof() ){
|
|
if(i==0){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}else{
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}
|
|
break;
|
|
}
|
|
if(c == delim){
|
|
if(i==0){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}
|
|
basic_ios<charT, traits>::mstreambuf->sputbackc(c);
|
|
break;
|
|
}
|
|
s[i] = c;
|
|
}
|
|
s[i] = traits::eos();
|
|
count_last_ufmt_input = i;
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb){
|
|
return get(sb, basic_ios<charT,traits>::widen('\n'));
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, char_type delim){
|
|
sentry(*this, true);
|
|
streamsize i = 0;
|
|
int_type c;
|
|
while(1){ //We will exit internally based upon error conditions
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(c == traits::eof()){
|
|
if(i==0){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}else{
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}
|
|
count_last_ufmt_input = i;
|
|
return *this;
|
|
}
|
|
if(c == delim){
|
|
if(i==0){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}
|
|
count_last_ufmt_input = i;
|
|
return *this;
|
|
}
|
|
if(sb.sputc(c) != c){ //Error doing output
|
|
count_last_ufmt_input = i;
|
|
return *this;
|
|
}
|
|
++i;
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
}
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n){
|
|
return getline(s, n, basic_ios<charT,traits>::widen('\n'));
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n, char_type delim){
|
|
sentry(*this, true);
|
|
streamsize i = 0;
|
|
int_type c;
|
|
for(i=0;i<n-1;++i){
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(c == traits::eof() ){
|
|
if( basic_ios<charT,traits>::eof() ){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}else{
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}
|
|
count_last_ufmt_input = i;
|
|
s[i] = traits::eos();
|
|
return *this;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf->sbumpc()==traits::eof() ){
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}
|
|
if(c == delim){
|
|
count_last_ufmt_input = i+1;
|
|
s[i] = traits::eos();
|
|
return *this;
|
|
}
|
|
s[i] = c;
|
|
}
|
|
s[n-1] = traits::eos();
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& ignore (streamsize n = 1, int_type delim = traits::eof()){
|
|
sentry(*this, true);
|
|
streamsize i;
|
|
int_type c;
|
|
for(i=0;i<n;++i){
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(c == traits::eof()){
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
return *this;
|
|
}
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
if(c == delim){
|
|
return *this;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT int_type peek(){
|
|
if(basic_ios<charT,traits>::good() == false){
|
|
return traits::eof();
|
|
}else{
|
|
int_type c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(c == traits::eof()){
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}
|
|
return basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
}
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& read (char_type* s, streamsize n){
|
|
sentry(*this, true);
|
|
streamsize i;
|
|
int_type c;
|
|
for(i=0;i<n;++i){
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
|
|
if(c == traits::eof()){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
count_last_ufmt_input = i;
|
|
return *this;
|
|
}
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
s[i] = c;
|
|
}
|
|
count_last_ufmt_input = n;
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT streamsize readsome(char_type* s, streamsize n){
|
|
sentry(*this, true);
|
|
if(!basic_ios<charT,traits>::good()){
|
|
count_last_ufmt_input = 0;
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
return 0;
|
|
}
|
|
|
|
if( basic_ios<charT, traits>::mstreambuf->in_avail() == -1){
|
|
count_last_ufmt_input=0;
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
return 0;
|
|
}
|
|
|
|
if(n > basic_ios<charT, traits>::mstreambuf->in_avail() ){
|
|
n = basic_ios<charT, traits>::mstreambuf->in_avail();
|
|
}
|
|
|
|
streamsize i;
|
|
int_type c;
|
|
|
|
for(i=0;i<n;++i){
|
|
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
s[i] = c;
|
|
}
|
|
count_last_ufmt_input = n;
|
|
return n;
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& putback(char_type c){
|
|
sentry(*this, true);
|
|
if(!basic_ios<charT,traits>::good()){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
return *this;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf == 0){
|
|
basic_ios<charT,traits>::setstate(ios_base::badbit);
|
|
return *this;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf->sputbackc(c) == traits::eof()){
|
|
basic_ios<charT,traits>::setstate(ios_base::badbit);
|
|
return *this;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& unget(){
|
|
sentry(*this, true);
|
|
if(!basic_ios<charT,traits>::good()){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
return *this;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf == 0){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
return *this;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf->sungetc() == traits::eof()){
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT int sync(){
|
|
sentry(*this, true);
|
|
if(basic_ios<charT, traits>::mstreambuf == 0){
|
|
return -1;
|
|
}
|
|
if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
|
|
basic_ios<charT,traits>::setstate(ios_base::badbit);
|
|
return traits::eof();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
_UCXXEXPORT pos_type tellg(){
|
|
if(basic_ios<charT,traits>::fail() !=false){
|
|
return pos_type(-1);
|
|
}
|
|
return basic_ios<charT, traits>::mstreambuf->pubseekoff(0, ios_base::cur, ios_base::in);
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& seekg(pos_type pos){
|
|
if(basic_ios<charT,traits>::fail() !=true){
|
|
basic_ios<charT, traits>::mstreambuf->pubseekpos(pos);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_UCXXEXPORT basic_istream<charT,traits>& seekg(off_type off, ios_base::seekdir dir){
|
|
if(basic_ios<charT,traits>::fail() !=true){
|
|
basic_ios<charT, traits>::mstreambuf->pubseekoff(off, dir);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
protected:
|
|
_UCXXEXPORT basic_istream(const basic_istream<charT,traits> &): basic_ios<charT, traits>() { }
|
|
_UCXXEXPORT basic_istream<charT,traits> & operator=(const basic_istream<charT,traits> &){ return *this; }
|
|
streamsize count_last_ufmt_input;
|
|
|
|
};
|
|
|
|
template <class charT,class traits = char_traits<charT> > class _UCXXEXPORT basic_istream<charT,traits>::sentry {
|
|
bool ok;
|
|
public:
|
|
explicit _UCXXEXPORT sentry(basic_istream<charT,traits>& os, bool noskipws = false){
|
|
if(os.good() !=0){ //Prepare for output
|
|
}
|
|
|
|
//Flush any tied buffer
|
|
if(os.tie() != 0){
|
|
os.tie()->flush();
|
|
}
|
|
if(!noskipws){
|
|
__skipws(os);
|
|
}
|
|
|
|
ok = true;
|
|
}
|
|
_UCXXEXPORT ~sentry() { }
|
|
_UCXXEXPORT operator bool() {
|
|
return ok;
|
|
}
|
|
};
|
|
|
|
//Template implementations of basic_istream functions which may be partially specialized
|
|
//For code reduction
|
|
|
|
template <class charT, class traits>
|
|
_UCXXEXPORT typename basic_istream<charT,traits>::int_type basic_istream<charT,traits>::get(){
|
|
sentry(*this, true);
|
|
int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(retval == traits::eof()){
|
|
count_last_ufmt_input = 0;
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
}else{
|
|
count_last_ufmt_input = 1;
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
template <class charT, class traits>
|
|
_UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::get(char_type& c){
|
|
sentry(*this, true);
|
|
int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
|
|
if(retval == traits::eof()){
|
|
count_last_ufmt_input = 0;
|
|
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
|
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
|
}else{
|
|
count_last_ufmt_input = 1;
|
|
c = traits::to_char_type(retval);
|
|
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(bool& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, bool>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(short& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, short>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(unsigned short& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, unsigned short>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(int& n){
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, int>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(unsigned int& n){
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, unsigned int>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(long int& n){
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, long int>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(unsigned long int& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, unsigned long int>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
#ifdef __UCLIBCXX_HAS_FLOATS__
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(float& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, float>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(double& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, double>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(long double& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, long double>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
#endif
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(void *& n)
|
|
{
|
|
sentry(*this);
|
|
__istream_readin<traits, charT, void*>::readin(*this, n);
|
|
return *this;
|
|
}
|
|
|
|
template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
operator>>(basic_istream<charT,traits>& is, charT& c)
|
|
{
|
|
typename basic_istream<charT,traits>::sentry s(is);
|
|
is.get(c);
|
|
return is;
|
|
}
|
|
|
|
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
|
operator>>(basic_istream<char,traits>& is, unsigned char& c)
|
|
{
|
|
typename basic_istream<char,traits>::sentry s(is);
|
|
char b;
|
|
is.get(b);
|
|
c = b;
|
|
return is;
|
|
}
|
|
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
|
operator>>(basic_istream<char,traits>& is, signed char& c)
|
|
{
|
|
typename basic_istream<char,traits>::sentry s(is);
|
|
is.get(c);
|
|
return is;
|
|
}
|
|
|
|
template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
operator>>(basic_istream<charT,traits>& is, charT* c)
|
|
{
|
|
typename basic_istream<charT,traits>::sentry s(is);
|
|
int n = is.width();
|
|
if(n == 0){
|
|
n = __STRING_MAX_UNITS;
|
|
}
|
|
is.get(c, n);
|
|
return is;
|
|
|
|
}
|
|
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
|
operator>>(basic_istream<char,traits>& is, unsigned char* c)
|
|
{
|
|
typename basic_istream<char,traits>::sentry s(is);
|
|
int n = is.width();
|
|
if(n == 0){
|
|
n = __STRING_MAX_UNITS;
|
|
}
|
|
is.get(c, n);
|
|
return is;
|
|
}
|
|
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
|
operator>>(basic_istream<char,traits>& is, signed char* c)
|
|
{
|
|
typename basic_istream<char,traits>::sentry s(is);
|
|
int n = is.width();
|
|
if(n == 0){
|
|
n = __STRING_MAX_UNITS;
|
|
}
|
|
is.get(c, n);
|
|
return is;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
|
|
{
|
|
sentry(*this);
|
|
pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
basic_istream<charT,traits>::operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
|
|
{
|
|
sentry(*this);
|
|
pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
|
ws(basic_istream<charT,traits>& is)
|
|
{
|
|
__skipws(is);
|
|
return is;
|
|
}
|
|
|
|
|
|
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
|
#ifndef __UCLIBCXX_COMPILE_ISTREAM__
|
|
|
|
|
|
template <> _UCXXEXPORT istream & basic_istream<char, char_traits<char> >::get(char & c);
|
|
template <> _UCXXEXPORT istream::int_type basic_istream<char, char_traits<char> >::get();
|
|
|
|
template <> _UCXXEXPORT istream & istream::operator>>(bool &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(short &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(int &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(long int &n);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(void *& p);
|
|
|
|
#ifdef __UCLIBCXX_HAS_FLOATS__
|
|
template <> _UCXXEXPORT istream & istream::operator>>(float &f);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(double &f);
|
|
template <> _UCXXEXPORT istream & istream::operator>>(long double &f);
|
|
#endif
|
|
|
|
template <> _UCXXEXPORT istream & operator>>(istream & is, char & c);
|
|
|
|
template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
#pragma GCC visibility pop
|
|
|
|
#endif
|
|
|