blob: 44d03f109ab74103f8dcc04bccb3fa1e45437e77 [file] [log] [blame]
// { dg-do assemble }
// { dg-require-effective-target ilp32 } */
// { dg-options "-w -fpermissive" }
// prms-id: 784
//# 1 "GctSymbol.GctSymbol.CHMap.cc"
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988, 2000, 2002 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#pragma implementation
//# 1 "GctSymbol.GctSymbol.CHMap.h" 1
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#pragma interface
//# 1 "GctSymbol.GctSymbol.Map.h" 1
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Pix.h" 1
typedef void* Pix;
//# 26 "GctSymbol.GctSymbol.Map.h" 2
//# 1 "GctSymbol.defs.h" 1
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//# 1 "../../GctSymbol.h" 1
// -*- C++ -*-
//
// GctSymbol class
//
// Expects to be included by Gct.h
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 25 "../../GctSymbol.h" 2
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 1
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 1
// Compatibility with old library.
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
// This is part of the iostream library, providing -*- C++ -*- input/output.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 1
// This is part of the iostream library, providing -*- C++ -*- input/output.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//#pragma interface
/* KLUDGES!! */
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
extern "C" {
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/mips/lib/gcc/decstatn/cygnus-1.96/include/stddef.h" 1
/* This avoids lossage on Sunos but only if stdtypes.h comes first.
There's no way to win with the other order! Sun lossage. */
/* In case nobody has defined these types, but we aren't running under
GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE__TYPE__, and
__WCHAR_TYPE__ have reasonable values. This can happen if the
parts of GCC is compiled by an older compiler, that actually
include gstddef.h, such as collect2. */
/* Signed type of difference of two pointers. */
typedef long int ptrdiff_t;
/* Unsigned type of `sizeof' something. */
typedef unsigned int size_t;
/* Data type for wide chars. */
/* A null pointer constant. */
/* Offset of member MEMBER in a struct of type TYPE. */
//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 2
}
//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 2
class ostream; class streambuf;
typedef long streamoff, streampos;
struct _ios_fields { // The data members of an ios.
streambuf *_strbuf;
ostream* _tie;
long _width;
unsigned long _flags;
char _fill;
unsigned char _state;
unsigned short _precision;
};
enum state_value { _good = 0, _eof = 1, _fail = 2, _bad = 4 };
class ios : public _ios_fields {
public:
enum io_state { goodbit=0, eofbit=1, failbit=2, badbit=4 };
enum open_mode {
in=1,
out=2,
ate=4,
app=8,
trunc=16,
nocreate=32,
noreplace=64 };
enum seek_dir { beg, cur, end};
enum { skipws=01, left=02, right=04, internal=010,
dec=020, oct=040, hex=0100,
showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
scientific=04000, fixed=0100000, unitbuf=020000, stdio=040000,
dont_close=0x80000000 //Don't close streambuf when destroying stream
};
ostream* tie() { return _tie; }
ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
// Methods to change the format state.
char fill() { return _fill; }
char fill(char newf) { char oldf = _fill; _fill = newf; return oldf; }
unsigned long flags() { return _flags; }
unsigned long flags(unsigned long new_val) {
unsigned long old_val = _flags; _flags = new_val; return old_val; }
unsigned short precision() { return _precision; }
unsigned short precision(int newp) {
unsigned short oldp = _precision; _precision = (unsigned short)newp;
return oldp; }
unsigned long setf(unsigned long val) {
unsigned long oldbits = _flags;
_flags |= val; return oldbits; }
unsigned long setf(unsigned long val, unsigned long mask) {
unsigned long oldbits = _flags;
_flags = (_flags & ~mask) | (val & mask); return oldbits; }
unsigned long unsetf(unsigned long mask) {
unsigned long oldbits = _flags & mask;
_flags &= ~mask; return oldbits; }
long width() { return _width; }
long width(long val) { long save = _width; _width = val; return save; }
static const unsigned long basefield;
static const unsigned long adjustfield;
static const unsigned long floatfield;
streambuf* rdbuf() { return _strbuf; }
void clear(int state = 0) { _state = state; }
int good() { return _state == 0; }
int eof() { return _state & ios::eofbit; }
int fail() { return _state & (ios::badbit|ios::failbit); }
int bad() { return _state & ios::badbit; }
int rdstate() { return _state; }
void set(int flag) { _state |= flag; }
operator void*() { return fail() ? (void*)0 : (void*)this; }
int operator!() { return fail(); }
void unset(state_value flag) { _state &= ~flag; }
void close();
int is_open();
int readable();
int writable();
protected:
ios(streambuf*sb) { _strbuf=sb; _state=0; _width=0; _fill=' ';
_flags=ios::skipws; _precision=6; }
};
typedef ios::seek_dir _seek_dir;
// Magic numbers and bits for the _flags field.
// The magic numbers use the high-order bits of _flags;
// the remaining bits are abailable for variable flags.
// Note: The magic numbers must all be negative if stdio
// emulation is desired.
struct __streambuf {
// NOTE: If this is changed, also change __FILE in stdio/stdio.h!
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
char* _gptr; /* Current get pointer */
char* _egptr; /* End of get area. */
char* _eback; /* Start of putback+get area. */
char* _pbase; /* Start of put area. */
char* _pptr; /* Current put pointer. */
char* _epptr; /* End of put area. */
char* _base; /* Start of reserve area. */
char* _ebuf; /* End of reserve area. */
struct streambuf *_chain;
};
struct streambuf : private __streambuf {
friend class ios;
friend class istream;
friend class ostream;
protected:
static streambuf* _list_all; /* List of open streambufs. */
streambuf*& xchain() { return _chain; }
void _un_link();
void _link_in();
char* gptr() const { return _gptr; }
char* pptr() const { return _pptr; }
char* egptr() const { return _egptr; }
char* epptr() const { return _epptr; }
char* pbase() const { return _pbase; }
char* eback() const { return _eback; }
char* ebuf() const { return _ebuf; }
char* base() const { return _base; }
void xput_char(char c) { *_pptr++ = c; }
int xflags() { return _flags; }
int xflags(int f) { int fl = _flags; _flags = f; return fl; }
void xsetflags(int f) { _flags |= f; }
void gbump(int n) { _gptr += n; }
void pbump(int n) { _pptr += n; }
void setb(char* b, char* eb, int a=0);
void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
public:
static int flush_all();
static void flush_all_linebuffered(); // Flush all line buffered files.
virtual int underflow(); // Leave public for now
virtual int overflow(int c = (-1) ); // Leave public for now
virtual int doallocate();
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
int sputbackc(char c);
int sungetc();
streambuf();
virtual ~streambuf();
int unbuffered() { return _flags & 2 ? 1 : 0; }
int linebuffered() { return _flags & 0x4000 ? 1 : 0; }
void unbuffered(int i)
{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
void linebuffered(int i)
{ if (i) _flags |= 0x4000 ; else _flags &= ~0x4000 ; }
int allocate() {
if (base() || unbuffered()) return 0;
else return doallocate(); }
virtual int sync();
virtual int pbackfail(int c);
virtual int ungetfail();
virtual streambuf* setbuf(char* p, int len);
int in_avail() { return _egptr - _gptr; }
int out_waiting() { return _pptr - _pbase; }
virtual int sputn(const char* s, int n);
virtual int sgetn(char* s, int n);
long sgetline(char* buf, size_t n, char delim, int putback_delim);
int sbumpc() {
if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
else return *(unsigned char*)_gptr++; }
int sgetc() {
if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
else return *(unsigned char*)_gptr; }
int snextc() {
if (++_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
else return *(unsigned char*)_gptr; }
int sputc(int c) {
if (_pptr >= _epptr) return overflow(c);
return *_pptr++ = c, (unsigned char)c; }
int vscan(char const *fmt0, char* ap);
int vform(char const *fmt0, char* ap);
};
struct __file_fields {
char _fake;
char _shortbuf[1];
short _fileno;
int _blksize;
char* _save_gptr;
char* _save_egptr;
long _offset;
};
class filebuf : public streambuf {
struct __file_fields _fb;
void init();
public:
filebuf();
filebuf(int fd);
filebuf(int fd, char* p, int len);
~filebuf();
filebuf* attach(int fd);
filebuf* open(const char *filename, const char *mode);
filebuf* open(const char *filename, int mode, int prot = 0664);
virtual int underflow();
virtual int overflow(int c = (-1) );
int is_open() { return _fb._fileno >= 0; }
int fd() { return is_open() ? _fb._fileno : (-1) ; }
filebuf* close();
virtual int doallocate();
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
int sputn(const char* s, int n);
int sgetn(char* s, int n);
protected: // See documentation in filebuf.C.
virtual int pbackfail(int c);
virtual int sync();
int is_reading() { return eback() != egptr(); }
char* cur_ptr() { return is_reading() ? gptr() : pptr(); }
/* System's idea of pointer */
char* file_ptr() { return _fb._save_gptr ? _fb._save_egptr : egptr(); }
int do_flush();
// Low-level operations (Usually invoke system calls.)
virtual int sys_read(char* buf, size_t size);
virtual long sys_seek(long , _seek_dir);
virtual long sys_write(const void*, long);
virtual int sys_stat(void*); // Actually, a (struct stat*)
virtual int sys_close();
};
inline int ios::readable() { return rdbuf()->_flags & 4 ; }
inline int ios::writable() { return rdbuf()->_flags & 8 ; }
inline int ios::is_open() {return rdbuf()->_flags & 4 +8 ;}
//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 2
class istream; class ostream;
typedef istream& (*__imanip)(istream&);
typedef ostream& (*__omanip)(ostream&);
extern istream& ws(istream& ins);
extern ostream& flush(ostream& outs);
extern ostream& endl(ostream& outs);
extern ostream& ends(ostream& outs);
class ostream : public ios
{
void do_osfx();
public:
ostream();
ostream(streambuf* sb, ostream* tied=(__null) );
~ostream();
int opfx() { if (!good()) return 0; if (_tie) _tie->flush(); return 1; }
void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
do_osfx(); }
streambuf* ostreambuf() const { return _strbuf; }
ostream& flush();
ostream& put(char c);
ostream& write(const char *s, int n);
ostream& write(const unsigned char *s, int n) { return write((char*)s, n);}
ostream& write(const void *s, int n) { return write((char*)s, n);}
ostream& seekp(streampos);
ostream& seekp(streamoff, _seek_dir);
streampos tellp();
ostream& form(const char *format ...);
ostream& vform(const char *format, char* args);
};
ostream& operator<<(ostream&, char c);
ostream& operator<<(ostream& os, unsigned char c) { return os << (char)c; }
//ostream& operator<<(ostream &os, signed char c) { return os << (char)c; }
extern ostream& operator<<(ostream&, const char *s);
inline ostream& operator<<(ostream& os, const unsigned char *s)
{ return os << (const char*)s; }
//inline ostream& operator<<(ostream& os, const signed char *s)
//{ return os << (const char*)s; }
ostream& operator<<(ostream&, void *p);
ostream& operator<<(ostream&, int n);
ostream& operator<<(ostream&, long n);
ostream& operator<<(ostream&, unsigned int n);
ostream& operator<<(ostream&, unsigned long n);
ostream& operator<<(ostream& os, short n) {return os << (int)n;}
ostream& operator<<(ostream& os, unsigned short n)
{return os << (unsigned int)n;}
ostream& operator<<(ostream&, float n);
ostream& operator<<(ostream&, double n);
ostream& operator<<(ostream& os, __omanip func) { return (*func)(os); }
ostream& operator<<(ostream&, streambuf*);
class istream : public ios
{
size_t _gcount;
public:
istream();
istream(streambuf* sb, ostream*tied=(__null) );
~istream();
streambuf* istreambuf() const { return _strbuf; }
istream& get(char& c);
istream& get(unsigned char& c);
istream& read(char *ptr, int n);
istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
istream& read(void *ptr, int n) { return read((char*)ptr, n); }
int get() { return _strbuf->sbumpc(); }
istream& getline(char* ptr, int len, char delim = '\n');
istream& get(char* ptr, int len, char delim = '\n');
istream& gets(char **s, char delim = '\n');
int ipfx(int need) {
if (!good()) { set(ios::failbit); return 0; }
if (_tie && (need == 0 || rdbuf()->in_avail())) ; //??? THIS LINE IS QUESTIONABLE */
if (!need && (flags() & ios::skipws) && !ws(*this)) return 0;
return 1;
}
int ipfx0() { // Optimized version of ipfx(0).
if (!good()) { set(ios::failbit); return 0; }
if (_tie) _tie->flush();
if ((flags() & ios::skipws) && !ws(*this)) return 0;
return 1;
}
int ipfx1() { // Optimized version of ipfx(1).
if (!good()) { set(ios::failbit); return 0; }
if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
return 1;
}
size_t gcount() { return _gcount; }
istream& seekg(streampos);
istream& seekg(streamoff, _seek_dir);
streampos tellg();
istream& putback(char ch) {
if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
return *this;}
istream& unget() {
if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
return *this;}
istream& unget(char ch) { return putback(ch); }
int skip(int i);
};
istream& operator>>(istream&, char*);
istream& operator>>(istream& is, unsigned char* p) { return is >> (char*)p; }
//istream& operator>>(istream& is, signed char* p) { return is >> (char*)p; }
istream& operator>>(istream&, char& c);
istream& operator>>(istream&, unsigned char& c);
//istream& operator>>(istream&, signed char& c);
istream& operator>>(istream&, int&);
istream& operator>>(istream&, long&);
istream& operator>>(istream&, short&);
istream& operator>>(istream&, unsigned int&);
istream& operator>>(istream&, unsigned long&);
istream& operator>>(istream&, unsigned short&);
istream& operator>>(istream&, float&);
istream& operator>>(istream&, double&);
istream& operator>>(istream& is, __imanip func) { return (*func)(is); }
class iostream : public ios {
size_t _gcount;
public:
iostream();
operator istream&() { return *(istream*)this; }
operator ostream&() { return *(ostream*)this; }
~iostream();
// NOTE: These duplicate istream methods.
istream& get(char& c) { return ((istream*)this)->get(c); }
istream& get(unsigned char& c) { return ((istream*)this)->get(c); }
istream& read(char *ptr, int n) { return ((istream*)this)->read(ptr, n); }
istream& read(unsigned char *ptr, int n)
{ return ((istream*)this)->read((char*)ptr, n); }
istream& read(void *ptr, int n)
{ return ((istream*)this)->read((char*)ptr, n); }
int get() { return _strbuf->sbumpc(); }
istream& getline(char* ptr, int len, char delim = '\n')
{ return ((istream*)this)->getline(ptr, len, delim); }
istream& get(char* ptr, int len, char delim = '\n')
{ return ((istream*)this)->get(ptr, len, delim); }
istream& gets(char **s, char delim = '\n')
{ return ((istream*)this)->gets(s, delim); }
int ipfx(int need) { return ((istream*)this)->ipfx(need); }
int ipfx0() { return ((istream*)this)->ipfx0(); }
int ipfx1() { return ((istream*)this)->ipfx1(); }
size_t gcount() { return _gcount; }
istream& putback(char ch) { return ((istream*)this)->putback(ch); }
istream& unget() { return ((istream*)this)->unget(); }
istream& seekg(streampos pos) { return ((istream*)this)->seekg(pos); }
istream& seekg(streamoff off, _seek_dir dir)
{ return ((istream*)this)->seekg(off, dir); }
streampos tellg() { return ((istream*)this)->tellg(); }
istream& unget(char ch) { return putback(ch); }
// NOTE: These duplicate ostream methods.
int opfx() { return ((ostream*)this)->opfx(); }
void osfx() { ((ostream*)this)->osfx(); }
ostream& flush() { return ((ostream*)this)->flush(); }
ostream& put(char c) { return ((ostream*)this)->put(c); }
ostream& write(const char *s, int n)
{ return ((ostream*)this)->write(s, n); }
ostream& write(const unsigned char *s, int n)
{ return ((ostream*)this)->write((char*)s, n); }
ostream& write(const void *s, int n)
{ return ((ostream*)this)->write((char*)s, n); }
ostream& form(const char *format ...);
ostream& vform(const char *format, char* args)
{ return ((ostream*)this)->vform(format, args); }
ostream& seekp(streampos pos) { return ((ostream*)this)->seekp(pos); }
ostream& seekp(streamoff off, _seek_dir dir)
{ return ((ostream*)this)->seekp(off, dir); }
streampos tellp() { return ((ostream*)this)->tellp(); }
};
extern istream cin;
extern ostream cout, cerr, clog; // clog->rdbuf() == cerr->rdbuf()
inline ostream& ostream::put(char c) { _strbuf->sputc(c); return *this; }
struct Iostream_init { } ; // Compatibility hack for AT&T libraray.
//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 2
extern char* form(char*, ...);
extern char* dec(long, int=0);
extern char* dec(int, int=0);
extern char* dec(unsigned long, int=0);
extern char* dec(unsigned int, int=0);
extern char* hex(long, int=0);
extern char* hex(int, int=0);
extern char* hex(unsigned long, int=0);
extern char* hex(unsigned int, int=0);
extern char* oct(long, int=0);
extern char* oct(int, int=0);
extern char* oct(unsigned long, int=0);
extern char* oct(unsigned int, int=0);
inline istream& WS(istream& str) { return ws(str); }
//# 26 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Regex.h" 1
// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#pragma interface
struct re_pattern_buffer; // defined elsewhere
struct re_registers;
class Regex
{
private:
Regex(const Regex&) {} // no X(X&)
void operator = (const Regex&) {} // no assignment
protected:
re_pattern_buffer* buf;
re_registers* reg;
public:
Regex(const char* t,
int fast = 0,
int bufsize = 40,
const char* transtable = 0);
~Regex();
int match(const char* s, int len, int pos = 0) const;
int search(const char* s, int len,
int& matchlen, int startpos = 0) const;
int match_info(int& start, int& length, int nth = 0) const;
int OK() const; // representation invariant
};
// some built in regular expressions
extern const Regex RXwhite; // = "[ \n\t\r\v\f]+"
extern const Regex RXint; // = "-?[0-9]+"
extern const Regex RXdouble; // = "-?\\(\\([0-9]+\\.[0-9]*\\)\\|
// \\([0-9]+\\)\\|\\(\\.[0-9]+\\)\\)
// \\([eE][---+]?[0-9]+\\)?"
extern const Regex RXalpha; // = "[A-Za-z]+"
extern const Regex RXlowercase; // = "[a-z]+"
extern const Regex RXuppercase; // = "[A-Z]+"
extern const Regex RXalphanum; // = "[0-9A-Za-z]+"
extern const Regex RXidentifier; // = "[A-Za-z_][A-Za-z0-9_]*"
//# 27 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
struct StrRep // internal String representations
{
unsigned short len; // string length
unsigned short sz; // allocated space
char s[1]; // the string starts here
// (at least 1 char for trailing null)
// allocated & expanded via non-public fcts
};
// primitive ops on StrReps -- nearly all String fns go through these.
StrRep* Salloc(StrRep*, const char*, int, int);
StrRep* Scopy(StrRep*, StrRep*);
StrRep* Sresize(StrRep*, int);
StrRep* Scat(StrRep*, const char*, int, const char*, int);
StrRep* Scat(StrRep*, const char*, int,const char*,int, const char*,int);
StrRep* Sprepend(StrRep*, const char*, int);
StrRep* Sreverse(StrRep*, StrRep*);
StrRep* Supcase(StrRep*, StrRep*);
StrRep* Sdowncase(StrRep*, StrRep*);
StrRep* Scapitalize(StrRep*, StrRep*);
// These classes need to be defined in the order given
class String;
class SubString;
class SubString
{
friend class String;
protected:
String& S; // The String I'm a substring of
unsigned short pos; // starting position in S's rep
unsigned short len; // length of substring
void assign(StrRep*, const char*, int = -1);
SubString(String& x, int p, int l);
SubString(const SubString& x);
public:
// Note there are no public constructors. SubStrings are always
// created via String operations
~SubString();
void operator = (const String& y);
void operator = (const SubString& y);
void operator = (const char* t);
void operator = (char c);
// return 1 if target appears anywhere in SubString; else 0
int contains(char c) const;
int contains(const String& y) const;
int contains(const SubString& y) const;
int contains(const char* t) const;
int contains(const Regex& r) const;
// return 1 if target matches entire SubString
int matches(const Regex& r) const;
// IO
friend ostream& operator<<(ostream& s, const SubString& x);
// status
unsigned int length() const;
int empty() const;
const char* chars() const;
int OK() const;
};
class String
{
friend class SubString;
protected:
StrRep* rep; // Strings are pointers to their representations
// some helper functions
int search(int, int, const char*, int = -1) const;
int search(int, int, char) const;
int match(int, int, int, const char*, int = -1) const;
int _gsub(const char*, int, const char* ,int);
int _gsub(const Regex&, const char*, int);
SubString _substr(int, int);
public:
// constructors & assignment
String();
String(const String& x);
String(const SubString& x);
String(const char* t);
String(const char* t, int len);
String(char c);
~String();
void operator = (const String& y);
void operator = (const char* y);
void operator = (char c);
void operator = (const SubString& y);
// concatenation
void operator += (const String& y);
void operator += (const SubString& y);
void operator += (const char* t);
void operator += (char c);
void prepend(const String& y);
void prepend(const SubString& y);
void prepend(const char* t);
void prepend(char c);
// procedural versions:
// concatenate first 2 args, store result in last arg
friend void cat(const String&, const String&, String&);
friend void cat(const String&, const SubString&, String&);
friend void cat(const String&, const char*, String&);
friend void cat(const String&, char, String&);
friend void cat(const SubString&, const String&, String&);
friend void cat(const SubString&, const SubString&, String&);
friend void cat(const SubString&, const char*, String&);
friend void cat(const SubString&, char, String&);
friend void cat(const char*, const String&, String&);
friend void cat(const char*, const SubString&, String&);
friend void cat(const char*, const char*, String&);
friend void cat(const char*, char, String&);
// double concatenation, by request. (yes, there are too many versions,
// but if one is supported, then the others should be too...)
// Concatenate first 3 args, store in last arg
friend void cat(const String&,const String&, const String&,String&);
friend void cat(const String&,const String&,const SubString&,String&);
friend void cat(const String&,const String&, const char*, String&);
friend void cat(const String&,const String&, char, String&);
friend void cat(const String&,const SubString&,const String&,String&);
friend void cat(const String&,const SubString&,const SubString&,String&);
friend void cat(const String&,const SubString&, const char*, String&);
friend void cat(const String&,const SubString&, char, String&);
friend void cat(const String&,const char*, const String&, String&);
friend void cat(const String&,const char*, const SubString&, String&);
friend void cat(const String&,const char*, const char*, String&);
friend void cat(const String&,const char*, char, String&);
friend void cat(const char*, const String&, const String&,String&);
friend void cat(const char*,const String&,const SubString&,String&);
friend void cat(const char*,const String&, const char*, String&);
friend void cat(const char*,const String&, char, String&);
friend void cat(const char*,const SubString&,const String&,String&);
friend void cat(const char*,const SubString&,const SubString&,String&);
friend void cat(const char*,const SubString&, const char*, String&);
friend void cat(const char*,const SubString&, char, String&);
friend void cat(const char*,const char*, const String&, String&);
friend void cat(const char*,const char*, const SubString&, String&);
friend void cat(const char*,const char*, const char*, String&);
friend void cat(const char*,const char*, char, String&);
// searching & matching
// return position of target in string or -1 for failure
int index(char c, int startpos = 0) const;
int index(const String& y, int startpos = 0) const;
int index(const SubString& y, int startpos = 0) const;
int index(const char* t, int startpos = 0) const;
int index(const Regex& r, int startpos = 0) const;
// return 1 if target appears anyhere in String; else 0
int contains(char c) const;
int contains(const String& y) const;
int contains(const SubString& y) const;
int contains(const char* t) const;
int contains(const Regex& r) const;
// return 1 if target appears anywhere after position pos
// (or before, if pos is negative) in String; else 0
int contains(char c, int pos) const;
int contains(const String& y, int pos) const;
int contains(const SubString& y, int pos) const;
int contains(const char* t, int pos) const;
int contains(const Regex& r, int pos) const;
// return 1 if target appears at position pos in String; else 0
int matches(char c, int pos = 0) const;
int matches(const String& y, int pos = 0) const;
int matches(const SubString& y, int pos = 0) const;
int matches(const char* t, int pos = 0) const;
int matches(const Regex& r, int pos = 0) const;
// return number of occurences of target in String
int freq(char c) const;
int freq(const String& y) const;
int freq(const SubString& y) const;
int freq(const char* t) const;
// SubString extraction
// Note that you can't take a substring of a const String, since
// this leaves open the possiblility of indirectly modifying the
// String through the SubString
SubString at(int pos, int len);
SubString operator () (int pos, int len); // synonym for at
SubString at(const String& x, int startpos = 0);
SubString at(const SubString& x, int startpos = 0);
SubString at(const char* t, int startpos = 0);
SubString at(char c, int startpos = 0);
SubString at(const Regex& r, int startpos = 0);
SubString before(int pos);
SubString before(const String& x, int startpos = 0);
SubString before(const SubString& x, int startpos = 0);
SubString before(const char* t, int startpos = 0);
SubString before(char c, int startpos = 0);
SubString before(const Regex& r, int startpos = 0);
SubString through(int pos);
SubString through(const String& x, int startpos = 0);
SubString through(const SubString& x, int startpos = 0);
SubString through(const char* t, int startpos = 0);
SubString through(char c, int startpos = 0);
SubString through(const Regex& r, int startpos = 0);
SubString from(int pos);
SubString from(const String& x, int startpos = 0);
SubString from(const SubString& x, int startpos = 0);
SubString from(const char* t, int startpos = 0);
SubString from(char c, int startpos = 0);
SubString from(const Regex& r, int startpos = 0);
SubString after(int pos);
SubString after(const String& x, int startpos = 0);
SubString after(const SubString& x, int startpos = 0);
SubString after(const char* t, int startpos = 0);
SubString after(char c, int startpos = 0);
SubString after(const Regex& r, int startpos = 0);
// deletion
// delete len chars starting at pos
void del(int pos, int len);
// delete the first occurrence of target after startpos
void del(const String& y, int startpos = 0);
void del(const SubString& y, int startpos = 0);
void del(const char* t, int startpos = 0);
void del(char c, int startpos = 0);
void del(const Regex& r, int startpos = 0);
// global substitution: substitute all occurrences of pat with repl
int gsub(const String& pat, const String& repl);
int gsub(const SubString& pat, const String& repl);
int gsub(const char* pat, const String& repl);
int gsub(const char* pat, const char* repl);
int gsub(const Regex& pat, const String& repl);
// friends & utilities
// split string into array res at separators; return number of elements
friend int split(const String& x, String res[], int maxn,
const String& sep);
friend int split(const String& x, String res[], int maxn,
const Regex& sep);
friend String common_prefix(const String& x, const String& y,
int startpos = 0);
friend String common_suffix(const String& x, const String& y,
int startpos = -1);
friend String replicate(char c, int n);
friend String replicate(const String& y, int n);
friend String join(String src[], int n, const String& sep);
// simple builtin transformations
friend String reverse(const String& x);
friend String upcase(const String& x);
friend String downcase(const String& x);
friend String capitalize(const String& x);
// in-place versions of above
void reverse();
void upcase();
void downcase();
void capitalize();
// element extraction
char& operator [] (int i);
char elem(int i) const;
char firstchar() const;
char lastchar() const;
// conversion
operator const char*() const;
const char* chars() const;
// IO
friend ostream& operator<<(ostream& s, const String& x);
friend ostream& operator<<(ostream& s, const SubString& x);
friend istream& operator>>(istream& s, String& x);
friend int readline(istream& s, String& x,
char terminator = '\n',
int discard_terminator = 1);
// status
unsigned int length() const;
int empty() const;
// preallocate some space for String
void alloc(int newsize);
// report current allocation (not length!)
int allocation() const;
volatile void error(const char* msg) const;
int OK() const;
};
typedef String StrTmp; // for backward compatibility
// other externs
int compare(const String& x, const String& y);
int compare(const String& x, const SubString& y);
int compare(const String& x, const char* y);
int compare(const SubString& x, const String& y);
int compare(const SubString& x, const SubString& y);
int compare(const SubString& x, const char* y);
int fcompare(const String& x, const String& y); // ignore case
extern StrRep _nilStrRep;
extern String _nilString;
// other inlines
String operator + (const String& x, const String& y);
String operator + (const String& x, const SubString& y);
String operator + (const String& x, const char* y);
String operator + (const String& x, char y);
String operator + (const SubString& x, const String& y);
String operator + (const SubString& x, const SubString& y);
String operator + (const SubString& x, const char* y);
String operator + (const SubString& x, char y);
String operator + (const char* x, const String& y);
String operator + (const char* x, const SubString& y);
int operator==(const String& x, const String& y);
int operator!=(const String& x, const String& y);
int operator> (const String& x, const String& y);
int operator>=(const String& x, const String& y);
int operator< (const String& x, const String& y);
int operator<=(const String& x, const String& y);
int operator==(const String& x, const SubString& y);
int operator!=(const String& x, const SubString& y);
int operator> (const String& x, const SubString& y);
int operator>=(const String& x, const SubString& y);
int operator< (const String& x, const SubString& y);
int operator<=(const String& x, const SubString& y);
int operator==(const String& x, const char* t);
int operator!=(const String& x, const char* t);
int operator> (const String& x, const char* t);
int operator>=(const String& x, const char* t);
int operator< (const String& x, const char* t);
int operator<=(const String& x, const char* t);
int operator==(const SubString& x, const String& y);
int operator!=(const SubString& x, const String& y);
int operator> (const SubString& x, const String& y);
int operator>=(const SubString& x, const String& y);
int operator< (const SubString& x, const String& y);
int operator<=(const SubString& x, const String& y);
int operator==(const SubString& x, const SubString& y);
int operator!=(const SubString& x, const SubString& y);
int operator> (const SubString& x, const SubString& y);
int operator>=(const SubString& x, const SubString& y);
int operator< (const SubString& x, const SubString& y);
int operator<=(const SubString& x, const SubString& y);
int operator==(const SubString& x, const char* t);
int operator!=(const SubString& x, const char* t);
int operator> (const SubString& x, const char* t);
int operator>=(const SubString& x, const char* t);
int operator< (const SubString& x, const char* t);
int operator<=(const SubString& x, const char* t);
// status reports, needed before defining other things
inline unsigned int String::length() const { return rep->len; }
inline int String::empty() const { return rep->len == 0; }
inline const char* String::chars() const { return &(rep->s[0]); }
inline int String::allocation() const { return rep->sz; }
inline void String::alloc(int newsize) { rep = Sresize(rep, newsize); }
inline unsigned int SubString::length() const { return len; }
inline int SubString::empty() const { return len == 0; }
inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
// constructors
inline String::String()
: rep(&_nilStrRep) {}
inline String::String(const String& x)
: rep(Scopy(0, x.rep)) {}
inline String::String(const char* t)
: rep(Salloc(0, t, -1, -1)) {}
inline String::String(const char* t, int tlen)
: rep(Salloc(0, t, tlen, tlen)) {}
inline String::String(const SubString& y)
: rep(Salloc(0, y.chars(), y.length(), y.length())) {}
inline String::String(char c)
: rep(Salloc(0, &c, 1, 1)) {}
inline String::~String() { if (rep != &_nilStrRep) delete rep; }
inline SubString::SubString(const SubString& x)
:S(x.S), pos(x.pos), len(x.len) {}
inline SubString::SubString(String& x, int first, int l)
:S(x), pos(first), len(l) {}
inline SubString::~SubString() {}
// assignment
inline void String::operator = (const String& y)
{
rep = Scopy(rep, y.rep);
}
inline void String::operator=(const char* t)
{
rep = Salloc(rep, t, -1, -1);
}
inline void String::operator=(const SubString& y)
{
rep = Salloc(rep, y.chars(), y.length(), y.length());
}
inline void String::operator=(char c)
{
rep = Salloc(rep, &c, 1, 1);
}
inline void SubString::operator = (const char* ys)
{
assign(0, ys);
}
inline void SubString::operator = (char ch)
{
assign(0, &ch, 1);
}
inline void SubString::operator = (const String& y)
{
assign(y.rep, y.chars(), y.length());
}
inline void SubString::operator = (const SubString& y)
{
assign(y.S.rep, y.chars(), y.length());
}
// Zillions of cats...
inline void cat(const String& x, const String& y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& x, const char* y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
}
inline void cat(const String& x, char y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
}
inline void cat(const SubString& x, const String& y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const SubString& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const SubString& x, const char* y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
}
inline void cat(const SubString& x, char y, String& r)
{
r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
}
inline void cat(const char* x, const String& y, String& r)
{
r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
}
inline void cat(const char* x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
}
inline void cat(const char* x, const char* y, String& r)
{
r.rep = Scat(r.rep, x, -1, y, -1);
}
inline void cat(const char* x, char y, String& r)
{
r.rep = Scat(r.rep, x, -1, &y, 1);
}
inline void cat(const String& a, const String& x, const String& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& a, const String& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& a, const String& x, const char* y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
}
inline void cat(const String& a, const String& x, char y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
}
inline void cat(const String& a, const SubString& x, const String& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const String& a, const SubString& x, const char* y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
}
inline void cat(const String& a, const SubString& x, char y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
}
inline void cat(const String& a, const char* x, const String& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
}
inline void cat(const String& a, const char* x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
}
inline void cat(const String& a, const char* x, const char* y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
}
inline void cat(const String& a, const char* x, char y, String& r)
{
r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
}
inline void cat(const char* a, const String& x, const String& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const char* a, const String& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const char* a, const String& x, const char* y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
}
inline void cat(const char* a, const String& x, char y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
}
inline void cat(const char* a, const SubString& x, const String& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
}
inline void cat(const char* a, const SubString& x, const char* y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
}
inline void cat(const char* a, const SubString& x, char y, String& r)
{
r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
}
inline void cat(const char* a, const char* x, const String& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
}
inline void cat(const char* a, const char* x, const SubString& y, String& r)
{
r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
}
inline void cat(const char* a, const char* x, const char* y, String& r)
{
r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
}
inline void cat(const char* a, const char* x, char y, String& r)
{
r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
}
// operator versions
inline void String::operator +=(const String& y)
{
cat(*this, y, *this);
}
inline void String::operator +=(const SubString& y)
{
cat(*this, y, *this);
}
inline void String::operator += (const char* y)
{
cat(*this, y, *this);
}
inline void String:: operator +=(char y)
{
cat(*this, y, *this);
}
// constructive concatenation
inline String operator + (const String& x, const String& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const String& x, const SubString& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const String& x, const char* y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const String& x, char y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const SubString& x, const String& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const SubString& x, const SubString& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const SubString& x, const char* y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const SubString& x, char y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const char* x, const String& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String operator + (const char* x, const SubString& y) return r; // { dg-error "" }
{
cat(x, y, r); // { dg-error "" }
}
inline String reverse(const String& x) return r; // { dg-error "" }
{
r.rep = Sreverse(x.rep, r.rep); // { dg-error "" }
}
inline String upcase(const String& x) return r; // { dg-error "" }
{
r.rep = Supcase(x.rep, r.rep); // { dg-error "" }
}
inline String downcase(const String& x) return r; // { dg-error "" }
{
r.rep = Sdowncase(x.rep, r.rep); // { dg-error "" }
}
inline String capitalize(const String& x) return r; // { dg-error "" }
{
r.rep = Scapitalize(x.rep, r.rep); // { dg-error "" }
}
//# 883 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h"
// prepend
inline void String::prepend(const String& y)
{
rep = Sprepend(rep, y.chars(), y.length());
}
inline void String::prepend(const char* y)
{
rep = Sprepend(rep, y, -1);
}
inline void String::prepend(char y)
{
rep = Sprepend(rep, &y, 1);
}
inline void String::prepend(const SubString& y)
{
rep = Sprepend(rep, y.chars(), y.length());
}
// misc transformations
inline void String::reverse()
{
rep = Sreverse(rep, rep);
}
inline void String::upcase()
{
rep = Supcase(rep, rep);
}
inline void String::downcase()
{
rep = Sdowncase(rep, rep);
}
inline void String::capitalize()
{
rep = Scapitalize(rep, rep);
}
// element extraction
inline char& String::operator [] (int i)
{
if (((unsigned)i) >= length()) error("invalid index");
return rep->s[i];
}
inline char String::elem (int i) const
{
if (((unsigned)i) >= length()) error("invalid index");
return rep->s[i];
}
inline char String::firstchar() const
{
return elem(0);
}
inline char String::lastchar() const
{
return elem(length() - 1);
}
// searching
inline int String::index(char c, int startpos) const
{
return search(startpos, length(), c);
}
inline int String::index(const char* t, int startpos) const
{
return search(startpos, length(), t);
}
inline int String::index(const String& y, int startpos) const
{
return search(startpos, length(), y.chars(), y.length());
}
inline int String::index(const SubString& y, int startpos) const
{
return search(startpos, length(), y.chars(), y.length());
}
inline int String::index(const Regex& r, int startpos) const
{
int unused; return r.search(chars(), length(), unused, startpos);
}
inline int String::contains(char c) const
{
return search(0, length(), c) >= 0;
}
inline int String::contains(const char* t) const
{
return search(0, length(), t) >= 0;
}
inline int String::contains(const String& y) const
{
return search(0, length(), y.chars(), y.length()) >= 0;
}
inline int String::contains(const SubString& y) const
{
return search(0, length(), y.chars(), y.length()) >= 0;
}
inline int String::contains(char c, int p) const
{
return match(p, length(), 0, &c, 1) >= 0;
}
inline int String::contains(const char* t, int p) const
{
return match(p, length(), 0, t) >= 0;
}
inline int String::contains(const String& y, int p) const
{
return match(p, length(), 0, y.chars(), y.length()) >= 0;
}
inline int String::contains(const SubString& y, int p) const
{
return match(p, length(), 0, y.chars(), y.length()) >= 0;
}
inline int String::contains(const Regex& r) const
{
int unused; return r.search(chars(), length(), unused, 0) >= 0;
}
inline int String::contains(const Regex& r, int p) const
{
return r.match(chars(), length(), p) >= 0;
}
inline int String::matches(const SubString& y, int p) const
{
return match(p, length(), 1, y.chars(), y.length()) >= 0;
}
inline int String::matches(const String& y, int p) const
{
return match(p, length(), 1, y.chars(), y.length()) >= 0;
}
inline int String::matches(const char* t, int p) const
{
return match(p, length(), 1, t) >= 0;
}
inline int String::matches(char c, int p) const
{
return match(p, length(), 1, &c, 1) >= 0;
}
inline int String::matches(const Regex& r, int p) const
{
int l = (p < 0)? -p : length() - p;
return r.match(chars(), length(), p) == l;
}
inline int SubString::contains(const char* t) const
{
return S.search(pos, pos+len, t) >= 0;
}
inline int SubString::contains(const String& y) const
{
return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
}
inline int SubString::contains(const SubString& y) const
{
return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
}
inline int SubString::contains(char c) const
{
return S.search(pos, pos+len, 0, c) >= 0;
}
inline int SubString::contains(const Regex& r) const
{
int unused; return r.search(chars(), len, unused, 0) >= 0;
}
inline int SubString::matches(const Regex& r) const
{
return r.match(chars(), len, 0) == len;
}
inline int String::gsub(const String& pat, const String& r)
{
return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
}
inline int String::gsub(const SubString& pat, const String& r)
{
return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
}
inline int String::gsub(const Regex& pat, const String& r)
{
return _gsub(pat, r.chars(), r.length());
}
inline int String::gsub(const char* pat, const String& r)
{
return _gsub(pat, -1, r.chars(), r.length());
}
inline int String::gsub(const char* pat, const char* r)
{
return _gsub(pat, -1, r, -1);
}
inline ostream& operator<<(ostream& s, const String& x)
{
s << x.chars(); return s;
}
// a zillion comparison operators
inline int operator==(const String& x, const String& y)
{
return compare(x, y) == 0;
}
inline int operator!=(const String& x, const String& y)
{
return compare(x, y) != 0;
}
inline int operator>(const String& x, const String& y)
{
return compare(x, y) > 0;
}
inline int operator>=(const String& x, const String& y)
{
return compare(x, y) >= 0;
}
inline int operator<(const String& x, const String& y)
{
return compare(x, y) < 0;
}
inline int operator<=(const String& x, const String& y)
{
return compare(x, y) <= 0;
}
inline int operator==(const String& x, const SubString& y)
{
return compare(x, y) == 0;
}
inline int operator!=(const String& x, const SubString& y)
{
return compare(x, y) != 0;
}
inline int operator>(const String& x, const SubString& y)
{
return compare(x, y) > 0;
}
inline int operator>=(const String& x, const SubString& y)
{
return compare(x, y) >= 0;
}
inline int operator<(const String& x, const SubString& y)
{
return compare(x, y) < 0;
}
inline int operator<=(const String& x, const SubString& y)
{
return compare(x, y) <= 0;
}
inline int operator==(const String& x, const char* t)
{
return compare(x, t) == 0;
}
inline int operator!=(const String& x, const char* t)
{
return compare(x, t) != 0;
}
inline int operator>(const String& x, const char* t)
{
return compare(x, t) > 0;
}
inline int operator>=(const String& x, const char* t)
{
return compare(x, t) >= 0;
}
inline int operator<(const String& x, const char* t)
{
return compare(x, t) < 0;
}
inline int operator<=(const String& x, const char* t)
{
return compare(x, t) <= 0;
}
inline int operator==(const SubString& x, const String& y)
{
return compare(y, x) == 0;
}
inline int operator!=(const SubString& x, const String& y)
{
return compare(y, x) != 0;
}
inline int operator>(const SubString& x, const String& y)
{
return compare(y, x) < 0;
}
inline int operator>=(const SubString& x, const String& y)
{
return compare(y, x) <= 0;
}
inline int operator<(const SubString& x, const String& y)
{
return compare(y, x) > 0;
}
inline int operator<=(const SubString& x, const String& y)
{
return compare(y, x) >= 0;
}
inline int operator==(const SubString& x, const SubString& y)
{
return compare(x, y) == 0;
}
inline int operator!=(const SubString& x, const SubString& y)
{
return compare(x, y) != 0;
}
inline int operator>(const SubString& x, const SubString& y)
{
return compare(x, y) > 0;
}
inline int operator>=(const SubString& x, const SubString& y)
{
return compare(x, y) >= 0;
}
inline int operator<(const SubString& x, const SubString& y)
{
return compare(x, y) < 0;
}
inline int operator<=(const SubString& x, const SubString& y)
{
return compare(x, y) <= 0;
}
inline int operator==(const SubString& x, const char* t)
{
return compare(x, t) == 0;
}
inline int operator!=(const SubString& x, const char* t)
{
return compare(x, t) != 0;
}
inline int operator>(const SubString& x, const char* t)
{
return compare(x, t) > 0;
}
inline int operator>=(const SubString& x, const char* t)
{
return compare(x, t) >= 0;
}
inline int operator<(const SubString& x, const char* t)
{
return compare(x, t) < 0;
}
inline int operator<=(const SubString& x, const char* t)
{
return compare(x, t) <= 0;
}
// a helper needed by at, before, etc.
inline SubString String::_substr(int first, int l)
{
if (first >= length() ) // ??? THIS LINE IS QUESTIONABLE
return SubString(_nilString, 0, 0) ;
else
return SubString(*this, first, l);
}
//# 26 "../../GctSymbol.h" 2
//# 1 "../../../../../../mips/include/Gct/Object/GctHashObject.h" 1
// -*- C++ -*-
//
// GctHashObject class (is abstract)
//
// Expects to be included by Object.h or where needed explicitly.
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 1 "../../../../../../mips/include/Gct/Object/GctObject.h" 1
// -*- C++ -*-
//
// GctObject class (is abstract)
//
// Expects to be included by Object.h or where needed explicitly.
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
// -*- C++ -*-
//
// tostrstream class
//
// A terminated oststream - an ostsrstream that auto-terminates on str()
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 1
// This is part of the iostream library, providing input/output for C++.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
// This is part of the iostream library, providing -*- C++ -*- input/output.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
//# 23 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 2
class strstreambuf : public streambuf {
size_t *lenp; /* current (logical) length (i.e. valid data bytes) */
size_t *sizep; /* allocated (physical) buffer size */
char **bufp;
size_t _len;
size_t _size;
char *buf;
int _frozen;
protected:
virtual int overflow(int = (-1) );
public:
strstreambuf();
strstreambuf(int initial);
strstreambuf(char *ptr, int size, char *pstart = (__null) );
~strstreambuf();
int frozen() { return _frozen; }
void freeze(int n=1) { _frozen = n != 0; }
size_t pcount();
char *str();
};
class istrstream : public istream {
public:
istrstream(char*);
istrstream(char*, int);
strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
};
class ostrstream : public ostream {
public:
ostrstream();
ostrstream(char *cp, int n, int mode=ios::out);
size_t pcount() { return ((strstreambuf*)_strbuf)->pcount(); }
char *str() { return ((strstreambuf*)_strbuf)->str(); }
void freeze(int n = 1) { ((strstreambuf*)_strbuf)->freeze(n); }
int frozen() { return ((strstreambuf*)_strbuf)->frozen(); }
strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
};
//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 2
//
// tostrstream class
//
// An isteam class that doesn't have that nasty skipws parameter that
// you have to remember to set. This class simply provides the istream
// functionality with a set of constructors which defaults skipws to
// FALSE (instead of defaulting to TRUE as is the case with plain istream).
//
class tostrstream: public ostrstream {
public:
tostrstream(): ostrstream()
{ }
// This constructor defines cp as the buffer to use for the
// stream (instead of one of its own devising); it does NOT
// initialize the ostrstream to contain cp (of length n).
tostrstream(char *cp, int n, int mode=ios::out): ostrtream(cp, n, mode) // { dg-error "" }
{ }
char *str()
{
char *s = ostrstream::str();
s[ostrstream::pcount()] = '\0';
return s;
}
};
//# 25 "../../../../../../mips/include/Gct/Object/GctObject.h" 2
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 1
// -*- C++ -*-
//
// GttObject class (is abstract)
//
// Expects to be included where needed explicitly.
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
// -*- C++ -*-
//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 1
// -*- C++ -*-
//
// GttErrorHandler class
//
// Expects to be included by Gtt.h
//
// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
//
//#pragma interface
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 1
// -*- C++ -*-
//
// Fake up a libstuff++
//
// This is done as a complete and utter hack; this library has no function
// at all being in the boot area; it is here solely in order to provide a
// libstuff++ against which the Makefiles can resolve link lines.
//
// The only reason that this is done is to allow the STANDARD_C++_LIBRARIES
// as provided by the Makefile templates in the boot area to be the same
// ones that are used by the tools outside this hierarchy.
//
// The tools outside this hierarchy use a different libstuff++; one that is
// written in C++. This one is not written in C++ in order to be simpler.
//
//#pragma interface
extern "C" {
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 1
/*
* Useful stuff
*/
/*
*/
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/ansi.h" 1
/*
* ANSI Compiler Support
*
* David Harrison
* University of California, Berkeley
* 1988
*
* ANSI compatible compilers are supposed to define the preprocessor
* directive __STDC__. Based on this directive, this file defines
* certain ANSI specific macros.
*
* ARGS:
* Used in function prototypes. Example:
* extern int foo
* ARGS((char *blah, double threshold));
*/
/*
*
* Modifications
* Wendell C Baker
* University of California, Berkeley
*/
/* Function prototypes */
//# 15 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
/*
* If g++, then we stub out part of this thing and let the C++ types take
* over and do the same job; some compatibility must be given however
*/
/*
* Use the GNU libg++ definition
*/
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
//# 26 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
//# 35 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
/*
* Make various pieces of C code that use the old ``Boolean''
* be compatible by faking up the definition of Boolean using
* the new bool type.
*/
//# 58 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
typedef long FitAny; /* can fit any integral type */
/*
* typedef char *String; - DO NOT USE THIS - it conflicts with C++
* typedef char **Stringv; - just use char* and char** instead.
* - void* can be used for arbitrary pointers
*/
extern int nocase_strcmp (char *, char *) ;
extern int nocase_strncmp (char *, char *, int) ;
extern bool nocase_strequal (char *, char *) ;
extern bool nocase_strnequal (char *, char *, int) ;
extern bool lead_strequal (char *, char *) ;
extern bool nocase_lead_strequal (char *, char *) ;
extern int strhash (char *, int) ;
extern int nocase_strhash (char *, int) ;
extern int sign (int) ;
/*
* Some useful macros.
*/
//# 33 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
}
//
// This is here because we wish to provide externs for the two
// functions btoa(bool, unsigned = 0) and operator<<(ostream&, bool)
// because they are not provided in bool.h.
//
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
//# 41 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
extern const char *stringify(bool b);
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
// This is part of the iostream library, providing -*- C++ -*- input/output.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
//# 43 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
extern ostream& operator<<(ostream&, bool);
// Should this be kept separate? bool isn't, but then is
// included here only to define ostream& operator<<(ostream&, bool)
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 1
// -*- C++ -*-
//
// unit enum
//
// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
//
//
// unit enum
//
// This _looks_ silly, but it has an important theoretical basis in category
// theory. For the pragmatic reason for its existence, see the example below.
//
enum unit {
UNIT = 1,
};
extern const char *stringify(unit u);
//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
// This is part of the iostream library, providing -*- C++ -*- input/output.
// Copyright (C) 1991 Per Bothner.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 2
extern ostream& operator<<(ostream&, unit);
//
// A unit is used in cases where the type signature of an overloaded
// function must be differentiated in some stronger way than can be
// denoted unambiguously in the C++ syntax. This enum is used to give
// one of the functions a different type signature, thereby allowing
// the overloading.
//
// The use of ``unit'' instead of int or bool is important because a unit
// has only one possible value; therefore it adds no more information to
// the code. For example, say a bool was used instead, then in the testing
// phase, would have to ask: what if TRUE was given, what if FALSE was given.
// The problem is compounded if char or int is used.
//
// Example:
//
// class ID {
// public:
// ID(); // construct a null ID
// ID(unit); // alloc a ID with a new id
// private:
// static unsigned high_water;
// unsigned id;
// };
//
// Try working this example save that ID implements all of the generic
// features of the identifier object, but the high_water is stored
// in the heir. That is what originally motivated the creation of unit.
//
//# 48 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
//
// In the spirit of the standard GNU error handler functions
// as described in
// typedef void (*one_arg_error_handler_t)(const char*);
// a one argument error handler function pointer
// typedef void (*two_arg_error_handler_t)(const char*, const char*);
// a two argument error handler function pointer
//
// And now the NEW
//
// typedef void (*zero_arg_error_handler_t)();
// a zero argument error handler function pointer
//
typedef void (*zero_arg_error_handler_t)();
//
// In the spirit of the default GNU error handler functions
// as described in
// extern void default_one_arg_error_handler(const char *message);
// print out message on stderr, and do the default thing (abort)
// extern void default_two_arg_error_handler(const char *kind, const char *message);
// print out kind and message on stderr, and do the default thing (abort)
//
// And now the NEW
//
// extern void default_zero_arg_error_handler(const char *message);
// do the default thing (abort)
//
extern void default_zero_arg_error_handler();
// Guaranteed to exit (1)
extern void exit_zero_arg_error_handler();
extern void exit_one_arg_error_handler(const char *message);
extern void exit_two_arg_error_handler(const char *kind, const char *message);
// Guaranteed to abort()
extern void abort_zero_arg_error_handler();
extern void abort_one_arg_error_handler(const char *message);
extern void abort_two_arg_error_handler(const char *kind, const char *message);
//
// In the spirit of the standard GNU error handlers
// as described in
// extern void verbose_File_error_handler(const char*);
// perror and set errno = 0
// extern void quiet_File_error_handler(const char*);
// set errno = 0
// extern void fatal_File_error_handler(const char*);
// perror and exit 1
//
// And now the NEW
//
// extern void preserve_File_error_handler(const char *message);
// no perror, no assignment to errno.
//
extern void preserve_File_error_handler(const char *message);
//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
// -*- C++ -*-
//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
//
// It is expected that this will be virtually multiply inherited
// into all of the classes that need error reporting services.
//
// The typical way to have that done is by inheriting the GttObject
// as a virtual base class.
//
//
// GttErrorHandler class
//
class GttErrorHandler {
public:
GttErrorHandler();
GttErrorHandler(const char *program);
virtual ~GttErrorHandler();
//
// Error messages
// - an unacceptable, but expected and recoverable condition
// was detected (but the test fails)
// - errors are for ``the expected environment was not found''
// rather than for ``file couldn't be opened''
// - these messages cannot be shut off
// - the error handler determines the recovery action
// TODO - one day exceptions will be used here
//
static void error(const char *message);
static void error(tostrstream& message);
static void error(const char *function, const char *message);
static void error(const char *function, tostrstream& message);
static void error(const char *class_name, const char *method, const char *message);
static void error(const char *class_name, const char *method, tostrstream& message);
//
// Fatal messages
// - an unacceptable and unexpected error was detected
// the data invariants were violated, there is no recovery
// - these messages cannot be shut off
// - the error handler determines the recovery action
// TODO - one day exceptions will be used here
//
static void fatal(const char *message);
static void fatal(tostrstream& message);
static void fatal(const char *function, const char *message);
static void fatal(const char *function, tostrstream& message);
static void fatal(const char *class_name, const char *method, const char *message);
static void fatal(const char *class_name, const char *method, tostrstream& message);
private:
//
// Two underscores are used here in order to prevent confusion of these
// private variables with any of the heir's private variables. Note that
// access control is different than visibility in C++, so all the variable
// names in a class hierarchy must be unique.
//
static bool __partial_init;
static void __partial_initialize();
static bool __full_init;
static void __full_initialize(const char *program);
static char *__program;
static void __handle_error();
static void __handle_fatal();
static void __add_newline(const char *message);
static bool __output_valid();
static ostream *__output;
};
//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
//
// GttObject class (is abstract)
//
class GttObject: virtual public GttErrorHandler {
protected:
GttObject();
GttObject(const GttObject&);
virtual ~GttObject(); // ensure descendants have virtual destructors
public:
//
// I/O Support
//
// The value typically persists only long enough for an i/o operation
// to be performed (see the defintion of output via operator<<(... ) below)
virtual const char *stringify();
protected:
// This is the buffer into which the printed representation of this
// object will be put when the time comes. It is associated with the
// object so it will never go away (so long as the object exists).
// Use a pointer so that you only pay for the space when I/O is used
tostrstream *stringbuf;
void clear_stringbuf();
public:
//
// Consistency
//
// The global data invariant for the whole object (heirs included).
// This OK function will call the local invariant function ok() if
// necessary and in addition the OK functions of the heirs
// This is expected to compute the data invariant of the object.
// It will execute GctErrorHandler::fatal if there is wrong.
virtual void OK() const;
protected:
//
// consistency
//
// This function computes the invariant which is local to this object.
// It does not call any of the ancestor's OK() or ok() functions.
// It is not a virtual function so that it can be called from within a
// constructor with impunity. Thus this function MUST NOT call an