526 lines
12 KiB
Plaintext
526 lines
12 KiB
Plaintext
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
|
|
|
This file is part of the uClibc++ Library.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <basic_definitions>
|
|
#include <cstddef>
|
|
#include <locale>
|
|
#include <iosfwd>
|
|
#include <new>
|
|
|
|
#ifndef __HEADER_STD_IOS
|
|
#define __HEADER_STD_IOS 1
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
namespace std{
|
|
typedef signed long int streamoff;
|
|
|
|
template <class stateT> class fpos;
|
|
|
|
class _UCXXEXPORT ios_base {
|
|
public:
|
|
class failure;
|
|
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
|
class failure : public exception {
|
|
public:
|
|
explicit failure(const std::string& msg) { }
|
|
explicit failure() { }
|
|
virtual const char* what() const throw() {
|
|
return "std::ios_base failure exception";
|
|
}
|
|
};
|
|
#endif
|
|
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
|
class _UCXXLOCAL Init{
|
|
public:
|
|
_UCXXEXPORT Init();
|
|
_UCXXEXPORT ~Init();
|
|
private:
|
|
static int init_cnt;
|
|
};
|
|
#endif
|
|
|
|
public:
|
|
|
|
typedef unsigned short int fmtflags;
|
|
|
|
static const fmtflags skipws = 0x0001;
|
|
|
|
static const fmtflags left = 0x0002;
|
|
static const fmtflags right = 0x0004;
|
|
static const fmtflags internal = 0x0008;
|
|
|
|
static const fmtflags boolalpha = 0x0010;
|
|
|
|
static const fmtflags dec = 0x0020;
|
|
static const fmtflags oct = 0x0040;
|
|
static const fmtflags hex = 0x0080;
|
|
|
|
static const fmtflags scientific = 0x0100;
|
|
static const fmtflags fixed = 0x0200;
|
|
|
|
static const fmtflags showbase = 0x0400;
|
|
static const fmtflags showpoint = 0x0800;
|
|
static const fmtflags showpos = 0x1000;
|
|
static const fmtflags uppercase = 0x2000;
|
|
|
|
static const fmtflags adjustfield = left | right | internal;
|
|
static const fmtflags basefield = dec | oct | hex;
|
|
static const fmtflags floatfield = fixed | scientific;
|
|
|
|
static const fmtflags unitbuf = 0x4000;
|
|
|
|
typedef unsigned char iostate;
|
|
static const iostate goodbit = 0x00;
|
|
static const iostate badbit = 0x01;
|
|
static const iostate eofbit = 0x02;
|
|
static const iostate failbit = 0x04;
|
|
|
|
typedef unsigned char openmode;
|
|
static const openmode app = 0x01;
|
|
static const openmode ate = 0x02;
|
|
static const openmode binary = 0x04;
|
|
static const openmode in = 0x08;
|
|
static const openmode out = 0x10;
|
|
static const openmode trunc = 0x20;
|
|
|
|
typedef unsigned char seekdir;
|
|
static const seekdir beg = 0x01;
|
|
static const seekdir cur = 0x02;
|
|
static const seekdir end = 0x04;
|
|
|
|
_UCXXEXPORT fmtflags flags() const{
|
|
return mformat;
|
|
}
|
|
|
|
_UCXXEXPORT fmtflags flags(fmtflags fmtfl) {
|
|
fmtflags temp = mformat;
|
|
mformat = fmtfl;
|
|
return temp;
|
|
}
|
|
|
|
|
|
fmtflags setf(fmtflags fmtfl) {
|
|
return flags(flags() | fmtfl);
|
|
}
|
|
|
|
fmtflags setf(fmtflags fmtfl, fmtflags mask ) {
|
|
return flags( (flags()& ~mask) | (fmtfl & mask));
|
|
}
|
|
|
|
_UCXXEXPORT void unsetf(fmtflags mask){
|
|
mformat&= ~mask;
|
|
}
|
|
|
|
_UCXXEXPORT streamsize precision() const{
|
|
return mprecision;
|
|
}
|
|
|
|
_UCXXEXPORT streamsize precision(streamsize prec) {
|
|
streamsize temp = mprecision;
|
|
mprecision = prec;
|
|
return temp;
|
|
}
|
|
|
|
_UCXXEXPORT streamsize width() const{
|
|
return mwidth;
|
|
}
|
|
|
|
_UCXXEXPORT streamsize width(streamsize wide) {
|
|
streamsize temp = mwidth;
|
|
mwidth = wide;
|
|
return temp;
|
|
}
|
|
|
|
_UCXXEXPORT locale imbue(const locale& loc) {
|
|
locale retval = mLocale;
|
|
mLocale = loc;
|
|
return retval;
|
|
}
|
|
|
|
_UCXXEXPORT locale getloc() const{
|
|
return mLocale;
|
|
}
|
|
|
|
// FIXME - These need to be implemented
|
|
// static int xalloc();
|
|
// long& iword(int index);
|
|
// void*& pword(int index);
|
|
|
|
_UCXXEXPORT ~ios_base() { }
|
|
|
|
enum event { erase_event, imbue_event, copyfmt_event };
|
|
|
|
typedef void (*event_callback)(event, ios_base&, int index);
|
|
// void register_callback(event_call_back fn, int index);
|
|
|
|
//We are going to wrap stdio so we don't need implementation of the following:
|
|
inline static bool sync_with_stdio(bool = true) { return true; }
|
|
|
|
protected:
|
|
_UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws ), mstate(goodbit),
|
|
mmode(), mdir(), mprecision(6), mwidth(0)
|
|
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
|
,mInit()
|
|
#endif
|
|
{
|
|
|
|
}
|
|
locale mLocale;
|
|
fmtflags mformat;
|
|
iostate mstate;
|
|
openmode mmode;
|
|
seekdir mdir;
|
|
streamsize mprecision;
|
|
streamsize mwidth;
|
|
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
|
Init mInit;
|
|
#endif
|
|
};
|
|
|
|
|
|
//ios_base manipulators
|
|
|
|
|
|
inline ios_base& boolalpha (ios_base& str){
|
|
str.setf(ios_base::boolalpha);
|
|
return str;
|
|
}
|
|
inline ios_base& noboolalpha(ios_base& str){
|
|
str.unsetf(ios_base::boolalpha);
|
|
return str;
|
|
}
|
|
inline ios_base& showbase (ios_base& str){
|
|
str.setf(ios_base::showbase);
|
|
return str;
|
|
}
|
|
inline ios_base& noshowbase (ios_base& str){
|
|
str.unsetf(ios_base::showbase);
|
|
return str;
|
|
}
|
|
inline ios_base& showpoint (ios_base& str){
|
|
str.setf(ios_base::showpoint);
|
|
return str;
|
|
}
|
|
inline ios_base& noshowpoint(ios_base& str){
|
|
str.unsetf(ios_base::showpoint);
|
|
return str;
|
|
}
|
|
inline ios_base& showpos (ios_base& str){
|
|
str.setf(ios_base::showpos);
|
|
return str;
|
|
}
|
|
inline ios_base& noshowpos (ios_base& str){
|
|
str.unsetf(ios_base::showpos);
|
|
return str;
|
|
}
|
|
inline ios_base& skipws (ios_base& str){
|
|
str.setf(ios_base::skipws);
|
|
return str;
|
|
}
|
|
inline ios_base& noskipws (ios_base& str){
|
|
str.unsetf(ios_base::skipws);
|
|
return str;
|
|
}
|
|
inline ios_base& uppercase (ios_base& str){
|
|
str.setf(ios_base::uppercase);
|
|
return str;
|
|
}
|
|
inline ios_base& nouppercase(ios_base& str){
|
|
str.unsetf(ios_base::uppercase);
|
|
return str;
|
|
}
|
|
|
|
inline ios_base& unitbuf (ios_base& str){
|
|
str.setf(ios_base::unitbuf);
|
|
return str;
|
|
}
|
|
inline ios_base& nounitbuf (ios_base& str){
|
|
str.unsetf(ios_base::unitbuf);
|
|
return str;
|
|
}
|
|
inline ios_base& internal (ios_base& str){
|
|
str.setf(ios_base::internal, ios_base::adjustfield);
|
|
return str;
|
|
}
|
|
inline ios_base& left (ios_base& str){
|
|
str.setf(ios_base::left, ios_base::adjustfield);
|
|
return str;
|
|
}
|
|
inline ios_base& right (ios_base& str){
|
|
str.setf(ios_base::right, ios_base::adjustfield);
|
|
return str;
|
|
}
|
|
|
|
inline ios_base& dec (ios_base& str){
|
|
str.setf(ios_base::dec, ios_base::basefield);
|
|
return str;
|
|
}
|
|
inline ios_base& hex (ios_base& str){
|
|
str.setf(ios_base::hex, ios_base::basefield);
|
|
return str;
|
|
}
|
|
inline ios_base& oct (ios_base& str){
|
|
str.setf(ios_base::oct, ios_base::basefield);
|
|
return str;
|
|
}
|
|
|
|
inline ios_base& fixed (ios_base& str){
|
|
str.setf(ios_base::fixed, ios_base::floatfield);
|
|
return str;
|
|
}
|
|
inline ios_base& scientific (ios_base& str){
|
|
str.setf(ios_base::scientific, ios_base::floatfield);
|
|
return str;
|
|
}
|
|
|
|
|
|
//basic_ios class definition
|
|
|
|
|
|
template <class charT, class traits > class _UCXXEXPORT basic_ios
|
|
: public ios_base
|
|
{
|
|
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;
|
|
|
|
_UCXXEXPORT operator void*() const{
|
|
if(fail() ){
|
|
return 0;
|
|
}
|
|
return (void *)(1); //Must return a non-NULL pointer (though it can be *any* pointer)
|
|
}
|
|
|
|
_UCXXEXPORT bool operator!() const{
|
|
return fail();
|
|
}
|
|
_UCXXEXPORT iostate rdstate() const{
|
|
return mstate;
|
|
}
|
|
_UCXXEXPORT void clear(iostate state = goodbit){
|
|
if(rdbuf()!=0){
|
|
mstate = state;
|
|
}else{
|
|
mstate = state|ios_base::badbit;
|
|
}
|
|
}
|
|
_UCXXEXPORT void setstate(iostate state) {
|
|
clear(rdstate() | state);
|
|
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
|
if(rdstate() & throw_mask){
|
|
throw failure();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
_UCXXEXPORT bool good() const{
|
|
return (rdstate() == 0);
|
|
}
|
|
_UCXXEXPORT bool eof() const{
|
|
if(rdstate() & eofbit){
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
_UCXXEXPORT bool fail() const{
|
|
if( mstate & (failbit | badbit) ){
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
_UCXXEXPORT bool bad() const{
|
|
if(mstate & badbit){
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
_UCXXEXPORT iostate exceptions() const{
|
|
return throw_mask;
|
|
}
|
|
_UCXXEXPORT void exceptions(iostate except){
|
|
throw_mask = except;
|
|
}
|
|
|
|
explicit _UCXXEXPORT basic_ios(basic_streambuf<charT,traits>* sb) : fill_char(' '), mtied(0), mstreambuf(0){
|
|
init(sb);
|
|
}
|
|
|
|
basic_ios() : mtied(0), mstreambuf(0){ }
|
|
|
|
virtual _UCXXEXPORT ~basic_ios(){
|
|
}
|
|
|
|
_UCXXEXPORT basic_ostream<charT,traits>* tie() const{
|
|
return mtied;
|
|
}
|
|
_UCXXEXPORT basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr){
|
|
basic_ostream<charT,traits>* retval= mtied;
|
|
mtied = tiestr;
|
|
return retval;
|
|
}
|
|
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf() const{
|
|
return mstreambuf;
|
|
}
|
|
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb){
|
|
basic_streambuf<charT,traits>* retval = mstreambuf;
|
|
mstreambuf = sb;
|
|
return retval;
|
|
}
|
|
_UCXXEXPORT basic_ios& copyfmt(const basic_ios& rhs);
|
|
_UCXXEXPORT char_type fill() const{
|
|
return fill_char;
|
|
}
|
|
_UCXXEXPORT char_type fill(char_type ch){
|
|
char_type temp = fill_char;
|
|
fill_char = ch;
|
|
return temp;
|
|
}
|
|
|
|
_UCXXEXPORT locale imbue(const locale& loc){
|
|
return ios_base::imbue(loc);
|
|
}
|
|
_UCXXEXPORT char narrow(char_type c, char dfault) const;
|
|
_UCXXEXPORT char_type widen(char c) const;
|
|
|
|
protected:
|
|
char_type fill_char;
|
|
basic_ostream<charT,traits>* mtied;
|
|
basic_streambuf<charT,traits>* mstreambuf;
|
|
iostate throw_mask;
|
|
_UCXXEXPORT basic_ios(const basic_ios<charT,traits> &){ }
|
|
_UCXXEXPORT basic_ios<charT,traits> & operator=(const basic_ios<charT,traits> &){ return *this; }
|
|
_UCXXEXPORT void init(basic_streambuf<charT,traits>* sb){
|
|
ios_base::mformat = skipws|dec;
|
|
mstreambuf = sb;
|
|
mstate = goodbit;
|
|
throw_mask = goodbit;
|
|
}
|
|
};
|
|
|
|
#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
|
|
#ifndef __UCLIBCXX_COMPILE_IOS__
|
|
|
|
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
|
|
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
template <class charT, class traits>
|
|
inline char basic_ios<charT, traits>::narrow(char_type c, char dfault) const
|
|
{
|
|
return dfault;
|
|
}
|
|
|
|
template <>
|
|
inline char basic_ios<char, char_traits<char> >::narrow(char_type c, char) const
|
|
{
|
|
return c;
|
|
}
|
|
|
|
#ifdef __UCLIBCXX_HAS_WCHAR__
|
|
|
|
template <>
|
|
inline char basic_ios<wchar_t, char_traits<wchar_t> >::narrow(char_type c, char dfault) const
|
|
{
|
|
char retval = wctob (c);
|
|
if(retval == EOF){
|
|
retval = dfault;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
#endif //__UCLIBCXX_HAS_WCHAR__
|
|
|
|
template <class charT, class traits>
|
|
inline typename basic_ios<charT, traits>::char_type
|
|
basic_ios<charT, traits>::widen(char c) const
|
|
{
|
|
return c;
|
|
}
|
|
|
|
template <>
|
|
inline basic_ios<char, char_traits<char> >::char_type
|
|
basic_ios<char, char_traits<char> >::widen(char c) const
|
|
{
|
|
return c;
|
|
}
|
|
|
|
#ifdef __UCLIBCXX_HAS_WCHAR__
|
|
|
|
template <>
|
|
inline basic_ios<wchar_t, char_traits<wchar_t> >::char_type
|
|
basic_ios<wchar_t, char_traits<wchar_t> >::widen(char c) const
|
|
{
|
|
return btowc(c);
|
|
}
|
|
|
|
#endif //__UCLIBCXX_HAS_WCHAR__
|
|
|
|
|
|
template <class stateT> class _UCXXEXPORT fpos{
|
|
public:
|
|
_UCXXEXPORT fpos(stateT s){
|
|
st = s;
|
|
}
|
|
_UCXXEXPORT stateT state() const{
|
|
return st;
|
|
}
|
|
_UCXXEXPORT void state(stateT s){
|
|
st = s;
|
|
}
|
|
_UCXXEXPORT bool operator==(const fpos &rhs){
|
|
return st == rhs.st;
|
|
}
|
|
_UCXXEXPORT bool operator!=(const fpos &rhs){
|
|
return st == rhs.st;
|
|
}
|
|
_UCXXEXPORT fpos & operator+(const streamoff & o){
|
|
st += o;
|
|
return *this;
|
|
}
|
|
_UCXXEXPORT fpos & operator-(const streamoff & o){
|
|
st -= o;
|
|
return *this;
|
|
}
|
|
_UCXXEXPORT streamoff operator-(const fpos & rhs){
|
|
return st - rhs.st;
|
|
}
|
|
|
|
|
|
private:
|
|
stateT st;
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#pragma GCC visibility pop
|
|
|
|
#endif
|
|
|