diff -Naur root/cint/Module.mk root.new/cint/Module.mk --- root/cint/Module.mk 2007-01-18 08:00:33.000000000 -0500 +++ root.new/cint/Module.mk 2007-11-26 09:10:13.000000000 -0500 @@ -42,6 +42,7 @@ CINTS2 := $(filter-out $(MODDIRS)/sunstrm.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/sun5strm.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/gcc3strm.%,$(CINTS2)) +CINTS2 := $(filter-out $(MODDIRS)/gcc4strm.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/longif3.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/accstrm.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/iccstrm.%,$(CINTS2)) @@ -170,7 +171,7 @@ ifeq ($(GCC_MAJOR),4) CINTS2 := $(filter-out $(MODDIRS)/libstrm.%,$(CINTS2)) CINTS2 := $(filter-out $(MODDIRS)/longif.%,$(CINTS2)) -CINTS2 += $(MODDIRS)/gcc3strm.cxx +CINTS2 += $(MODDIRS)/gcc4strm.cxx CINTS2 += $(MODDIRS)/longif3.cxx endif ifeq ($(CXXCMD),xlC) @@ -266,7 +267,8 @@ distclean-cint: clean-cint @rm -f $(CINTALLDEP) $(CINTLIB) $(IOSENUM) $(CINTEXEDEP) \ $(CINT) $(CINTTMP) $(MAKECINT) $(CINTDIRM)/*.exp \ - $(CINTDIRM)/*.lib $(CINTDIRS)/v6_loadfile_tmp.cxx + $(CINTDIRM)/*.lib $(CINTDIRS)/v6_loadfile_tmp.cxx \ + $(CINTDIRDLLS)/sys/types.h $(CINTDIRDLLS)/systypes.h distclean:: distclean-cint diff -Naur root/cint/lib/gcc4strm/Makefile root.new/cint/lib/gcc4strm/Makefile --- root/cint/lib/gcc4strm/Makefile 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/Makefile 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,28 @@ +# +# lib/gcc4strm/Makefile +# +CP = cp +MV = mv + +CINTSYSDIR = ../.. + +SRCCPPIFC = $(CINTSYSDIR)/src/gcc4strm.cxx +SRCCPPIFH = $(CINTSYSDIR)/src/gcc4strm.h +CPPIFC = gcc4strm.cxx +CPPIFH = gcc4strm.h + +CPPHEADER = iostrm.h fstrm.h sstrm.h linkdef.h + +# stdiostr.h \ + + +$(SRCCPPIFC) : $(CPPIFC) +# cint ../snstream/length.cxx 255 $(CPPIFC) $(CPPIFH) + $(MV) $(CPPIFC) $(SRCCPPIFC) + $(MV) $(CPPIFH) $(SRCCPPIFH) + + +$(CPPIFC) : $(CPPHEADER) + cint -Z0 -n$(CPPIFC) -NG__stream $(DLLSPEC) -D__MAKECINT__ -DG__MAKECINT -c-1 $(IPATH) $(MACRO) $(CPPHEADER) + +# cint -Z0 -n$(CPPIFC) -NG__stream $(DLLSPEC) -D__MAKECINT__ -DG__MAKECINT -M0x10 -c-1 $(IPATH) $(MACRO) $(CPPHEADER) diff -Naur root/cint/lib/gcc4strm/README.txt root.new/cint/lib/gcc4strm/README.txt --- root/cint/lib/gcc4strm/README.txt 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/README.txt 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,15 @@ +lib/gcc4strm/README + + lib/gcc4strm directory exists for creating iostream library linkage file +src/gcc4strm.cxx and src/gcc4strm.h for g++ 3.00 compiler. These files +contain interface methods for iostream library. You can create those by +doing 'make' under this directory. Usually nobody but only author should +do this. User doesn't need to recognize this. + Files in this directory are originally copied from lib/snstream/* and +modified for gcc4strm. + + cbstream.cpp is based on template based stream library. + + Creating src/gcc4strm.cxx + + 1) Just do 'make' in this directory. diff -Naur root/cint/lib/gcc4strm/fstrm.h root.new/cint/lib/gcc4strm/fstrm.h --- root/cint/lib/gcc4strm/fstrm.h 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/fstrm.h 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,161 @@ +/* /% C++ %/ */ +/*********************************************************************** + * cint (C/C++ interpreter) + ************************************************************************ + * header file fstrm.h + ************************************************************************ + * Description: + * Stub file for making iostream library + ************************************************************************ + * Copyright(c) 2007 Masaharu Goto (cint@pcroot.cern.ch) + * + * For the licensing terms see the file COPYING + * + ************************************************************************/ + +#ifndef G__FSTREAM_H +#define G__FSTREAM_H + +#ifndef __CINT__ + +#include +using namespace std; + +#else // __CINT__ + +#include "iostrm.h" + +template +class basic_filebuf : public basic_streambuf { + private: + typedef basic_ios ios_type; +#ifndef __CINT__ + typedef traits::state_type state_t; +#endif + public: + typedef traits traits_type; + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + basic_filebuf(); +#if !(G__GNUC>=3) + basic_filebuf(int fd); +#endif + virtual ~basic_filebuf(); + bool is_open() const; +#if !(G__GNUC>=3) + basic_filebuf * + open(const char *s, ios_base::openmode, long protection = 0666 ); +#else + basic_filebuf * open(const char *s, ios_base::openmode); +#endif +#if !(G__GNUC>=3) + basic_filebuf *open(int fd); +#endif + basic_filebuf *close(); + protected: + virtual int showmanyc(); + virtual int_type overflow(int_type c = traits::eof()); + virtual int_type pbackfail(int_type c = traits::eof()); + virtual int_type underflow(); + virtual basic_streambuf* setbuf(char_type *s,streamsize n); + virtual pos_type seekoff(off_type off,ios_base::seekdir way + ,ios_base::openmode which = + ios_base::in | ios_base::out); + virtual pos_type seekpos(pos_type sp + ,ios_base::openmode which = + ios_base::in | ios_base::out); + virtual int sync(); + virtual streamsize xsputn(const char_type *s, streamsize n); +#if (G__GNUC>=3) + private: + basic_filebuf& operator=(const basic_filebuf& x); +#endif +}; + +template +class basic_ifstream : public basic_istream { + public: + typedef basic_ios ios_type; + typedef traits traits_type; + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + public: + basic_ifstream(); +#if !(G__GNUC>=3) + basic_ifstream(const char *s,ios_base::openmode mode = ios_base::in + ,long protection = 0666 ); + basic_ifstream(int fd); + basic_ifstream(int fd, char_type *buf, int len); +#else + basic_ifstream(const char *s,ios_base::openmode mode = ios_base::in); +#endif + virtual ~basic_ifstream(); + basic_filebuf *rdbuf() const; + bool is_open(); +#if !(G__GNUC>=3) + void open(const char *s, ios_base::openmode mode = ios_base::in + ,long protection = 0666 ); +#else + void open(const char *s, ios_base::openmode mode = ios_base::in); +#endif + void close(); +}; + +template +class basic_ofstream : public basic_ostream { + public: + typedef basic_ios ios_type; + typedef traits traits_type; + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + public: + basic_ofstream(); +#if !(G__GNUC>=3) + basic_ofstream(const char *s, ios_base::openmode mode=ios_base::out + ,long protection = 0666 ); + basic_ofstream(int fd); + basic_ofstream(int fd, char_type *buf, int len); +#else + basic_ofstream(const char *s, ios_base::openmode mode=ios_base::out); +#endif + virtual ~basic_ofstream(); + basic_filebuf *rdbuf() const; + bool is_open(); +#if !(G__GNUC>=3) + void open(const char *s,ios_base::openmode mode=ios_base::out + ,long protection = 0666 ); +#else + void open(const char *s,ios_base::openmode mode=ios_base::out); +#endif + void close(); + }; + +template +class basic_fstream : public basic_iostream { + public: + basic_fstream(); + basic_fstream(const char *s,ios_base::openmode mode); + basic_filebuf *rdbuf() const; + bool is_open(); + void open(const char *s,ios_base::openmode mode); + void close(); +}; + +typedef basic_filebuf > filebuf; +//typedef basic_filebuf > wfilebuf; +typedef basic_ifstream > ifstream; +//typedef basic_ifstream > wifstream; +typedef basic_ofstream > ofstream; +//typedef basic_ofstream > wofstream; +typedef basic_fstream > fstream; +//typedef basic_fstream > wfstream; + + +#endif // __CINT__ +#endif // G__FSTREAM_H diff -Naur root/cint/lib/gcc4strm/iostrm.h root.new/cint/lib/gcc4strm/iostrm.h --- root/cint/lib/gcc4strm/iostrm.h 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/iostrm.h 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,684 @@ +/* /% C++ %/ */ +/*********************************************************************** + * cint (C/C++ interpreter) + ************************************************************************ + * header file iostrm.h + ************************************************************************ + * Description: + * Stub file for making iostream library for g++ 4.00 + ************************************************************************ + * Copyright(c) 2007 Masaharu Goto + * + * For the licensing terms see the file COPYING + * + ************************************************************************/ + +#ifndef G__IOSTREAM_H +#define G__IOSTREAM_H + +#define G__TMPLTIOS + +#define G__OSTREAMBODY +//#define G__OSTREAMMEMBERSTUB +#define G__OSTREAMGLOBALSTUB + +#ifndef __CINT__ + +#include +using namespace std; + +//inline ostream& operator<< (ostream& ost,unsigned char c) +// {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,short c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,unsigned short c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,int c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,unsigned int c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,long c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,unsigned long c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,float c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,double c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,long double c) + {return(ost.operator<<(c));} +inline ostream& operator<< (ostream& ost,bool c) + {return(ost.operator<<(c));} +inline ostream& operator<< ( ostream& ost, void* p) + {return(ost.operator<<(p));} + +//inline istream& operator>> ( istream& ist, unsigned char& p) +// {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, short& p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, unsigned short& p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, int & p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, unsigned int& p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, long & p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, unsigned long& p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, float & p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, double & p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, bool& p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, long double & p) + {return(ist.operator>>(p));} +inline istream& operator>> ( istream& ist, void*& p) + {return(ist.operator>>(p));} + +#ifndef G__OLDIMPLEMENTATION1635 +#include +/******************************************************************** + * static variables for iostream redirection + ********************************************************************/ +static ostream::__streambuf_type *G__store_cout; +static ostream::__streambuf_type *G__store_cerr; +static istream::__streambuf_type *G__store_cin; +static ofstream *G__redirected_cout; +static ofstream *G__redirected_cerr; +static ifstream *G__redirected_cin; +/******************************************************************** + * G__redirectcout + ********************************************************************/ +extern "C" void G__unredirectcout() { + if(G__store_cout) { + cout.rdbuf(G__store_cout); + G__store_cout = 0; + } + if(G__redirected_cout) { + delete G__redirected_cout; + G__redirected_cout = 0; + } +} +/******************************************************************** + * G__redirectcout + ********************************************************************/ +extern "C" void G__redirectcout(const char* filename) { + G__unredirectcout(); + G__redirected_cout = new ofstream(filename,ios_base::app); + G__store_cout = cout.rdbuf(G__redirected_cout->rdbuf()) ; +} +/******************************************************************** + * G__redirectcerr + ********************************************************************/ +extern "C" void G__unredirectcerr() { + if(G__store_cerr) { + cerr.rdbuf(G__store_cerr); + G__store_cerr = 0; + } + if(G__redirected_cerr) { + delete G__redirected_cerr; + G__redirected_cerr = 0; + } +} +/******************************************************************** + * G__redirectcerr + ********************************************************************/ +extern "C" void G__redirectcerr(const char* filename) { + G__unredirectcerr(); + G__redirected_cerr = new ofstream(filename,ios_base::app); + G__store_cerr = cerr.rdbuf(G__redirected_cerr->rdbuf()) ; +} +/******************************************************************** + * G__redirectcin + ********************************************************************/ +extern "C" void G__unredirectcin() { + if(G__store_cin) { + cin.rdbuf(G__store_cin); + G__store_cin = 0; + } + if(G__redirected_cin) { + delete G__redirected_cin; + G__redirected_cin = 0; + } +} +/******************************************************************** + * G__redirectcin + ********************************************************************/ +extern "C" void G__redirectcin(const char* filename) { + G__unredirectcin(); + G__redirected_cin = new ifstream(filename,ios_base::in); + G__store_cin = cin.rdbuf(G__redirected_cin->rdbuf()) ; +} +#endif /* 1635 */ + +#else // __CINT__ + +#include + +/******************************************************************** +* streampos +*********************************************************************/ +extern "C" { + typedef struct { + private: + int __fill[6]; + } mbstate_t; +} + +#ifdef G__THIS_DOES_NOT_WORK_WITH_CYGWIN_GCC3 +class wstreampos { }; +#endif +class streamoff { }; + + +typedef long long streampos ; +typedef long long streamoff ; + +typedef long long SZ_T; +typedef SZ_T streamsize; + +template +class fpos { + public: + fpos(); + fpos(const fpos&); + fpos(long long); + operator streamoff() const; + fpos operator+(streamoff a) const; + fpos operator-(streamoff a) const; + streamoff operator-(const fpos& a) const; + fpos& operator+=(streamoff a); + fpos& operator-=(streamoff a); + _StateT state() const; + void state(_StateT a); + //bool operator==(const fpos& a); + //bool operator!=(const fpos& a); + //FIXME: operator+= and operator-= are missing + //bool operator>(const fpos& a); + //friend bool operator<(const fpos& a,const fpos& b); + //friend bool operator>(const fpos& a,const fpos& b); + //friend bool operator<=(const fpos& a,const fpos& b); + //friend bool operator<=(const fpos& a,const fpos& b); +}; + +template +inline bool operator==(const fpos<_StateT>& l, const fpos<_StateT>& r); + +template +inline bool operator!=(const fpos<_StateT>& l, const fpos<_StateT>& r); + +typedef fpos streampos; + +/******************************************************************** +* macro G__MANIP_SUPPORT must be defined to enable true manipulator +*********************************************************************/ +#define G__MANIP_SUPPORT + +class ios_base { + public: + typedef int iostate; + enum io_state { + goodbit = 0x00, + badbit = 0x01, + eofbit = 0x02, + failbit = 0x04 + }; + typedef int openmode; + enum open_mode { + app = 0x01, + binary = 0x02, + in = 0x04, + out = 0x08, + trunc = 0x10, + ate = 0x20 + }; + typedef int seekdir; + enum seek_dir { + beg = 0x0, + cur = 0x1, + end = 0x2 + }; + typedef int fmtflags; + enum fmt_flags { + boolalpha = 0x0001, + dec = 0x0002, + fixed = 0x0004, + hex = 0x0008, + internal = 0x0010, + left = 0x0020, + oct = 0x0040, + right = 0x0080, + scientific = 0x0100, + showbase = 0x0200, + showpoint = 0x0400, + showpos = 0x0800, + skipws = 0x1000, + unitbuf = 0x2000, + uppercase = 0x4000, + adjustfield = left | right | internal, + basefield = dec | oct | hex, + floatfield = scientific | fixed + }; + enum event { + erase_event = 0x0001, + imbue_event = 0x0002, + copyfmt_event = 0x0004 + }; + typedef void (*event_callback) (event, ios_base&, int index); + void register_callback( event_callback fn, int index); +#ifdef G__SUNCC5 + enum EmptyCtor {emptyctor}; +#endif + class Init { + public: +#if !(G__GNUC>=3) + static int getinit_cnt_(); +#endif + Init(); +#ifdef __MAKECINT__ + private: +#endif + ~Init(); + }; + inline fmtflags flags() const; + inline fmtflags flags(fmtflags fmtfl); + inline fmtflags setf(fmtflags fmtfl); + inline fmtflags setf(fmtflags fmtfl, fmtflags mask); + inline void unsetf(fmtflags mask); +#if !(G__GNUC>=3) + ios_base& copyfmt(const ios_base& rhs); +#endif + inline streamsize precision() const; + inline streamsize precision(streamsize prec); + inline streamsize width() const; + inline streamsize width(streamsize wide); + static int xalloc(); + long& iword(int index); + void*& pword(int index); + //locale imbue(const locale& loc); + //locale getloc() const ; +#if !(G__GNUC>=3) + bool is_synch() ; +#endif +#ifdef G__SUNCC5 + static bool sync_with_stdio(bool sync = true); +#else + bool sync_with_stdio(bool sync = true); +#endif +#ifdef G__SUNCC5 + virtual ~ios_base(); +#endif + protected: + ios_base(); +#ifndef G__SUNCC5 + ~ios_base(); +#endif +#if (G__GNUC>=3) + private: + ios_base(const ios_base& x); + ios_base& operator=(const ios_base& x); +#endif +}; + +template +class basic_ios : public ios_base { + public: +#if !(G__GNUC>=3) + typedef basic_ios ios_type; + typedef basic_streambuf streambuf_type; + typedef basic_ostream ostream_type; +#endif + typedef traits::char_type char_type; + typedef traits traits_type; + typedef traits::int_type int_type; + typedef traits::off_type off_type; + typedef traits::pos_type pos_type; + explicit basic_ios(basic_streambuf *sb_arg); + virtual ~basic_ios(); + char_type fill() const; + char_type fill(char_type ch); + inline void exceptions(iostate excpt); + inline iostate exceptions() const; + inline void clear(iostate state = goodbit); + inline void setstate(iostate state); + inline iostate rdstate() const; + inline operator void*() const; + inline bool operator! () const; + inline bool good() const; + inline bool eof() const; + inline bool fail() const; + inline bool bad() const; +#if !(G__GNUC>=3) + ios_type& copyfmt(const ios_type& rhs); +#else + basic_ios& copyfmt(const basic_ios& rhs); +#endif + inline basic_ostream *tie() const; + basic_ostream *tie(basic_ostream *tie_arg); + inline basic_streambuf *rdbuf() const; + basic_streambuf *rdbuf( basic_streambuf *sb); + //locale imbue(const locale& loc); + inline char narrow(charT, char) const; + inline charT widen(char) const; + protected: + basic_ios(); + void init(basic_streambuf *sb); + private: +// #ifdef G__SUNCC5 + basic_ios(const basic_ios& ); // not defined + basic_ios& operator=(const basic_ios&); // not defined +// #endif +}; + +template +class basic_streambuf { + public: + typedef charT char_type; + typedef traits traits_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + virtual ~basic_streambuf(); + //locale pubimbue( const locale& loc); + //locale getloc() const; + inline basic_streambuf * + pubsetbuf(char_type *s, streamsize n); + inline pos_type pubseekoff(off_type off, ios_base::seekdir way, + ios_base::openmode which = + ios_base::in | ios_base::out); + inline pos_type pubseekpos(pos_type sp, ios_base::openmode which = + ios_base::in | ios_base::out); + inline int pubsync( ); +#if !(G__GNUC>=3) + inline ios_base::openmode which_open_mode(); +#endif + inline streamsize in_avail(); + inline int_type snextc(); + inline int_type sbumpc(); + inline int_type sgetc(); + inline streamsize sgetn(char_type *s, streamsize n); + inline int_type sputbackc(char_type c); + inline int_type sungetc(); + inline int_type sputc(char_type c); + inline streamsize sputn(const char_type *s, streamsize n); + protected: + basic_streambuf(); +#if (G__GNUC>=3) + private: + basic_streambuf(const basic_streambuf& x); + basic_streambuf& operator=(const basic_streambuf& x); +#endif +}; + +template +class basic_istream : virtual public basic_ios { + public: + typedef basic_istream __istream_type; + typedef basic_ios __ios_type; + typedef basic_streambuf __streambuf_type; + typedef traits traits_type; + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + explicit basic_istream(basic_streambuf *sb); + virtual ~basic_istream(); + class sentry { + public: + inline sentry(basic_istream& stream,bool noskipws = 0); +#ifdef __MAKECINT__ + private: + ~sentry() {} + public: +#else + ~sentry() {} +#endif + operator bool () { return ok_; } + }; + //__istream_type& operator>>(__istream_type& (*pf)(__istream_type&)); + //__istream_type& operator>>(ios_base& (*pf)(ios_base&)); + //__istream_type& operator>>(__ios_type& (*pf)(__ios_type&)); +#ifndef __CINT__ + __istream_type& operator>>(bool& n); + __istream_type& operator>>(short& n); + __istream_type& operator>>(unsigned short& n); + __istream_type& operator>>(int& n); + __istream_type& operator>>(unsigned int& n); + __istream_type& operator>>(long& n); + __istream_type& operator>>(unsigned long& n); + __istream_type& operator>>(float& f); + __istream_type& operator>>(double& f); + __istream_type& operator>>(long double& f); +#if !(G__GNUC>=3) + __istream_type& operator>>(__streambuf_type *sb); +#endif + __istream_type& operator>>(void*& p); +#endif +#if !(G__GNUC>=3) + __istream_type& operator>>(__streambuf_type& sb); +#endif + int_type get(); + __istream_type& get(char_type *s, streamsize n, char_type delim); + __istream_type& get(char_type *s, streamsize n); + __istream_type& get(char_type& c); + __istream_type& get(__streambuf_type& sb, char_type delim); + __istream_type& get(__streambuf_type& sb); + __istream_type& getline(char_type *s, streamsize n, char_type delim); + __istream_type& getline(char_type *s, streamsize n); + __istream_type& ignore(streamsize n , int_type delim ); + __istream_type& ignore(streamsize n =1 ); + //__istream_type& ignore(streamsize n = 1, int_type delim = traits::eof()); + __istream_type& read(char_type *s, streamsize n); + streamsize readsome(char_type *s, streamsize n); + int peek(); + pos_type tellg(); + __istream_type& seekg(pos_type pos); + int sync(); +//#ifndef __CINT__ + __istream_type& seekg(off_type, ios_base::seekdir); +//#endif + __istream_type& putback(char_type c); + __istream_type& unget(); + streamsize gcount() const; + protected: + basic_istream( ); +}; + +template +class basic_ostream : virtual public basic_ios { + public: + typedef basic_ostream __ostream_type; + typedef basic_ios __ios_type; + typedef traits traits_type; + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + explicit basic_ostream(basic_streambuf *sb); + virtual ~basic_ostream(); + class sentry { + public: + inline explicit sentry(basic_ostream& stream); +#ifdef __MAKECINT__ + private: + ~sentry() {} + public: +#else + ~sentry() ; +#endif + operator bool () ; + private: +//#ifdef G__SUNCC5 + sentry(const sentry&); // not defined + sentry& operator=(const sentry&); // not defined +//#endif + }; + //__ostream_type& operator<<(__ostream_type& (*pf)(__ostream_type&)); + //__ostream_type& operator<<(ios_base& (*pf)(ios_base&)); + //__ostream_type& operator<<(__ios_type& (*pf)(__ios_type&)); +#ifndef __CINT__ + __ostream_type& operator<<(short n); + __ostream_type& operator<<(unsigned short n); + __ostream_type& operator<<(int n); + __ostream_type& operator<<(unsigned int n); + __ostream_type& operator<<(long n); + __ostream_type& operator<<(unsigned long n); + __ostream_type& operator<<(float f); + __ostream_type& operator<<(double f); + __ostream_type& operator<<(long double f); + __ostream_type& operator<<(bool n); + __ostream_type& operator<<(basic_streambuf *sb); + __ostream_type& operator<<(void *p); +#endif + //__ostream_type& operator<<(basic_streambuf& sb); + __ostream_type& put(char_type c); + __ostream_type& write(const char_type *s, streamsize n); + __ostream_type& flush(); + __ostream_type& seekp(pos_type pos); + __ostream_type& seekp(off_type , ios_base::seekdir ); + pos_type tellp(); + protected: + basic_ostream(); +}; + + +template +class basic_iostream + : public basic_istream,public basic_ostream +{ +public: + explicit basic_iostream(basic_streambuf *sb); + virtual ~basic_iostream(); + +protected: + explicit basic_iostream(); +}; + + +typedef int INT_T; + +template +struct char_traits { + typedef charT char_type; + typedef INT_T int_type; + typedef mbstate_t state_type; + typedef fpos pos_type; + typedef wstreamoff off_type; + static void assign (char_type& c1, const char_type& c2) ; + static char_type to_char_type(const int_type& c); + static int_type to_int_type(const char_type& c); + static bool eq(const char_type& c1,const char_type& c2); + static bool lt (const char_type& c1, const char_type& c2) ; + static int compare (const char_type* s1, const char_type* s2, size_t n); + static bool eq_int_type(const int_type& c1,const int_type& c2); + static int_type eof(); + static int_type not_eof(const int_type& c); + static size_t length(const char_type *s); + static const char_type* find (const char_type* s,int n,const char_type& a); + static char_type *copy(char_type *dst,const char_type *src, size_t n); + static char_type* move (char_type* s1, const char_type* s2, size_t n); + static char_type* assign (char_type* s, size_t n, const char_type a); +}; + +struct char_traits { + typedef char char_type; + typedef int int_type; + +#ifdef __CINT__ + typedef streamoff off_type; + typedef streampos pos_type; + typedef mbstate_t state_type; +#endif + static void assign (char_type& c1, const char_type& c2) ; + static char_type to_char_type(const int_type& c); + static int_type to_int_type(const char_type& c); + static bool eq(const char_type& c1,const char_type& c2); + static bool lt (const char_type& c1, const char_type& c2) ; + static int compare (const char_type* s1, const char_type* s2, size_t n); + static const char_type* find (const char_type* s,int n,const char_type& a); + static bool eq_int_type(const int_type& c1,const int_type& c2); + static int_type eof(); + static int_type not_eof(const int_type& c); + static size_t length(const char_type *s); + static char_type *copy(char_type *dst,const char_type *src, size_t n); + static char_type * move (char_type* s1, const char_type* s2, size_t n); + static char_type* assign (char_type* s, size_t n, const char_type a); +}; + +//typedef basic_istream > istream; +typedef basic_istream > istream; +//typedef basic_ostream ostream; +typedef basic_ostream > ostream; + +typedef basic_streambuf > streambuf; + +extern istream cin ; +extern ostream cout ; +extern ostream cerr ; +extern ostream clog ; + +#ifndef G__OLDIMPLEMENTATION1938 +ios_base& dec(ios_base&) ; +ios_base& hex(ios_base&) ; +ios_base& oct(ios_base&) ; +ios_base& fixed(ios_base&); +ios_base& scientific(ios_base&); +ios_base& right(ios_base&); +ios_base& left(ios_base&); +ios_base& internal(ios_base&); +ios_base& nouppercase(ios_base&); +ios_base& uppercase(ios_base&); +ios_base& noskipws(ios_base&); +ios_base& skipws(ios_base&); +ios_base& noshowpos(ios_base&); +ios_base& showpos(ios_base&); +ios_base& noshowpoint(ios_base&); +ios_base& showpoint(ios_base&); +ios_base& noshowbase(ios_base&); +ios_base& showbase(ios_base&); +ios_base& noboolalpha(ios_base&); +ios_base& boolalpha(ios_base&); +#endif + +istream& ws(istream&) ; + +ostream& endl(ostream& i) ; +ostream& ends(ostream& i) ; +ostream& flush(ostream&) ; + +ostream& operator<< ( ostream&, char ); +ostream& operator<< ( ostream&, char* ); +ostream& operator<< ( ostream&, void* ); +ostream& operator<< ( ostream&, unsigned char ); +ostream& operator<< ( ostream&, short ); +ostream& operator<< ( ostream&, unsigned short ); +ostream& operator<< ( ostream&, int ); +ostream& operator<< ( ostream&, unsigned int ); +ostream& operator<< ( ostream&, long ); +ostream& operator<< ( ostream&, unsigned long); +ostream& operator<< ( ostream&, float ); +ostream& operator<< ( ostream&, double ); +//ostream& operator<< ( ostream&, long double ); +ostream& operator<< ( ostream&, bool ); +//ostream& operator<< (ostream&,const streampos&); + +istream& operator>> ( istream&, char& ); +istream& operator>> ( istream&, unsigned char& ); +istream& operator>> ( istream&, short& ); +istream& operator>> ( istream&, unsigned short& ); +istream& operator>> ( istream&, int& ); +istream& operator>> ( istream&, unsigned int& ); +istream& operator>> ( istream&, long& ); +istream& operator>> ( istream&, unsigned long& ); +istream& operator>> ( istream&, float& ); +istream& operator>> ( istream&, double& ); +//istream& operator>> ( istream&, long double& ); +istream& operator>> ( istream&, bool& ); +istream& operator>> ( istream&, char* ); +istream& operator>> ( istream&, void*& ); + +#endif // __CINT__ + +#endif // G__IOSTREAM_H diff -Naur root/cint/lib/gcc4strm/linkdef.h root.new/cint/lib/gcc4strm/linkdef.h --- root/cint/lib/gcc4strm/linkdef.h 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/linkdef.h 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,15 @@ +/* -*- C++ -*- */ +/************************************************************************* + * Copyright(c) 2007 Masaharu Goto (cint@pcroot.cern.ch) + * + * For the licensing terms see the file COPYING + * + ************************************************************************/ + +#ifdef __MAKECINT__ + +#pragma link off class allocator; +#pragma link off class allocator; +#pragma link MACRO function char_traits::assign(char_type*,size_t,const char_type); + +#endif diff -Naur root/cint/lib/gcc4strm/sstrm.h root.new/cint/lib/gcc4strm/sstrm.h --- root/cint/lib/gcc4strm/sstrm.h 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/lib/gcc4strm/sstrm.h 2007-11-26 09:07:47.000000000 -0500 @@ -0,0 +1,219 @@ +/* /% C++ %/ */ +/*********************************************************************** + * cint (C/C++ interpreter) + ************************************************************************ + * header file sstrm.h + ************************************************************************ + * Description: + * Stub file for making iostream library + ************************************************************************ + * Copyright(c) 2007 Masaharu Goto + * + * For the licensing terms see the file COPYING + * + ************************************************************************/ + +#ifndef G__SSTREAM_H +#define G__SSTREAM_H + +#ifndef __CINT__ + +#include +using namespace std; + +#else // __CINT__ + +#if !(G__GNUC>=3) +#error This header must be processed with a Cint compiled with gcc3.x +#endif + +#include +//#include +class allocator; +class allocator; +#include "iostrm.h" + +template +class basic_stringbuf : public basic_streambuf +{ + public: + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + typedef traits traits_type; + + typedef basic_ios ios_type; +#ifdef __CINT__ +#if 0 && !(G__GNUC>=3) + typedef string string_type; +#else + typedef string __string_type; + //typedef basic_string __string_type; +#endif +#else + typedef basic_string string_type; +#endif + + explicit basic_stringbuf(ios_base::openmode which = + ios_base::in | ios_base::out ); + + explicit basic_stringbuf(const __string_type& str, + ios_base::openmode which = + ios_base::in | ios_base::out ); + + virtual ~basic_stringbuf(); + + __string_type str() const; + void str(const __string_type& str_arg); + + protected: + + virtual int_type overflow(int_type c = traits::eof()); + virtual int_type pbackfail(int_type c = traits::eof()); + virtual int_type underflow(); + virtual pos_type seekoff(off_type off, ios_base::seekdir way, + ios_base::openmode which = + ios_base::in | ios_base::out); + + virtual pos_type seekpos(pos_type sp, + ios_base::openmode which = + ios_base::in | ios_base::out); + + virtual basic_streambuf* setbuf(char_type* s, streamsize n); + virtual streamsize xsputn(const char_type *s, streamsize n); +#if (G__GNUC>=3) + private: + basic_stringbuf& operator=(const basic_stringbuf& x); +#endif +}; + + +template +class basic_istringstream : public basic_istream +{ + public: + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + typedef traits traits_type; + + typedef basic_stringbuf sb_type; + typedef basic_ios ios_type; +#ifdef __CINT__ +#if 0 && !(G__GNUC>=3) + typedef string string_type; +#else + typedef string __string_type; +#endif +#else + typedef basic_string string_type; +#endif + + explicit basic_istringstream(ios_base::openmode which = ios_base::in); + explicit basic_istringstream(const __string_type& str, + ios_base::openmode which = ios_base::in); +#ifdef __CINT__ + explicit basic_istringstream(const char *str, + ios_base::openmode which = ios_base::in); +#endif + + virtual ~basic_istringstream(); + + basic_stringbuf *rdbuf() const; + __string_type str() const; + + void str(const __string_type& str); +}; + + +template +class basic_ostringstream : public basic_ostream +{ + public: + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + typedef traits traits_type; + + typedef basic_stringbuf sb_type; + typedef basic_ios ios_type; +#ifdef __CINT__ + typedef string __string_type; +#else + typedef basic_string string_type; +#endif + + explicit basic_ostringstream(ios_base::openmode which = ios_base::out); + explicit basic_ostringstream(const __string_type& str, + ios_base::openmode which = ios_base::out); + + virtual ~basic_ostringstream(); + basic_stringbuf *rdbuf() const; + + __string_type str() const; + void str(const __string_type& str); +}; + + +template +class basic_stringstream : public basic_iostream +{ + public: + typedef charT char_type; + typedef traits::int_type int_type; + typedef traits::pos_type pos_type; + typedef traits::off_type off_type; + typedef traits traits_type; + + typedef basic_stringbuf sb_type; + typedef basic_ios ios_type; +#ifdef __CINT__ + typedef string __string_type; +#else + typedef basic_string string_type; +#endif + + explicit basic_stringstream(ios_base::openmode which = ios_base::out | + ios_base::in); + + explicit basic_stringstream(const __string_type& str, + ios_base::openmode which = + ios_base::out | ios_base::in); + + virtual ~basic_stringstream(); + basic_stringbuf *rdbuf() const; + __string_type str() const; + void str(const __string_type& str); +}; + + +//typedef basic_stringbuf stringbuf; +typedef basic_stringbuf,allocator > stringbuf; + +//typedef basic_stringbuf wstringbuf; +//typedef basic_stringbuf,allocator > wstringbuf; + +//typedef basic_istringstream istringstream; +typedef basic_istringstream,allocator > istringstream; + +//typedef basic_istringstream wistringstream; +//typedef basic_istringstream,allocator > wistringstream; + +//typedef basic_ostringstream ostringstream; +typedef basic_ostringstream,allocator > ostringstream; + +//typedef basic_ostringstream wostringstream; +//typedef basic_ostringstream,allocator > wostringstream; + +//typedef basic_stringstream stringstream; +typedef basic_stringstream,allocator > stringstream; + +//typedef basic_stringstream wstringstream; +//typedef basic_stringstream, allocator > wstringstream; + +#endif // __CINT__ + +#endif // G__SSTREAM_H diff -Naur root/cint/src/gcc4strm.cxx root.new/cint/src/gcc4strm.cxx --- root/cint/src/gcc4strm.cxx 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/src/gcc4strm.cxx 2007-11-26 09:09:29.000000000 -0500 @@ -0,0 +1,4706 @@ +/******************************************************** +* gcc4strm.cxx +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************/ +#include "gcc4strm.h" + +#ifdef G__MEMTEST +#undef malloc +#undef free +#endif + +extern "C" void G__cpp_reset_tagtableG__stream(); + +extern "C" void G__set_cpp_environmentG__stream() { + G__add_compiledheader("iostrm.h"); + G__add_compiledheader("fstrm.h"); + G__add_compiledheader("sstrm.h"); + G__add_compiledheader("linkdef.h"); + G__cpp_reset_tagtableG__stream(); +} +#include +extern "C" int G__cpp_dllrevG__stream() { return(30051515); } + +/********************************************************* +* Member function Interface Method +*********************************************************/ + +/* mbstate_t */ +// automatic default constructor +static int G__G__stream_1_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + mbstate_t *p; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new mbstate_t[n]; + } else { + p = new((void*) gvp) mbstate_t[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new mbstate_t; + } else { + p = new((void*) gvp) mbstate_t; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_mbstate_t); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__G__stream_1_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + mbstate_t* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new mbstate_t(*(mbstate_t*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_mbstate_t); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef mbstate_t G__Tmbstate_t; +static int G__G__stream_1_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (mbstate_t*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((mbstate_t*) (soff+(sizeof(mbstate_t)*i)))->~G__Tmbstate_t(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (mbstate_t*) soff; + } else { + G__setgvp(G__PVOID); + ((mbstate_t*) (soff))->~G__Tmbstate_t(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_1_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + mbstate_t* dest = (mbstate_t*) G__getstructoffset(); + *dest = *(mbstate_t*) libp->para[0].ref; + const mbstate_t& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* streamoff */ +// automatic default constructor +static int G__G__stream_2_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + streamoff *p; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new streamoff[n]; + } else { + p = new((void*) gvp) streamoff[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new streamoff; + } else { + p = new((void*) gvp) streamoff; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_streamoff); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__G__stream_2_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + streamoff* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new streamoff(*(streamoff*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_streamoff); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef streamoff G__Tstreamoff; +static int G__G__stream_2_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (streamoff*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((streamoff*) (soff+(sizeof(streamoff)*i)))->~G__Tstreamoff(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (streamoff*) soff; + } else { + G__setgvp(G__PVOID); + ((streamoff*) (soff))->~G__Tstreamoff(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_2_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + streamoff* dest = (streamoff*) G__getstructoffset(); + const streamoff& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* fpos */ +static int G__G__stream_3_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + fpos* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new fpos[n]; + } else { + p = new((void*) gvp) fpos[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new fpos; + } else { + p = new((void*) gvp) fpos; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + fpos* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new fpos(*(fpos*) libp->para[0].ref); + } else { + p = new((void*) gvp) fpos(*(fpos*) libp->para[0].ref); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + fpos* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new fpos((long long) G__Longlong(libp->para[0])); + } else { + p = new((void*) gvp) fpos((long long) G__Longlong(libp->para[0])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((const fpos*) G__getstructoffset())->operator streamoff()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const fpos* pobj; + const fpos xobj = ((const fpos*) G__getstructoffset())->operator+((streamoff) G__Longlong(libp->para[0])); + pobj = new fpos(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const fpos* pobj; + const fpos xobj = ((const fpos*) G__getstructoffset())->operator-((streamoff) G__Longlong(libp->para[0])); + pobj = new fpos(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((const fpos*) G__getstructoffset())->operator-(*(fpos*) libp->para[0].ref)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const fpos& obj = ((fpos*) G__getstructoffset())->operator+=((streamoff) G__Longlong(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const fpos& obj = ((fpos*) G__getstructoffset())->operator-=((streamoff) G__Longlong(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const mbstate_t* pobj; + const mbstate_t xobj = ((const fpos*) G__getstructoffset())->state(); + pobj = new mbstate_t(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_3_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((fpos*) G__getstructoffset())->state(*((mbstate_t*) G__int(libp->para[0]))); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef fpos G__TfposlEmbstate_tgR; +static int G__G__stream_3_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (fpos*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((fpos*) (soff+(sizeof(fpos)*i)))->~G__TfposlEmbstate_tgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (fpos*) soff; + } else { + G__setgvp(G__PVOID); + ((fpos*) (soff))->~G__TfposlEmbstate_tgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_3_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + fpos* dest = (fpos*) G__getstructoffset(); + const fpos& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* ios_base */ +static int G__G__stream_4_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ios_base*) G__getstructoffset())->register_callback((ios_base::event_callback) G__int(libp->para[0]), (int) G__int(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((const ios_base*) G__getstructoffset())->flags()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->flags((ios_base::fmtflags) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->setf((ios_base::fmtflags) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->setf((ios_base::fmtflags) G__int(libp->para[0]), (ios_base::fmtflags) G__int(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ios_base*) G__getstructoffset())->unsetf((ios_base::fmtflags) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((const ios_base*) G__getstructoffset())->precision()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((ios_base*) G__getstructoffset())->precision((streamsize) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((const ios_base*) G__getstructoffset())->width()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((ios_base*) G__getstructoffset())->width((streamsize) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ios_base::xalloc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const long& obj = ((ios_base*) G__getstructoffset())->iword((int) G__int(libp->para[0])); + result7->ref = (long) (&obj); + G__letint(result7, result7->type, (long)obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + void*& obj = ((ios_base*) G__getstructoffset())->pword((int) G__int(libp->para[0])); + result7->ref = (long) (&obj); + G__letint(result7, result7->type, (long)obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_4_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 1: + G__letint(result7, 103, (long) ((ios_base*) G__getstructoffset())->sync_with_stdio((bool) G__int(libp->para[0]))); + break; + case 0: + G__letint(result7, 103, (long) ((ios_base*) G__getstructoffset())->sync_with_stdio()); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + + +/* ios_base::Init */ +static int G__G__stream_10_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ios_base::Init* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + p = 0; + G__genericerror("Error: Array construction with private/protected destructor is illegal"); + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new ios_base::Init; + } else { + p = new((void*) gvp) ios_base::Init; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__G__stream_10_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + ios_base::Init* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new ios_base::Init(*(ios_base::Init*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_10_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ios_base::Init* dest = (ios_base::Init*) G__getstructoffset(); + const ios_base::Init& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* char_traits */ +static int G__G__stream_11_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char_traits::assign(*(char_traits::char_type*) G__Charref(&libp->para[0]), *(char_traits::char_type*) G__Charref(&libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 99, (long) char_traits::to_char_type(*(char_traits::int_type*) G__Intref(&libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) char_traits::to_int_type(*(char_traits::char_type*) G__Charref(&libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) char_traits::eq(*(char_traits::char_type*) G__Charref(&libp->para[0]), *(char_traits::char_type*) G__Charref(&libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) char_traits::lt(*(char_traits::char_type*) G__Charref(&libp->para[0]), *(char_traits::char_type*) G__Charref(&libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) char_traits::compare((const char_traits::char_type*) G__int(libp->para[0]), (const char_traits::char_type*) G__int(libp->para[1]) +, (size_t) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) char_traits::find((const char_traits::char_type*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, *(char_traits::char_type*) G__Charref(&libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) char_traits::eq_int_type(*(char_traits::int_type*) G__Intref(&libp->para[0]), *(char_traits::int_type*) G__Intref(&libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) char_traits::eof()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) char_traits::not_eof(*(char_traits::int_type*) G__Intref(&libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 107, (long) char_traits::length((const char_traits::char_type*) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) char_traits::copy((char_traits::char_type*) G__int(libp->para[0]), (const char_traits::char_type*) G__int(libp->para[1]) +, (size_t) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) char_traits::move((char_traits::char_type*) G__int(libp->para[0]), (const char_traits::char_type*) G__int(libp->para[1]) +, (size_t) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_11_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) char_traits::assign((char_traits::char_type*) G__int(libp->para[0]), (size_t) G__int(libp->para[1]) +, (const char_traits::char_type) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic default constructor +static int G__G__stream_11_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char_traits *p; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new char_traits[n]; + } else { + p = new((void*) gvp) char_traits[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new char_traits; + } else { + p = new((void*) gvp) char_traits; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__G__stream_11_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + char_traits* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new char_traits(*(char_traits*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef char_traits G__Tchar_traitslEchargR; +static int G__G__stream_11_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (char_traits*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((char_traits*) (soff+(sizeof(char_traits)*i)))->~G__Tchar_traitslEchargR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (char_traits*) soff; + } else { + G__setgvp(G__PVOID); + ((char_traits*) (soff))->~G__Tchar_traitslEchargR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_11_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char_traits* dest = (char_traits*) G__getstructoffset(); + const char_traits& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_istream > */ +static int G__G__stream_12_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istream >* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istream >((basic_streambuf >*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_istream >((basic_streambuf >*) G__int(libp->para[0])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_istream >*) G__getstructoffset())->get()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->get((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]) +, (basic_istream >::char_type) G__int(libp->para[2])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->get((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->get(*(basic_istream >::char_type*) G__Charref(&libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->get(*(basic_istream >::__streambuf_type*) libp->para[0].ref, (basic_istream >::char_type) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->get(*(basic_istream >::__streambuf_type*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->getline((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]) +, (basic_istream >::char_type) G__int(libp->para[2])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->getline((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->ignore((streamsize) G__Longlong(libp->para[0]), (basic_istream >::int_type) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 1: + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->ignore((streamsize) G__Longlong(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + break; + case 0: + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->ignore(); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->read((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_istream >*) G__getstructoffset())->readsome((basic_istream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_istream >*) G__getstructoffset())->peek()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_istream >*) G__getstructoffset())->tellg()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->seekg((basic_istream >::pos_type) G__Longlong(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_istream >*) G__getstructoffset())->sync()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->seekg((basic_istream >::off_type) G__Longlong(libp->para[0]), (ios_base::seekdir) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->putback((basic_istream >::char_type) G__int(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istream >::__istream_type& obj = ((basic_istream >*) G__getstructoffset())->unget(); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_12_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((const basic_istream >*) G__getstructoffset())->gcount()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_istream > G__Tbasic_istreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_12_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_istream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_istream >*) (soff+(sizeof(basic_istream >)*i)))->~G__Tbasic_istreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_istream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_istream >*) (soff))->~G__Tbasic_istreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ios > */ +static int G__G__stream_13_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ios >* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ios >((basic_streambuf >*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_ios >((basic_streambuf >*) G__int(libp->para[0])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 99, (long) ((const basic_ios >*) G__getstructoffset())->fill()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 99, (long) ((basic_ios >*) G__getstructoffset())->fill((basic_ios >::char_type) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_ios >*) G__getstructoffset())->exceptions((ios_base::iostate) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((const basic_ios >*) G__getstructoffset())->exceptions()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 1: + ((basic_ios >*) G__getstructoffset())->clear((ios_base::iostate) G__int(libp->para[0])); + G__setnull(result7); + break; + case 0: + ((basic_ios >*) G__getstructoffset())->clear(); + G__setnull(result7); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_ios >*) G__getstructoffset())->setstate((ios_base::iostate) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((const basic_ios >*) G__getstructoffset())->rdstate()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 89, (long) ((const basic_ios >*) G__getstructoffset())->operator void*()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_ios >*) G__getstructoffset())->operator!()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_ios >*) G__getstructoffset())->good()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_ios >*) G__getstructoffset())->eof()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_ios >*) G__getstructoffset())->fail()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_ios >*) G__getstructoffset())->bad()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ios >& obj = ((basic_ios >*) G__getstructoffset())->copyfmt(*(basic_ios >*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_ios >*) G__getstructoffset())->tie()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((basic_ios >*) G__getstructoffset())->tie((basic_ostream >*) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_ios >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((basic_ios >*) G__getstructoffset())->rdbuf((basic_streambuf >*) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 99, (long) ((const basic_ios >*) G__getstructoffset())->narrow((char) G__int(libp->para[0]), (char) G__int(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_13_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 99, (long) ((const basic_ios >*) G__getstructoffset())->widen((char) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_ios > G__Tbasic_ioslEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_13_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_ios >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_ios >*) (soff+(sizeof(basic_ios >)*i)))->~G__Tbasic_ioslEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_ios >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_ios >*) (soff))->~G__Tbasic_ioslEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_streambuf > */ +static int G__G__stream_14_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((basic_streambuf >*) G__getstructoffset())->pubsetbuf((basic_streambuf >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 3: + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->pubseekoff((basic_streambuf >::off_type) G__Longlong(libp->para[0]), (ios_base::seekdir) G__int(libp->para[1]) +, (ios_base::openmode) G__int(libp->para[2]))); + break; + case 2: + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->pubseekoff((basic_streambuf >::off_type) G__Longlong(libp->para[0]), (ios_base::seekdir) G__int(libp->para[1]))); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 2: + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->pubseekpos((basic_streambuf >::pos_type) G__Longlong(libp->para[0]), (ios_base::openmode) G__int(libp->para[1]))); + break; + case 1: + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->pubseekpos((basic_streambuf >::pos_type) G__Longlong(libp->para[0]))); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->pubsync()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->in_avail()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->snextc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->sbumpc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->sgetc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->sgetn((basic_streambuf >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->sputbackc((basic_streambuf >::char_type) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->sungetc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((basic_streambuf >*) G__getstructoffset())->sputc((basic_streambuf >::char_type) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_14_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_streambuf >*) G__getstructoffset())->sputn((const basic_streambuf >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_streambuf > G__Tbasic_streambuflEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_14_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_streambuf >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_streambuf >*) (soff+(sizeof(basic_streambuf >)*i)))->~G__Tbasic_streambuflEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_streambuf >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_streambuf >*) (soff))->~G__Tbasic_streambuflEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ostream > */ +static int G__G__stream_15_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ostream >* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostream >((basic_streambuf >*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_ostream >((basic_streambuf >*) G__int(libp->para[0])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostream >::__ostream_type& obj = ((basic_ostream >*) G__getstructoffset())->put((basic_ostream >::char_type) G__int(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostream >::__ostream_type& obj = ((basic_ostream >*) G__getstructoffset())->write((const basic_ostream >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostream >::__ostream_type& obj = ((basic_ostream >*) G__getstructoffset())->flush(); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostream >::__ostream_type& obj = ((basic_ostream >*) G__getstructoffset())->seekp((basic_ostream >::pos_type) G__Longlong(libp->para[0])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostream >::__ostream_type& obj = ((basic_ostream >*) G__getstructoffset())->seekp((basic_ostream >::off_type) G__Longlong(libp->para[0]), (ios_base::seekdir) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_15_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((basic_ostream >*) G__getstructoffset())->tellp()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_ostream > G__Tbasic_ostreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_15_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_ostream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_ostream >*) (soff+(sizeof(basic_ostream >)*i)))->~G__Tbasic_ostreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_ostream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_ostream >*) (soff))->~G__Tbasic_ostreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ostream >::sentry */ +static int G__G__stream_16_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ostream >::sentry* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostream >::sentry(*(basic_ostream >*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_ostream >::sentry(*(basic_ostream >*) libp->para[0].ref); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_16_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((basic_ostream >::sentry*) G__getstructoffset())->operator bool()); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_istream >::sentry */ +static int G__G__stream_17_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istream >::sentry* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istream >::sentry(*(basic_istream >*) libp->para[0].ref, (bool) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_istream >::sentry(*(basic_istream >*) libp->para[0].ref, (bool) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istream >::sentry(*(basic_istream >*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_istream >::sentry(*(basic_istream >*) libp->para[0].ref); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_17_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((basic_istream >::sentry*) G__getstructoffset())->operator bool()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__G__stream_17_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + basic_istream >::sentry* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new basic_istream >::sentry(*(basic_istream >::sentry*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__G__stream_17_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istream >::sentry* dest = (basic_istream >::sentry*) G__getstructoffset(); + const basic_istream >::sentry& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_filebuf > */ +static int G__G__stream_18_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_filebuf >* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_filebuf >[n]; + } else { + p = new((void*) gvp) basic_filebuf >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_filebuf >; + } else { + p = new((void*) gvp) basic_filebuf >; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_18_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((const basic_filebuf >*) G__getstructoffset())->is_open()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_18_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((basic_filebuf >*) G__getstructoffset())->open((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_18_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((basic_filebuf >*) G__getstructoffset())->close()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_filebuf > G__Tbasic_filebuflEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_18_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_filebuf >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_filebuf >*) (soff+(sizeof(basic_filebuf >)*i)))->~G__Tbasic_filebuflEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_filebuf >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_filebuf >*) (soff))->~G__Tbasic_filebuflEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ifstream > */ +static int G__G__stream_19_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ifstream >* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ifstream >[n]; + } else { + p = new((void*) gvp) basic_ifstream >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ifstream >; + } else { + p = new((void*) gvp) basic_ifstream >; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_19_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ifstream >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ifstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_ifstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ifstream >((const char*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_ifstream >((const char*) G__int(libp->para[0])); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_19_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_ifstream >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_19_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((basic_ifstream >*) G__getstructoffset())->is_open()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_19_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 2: + ((basic_ifstream >*) G__getstructoffset())->open((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + G__setnull(result7); + break; + case 1: + ((basic_ifstream >*) G__getstructoffset())->open((const char*) G__int(libp->para[0])); + G__setnull(result7); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_19_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_ifstream >*) G__getstructoffset())->close(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_ifstream > G__Tbasic_ifstreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_19_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_ifstream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_ifstream >*) (soff+(sizeof(basic_ifstream >)*i)))->~G__Tbasic_ifstreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_ifstream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_ifstream >*) (soff))->~G__Tbasic_ifstreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ofstream > */ +static int G__G__stream_20_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ofstream >* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ofstream >[n]; + } else { + p = new((void*) gvp) basic_ofstream >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ofstream >; + } else { + p = new((void*) gvp) basic_ofstream >; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_20_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ofstream >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ofstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_ofstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ofstream >((const char*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_ofstream >((const char*) G__int(libp->para[0])); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_20_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_ofstream >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_20_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((basic_ofstream >*) G__getstructoffset())->is_open()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_20_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 2: + ((basic_ofstream >*) G__getstructoffset())->open((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + G__setnull(result7); + break; + case 1: + ((basic_ofstream >*) G__getstructoffset())->open((const char*) G__int(libp->para[0])); + G__setnull(result7); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_20_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_ofstream >*) G__getstructoffset())->close(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_ofstream > G__Tbasic_ofstreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_20_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_ofstream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_ofstream >*) (soff+(sizeof(basic_ofstream >)*i)))->~G__Tbasic_ofstreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_ofstream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_ofstream >*) (soff))->~G__Tbasic_ofstreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_fstream > */ +static int G__G__stream_21_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_fstream >* p = NULL; + long gvp = G__getgvp(); + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_fstream >[n]; + } else { + p = new((void*) gvp) basic_fstream >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_fstream >; + } else { + p = new((void*) gvp) basic_fstream >; + } + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_21_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_fstream >* p = NULL; + long gvp = G__getgvp(); + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_fstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_fstream >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_21_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_fstream >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_21_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((basic_fstream >*) G__getstructoffset())->is_open()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_21_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_fstream >*) G__getstructoffset())->open((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_21_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_fstream >*) G__getstructoffset())->close(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_fstream > G__Tbasic_fstreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_21_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_fstream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_fstream >*) (soff+(sizeof(basic_fstream >)*i)))->~G__Tbasic_fstreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_fstream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_fstream >*) (soff))->~G__Tbasic_fstreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_iostream > */ +static int G__G__stream_22_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_iostream >* p = NULL; + long gvp = G__getgvp(); + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_iostream >((basic_streambuf >*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_iostream >((basic_streambuf >*) G__int(libp->para[0])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_iostream > G__Tbasic_iostreamlEcharcOchar_traitslEchargRsPgR; +static int G__G__stream_22_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_iostream >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_iostream >*) (soff+(sizeof(basic_iostream >)*i)))->~G__Tbasic_iostreamlEcharcOchar_traitslEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_iostream >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_iostream >*) (soff))->~G__Tbasic_iostreamlEcharcOchar_traitslEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_stringbuf,allocator > */ +static int G__G__stream_27_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_stringbuf,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringbuf,allocator >((ios_base::openmode) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_stringbuf,allocator >((ios_base::openmode) G__int(libp->para[0])); + } + break; + case 0: + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringbuf,allocator >[n]; + } else { + p = new((void*) gvp) basic_stringbuf,allocator >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringbuf,allocator >; + } else { + p = new((void*) gvp) basic_stringbuf,allocator >; + } + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_27_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_stringbuf,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringbuf,allocator >(*(basic_stringbuf,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_stringbuf,allocator >(*(basic_stringbuf,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringbuf,allocator >(*(basic_stringbuf,allocator >::__string_type*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_stringbuf,allocator >(*(basic_stringbuf,allocator >::__string_type*) libp->para[0].ref); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_27_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_stringbuf,allocator >::__string_type* pobj; + const basic_stringbuf,allocator >::__string_type xobj = ((const basic_stringbuf,allocator >*) G__getstructoffset())->str(); + pobj = new basic_stringbuf,allocator >::__string_type(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_27_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_stringbuf,allocator >*) G__getstructoffset())->str(*(basic_stringbuf,allocator >::__string_type*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_stringbuf,allocator > G__Tbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +static int G__G__stream_27_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_stringbuf,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_stringbuf,allocator >*) (soff+(sizeof(basic_stringbuf,allocator >)*i)))->~G__Tbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_stringbuf,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_stringbuf,allocator >*) (soff))->~G__Tbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_istringstream,allocator > */ +static int G__G__stream_28_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_istringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } + break; + case 0: + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >[n]; + } else { + p = new((void*) gvp) basic_istringstream,allocator >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >; + } else { + p = new((void*) gvp) basic_istringstream,allocator >; + } + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_28_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >(*(basic_istringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_istringstream,allocator >(*(basic_istringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >(*(basic_istringstream,allocator >::__string_type*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_istringstream,allocator >(*(basic_istringstream,allocator >::__string_type*) libp->para[0].ref); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_28_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_istringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_istringstream,allocator >((const char*) G__int(libp->para[0]), (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_istringstream,allocator >((const char*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_istringstream,allocator >((const char*) G__int(libp->para[0])); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_28_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_istringstream,allocator >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_28_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_istringstream,allocator >::__string_type* pobj; + const basic_istringstream,allocator >::__string_type xobj = ((const basic_istringstream,allocator >*) G__getstructoffset())->str(); + pobj = new basic_istringstream,allocator >::__string_type(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_28_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_istringstream,allocator >*) G__getstructoffset())->str(*(basic_istringstream,allocator >::__string_type*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_istringstream,allocator > G__Tbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +static int G__G__stream_28_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_istringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_istringstream,allocator >*) (soff+(sizeof(basic_istringstream,allocator >)*i)))->~G__Tbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_istringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_istringstream,allocator >*) (soff))->~G__Tbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_ostringstream,allocator > */ +static int G__G__stream_29_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ostringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_ostringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } + break; + case 0: + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostringstream,allocator >[n]; + } else { + p = new((void*) gvp) basic_ostringstream,allocator >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostringstream,allocator >; + } else { + p = new((void*) gvp) basic_ostringstream,allocator >; + } + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_29_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_ostringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostringstream,allocator >(*(basic_ostringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_ostringstream,allocator >(*(basic_ostringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_ostringstream,allocator >(*(basic_ostringstream,allocator >::__string_type*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_ostringstream,allocator >(*(basic_ostringstream,allocator >::__string_type*) libp->para[0].ref); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_29_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_ostringstream,allocator >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_29_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_ostringstream,allocator >::__string_type* pobj; + const basic_ostringstream,allocator >::__string_type xobj = ((const basic_ostringstream,allocator >*) G__getstructoffset())->str(); + pobj = new basic_ostringstream,allocator >::__string_type(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_29_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_ostringstream,allocator >*) G__getstructoffset())->str(*(basic_ostringstream,allocator >::__string_type*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_ostringstream,allocator > G__Tbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +static int G__G__stream_29_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_ostringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_ostringstream,allocator >*) (soff+(sizeof(basic_ostringstream,allocator >)*i)))->~G__Tbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_ostringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_ostringstream,allocator >*) (soff))->~G__Tbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* basic_stringstream,allocator > */ +static int G__G__stream_30_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_stringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } else { + p = new((void*) gvp) basic_stringstream,allocator >((ios_base::openmode) G__int(libp->para[0])); + } + break; + case 0: + int n = G__getaryconstruct(); + if (n) { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringstream,allocator >[n]; + } else { + p = new((void*) gvp) basic_stringstream,allocator >[n]; + } + } else { + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringstream,allocator >; + } else { + p = new((void*) gvp) basic_stringstream,allocator >; + } + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_30_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + basic_stringstream,allocator >* p = NULL; + long gvp = G__getgvp(); + switch (libp->paran) { + case 2: + //m: 2 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringstream,allocator >(*(basic_stringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } else { + p = new((void*) gvp) basic_stringstream,allocator >(*(basic_stringstream,allocator >::__string_type*) libp->para[0].ref, (ios_base::openmode) G__int(libp->para[1])); + } + break; + case 1: + //m: 1 + if ((gvp == G__PVOID) || (gvp == 0)) { + p = new basic_stringstream,allocator >(*(basic_stringstream,allocator >::__string_type*) libp->para[0].ref); + } else { + p = new((void*) gvp) basic_stringstream,allocator >(*(basic_stringstream,allocator >::__string_type*) libp->para[0].ref); + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_30_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((const basic_stringstream,allocator >*) G__getstructoffset())->rdbuf()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_30_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const basic_stringstream,allocator >::__string_type* pobj; + const basic_stringstream,allocator >::__string_type xobj = ((const basic_stringstream,allocator >*) G__getstructoffset())->str(); + pobj = new basic_stringstream,allocator >::__string_type(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream_30_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((basic_stringstream,allocator >*) G__getstructoffset())->str(*(basic_stringstream,allocator >::__string_type*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef basic_stringstream,allocator > G__Tbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +static int G__G__stream_30_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + long gvp = G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == G__PVOID) { + delete[] (basic_stringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((basic_stringstream,allocator >*) (soff+(sizeof(basic_stringstream,allocator >)*i)))->~G__Tbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + } + G__setgvp(gvp); + } + } else { + if (gvp == G__PVOID) { + delete (basic_stringstream,allocator >*) soff; + } else { + G__setgvp(G__PVOID); + ((basic_stringstream,allocator >*) (soff))->~G__Tbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(); + G__setgvp(gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* Setting up global function */ +static int G__G__stream__0_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = dec(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = hex(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = oct(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = fixed(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = scientific(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = right(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = left(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = internal(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = nouppercase(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = uppercase(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = noskipws(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = skipws(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = noshowpos(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = showpos(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = noshowpoint(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = showpoint(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = noshowbase(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = showbase(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = noboolalpha(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ios_base& obj = boolalpha(*(ios_base*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = ws(*(istream*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = endl(*(ostream*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = ends(*(ostream*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = flush(*(ostream*) libp->para[0].ref); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (char) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (char*) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (void*) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (unsigned char) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (short) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (unsigned short) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, *(int*) G__Intref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (long) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (unsigned long) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (float) G__double(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (double) G__double(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, (bool) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(char*) G__Charref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(unsigned char*) G__UCharref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(short*) G__Shortref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(unsigned short*) G__UShortref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(int*) G__Intref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(unsigned int*) G__UIntref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(long*) G__Longref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(unsigned long*) G__ULongref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(float*) G__Floatref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(bool*) G__Boolref(&libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, (char*) G__int(libp->para[1])); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__G__stream__0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + const istream& obj = operator>>(*(istream*) libp->para[0].ref, libp->para[1].ref ? *(void**) libp->para[1].ref : *(void**) (&G__Mlong(libp->para[1]))); + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + + +/********************************************************* +* Member function Stub +*********************************************************/ + +/* mbstate_t */ + +/* streamoff */ + +/* fpos */ + +/* ios_base */ + +/* ios_base::Init */ + +/* char_traits */ + +/* basic_istream > */ + +/* basic_ios > */ + +/* basic_streambuf > */ + +/* basic_ostream > */ + +/* basic_ostream >::sentry */ + +/* basic_istream >::sentry */ + +/* basic_filebuf > */ + +/* basic_ifstream > */ + +/* basic_ofstream > */ + +/* basic_fstream > */ + +/* basic_iostream > */ + +/* basic_stringbuf,allocator > */ + +/* basic_istringstream,allocator > */ + +/* basic_ostringstream,allocator > */ + +/* basic_stringstream,allocator > */ + +/********************************************************* +* Global function Stub +*********************************************************/ + +/********************************************************* +* Get size of pointer to member function +*********************************************************/ +class G__Sizep2memfuncG__stream { + public: + G__Sizep2memfuncG__stream(): p(&G__Sizep2memfuncG__stream::sizep2memfunc) {} + size_t sizep2memfunc() { return(sizeof(p)); } + private: + size_t (G__Sizep2memfuncG__stream::*p)(); +}; + +size_t G__get_sizep2memfuncG__stream() +{ + G__Sizep2memfuncG__stream a; + G__setsizep2memfunc((int)a.sizep2memfunc()); + return((size_t)a.sizep2memfunc()); +} + + +/********************************************************* +* virtual base class offset calculation interface +*********************************************************/ + + /* Setting up class inheritance */ +static long G__2vbo_basic_istreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_0(long pobject) { + basic_istream > *G__Lderived=(basic_istream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_istreamlEcharcOchar_traitslEchargRsPgR_ios_base_1(long pobject) { + basic_istream > *G__Lderived=(basic_istream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_0(long pobject) { + basic_ostream > *G__Lderived=(basic_ostream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ostreamlEcharcOchar_traitslEchargRsPgR_ios_base_1(long pobject) { + basic_ostream > *G__Lderived=(basic_ostream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ifstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1(long pobject) { + basic_ifstream > *G__Lderived=(basic_ifstream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ifstreamlEcharcOchar_traitslEchargRsPgR_ios_base_2(long pobject) { + basic_ifstream > *G__Lderived=(basic_ifstream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ofstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1(long pobject) { + basic_ofstream > *G__Lderived=(basic_ofstream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ofstreamlEcharcOchar_traitslEchargRsPgR_ios_base_2(long pobject) { + basic_ofstream > *G__Lderived=(basic_ofstream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_2(long pobject) { + basic_fstream > *G__Lderived=(basic_fstream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_ios_base_3(long pobject) { + basic_fstream > *G__Lderived=(basic_fstream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_5(long pobject) { + basic_fstream > *G__Lderived=(basic_fstream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_ios_base_6(long pobject) { + basic_fstream > *G__Lderived=(basic_fstream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1(long pobject) { + basic_iostream > *G__Lderived=(basic_iostream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_ios_base_2(long pobject) { + basic_iostream > *G__Lderived=(basic_iostream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_4(long pobject) { + basic_iostream > *G__Lderived=(basic_iostream >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_ios_base_5(long pobject) { + basic_iostream > *G__Lderived=(basic_iostream >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1(long pobject) { + basic_istringstream,allocator > *G__Lderived=(basic_istringstream,allocator >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_2(long pobject) { + basic_istringstream,allocator > *G__Lderived=(basic_istringstream,allocator >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1(long pobject) { + basic_ostringstream,allocator > *G__Lderived=(basic_ostringstream,allocator >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_2(long pobject) { + basic_ostringstream,allocator > *G__Lderived=(basic_ostringstream,allocator >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_2(long pobject) { + basic_stringstream,allocator > *G__Lderived=(basic_stringstream,allocator >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_3(long pobject) { + basic_stringstream,allocator > *G__Lderived=(basic_stringstream,allocator >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_5(long pobject) { + basic_stringstream,allocator > *G__Lderived=(basic_stringstream,allocator >*)pobject; + basic_ios > *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + +static long G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_6(long pobject) { + basic_stringstream,allocator > *G__Lderived=(basic_stringstream,allocator >*)pobject; + ios_base *G__Lbase=G__Lderived; + return((long)G__Lbase-(long)G__Lderived); +} + + +/********************************************************* +* Inheritance information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_inheritanceG__stream() { + + /* Setting up class inheritance */ + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR))) { + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_istreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_0,1,3); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_istreamlEcharcOchar_traitslEchargRsPgR_ios_base_1,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR))) { + basic_ios > *G__Lderived; + G__Lderived=(basic_ios >*)0x1000; + { + ios_base *G__Lpbase=(ios_base*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR))) { + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_ostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_0,1,3); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_ostreamlEcharcOchar_traitslEchargRsPgR_ios_base_1,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR))) { + basic_filebuf > *G__Lderived; + G__Lderived=(basic_filebuf >*)0x1000; + { + basic_streambuf > *G__Lpbase=(basic_streambuf >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR))) { + basic_ifstream > *G__Lderived; + G__Lderived=(basic_ifstream >*)0x1000; + { + basic_istream > *G__Lpbase=(basic_istream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_ifstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_ifstreamlEcharcOchar_traitslEchargRsPgR_ios_base_2,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR))) { + basic_ofstream > *G__Lderived; + G__Lderived=(basic_ofstream >*)0x1000; + { + basic_ostream > *G__Lpbase=(basic_ostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_ofstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_ofstreamlEcharcOchar_traitslEchargRsPgR_ios_base_2,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR))) { + basic_fstream > *G__Lderived; + G__Lderived=(basic_fstream >*)0x1000; + { + basic_iostream > *G__Lpbase=(basic_iostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + basic_istream > *G__Lpbase=(basic_istream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_2,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_ios_base_3,1,6); + } + { + basic_ostream > *G__Lpbase=(basic_ostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_5,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_fstreamlEcharcOchar_traitslEchargRsPgR_ios_base_6,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR))) { + basic_iostream > *G__Lderived; + G__Lderived=(basic_iostream >*)0x1000; + { + basic_istream > *G__Lpbase=(basic_istream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_ios_base_2,1,6); + } + { + basic_ostream > *G__Lpbase=(basic_ostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_4,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_iostreamlEcharcOchar_traitslEchargRsPgR_ios_base_5,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR))) { + basic_stringbuf,allocator > *G__Lderived; + G__Lderived=(basic_stringbuf,allocator >*)0x1000; + { + basic_streambuf > *G__Lpbase=(basic_streambuf >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR))) { + basic_istringstream,allocator > *G__Lderived; + G__Lderived=(basic_istringstream,allocator >*)0x1000; + { + basic_istream > *G__Lpbase=(basic_istream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_2,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR))) { + basic_ostringstream,allocator > *G__Lderived; + G__Lderived=(basic_ostringstream,allocator >*)0x1000; + { + basic_ostream > *G__Lpbase=(basic_ostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_1,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_2,1,6); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR))) { + basic_stringstream,allocator > *G__Lderived; + G__Lderived=(basic_stringstream,allocator >*)0x1000; + { + basic_iostream > *G__Lpbase=(basic_iostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + basic_istream > *G__Lpbase=(basic_istream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_2,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_3,1,6); + } + { + basic_ostream > *G__Lpbase=(basic_ostream >*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_basic_ioslEcharcOchar_traitslEchargRsPgR_5,1,2); + } + { + G__inheritance_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__get_linked_tagnum(&G__G__streamLN_ios_base),(long)G__2vbo_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_ios_base_6,1,6); + } + } +} + +/********************************************************* +* typedef information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_typetableG__stream() { + + /* Setting up typedef entry */ + G__search_typename2("mbstate_t",117,G__get_linked_tagnum(&G__G__streamLN_mbstate_t),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("streampos",110,-1,0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("streamoff",110,-1,0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("SZ_T",110,-1,0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("streamsize",110,-1,0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iostate",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__setnewtype(-1,NULL,0); + G__search_typename2("openmode",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__setnewtype(-1,NULL,0); + G__search_typename2("seekdir",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__setnewtype(-1,NULL,0); + G__search_typename2("fmtflags",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__setnewtype(-1,NULL,0); + G__search_typename2("event_callback",89,-1,0,G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__setnewtype(-1,"void (*event_callback) (event, ios_base&, int index);",0); + G__search_typename2("INT_T",105,-1,0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("state_type",117,G__get_linked_tagnum(&G__G__streamLN_mbstate_t),0,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("basic_streambuf >",117,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__ostream_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__istream_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__streambuf_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("istream",117,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("ostream",117,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("streambuf",117,G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("filebuf",117,G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ifstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ofstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("fstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__string_type",117,G__get_linked_tagnum(&G__G__streamLN_string),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("stringbuf",117,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("sb_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__string_type",117,G__get_linked_tagnum(&G__G__streamLN_string),0,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("istringstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("sb_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__string_type",117,G__get_linked_tagnum(&G__G__streamLN_string),0,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ostringstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("char_type",99,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("int_type",105,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("pos_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("off_type",110,-1,0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("traits_type",117,G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("sb_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("ios_type",117,G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("__string_type",117,G__get_linked_tagnum(&G__G__streamLN_string),0,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("stringstream",117,G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),0,-1); + G__setnewtype(-1,NULL,0); +} + +/********************************************************* +* Data Member information setup/ +*********************************************************/ + + /* Setting up class,struct,union tag member variable */ + + /* mbstate_t */ +static void G__setup_memvarmbstate_t(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_mbstate_t)); + { mbstate_t *p; p=(mbstate_t*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* streamoff */ +static void G__setup_memvarstreamoff(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_streamoff)); + { streamoff *p; p=(streamoff*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* fpos */ +static void G__setup_memvarfposlEmbstate_tgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR)); + { fpos *p; p=(fpos*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* ios_base */ +static void G__setup_memvarios_base(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_ios_base)); + { ios_base *p; p=(ios_base*)0x1000; if (p) { } + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLio_state),-1,-2,1,"goodbit=0",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLio_state),-1,-2,1,"badbit=1",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLio_state),-1,-2,1,"eofbit=2",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLio_state),-1,-2,1,"failbit=4",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"app=1",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"binary=2",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"in=4",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"out=8",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"trunc=16",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),-1,-2,1,"ate=32",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLseek_dir),-1,-2,1,"beg=0",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLseek_dir),-1,-2,1,"cur=1",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLseek_dir),-1,-2,1,"end=2",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"boolalpha=1",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"dec=2",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"fixed=4",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"hex=8",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"internal=16",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"left=32",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"oct=64",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"right=128",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"scientific=256",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"showbase=512",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"showpoint=1024",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"showpos=2048",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"skipws=4096",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"unitbuf=8192",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"uppercase=16384",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"adjustfield=176",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"basefield=74",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),-1,-2,1,"floatfield=260",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLevent),-1,-2,1,"erase_event=1",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLevent),-1,-2,1,"imbue_event=2",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLevent),-1,-2,1,"copyfmt_event=4",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* ios_base::Init */ +static void G__setup_memvarios_basecLcLInit(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit)); + { ios_base::Init *p; p=(ios_base::Init*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* char_traits */ +static void G__setup_memvarchar_traitslEchargR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + { char_traits *p; p=(char_traits*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_istream > */ +static void G__setup_memvarbasic_istreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + { basic_istream > *p; p=(basic_istream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ios > */ +static void G__setup_memvarbasic_ioslEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + { basic_ios > *p; p=(basic_ios >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_streambuf > */ +static void G__setup_memvarbasic_streambuflEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + { basic_streambuf > *p; p=(basic_streambuf >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ostream > */ +static void G__setup_memvarbasic_ostreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + { basic_ostream > *p; p=(basic_ostream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ostream >::sentry */ +static void G__setup_memvarbasic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry)); + { basic_ostream >::sentry *p; p=(basic_ostream >::sentry*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_istream >::sentry */ +static void G__setup_memvarbasic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry)); + { basic_istream >::sentry *p; p=(basic_istream >::sentry*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_filebuf > */ +static void G__setup_memvarbasic_filebuflEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + { basic_filebuf > *p; p=(basic_filebuf >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ifstream > */ +static void G__setup_memvarbasic_ifstreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + { basic_ifstream > *p; p=(basic_ifstream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ofstream > */ +static void G__setup_memvarbasic_ofstreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + { basic_ofstream > *p; p=(basic_ofstream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_fstream > */ +static void G__setup_memvarbasic_fstreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR)); + { basic_fstream > *p; p=(basic_fstream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_iostream > */ +static void G__setup_memvarbasic_iostreamlEcharcOchar_traitslEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR)); + { basic_iostream > *p; p=(basic_iostream >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_stringbuf,allocator > */ +static void G__setup_memvarbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + { basic_stringbuf,allocator > *p; p=(basic_stringbuf,allocator >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_istringstream,allocator > */ +static void G__setup_memvarbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + { basic_istringstream,allocator > *p; p=(basic_istringstream,allocator >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_ostringstream,allocator > */ +static void G__setup_memvarbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + { basic_ostringstream,allocator > *p; p=(basic_ostringstream,allocator >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + + + /* basic_stringstream,allocator > */ +static void G__setup_memvarbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + { basic_stringstream,allocator > *p; p=(basic_stringstream,allocator >*)0x1000; if (p) { } + } + G__tag_memvar_reset(); +} + +extern "C" void G__cpp_setup_memvarG__stream() { +} +/*********************************************************** +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +***********************************************************/ + +/********************************************************* +* Member function information setup for each class +*********************************************************/ +static void G__setup_memfuncmbstate_t(void) { + /* mbstate_t */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_mbstate_t)); + // automatic default constructor + G__memfunc_setup("mbstate_t", 963, G__G__stream_1_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_mbstate_t), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("mbstate_t", 963, G__G__stream_1_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_mbstate_t), -1, 0, 1, 1, 1, 0, "u 'mbstate_t' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~mbstate_t", 1089, G__G__stream_1_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_1_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_mbstate_t), -1, 1, 1, 1, 1, 0, "u 'mbstate_t' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncstreamoff(void) { + /* streamoff */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_streamoff)); + // automatic default constructor + G__memfunc_setup("streamoff", 967, G__G__stream_2_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_streamoff), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("streamoff", 967, G__G__stream_2_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_streamoff), -1, 0, 1, 1, 1, 0, "u 'streamoff' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~streamoff", 1093, G__G__stream_2_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_2_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_streamoff), -1, 1, 1, 1, 1, 0, "u 'streamoff' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncfposlEmbstate_tgR(void) { + /* fpos */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR)); + G__memfunc_setup("fpos",1525,G__G__stream_3_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fpos",1525,G__G__stream_3_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 0, 1, 1, 1, 0, "u 'fpos' - 11 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fpos",1525,G__G__stream_3_0_3, 105, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 0, 1, 1, 1, 0, "n - - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator streamoff",1875,G__G__stream_3_0_4, 110, -1, G__defined_typename("streamoff"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator+",919,G__G__stream_3_0_5, 117, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 0, 1, 1, 1, 8, "n - 'streamoff' 0 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator-",921,G__G__stream_3_0_6, 117, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 0, 1, 1, 1, 8, "n - 'streamoff' 0 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator-",921,G__G__stream_3_0_7, 110, -1, G__defined_typename("streamoff"), 0, 1, 1, 1, 8, "u 'fpos' - 11 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator+=",980,G__G__stream_3_0_8, 117, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 1, 1, 1, 1, 0, "n - 'streamoff' 0 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator-=",982,G__G__stream_3_0_9, 117, G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 1, 1, 1, 1, 0, "n - 'streamoff' 0 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("state",545,G__G__stream_3_0_10, 117, G__get_linked_tagnum(&G__G__streamLN_mbstate_t), G__defined_typename("mbstate_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("state",545,G__G__stream_3_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'mbstate_t' 'mbstate_t' 0 - a", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~fpos", 1651, G__G__stream_3_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_3_0_13, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR), -1, 1, 1, 1, 1, 0, "u 'fpos' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncios_base(void) { + /* ios_base */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_ios_base)); + G__memfunc_setup("register_callback",1777,G__G__stream_4_0_1, 121, -1, -1, 0, 2, 1, 1, 0, +"Y - 'ios_base::event_callback' 0 - fn i - - 0 - index", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("flags",525,G__G__stream_4_0_2, 105, -1, G__defined_typename("ios_base::fmtflags"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("flags",525,G__G__stream_4_0_3, 105, -1, G__defined_typename("ios_base::fmtflags"), 0, 1, 1, 1, 0, "i - 'ios_base::fmtflags' 0 - fmtfl", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setf",434,G__G__stream_4_0_4, 105, -1, G__defined_typename("ios_base::fmtflags"), 0, 1, 1, 1, 0, "i - 'ios_base::fmtflags' 0 - fmtfl", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setf",434,G__G__stream_4_0_5, 105, -1, G__defined_typename("ios_base::fmtflags"), 0, 2, 1, 1, 0, +"i - 'ios_base::fmtflags' 0 - fmtfl i - 'ios_base::fmtflags' 0 - mask", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("unsetf",661,G__G__stream_4_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'ios_base::fmtflags' 0 - mask", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("precision",972,G__G__stream_4_0_7, 110, -1, G__defined_typename("streamsize"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("precision",972,G__G__stream_4_0_8, 110, -1, G__defined_typename("streamsize"), 0, 1, 1, 1, 0, "n - 'streamsize' 0 - prec", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("width",544,G__G__stream_4_0_9, 110, -1, G__defined_typename("streamsize"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("width",544,G__G__stream_4_0_10, 110, -1, G__defined_typename("streamsize"), 0, 1, 1, 1, 0, "n - 'streamsize' 0 - wide", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("xalloc",643,G__G__stream_4_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&ios_base::xalloc), 0); + G__memfunc_setup("iword",549,G__G__stream_4_0_12, 108, -1, -1, 1, 1, 1, 1, 0, "i - - 0 - index", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("pword",556,G__G__stream_4_0_13, 89, -1, -1, 1, 1, 1, 1, 0, "i - - 0 - index", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sync_with_stdio",1626,G__G__stream_4_0_14, 103, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' sync", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ios_base",837,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ios_base",837,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 0, 1, 1, 4, 0, "u 'ios_base' - 11 - x", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 4, 0, "u 'ios_base' - 11 - x", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~ios_base", 963, (G__InterfaceMethod) NULL, (int) ('y'), -1, -1, 0, 0, 1, 2, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncios_basecLcLInit(void) { + /* ios_base::Init */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit)); + G__memfunc_setup("Init",404,G__G__stream_10_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("Init", 404, G__G__stream_10_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit), -1, 0, 1, 1, 1, 0, "u 'ios_base::Init' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~Init", 530, (G__InterfaceMethod) NULL, (int) ('y'), -1, -1, 0, 0, 1, 4, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_10_0_3, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit), -1, 1, 1, 1, 1, 0, "u 'ios_base::Init' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncchar_traitslEchargR(void) { + /* char_traits */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR)); + G__memfunc_setup("assign",645,G__G__stream_11_0_1, 121, -1, -1, 0, 2, 3, 1, 0, +"c - 'char_traits::char_type' 1 - c1 c - 'char_traits::char_type' 11 - c2", (char*)NULL, (void*) (void (*)(char_traits::char_type&, const char_traits::char_type&))(&char_traits::assign), 0); + G__memfunc_setup("to_char_type",1281,G__G__stream_11_0_2, 99, -1, G__defined_typename("char_traits::char_type"), 0, 1, 3, 1, 0, "i - 'char_traits::int_type' 11 - c", (char*)NULL, (void*) (char_traits::char_type (*)(const char_traits::int_type&))(&char_traits::to_char_type), 0); + G__memfunc_setup("to_int_type",1198,G__G__stream_11_0_3, 105, -1, G__defined_typename("char_traits::int_type"), 0, 1, 3, 1, 0, "c - 'char_traits::char_type' 11 - c", (char*)NULL, (void*) (char_traits::int_type (*)(const char_traits::char_type&))(&char_traits::to_int_type), 0); + G__memfunc_setup("eq",214,G__G__stream_11_0_4, 103, -1, -1, 0, 2, 3, 1, 0, +"c - 'char_traits::char_type' 11 - c1 c - 'char_traits::char_type' 11 - c2", (char*)NULL, (void*) (bool (*)(const char_traits::char_type&, const char_traits::char_type&))(&char_traits::eq), 0); + G__memfunc_setup("lt",224,G__G__stream_11_0_5, 103, -1, -1, 0, 2, 3, 1, 0, +"c - 'char_traits::char_type' 11 - c1 c - 'char_traits::char_type' 11 - c2", (char*)NULL, (void*) (bool (*)(const char_traits::char_type&, const char_traits::char_type&))(&char_traits::lt), 0); + G__memfunc_setup("compare",743,G__G__stream_11_0_6, 105, -1, -1, 0, 3, 3, 1, 0, +"C - 'char_traits::char_type' 10 - s1 C - 'char_traits::char_type' 10 - s2 " +"k - 'size_t' 0 - n", (char*)NULL, (void*) (int (*)(const char_traits::char_type*, const char_traits::char_type*, size_t))(&char_traits::compare), 0); + G__memfunc_setup("find",417,G__G__stream_11_0_7, 67, -1, G__defined_typename("char_traits::char_type"), 0, 3, 3, 1, 1, +"C - 'char_traits::char_type' 10 - s i - - 0 - n " +"c - 'char_traits::char_type' 11 - a", (char*)NULL, (void*) (const char_traits::char_type* (*)(const char_traits::char_type*, int, const char_traits::char_type&))(&char_traits::find), 0); + G__memfunc_setup("eq_int_type",1185,G__G__stream_11_0_8, 103, -1, -1, 0, 2, 3, 1, 0, +"i - 'char_traits::int_type' 11 - c1 i - 'char_traits::int_type' 11 - c2", (char*)NULL, (void*) (bool (*)(const char_traits::int_type&, const char_traits::int_type&))(&char_traits::eq_int_type), 0); + G__memfunc_setup("eof",314,G__G__stream_11_0_9, 105, -1, G__defined_typename("char_traits::int_type"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (char_traits::int_type (*)())(&char_traits::eof), 0); + G__memfunc_setup("not_eof",746,G__G__stream_11_0_10, 105, -1, G__defined_typename("char_traits::int_type"), 0, 1, 3, 1, 0, "i - 'char_traits::int_type' 11 - c", (char*)NULL, (void*) (char_traits::int_type (*)(const char_traits::int_type&))(&char_traits::not_eof), 0); + G__memfunc_setup("length",642,G__G__stream_11_0_11, 107, -1, G__defined_typename("size_t"), 0, 1, 3, 1, 0, "C - 'char_traits::char_type' 10 - s", (char*)NULL, (void*) (size_t (*)(const char_traits::char_type*))(&char_traits::length), 0); + G__memfunc_setup("copy",443,G__G__stream_11_0_12, 67, -1, G__defined_typename("char_traits::char_type"), 0, 3, 3, 1, 0, +"C - 'char_traits::char_type' 0 - dst C - 'char_traits::char_type' 10 - src " +"k - 'size_t' 0 - n", (char*)NULL, (void*) (char_traits::char_type* (*)(char_traits::char_type*, const char_traits::char_type*, size_t))(&char_traits::copy), 0); + G__memfunc_setup("move",439,G__G__stream_11_0_13, 67, -1, G__defined_typename("char_traits::char_type"), 0, 3, 3, 1, 0, +"C - 'char_traits::char_type' 0 - s1 C - 'char_traits::char_type' 10 - s2 " +"k - 'size_t' 0 - n", (char*)NULL, (void*) (char_traits::char_type* (*)(char_traits::char_type*, const char_traits::char_type*, size_t))(&char_traits::move), 0); + G__memfunc_setup("assign",645,G__G__stream_11_0_14, 67, -1, G__defined_typename("char_traits::char_type"), 0, 3, 3, 1, 0, +"C - 'char_traits::char_type' 0 - s k - 'size_t' 0 - n " +"c - 'char_traits::char_type' 10 - a", (char*)NULL, (void*) NULL, 0); + // automatic default constructor + G__memfunc_setup("char_traits", 1708, G__G__stream_11_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("char_traits", 1708, G__G__stream_11_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR), -1, 0, 1, 1, 1, 0, "u 'char_traits' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~char_traits", 1834, G__G__stream_11_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_11_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR), -1, 1, 1, 1, 1, 0, "u 'char_traits' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_istreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_istream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_istream >",3686,G__G__stream_12_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 5, 1, 0, "U 'basic_streambuf >' - 0 - sb", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_2, 105, -1, G__defined_typename("basic_istream >::int_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_3, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 3, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n " +"c - 'basic_istream >::char_type' 0 - delim", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_4, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_5, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 1, 1, 1, 0, "c - 'basic_istream >::char_type' 1 - c", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_6, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"u 'basic_streambuf >' 'basic_istream >::__streambuf_type' 1 - sb c - 'basic_istream >::char_type' 0 - delim", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("get",320,G__G__stream_12_0_7, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 1, 1, 1, 0, "u 'basic_streambuf >' 'basic_istream >::__streambuf_type' 1 - sb", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getline",744,G__G__stream_12_0_8, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 3, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n " +"c - 'basic_istream >::char_type' 0 - delim", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getline",744,G__G__stream_12_0_9, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ignore",644,G__G__stream_12_0_10, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"n - 'streamsize' 0 - n i - 'basic_istream >::int_type' 0 - delim", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ignore",644,G__G__stream_12_0_11, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 1, 1, 1, 0, "n - 'streamsize' 0 '1' n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("read",412,G__G__stream_12_0_12, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("readsome",848,G__G__stream_12_0_13, 110, -1, G__defined_typename("streamsize"), 0, 2, 1, 1, 0, +"C - 'basic_istream >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("peek",421,G__G__stream_12_0_14, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("tellg",536,G__G__stream_12_0_15, 110, -1, G__defined_typename("basic_istream >::pos_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("seekg",527,G__G__stream_12_0_16, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 1, 1, 1, 0, "n - 'basic_istream >::pos_type' 0 - pos", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sync",445,G__G__stream_12_0_17, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("seekg",527,G__G__stream_12_0_18, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 2, 1, 1, 0, +"n - 'basic_istream >::off_type' 0 - - i - 'ios_base::seekdir' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("putback",746,G__G__stream_12_0_19, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 1, 1, 1, 0, "c - 'basic_istream >::char_type' 0 - c", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("unget",547,G__G__stream_12_0_20, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_istream >::__istream_type"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("gcount",656,G__G__stream_12_0_21, 110, -1, G__defined_typename("streamsize"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_istream >",3686,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_istream >", 3812, G__G__stream_12_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ioslEcharcOchar_traitslEchargRsPgR(void) { + /* basic_ios > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_ios >",3260,G__G__stream_13_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 5, 1, 0, "U 'basic_streambuf >' - 0 - sb_arg", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill",423,G__G__stream_13_0_2, 99, -1, G__defined_typename("basic_ios >::char_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill",423,G__G__stream_13_0_3, 99, -1, G__defined_typename("basic_ios >::char_type"), 0, 1, 1, 1, 0, "c - 'basic_ios >::char_type' 0 - ch", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("exceptions",1090,G__G__stream_13_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'ios_base::iostate' 0 - excpt", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("exceptions",1090,G__G__stream_13_0_5, 105, -1, G__defined_typename("ios_base::iostate"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("clear",519,G__G__stream_13_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'ios_base::iostate' 0 'goodbit' state", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setstate",877,G__G__stream_13_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'ios_base::iostate' 0 - state", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdstate",759,G__G__stream_13_0_8, 105, -1, G__defined_typename("ios_base::iostate"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator void*",1384,G__G__stream_13_0_9, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator!",909,G__G__stream_13_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("good",425,G__G__stream_13_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("eof",314,G__G__stream_13_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fail",412,G__G__stream_13_0_13, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("bad",295,G__G__stream_13_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("copyfmt",770,G__G__stream_13_0_15, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR), -1, 1, 1, 1, 1, 0, "u 'basic_ios >' - 11 - rhs", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("tie",322,G__G__stream_13_0_16, 85, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("tie",322,G__G__stream_13_0_17, 85, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 1, 1, 0, "U 'basic_ostream >' - 0 - tie_arg", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_13_0_18, 85, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_13_0_19, 85, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 1, 1, 0, "U 'basic_streambuf >' - 0 - sb", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("narrow",665,G__G__stream_13_0_20, 99, -1, -1, 0, 2, 1, 1, 8, +"c - - 0 - - c - - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("widen",535,G__G__stream_13_0_21, 99, -1, -1, 0, 1, 1, 1, 8, "c - - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ios >",3260,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ios >",3260,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 1, 4, 0, "u 'basic_ios >' - 11 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR), -1, 1, 1, 1, 4, 0, "u 'basic_ios >' - 11 - -", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_ios >", 3386, G__G__stream_13_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_streambuflEcharcOchar_traitslEchargRsPgR(void) { + /* basic_streambuf > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("pubsetbuf",976,G__G__stream_14_0_1, 85, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_streambuf >::basic_streambuf >"), 0, 2, 1, 1, 0, +"C - 'basic_streambuf >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("pubseekoff",1066,G__G__stream_14_0_2, 110, -1, G__defined_typename("basic_streambuf >::pos_type"), 0, 3, 1, 1, 0, +"n - 'basic_streambuf >::off_type' 0 - off i - 'ios_base::seekdir' 0 - way " +"i - 'ios_base::openmode' 0 'ios_base::in|ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("pubseekpos",1089,G__G__stream_14_0_3, 110, -1, G__defined_typename("basic_streambuf >::pos_type"), 0, 2, 1, 1, 0, +"n - 'basic_streambuf >::pos_type' 0 - sp i - 'ios_base::openmode' 0 'ios_base::in|ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("pubsync",772,G__G__stream_14_0_4, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("in_avail",835,G__G__stream_14_0_5, 110, -1, G__defined_typename("streamsize"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("snextc",661,G__G__stream_14_0_6, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sbumpc",650,G__G__stream_14_0_7, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sgetc",534,G__G__stream_14_0_8, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sgetn",545,G__G__stream_14_0_9, 110, -1, G__defined_typename("streamsize"), 0, 2, 1, 1, 0, +"C - 'basic_streambuf >::char_type' 0 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sputbackc",960,G__G__stream_14_0_10, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 1, 1, 1, 0, "c - 'basic_streambuf >::char_type' 0 - c", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sungetc",761,G__G__stream_14_0_11, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sputc",559,G__G__stream_14_0_12, 105, -1, G__defined_typename("basic_streambuf >::int_type"), 0, 1, 1, 1, 0, "c - 'basic_streambuf >::char_type' 0 - c", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sputn",570,G__G__stream_14_0_13, 110, -1, G__defined_typename("streamsize"), 0, 2, 1, 1, 0, +"C - 'basic_streambuf >::char_type' 10 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_streambuf >",3898,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_streambuf >",3898,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 1, 4, 0, "u 'basic_streambuf >' - 11 - x", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR), -1, 1, 1, 1, 4, 0, "u 'basic_streambuf >' - 11 - x", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_streambuf >", 4024, G__G__stream_14_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ostreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_ostream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_ostream >",3692,G__G__stream_15_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 5, 1, 0, "U 'basic_streambuf >' - 0 - sb", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("put",345,G__G__stream_15_0_2, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_ostream >::__ostream_type"), 1, 1, 1, 1, 0, "c - 'basic_ostream >::char_type' 0 - c", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("write",555,G__G__stream_15_0_3, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_ostream >::__ostream_type"), 1, 2, 1, 1, 0, +"C - 'basic_ostream >::char_type' 10 - s n - 'streamsize' 0 - n", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("flush",546,G__G__stream_15_0_4, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_ostream >::__ostream_type"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("seekp",536,G__G__stream_15_0_5, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_ostream >::__ostream_type"), 1, 1, 1, 1, 0, "n - 'basic_ostream >::pos_type' 0 - pos", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("seekp",536,G__G__stream_15_0_6, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("basic_ostream >::__ostream_type"), 1, 2, 1, 1, 0, +"n - 'basic_ostream >::off_type' 0 - - i - 'ios_base::seekdir' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("tellp",545,G__G__stream_15_0_7, 110, -1, G__defined_typename("basic_ostream >::pos_type"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ostream >",3692,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_ostream >", 3818, G__G__stream_15_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry(void) { + /* basic_ostream >::sentry */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry)); + G__memfunc_setup("sentry",677,G__G__stream_16_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 0, 1, 5, 1, 0, "u 'basic_ostream >' - 1 - stream", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator bool",1336,G__G__stream_16_0_2, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("sentry",677,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 0, 1, 1, 4, 0, "u 'basic_ostream >::sentry' - 11 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 1, 1, 1, 4, 0, "u 'basic_ostream >::sentry' - 11 - -", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~sentry", 803, (G__InterfaceMethod) NULL, (int) ('y'), -1, -1, 0, 0, 1, 4, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry(void) { + /* basic_istream >::sentry */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry)); + G__memfunc_setup("sentry",677,G__G__stream_17_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 0, 2, 1, 1, 0, +"u 'basic_istream >' - 1 - stream g - - 0 '0' noskipws", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator bool",1336,G__G__stream_17_0_2, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("sentry", 677, G__G__stream_17_0_3, (int) ('i'), G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 0, 1, 1, 1, 0, "u 'basic_istream >::sentry' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~sentry", 803, (G__InterfaceMethod) NULL, (int) ('y'), -1, -1, 0, 0, 1, 4, 0, "", (char*) NULL, (void*) NULL, 0); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__G__stream_17_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry), -1, 1, 1, 1, 1, 0, "u 'basic_istream >::sentry' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_filebuflEcharcOchar_traitslEchargRsPgR(void) { + /* basic_filebuf > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_filebuf >",3662,G__G__stream_18_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("is_open",749,G__G__stream_18_0_2, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("open",434,G__G__stream_18_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("close",534,G__G__stream_18_0_4, 85, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 1, 1, 1, 4, 0, "u 'basic_filebuf >' - 11 - x", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_filebuf >", 3788, G__G__stream_18_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ifstreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_ifstream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_ifstream >",3788,G__G__stream_19_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ifstream >",3788,G__G__stream_19_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 'ios_base::in' mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_19_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("is_open",749,G__G__stream_19_0_4, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("open",434,G__G__stream_19_0_5, 121, -1, -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 'ios_base::in' mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("close",534,G__G__stream_19_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_ifstream >", 3914, G__G__stream_19_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ofstreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_ofstream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_ofstream >",3794,G__G__stream_20_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ofstream >",3794,G__G__stream_20_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 'ios_base::out' mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_20_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("is_open",749,G__G__stream_20_0_4, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("open",434,G__G__stream_20_0_5, 121, -1, -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 'ios_base::out' mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("close",534,G__G__stream_20_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_ofstream >", 3920, G__G__stream_20_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_fstreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_fstream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_fstream >",3683,G__G__stream_21_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_fstream >",3683,G__G__stream_21_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 - mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_21_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("is_open",749,G__G__stream_21_0_4, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("open",434,G__G__stream_21_0_5, 121, -1, -1, 0, 2, 1, 1, 0, +"C - - 10 - s i - 'ios_base::openmode' 0 - mode", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("close",534,G__G__stream_21_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_fstream >", 3809, G__G__stream_21_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_iostreamlEcharcOchar_traitslEchargRsPgR(void) { + /* basic_iostream > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR)); + G__memfunc_setup("basic_iostream >",3797,G__G__stream_22_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 1, 5, 1, 0, "U 'basic_streambuf >' - 0 - sb", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_iostream >",3797,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR), -1, 0, 0, 5, 2, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_iostream >", 3923, G__G__stream_22_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + /* basic_stringbuf,allocator > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__memfunc_setup("basic_stringbuf,allocator >",5450,G__G__stream_27_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 1, 5, 1, 0, "i - 'ios_base::openmode' 0 'ios_base::in|ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_stringbuf,allocator >",5450,G__G__stream_27_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 2, 5, 1, 0, +"u 'string' 'basic_stringbuf,allocator >::__string_type' 11 - str i - 'ios_base::openmode' 0 'ios_base::in|ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_27_0_3, 117, G__get_linked_tagnum(&G__G__streamLN_string), G__defined_typename("basic_stringbuf,allocator >::__string_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_27_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' 'basic_stringbuf,allocator >::__string_type' 11 - str_arg", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 1, 1, 1, 4, 0, "u 'basic_stringbuf,allocator >' - 11 - x", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_stringbuf,allocator >", 5576, G__G__stream_27_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + /* basic_istringstream,allocator > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__memfunc_setup("basic_istringstream,allocator >",5890,G__G__stream_28_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 1, 5, 1, 0, "i - 'ios_base::openmode' 0 'ios_base::in' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_istringstream,allocator >",5890,G__G__stream_28_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 2, 5, 1, 0, +"u 'string' 'basic_istringstream,allocator >::__string_type' 11 - str i - 'ios_base::openmode' 0 'ios_base::in' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_istringstream,allocator >",5890,G__G__stream_28_0_3, 105, G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 2, 5, 1, 0, +"C - - 10 - str i - 'ios_base::openmode' 0 'ios_base::in' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_28_0_4, 85, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_28_0_5, 117, G__get_linked_tagnum(&G__G__streamLN_string), G__defined_typename("basic_istringstream,allocator >::__string_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_28_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' 'basic_istringstream,allocator >::__string_type' 11 - str", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_istringstream,allocator >", 6016, G__G__stream_28_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + /* basic_ostringstream,allocator > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__memfunc_setup("basic_ostringstream,allocator >",5896,G__G__stream_29_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 1, 5, 1, 0, "i - 'ios_base::openmode' 0 'ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_ostringstream,allocator >",5896,G__G__stream_29_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 2, 5, 1, 0, +"u 'string' 'basic_ostringstream,allocator >::__string_type' 11 - str i - 'ios_base::openmode' 0 'ios_base::out' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_29_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_29_0_4, 117, G__get_linked_tagnum(&G__G__streamLN_string), G__defined_typename("basic_ostringstream,allocator >::__string_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_29_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' 'basic_ostringstream,allocator >::__string_type' 11 - str", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_ostringstream,allocator >", 6022, G__G__stream_29_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void) { + /* basic_stringstream,allocator > */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR)); + G__memfunc_setup("basic_stringstream,allocator >",5785,G__G__stream_30_0_1, 105, G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 1, 5, 1, 0, "i - 'ios_base::openmode' 0 'ios_base::out|ios_base::in' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("basic_stringstream,allocator >",5785,G__G__stream_30_0_2, 105, G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 2, 5, 1, 0, +"u 'string' 'basic_stringstream,allocator >::__string_type' 11 - str i - 'ios_base::openmode' 0 'ios_base::out|ios_base::in' which", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("rdbuf",531,G__G__stream_30_0_3, 85, G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_30_0_4, 117, G__get_linked_tagnum(&G__G__streamLN_string), G__defined_typename("basic_stringstream,allocator >::__string_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("str",345,G__G__stream_30_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' 'basic_stringstream,allocator >::__string_type' 11 - str", (char*)NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~basic_stringstream,allocator >", 5911, G__G__stream_30_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + G__tag_memfunc_reset(); +} + + +/********************************************************* +* Member function information setup +*********************************************************/ +extern "C" void G__cpp_setup_memfuncG__stream() { +} + +/********************************************************* +* Global variable information setup for each class +*********************************************************/ +static void G__cpp_setup_global0() { + + /* Setting up global variables */ + G__resetplocal(); + + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"__GNUC__=3",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"__GNUC_MINOR__=4",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__IOSTREAM_H=0",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__TMPLTIOS=0",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__OSTREAMBODY=0",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__OSTREAMGLOBALSTUB=0",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__MANIP_SUPPORT=0",1,(char*)NULL); + G__memvar_setup((void*)(&cin),117,0,0,G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("istream"),-1,1,"cin=",0,(char*)NULL); + G__memvar_setup((void*)(&cout),117,0,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ostream"),-1,1,"cout=",0,(char*)NULL); + G__memvar_setup((void*)(&cerr),117,0,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ostream"),-1,1,"cerr=",0,(char*)NULL); + G__memvar_setup((void*)(&clog),117,0,0,G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ostream"),-1,1,"clog=",0,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__FSTREAM_H=0",1,(char*)NULL); + G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__SSTREAM_H=0",1,(char*)NULL); + + G__resetglobalenv(); +} +extern "C" void G__cpp_setup_globalG__stream() { + G__cpp_setup_global0(); +} + +/********************************************************* +* Global function information setup for each class +*********************************************************/ +static void G__cpp_setup_func0() { + G__lastifuncposition(); + + G__memfunc_setup("dec", 300, G__G__stream__0_0, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef dec +, (void*) (ios_base& (*)(ios_base&))dec, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("hex", 325, G__G__stream__0_1, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef hex +, (void*) (ios_base& (*)(ios_base&))hex, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("oct", 326, G__G__stream__0_2, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef oct +, (void*) (ios_base& (*)(ios_base&))oct, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("fixed", 528, G__G__stream__0_3, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef fixed +, (void*) (ios_base& (*)(ios_base&))fixed, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("scientific", 1057, G__G__stream__0_4, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef scientific +, (void*) (ios_base& (*)(ios_base&))scientific, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("right", 542, G__G__stream__0_5, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef right +, (void*) (ios_base& (*)(ios_base&))right, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("left", 427, G__G__stream__0_6, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef left +, (void*) (ios_base& (*)(ios_base&))left, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("internal", 861, G__G__stream__0_7, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef internal +, (void*) (ios_base& (*)(ios_base&))internal, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("nouppercase", 1189, G__G__stream__0_8, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef nouppercase +, (void*) (ios_base& (*)(ios_base&))nouppercase, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("uppercase", 968, G__G__stream__0_9, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef uppercase +, (void*) (ios_base& (*)(ios_base&))uppercase, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("noskipws", 894, G__G__stream__0_10, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef noskipws +, (void*) (ios_base& (*)(ios_base&))noskipws, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("skipws", 673, G__G__stream__0_11, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef skipws +, (void*) (ios_base& (*)(ios_base&))skipws, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("noshowpos", 1008, G__G__stream__0_12, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef noshowpos +, (void*) (ios_base& (*)(ios_base&))noshowpos, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("showpos", 787, G__G__stream__0_13, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef showpos +, (void*) (ios_base& (*)(ios_base&))showpos, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("noshowpoint", 1224, G__G__stream__0_14, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef noshowpoint +, (void*) (ios_base& (*)(ios_base&))noshowpoint, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("showpoint", 1003, G__G__stream__0_15, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef showpoint +, (void*) (ios_base& (*)(ios_base&))showpoint, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("noshowbase", 1081, G__G__stream__0_16, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef noshowbase +, (void*) (ios_base& (*)(ios_base&))noshowbase, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("showbase", 860, G__G__stream__0_17, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef showbase +, (void*) (ios_base& (*)(ios_base&))showbase, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("noboolalpha", 1167, G__G__stream__0_18, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef noboolalpha +, (void*) (ios_base& (*)(ios_base&))noboolalpha, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("boolalpha", 946, G__G__stream__0_19, 117, G__get_linked_tagnum(&G__G__streamLN_ios_base), -1, 1, 1, 1, 1, 0, "u 'ios_base' - 1 - -", (char*) NULL +#ifndef boolalpha +, (void*) (ios_base& (*)(ios_base&))boolalpha, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("ws", 234, G__G__stream__0_20, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 1, 1, 1, 0, "u 'basic_istream >' 'istream' 1 - -", (char*) NULL +#ifndef ws +, (void*) (istream& (*)(istream&))ws, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("endl", 419, G__G__stream__0_21, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 1, 1, 1, 0, "u 'basic_ostream >' 'ostream' 1 - i", (char*) NULL +#ifndef endl +, (void*) (ostream& (*)(ostream&))endl, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("ends", 426, G__G__stream__0_22, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 1, 1, 1, 0, "u 'basic_ostream >' 'ostream' 1 - i", (char*) NULL +#ifndef ends +, (void*) (ostream& (*)(ostream&))ends, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("flush", 546, G__G__stream__0_23, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 1, 1, 1, 0, "u 'basic_ostream >' 'ostream' 1 - -", (char*) NULL +#ifndef flush +, (void*) (ostream& (*)(ostream&))flush, 0); +#else +, (void*) NULL, 0); +#endif + G__memfunc_setup("operator<<", 996, G__G__stream__0_24, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - c - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_25, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - C - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_26, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - Y - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_27, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - b - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_28, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - s - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_29, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - r - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_30, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - ostr i - - 1 - i", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_31, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - h - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_32, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - l - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_33, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - k - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_34, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - f - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_35, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - d - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator<<", 996, G__G__stream__0_36, 117, G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, +"u 'basic_ostream >' 'ostream' 1 - - g - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_37, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - c - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_38, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - b - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_39, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - s - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_40, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - r - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_41, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - istr i - - 1 - i", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_42, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - h - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_43, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - l - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_44, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - k - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_45, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - f - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_46, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - d - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_47, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - g - - 1 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_48, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - C - - 0 - -", (char*) NULL +, (void*) NULL, 0); + G__memfunc_setup("operator>>", 1000, G__G__stream__0_49, 117, G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, +"u 'basic_istream >' 'istream' 1 - - Y - - 1 - -", (char*) NULL +, (void*) NULL, 0); + + G__resetifuncposition(); +} + +extern "C" void G__cpp_setup_funcG__stream() { + G__cpp_setup_func0(); +} + +/********************************************************* +* Class,struct,union,enum tag information setup +*********************************************************/ +/* Setup class/struct taginfo */ +G__linked_taginfo G__G__streamLN_mbstate_t = { "mbstate_t" , 115 , -1 }; +G__linked_taginfo G__G__streamLN_streamoff = { "streamoff" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_fposlEmbstate_tgR = { "fpos" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_ios_base = { "ios_base" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLio_state = { "ios_base::io_state" , 101 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLopen_mode = { "ios_base::open_mode" , 101 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLseek_dir = { "ios_base::seek_dir" , 101 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLfmt_flags = { "ios_base::fmt_flags" , 101 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLevent = { "ios_base::event" , 101 , -1 }; +G__linked_taginfo G__G__streamLN_ios_basecLcLInit = { "ios_base::Init" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_char_traitslEchargR = { "char_traits" , 115 , -1 }; +G__linked_taginfo G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR = { "basic_ios >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR = { "basic_streambuf >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry = { "basic_ostream >::sentry" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry = { "basic_istream >::sentry" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR = { "basic_filebuf >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ifstream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR = { "basic_fstream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR = { "basic_iostream >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_string = { "string" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_stringbuf,allocator >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_istringstream,allocator >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_ostringstream,allocator >" , 99 , -1 }; +G__linked_taginfo G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_stringstream,allocator >" , 99 , -1 }; + +/* Reset class/struct taginfo */ +extern "C" void G__cpp_reset_tagtableG__stream() { + G__G__streamLN_mbstate_t.tagnum = -1 ; + G__G__streamLN_streamoff.tagnum = -1 ; + G__G__streamLN_fposlEmbstate_tgR.tagnum = -1 ; + G__G__streamLN_ios_base.tagnum = -1 ; + G__G__streamLN_ios_basecLcLio_state.tagnum = -1 ; + G__G__streamLN_ios_basecLcLopen_mode.tagnum = -1 ; + G__G__streamLN_ios_basecLcLseek_dir.tagnum = -1 ; + G__G__streamLN_ios_basecLcLfmt_flags.tagnum = -1 ; + G__G__streamLN_ios_basecLcLevent.tagnum = -1 ; + G__G__streamLN_ios_basecLcLInit.tagnum = -1 ; + G__G__streamLN_char_traitslEchargR.tagnum = -1 ; + G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry.tagnum = -1 ; + G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry.tagnum = -1 ; + G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ; + G__G__streamLN_string.tagnum = -1 ; + G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ; + G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ; +} + + +extern "C" void G__cpp_setup_tagtableG__stream() { + + /* Setting up class,struct,union tag entry */ + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_mbstate_t),sizeof(mbstate_t),-1,0,(char*)NULL,G__setup_memvarmbstate_t,G__setup_memfuncmbstate_t); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_streamoff),sizeof(streamoff),-1,0,(char*)NULL,G__setup_memvarstreamoff,G__setup_memfuncstreamoff); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR),sizeof(fpos),-1,33536,(char*)NULL,G__setup_memvarfposlEmbstate_tgR,G__setup_memfuncfposlEmbstate_tgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_base),sizeof(ios_base),-1,3840,(char*)NULL,G__setup_memvarios_base,G__setup_memfuncios_base); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLio_state),sizeof(int),-1,0,(char*)NULL,NULL,NULL); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLopen_mode),sizeof(int),-1,0,(char*)NULL,NULL,NULL); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLseek_dir),sizeof(int),-1,0,(char*)NULL,NULL,NULL); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLfmt_flags),sizeof(int),-1,0,(char*)NULL,NULL,NULL); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLevent),sizeof(int),-1,0,(char*)NULL,NULL,NULL); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit),sizeof(ios_base::Init),-1,1280,(char*)NULL,G__setup_memvarios_basecLcLInit,G__setup_memfuncios_basecLcLInit); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR),sizeof(char_traits),-1,0,(char*)NULL,G__setup_memvarchar_traitslEchargR,G__setup_memfuncchar_traitslEchargR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_istream >),-1,34048,(char*)NULL,G__setup_memvarbasic_istreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_istreamlEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR),sizeof(basic_ios >),-1,36608,(char*)NULL,G__setup_memvarbasic_ioslEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_ioslEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR),sizeof(basic_streambuf >),-1,3840,(char*)NULL,G__setup_memvarbasic_streambuflEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_streambuflEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_ostream >),-1,34048,(char*)NULL,G__setup_memvarbasic_ostreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_ostreamlEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry),sizeof(basic_ostream >::sentry),-1,36352,(char*)NULL,G__setup_memvarbasic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry,G__setup_memfuncbasic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry),sizeof(basic_istream >::sentry),-1,33792,(char*)NULL,G__setup_memvarbasic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry,G__setup_memfuncbasic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR),sizeof(basic_filebuf >),-1,3328,(char*)NULL,G__setup_memvarbasic_filebuflEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_filebuflEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_ifstream >),-1,34048,(char*)NULL,G__setup_memvarbasic_ifstreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_ifstreamlEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_ofstream >),-1,34048,(char*)NULL,G__setup_memvarbasic_ofstreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_ofstreamlEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_fstream >),-1,33024,(char*)NULL,G__setup_memvarbasic_fstreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_fstreamlEcharcOchar_traitslEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR),sizeof(basic_iostream >),-1,34048,(char*)NULL,G__setup_memvarbasic_iostreamlEcharcOchar_traitslEchargRsPgR,G__setup_memfuncbasic_iostreamlEcharcOchar_traitslEchargRsPgR); + G__get_linked_tagnum_fwd(&G__G__streamLN_string); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),sizeof(basic_stringbuf,allocator >),-1,36096,(char*)NULL,G__setup_memvarbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR,G__setup_memfuncbasic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),sizeof(basic_istringstream,allocator >),-1,34048,(char*)NULL,G__setup_memvarbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR,G__setup_memfuncbasic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),sizeof(basic_ostringstream,allocator >),-1,34048,(char*)NULL,G__setup_memvarbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR,G__setup_memfuncbasic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); + G__tagtable_setup(G__get_linked_tagnum(&G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),sizeof(basic_stringstream,allocator >),-1,34048,(char*)NULL,G__setup_memvarbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR,G__setup_memfuncbasic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR); +} +extern "C" void G__cpp_setupG__stream(void) { + G__check_setup_version(30051515,"G__cpp_setupG__stream()"); + G__set_cpp_environmentG__stream(); + G__cpp_setup_tagtableG__stream(); + + G__cpp_setup_inheritanceG__stream(); + + G__cpp_setup_typetableG__stream(); + + G__cpp_setup_memvarG__stream(); + + G__cpp_setup_memfuncG__stream(); + G__cpp_setup_globalG__stream(); + G__cpp_setup_funcG__stream(); + + if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__stream(); + return; +} diff -Naur root/cint/src/gcc4strm.h root.new/cint/src/gcc4strm.h --- root/cint/src/gcc4strm.h 1969-12-31 19:00:00.000000000 -0500 +++ root.new/cint/src/gcc4strm.h 2007-11-26 09:09:29.000000000 -0500 @@ -0,0 +1,83 @@ +/******************************************************************** +* gcc4strm.h +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************************/ +#ifdef __CINT__ +#error gcc4strm.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#include "G__ci.h" +extern "C" { +extern void G__cpp_setup_tagtableG__stream(); +extern void G__cpp_setup_inheritanceG__stream(); +extern void G__cpp_setup_typetableG__stream(); +extern void G__cpp_setup_memvarG__stream(); +extern void G__cpp_setup_globalG__stream(); +extern void G__cpp_setup_memfuncG__stream(); +extern void G__cpp_setup_funcG__stream(); +extern void G__set_cpp_environmentG__stream(); +} + + +#include "iostrm.h" +#include "fstrm.h" +#include "sstrm.h" +#include "linkdef.h" + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__G__streamLN_mbstate_t; +extern G__linked_taginfo G__G__streamLN_streamoff; +extern G__linked_taginfo G__G__streamLN_fposlEmbstate_tgR; +extern G__linked_taginfo G__G__streamLN_ios_base; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLio_state; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLopen_mode; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLseek_dir; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLfmt_flags; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLevent; +extern G__linked_taginfo G__G__streamLN_ios_basecLcLInit; +extern G__linked_taginfo G__G__streamLN_char_traitslEchargR; +extern G__linked_taginfo G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ioslEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_streambuflEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry; +extern G__linked_taginfo G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry; +extern G__linked_taginfo G__G__streamLN_basic_filebuflEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_fstreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_iostreamlEcharcOchar_traitslEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_string; +extern G__linked_taginfo G__G__streamLN_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +extern G__linked_taginfo G__G__streamLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; + +/* STUB derived class for protected member access */ +typedef fpos G__fposlEmbstate_tgR; +typedef char_traits G__char_traitslEchargR; +typedef basic_istream > G__basic_istreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_ios > G__basic_ioslEcharcOchar_traitslEchargRsPgR; +typedef basic_streambuf > G__basic_streambuflEcharcOchar_traitslEchargRsPgR; +typedef basic_ostream > G__basic_ostreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_ostream >::sentry G__basic_ostreamlEcharcOchar_traitslEchargRsPgRcLcLsentry; +typedef basic_istream >::sentry G__basic_istreamlEcharcOchar_traitslEchargRsPgRcLcLsentry; +typedef basic_filebuf > G__basic_filebuflEcharcOchar_traitslEchargRsPgR; +typedef basic_ifstream > G__basic_ifstreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_ofstream > G__basic_ofstreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_fstream > G__basic_fstreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_iostream > G__basic_iostreamlEcharcOchar_traitslEchargRsPgR; +typedef basic_stringbuf,allocator > G__basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +typedef basic_istringstream,allocator > G__basic_istringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +typedef basic_ostringstream,allocator > G__basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; +typedef basic_stringstream,allocator > G__basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR; diff -Naur root/thread/inc/TAtomicCountGcc.h root.new/thread/inc/TAtomicCountGcc.h --- root/thread/inc/TAtomicCountGcc.h 2006-11-16 13:07:33.000000000 -0500 +++ root.new/thread/inc/TAtomicCountGcc.h 2007-11-26 11:59:11.000000000 -0500 @@ -28,7 +28,11 @@ // // ////////////////////////////////////////////////////////////////////////// +#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2) #include +#else +#include +#endif #if defined(__GLIBCXX__) // g++ 3.4+