BUG: egcs 971008: No member template `simple_alloc' ...
Joseph Heled
pepe@iconz.co.nz
Thu Oct 16 23:09:00 GMT 1997
This simple program:
-----------------------------------
#include <vector>
template <class T>
void
del(vector<T*>* const v)
{
delete v;
}
template <>
void
del(vector<char*>* const args)
{
delete args;
}
-----------------------------------
generates lots of errors. I enclose 2 outputs, one with libg++-2.8.0 (b6), the
second with stl in egsc.
thanks, pepe
***** Program source:
#include <vector>
template <class T>
void
del(vector<T*>* const v)
{
delete v;
}
template <>
void
del(vector<char*>* const args)
{
delete args;
}
***** Program source after cpp:
# 1 "b2.cc"
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/vector" 1
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h" 1
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 1 3 4
# 61 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
typedef int ptrdiff_t;
typedef unsigned int size_t;
typedef unsigned int wint_t;
# 302 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
# 30 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 1
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/string.h" 1 3 4
#pragma ident "@(#)string.h 1.17 95/08/28 SMI"
# 1 "/usr/include/sys/feature_tests.h" 1 3 4
#pragma ident "@(#)feature_tests.h 1.7 94/12/06 SMI"
extern "C" {
}
# 13 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/string.h" 2 3 4
extern "C" {
extern void *memcpy(void *, const void *, size_t);
extern void *memmove(void *, const void *, size_t);
extern char *strcpy(char *, const char *);
extern char *strncpy(char *, const char *, size_t);
extern char *strcat(char *, const char *);
extern char *strncat(char *, const char *, size_t);
extern int memcmp(const void *, const void *, size_t);
extern int strcmp(const char *, const char *);
extern int strcoll(const char *, const char *);
extern int strncmp(const char *, const char *, size_t);
extern size_t strxfrm(char *, const char *, size_t);
extern void *memchr(const void *, int, size_t);
extern char *strchr(const char *, int);
extern size_t strcspn(const char *, const char *);
extern char *strpbrk(const char *, const char *);
extern char *strrchr(const char *, int);
extern size_t strspn(const char *, const char *);
extern char *strstr(const char *, const char *);
extern char *strtok(char *, const char *);
extern void *memset(void *, int, size_t);
extern char *strerror(int);
extern size_t strlen(const char *);
extern void *memccpy(void *, const void *, int, size_t);
extern char *strdup(const char *);
extern char *strsignal(int);
extern int ffs(const int);
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, size_t);
# 119 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/string.h" 3 4
}
# 30 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/limits.h" 1 3 4
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/syslimits.h" 1 3 4
#pragma ident "@(#)limits.h 1.26 95/08/24 SMI"
extern "C" {
extern long _sysconf(int);
}
# 11 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/limits.h" 2 3 4
# 31 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/function.h" 1
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 1 3 4
# 327 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
# 30 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/function.h" 2
template <class T1, class T2>
inline bool operator!=(const T1& x, const T2& y) {
return !(x == y);
}
template <class T1, class T2>
inline bool operator>(const T1& x, const T2& y) {
return y < x;
}
template <class T1, class T2>
inline bool operator<=(const T1& x, const T2& y) {
return !(y < x);
}
template <class T1, class T2>
inline bool operator>=(const T1& x, const T2& y) {
return !(x < y);
}
template <class Arg, class Result>
struct unary_function {
typedef Arg argument_type;
typedef Result result_type;
};
template <class Arg1, class Arg2, class Result>
struct binary_function {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
template <class T>
struct plus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x + y; }
};
template <class T>
struct minus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x - y; }
};
template <class T>
struct multiplies : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x * y; }
};
template <class T>
struct divides : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x / y; }
};
template <class T>
struct modulus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x % y; }
};
template <class T>
struct negate : public unary_function<T, T> {
T operator()(const T& x) const { return -x; }
};
template <class T>
struct equal_to : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x == y; }
};
template <class T>
struct not_equal_to : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x != y; }
};
template <class T>
struct greater : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x > y; }
};
template <class T>
struct less : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x < y; }
};
template <class T>
struct greater_equal : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x >= y; }
};
template <class T>
struct less_equal : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x <= y; }
};
template <class T>
struct logical_and : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x && y; }
};
template <class T>
struct logical_or : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x || y; }
};
template <class T>
struct logical_not : public unary_function<T, bool> {
bool operator()(const T& x) const { return !x; }
};
template <class Predicate>
class unary_negate : public unary_function<typename Predicate::argument_type, bool> {
protected:
Predicate pred;
public:
unary_negate(const Predicate& x) : pred(x) {}
bool operator()(const argument_type& x) const { return !pred(x); }
};
template <class Predicate>
unary_negate<Predicate> not1(const Predicate& pred) {
return unary_negate<Predicate>(pred);
}
template <class Predicate>
class binary_negate
: public binary_function<typename Predicate::first_argument_type,
typename Predicate::second_argument_type, bool> {
protected:
Predicate pred;
public:
binary_negate(const Predicate& x) : pred(x) {}
bool operator()(const first_argument_type& x,
const second_argument_type& y) const {
return !pred(x, y);
}
};
template <class Predicate>
binary_negate<Predicate> not2(const Predicate& pred) {
return binary_negate<Predicate>(pred);
}
template <class Operation>
class binder1st : public unary_function<typename Operation::second_argument_type,
typename Operation::result_type> {
protected:
Operation op;
typename Operation::first_argument_type value;
public:
binder1st(const Operation& x, const typename Operation::first_argument_type& y)
: op(x), value(y) {}
result_type operator()(const argument_type& x) const {
return op(value, x);
}
};
template <class Operation, class T>
binder1st<Operation> bind1st(const Operation& op, const T& x) {
return binder1st<Operation>(op, typename Operation::first_argument_type(x));
}
template <class Operation>
class binder2nd : public unary_function<typename Operation::first_argument_type,
typename Operation::result_type> {
protected:
Operation op;
typename Operation::second_argument_type value;
public:
binder2nd(const Operation& x, const typename Operation::second_argument_type& y)
: op(x), value(y) {}
result_type operator()(const argument_type& x) const {
return op(x, value);
}
};
template <class Operation, class T>
binder2nd<Operation> bind2nd(const Operation& op, const T& x) {
return binder2nd<Operation>(op, typename Operation::second_argument_type(x));
}
template <class Operation1, class Operation2>
class unary_compose : public unary_function<typename Operation2::argument_type,
typename Operation1::result_type> {
protected:
Operation1 op1;
Operation2 op2;
public:
unary_compose(const Operation1& x, const Operation2& y) : op1(x), op2(y) {}
result_type operator()(const argument_type& x) const {
return op1(op2(x));
}
};
template <class Operation1, class Operation2>
unary_compose<Operation1, Operation2> compose1(const Operation1& op1,
const Operation2& op2) {
return unary_compose<Operation1, Operation2>(op1, op2);
}
template <class Operation1, class Operation2, class Operation3>
class binary_compose : public unary_function<typename Operation2::argument_type,
typename Operation1::result_type> {
protected:
Operation1 op1;
Operation2 op2;
Operation3 op3;
public:
binary_compose(const Operation1& x, const Operation2& y,
const Operation3& z) : op1(x), op2(y), op3(z) { }
result_type operator()(const argument_type& x) const {
return op1(op2(x), op3(x));
}
};
template <class Operation1, class Operation2, class Operation3>
binary_compose<Operation1, Operation2, Operation3>
compose2(const Operation1& op1, const Operation2& op2, const Operation3& op3) {
return binary_compose<Operation1, Operation2, Operation3>(op1, op2, op3);
}
template <class Arg, class Result>
class pointer_to_unary_function : public unary_function<Arg, Result> {
protected:
Result (*ptr)(Arg);
public:
pointer_to_unary_function() {}
pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {}
Result operator()(Arg x) const { return ptr(x); }
};
template <class Arg, class Result>
pointer_to_unary_function<Arg, Result> ptr_fun(Result (*x)(Arg)) {
return pointer_to_unary_function<Arg, Result>(x);
}
template <class Arg1, class Arg2, class Result>
class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> {
protected:
Result (*ptr)(Arg1, Arg2);
public:
pointer_to_binary_function() {}
pointer_to_binary_function(Result (*x)(Arg1, Arg2)) : ptr(x) {}
Result operator()(Arg1 x, Arg2 y) const { return ptr(x, y); }
};
template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1, Arg2, Result>
ptr_fun(Result (*x)(Arg1, Arg2)) {
return pointer_to_binary_function<Arg1, Arg2, Result>(x);
}
template <class T>
struct identity : public unary_function<T, T> {
const T& operator()(const T& x) const { return x; }
};
template <class Pair>
struct select1st : public unary_function<Pair, typename Pair::first_type> {
const typename Pair::first_type& operator()(const Pair& x) const
{
return x.first;
}
};
template <class Pair>
struct select2nd : public unary_function<Pair, typename Pair::second_type> {
const typename Pair::second_type& operator()(const Pair& x) const
{
return x.second;
}
};
template <class Arg1, class Arg2>
struct project1st : public binary_function<Arg1, Arg2, Arg1> {
Arg1 operator()(const Arg1& x, const Arg2&) const { return x; }
};
template <class Arg1, class Arg2>
struct project2nd : public binary_function<Arg1, Arg2, Arg2> {
Arg2 operator()(const Arg1&, const Arg2& y) const { return y; }
};
template <class Result>
struct constant_void_fun
{
typedef Result result_type;
result_type val;
constant_void_fun(const result_type& v) : val(v) {}
const result_type& operator()() const { return val; }
};
template <class Result, class Argument = Result>
struct constant_unary_fun : public unary_function<Argument, Result> {
result_type val;
constant_unary_fun(const result_type& v) : val(v) {}
const result_type& operator()(const argument_type&) const { return val; }
};
template <class Result, class Arg1 = Result, class Arg2 = Arg1>
struct constant_binary_fun : public binary_function<Arg1, Arg2, Result> {
result_type val;
constant_binary_fun(const result_type& v) : val(v) {}
const result_type& operator()(const first_argument_type&,
const second_argument_type&) const {
return val;
}
};
template <class Result>
inline constant_void_fun<Result> constant0(const Result& val)
{
return constant_void_fun<Result>(val);
}
template <class Result>
inline constant_unary_fun<Result> constant1(const Result& val)
{
return constant_unary_fun<Result>(val);
}
template <class Result>
inline constant_binary_fun<Result> constant2(const Result& val)
{
return constant_binary_fun<Result>(val);
}
class subtractive_rng : public unary_function<unsigned int, unsigned int> {
private:
unsigned int table[55];
size_t index1;
size_t index2;
public:
unsigned int operator()(unsigned int limit) {
index1 = (index1 + 1) % 55;
index2 = (index2 + 1) % 55;
table[index1] = table[index1] - table[index2];
return table[index1] % limit;
}
void initialize(unsigned int seed)
{
unsigned int k = 1;
table[54] = seed;
size_t i;
for (i = 0; i < 54; i++) {
size_t ii = (21 * (i + 1) % 55) - 1;
table[ii] = k;
k = seed - k;
seed = table[ii];
}
for (int loop = 0; loop < 4; loop++) {
for (i = 0; i < 55; i++)
table[i] = table[i] - table[(1 + i + 30) % 55];
}
index1 = 0;
index2 = 31;
}
subtractive_rng(unsigned int seed) { initialize(seed); }
subtractive_rng() { initialize(161803398u); }
};
# 32 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/pair.h" 1
template <class T1, class T2>
struct pair {
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair() {}
pair(const T1& a, const T2& b) : first(a), second(b) {}
};
template <class T1, class T2>
inline bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y) {
return x.first == y.first && x.second == y.second;
}
template <class T1, class T2>
inline bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y) {
return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
}
template <class T1, class T2>
inline pair<T1, T2> make_pair(const T1& x, const T2& y) {
return pair<T1, T2>(x, y);
}
# 33 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/iterator.h" 1
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 1 3 4
# 327 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
# 30 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/iterator.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libio/iostream.h" 1
#pragma interface
# 1 "/export/home/software/new-software/libg++-2.8.0/libio/streambuf.h" 1
#pragma interface
extern "C" {
# 1 "/export/home/software/new-software/libg++-2.8.0/libio/libio.h" 1
# 1 "/export/home/software/new-software/libg++-2.8.0/libio/_G_config.h" 1
typedef int _G_int8_t __attribute__((__mode__(__QI__)));
typedef unsigned int _G_uint8_t __attribute__((__mode__(__QI__)));
typedef int _G_int16_t __attribute__((__mode__(__HI__)));
typedef unsigned int _G_uint16_t __attribute__((__mode__(__HI__)));
typedef int _G_int32_t __attribute__((__mode__(__SI__)));
typedef unsigned int _G_uint32_t __attribute__((__mode__(__SI__)));
typedef int _G_int64_t __attribute__((__mode__(__DI__)));
typedef unsigned int _G_uint64_t __attribute__((__mode__(__DI__)));
__extension__ typedef long long _G_llong;
__extension__ typedef unsigned long long _G_ullong;
typedef long _G_clock_t;
typedef unsigned long _G_dev_t;
typedef long _G_fpos_t;
typedef long _G_gid_t;
typedef unsigned long _G_ino_t;
typedef unsigned long _G_mode_t;
typedef unsigned long _G_nlink_t;
typedef long _G_off_t;
typedef long _G_pid_t;
typedef int _G_ptrdiff_t;
typedef int _G_sigset_t;
typedef unsigned int _G_size_t;
typedef long _G_time_t;
typedef long _G_uid_t;
typedef long int _G_wchar_t;
typedef int _G_ssize_t;
typedef unsigned int _G_wint_t;
typedef void * _G_va_list;
# 30 "/export/home/software/new-software/libg++-2.8.0/libio/libio.h" 2
# 51 "/export/home/software/new-software/libg++-2.8.0/libio/libio.h"
# 95 "/export/home/software/new-software/libg++-2.8.0/libio/libio.h"
struct _IO_jump_t; struct _IO_FILE;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
# 168 "/export/home/software/new-software/libg++-2.8.0/libio/libio.h"
};
struct _IO_FILE {
int _flags;
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _blksize;
_G_off_t _offset;
unsigned short _cur_column;
char _unused;
char _shortbuf[1];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_stdin_, _IO_stdout_, _IO_stderr_;
extern "C" {
extern int __underflow (_IO_FILE*) ;
extern int __uflow (_IO_FILE*) ;
extern int __overflow (_IO_FILE*, int) ;
extern int _IO_vfscanf (_IO_FILE*, const char*, _G_va_list , int*) ;
extern int _IO_vfprintf (_IO_FILE*, const char*, _G_va_list ) ;
extern _G_ssize_t _IO_padn (_IO_FILE *, int, _G_ssize_t ) ;
extern _G_size_t _IO_sgetn (_IO_FILE *, void*, _G_size_t ) ;
extern _G_fpos_t _IO_seekoff (_IO_FILE*, _G_off_t , int, int) ;
extern _G_fpos_t _IO_seekpos (_IO_FILE*, _G_fpos_t , int) ;
extern void _IO_free_backup_area (_IO_FILE*) ;
}
# 36 "/export/home/software/new-software/libg++-2.8.0/libio/streambuf.h" 2
}
extern "C++" {
class istream;
class ostream; class streambuf;
typedef _G_off_t streamoff;
typedef _G_fpos_t streampos;
typedef _G_ssize_t streamsize;
typedef unsigned long __fmtflags;
typedef unsigned char __iostate;
struct _ios_fields
{
streambuf *_strbuf;
ostream* _tie;
int _width;
__fmtflags _flags;
short _fill;
__iostate _state;
__iostate _exceptions;
int _precision;
void *_arrays;
};
# 115 "/export/home/software/new-software/libg++-2.8.0/libio/streambuf.h"
class ios : public _ios_fields {
ios& operator=(ios&);
ios (const ios&);
public:
typedef __fmtflags fmtflags;
typedef int iostate;
typedef int openmode;
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 ,
bin = 128 ,
binary = 128 };
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= 010000 ,
unitbuf= 020000 , stdio= 040000
};
enum {
basefield=dec+oct+hex,
floatfield = scientific+fixed,
adjustfield = left+right+internal
};
# 167 "/export/home/software/new-software/libg++-2.8.0/libio/streambuf.h"
ostream* tie() const { return _tie; }
ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
short fill() const { return (short )_fill; }
short fill(short newf)
{short oldf = (short )_fill; _fill = (char)newf; return oldf;}
fmtflags flags() const { return _flags; }
fmtflags flags(fmtflags new_val) {
fmtflags old_val = _flags; _flags = new_val; return old_val; }
int precision() const { return _precision; }
int precision(int newp) {
unsigned short oldp = _precision; _precision = (unsigned short)newp;
return oldp; }
fmtflags setf(fmtflags val) {
fmtflags oldbits = _flags;
_flags |= val; return oldbits; }
fmtflags setf(fmtflags val, fmtflags mask) {
fmtflags oldbits = _flags;
_flags = (_flags & ~mask) | (val & mask); return oldbits; }
fmtflags unsetf(fmtflags mask) {
fmtflags oldbits = _flags;
_flags &= ~mask; return oldbits; }
int width() const { return _width; }
int width(int val) { int save = _width; _width = val; return save; }
void _throw_failure() const { }
void clear(iostate state = 0) {
_state = _strbuf ? state : state|badbit;
if (_state & _exceptions) _throw_failure(); }
void set(iostate flag) { _state |= flag;
if (_state & _exceptions) _throw_failure(); }
void setstate(iostate flag) { _state |= flag;
if (_state & _exceptions) _throw_failure(); }
int good() const { return _state == 0; }
int eof() const { return _state & ios::eofbit; }
int fail() const { return _state & (ios::badbit|ios::failbit); }
int bad() const { return _state & ios::badbit; }
iostate rdstate() const { return _state; }
operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
int operator!() const { return fail(); }
iostate exceptions() const { return _exceptions; }
void exceptions(iostate enable) {
_exceptions = enable;
if (_state & _exceptions) _throw_failure(); }
streambuf* rdbuf() const { return _strbuf; }
streambuf* rdbuf(streambuf *_s) {
streambuf *_old = _strbuf; _strbuf = _s; clear (); return _old; }
static int sync_with_stdio(int on);
static void sync_with_stdio() { sync_with_stdio(1); }
static fmtflags bitalloc();
static int xalloc();
void*& pword(int);
void* pword(int) const;
long& iword(int);
long iword(int) const;
class Init {
public:
Init () { }
};
protected:
inline ios(streambuf* sb = 0, ostream* tie_to = 0);
inline virtual ~ios();
inline void init(streambuf* sb, ostream* tie = 0);
};
typedef ios::seek_dir _seek_dir;
class streammarker : private _IO_marker {
friend class streambuf;
void set_offset(int offset) { _pos = offset; }
public:
streammarker(streambuf *sb);
~streammarker();
int saving() { return 1; }
int delta(streammarker&);
int delta();
};
struct streambuf : public _IO_FILE {
friend class ios;
friend class istream;
friend class ostream;
friend class streammarker;
const void *&_vtable() { return *(const void**)((_IO_FILE*)this + 1); }
protected:
static streambuf* _list_all;
_IO_FILE*& xchain() { return _chain; }
void _un_link();
void _link_in();
char* gptr() const
{ return _flags & 0x100 ? _IO_save_base : _IO_read_ptr; }
char* pptr() const { return _IO_write_ptr; }
char* egptr() const
{ return _flags & 0x100 ? _IO_save_end : _IO_read_end; }
char* epptr() const { return _IO_write_end; }
char* pbase() const { return _IO_write_base; }
char* eback() const
{ return _flags & 0x100 ? _IO_save_base : _IO_read_base;}
char* base() const { return _IO_buf_base; }
char* ebuf() const { return _IO_buf_end; }
int blen() const { return _IO_buf_end - _IO_buf_base; }
void xput_char(char c) { *_IO_write_ptr++ = c; }
int xflags() { return _flags ; }
int xflags(int f) {int fl = _flags ; _flags = f; return fl;}
void xsetflags(int f) { _flags |= f; }
void xsetflags(int f, int mask)
{ _flags = (_flags & ~mask) | (f & mask); }
void gbump(int n)
{ _flags & 0x100 ? (_IO_save_base+=n):(_IO_read_ptr+=n);}
void pbump(int n) { _IO_write_ptr += n; }
void setb(char* b, char* eb, int a=0);
void setp(char* p, char* ep)
{ _IO_write_base=_IO_write_ptr=p; _IO_write_end=ep; }
void setg(char* eb, char* g, char *eg) {
if (_flags & 0x100 ) _IO_free_backup_area(this);
_IO_read_base = eb; _IO_read_ptr = g; _IO_read_end = eg; }
char *shortbuf() { return _shortbuf; }
int in_backup() { return _flags & 0x100 ; }
char *Gbase() { return in_backup() ? _IO_save_base : _IO_read_base; }
char *eGptr() { return in_backup() ? _IO_save_end : _IO_read_end; }
char *Bbase() { return in_backup() ? _IO_read_base : _IO_save_base; }
char *Bptr() { return _IO_backup_base; }
char *eBptr() { return in_backup() ? _IO_read_end : _IO_save_end; }
char *Nbase() { return _IO_save_base; }
char *eNptr() { return _IO_save_end; }
int have_backup() { return _IO_save_base != __null ; }
int have_markers() { return _markers != __null ; }
void free_backup_area();
void unsave_markers();
int put_mode() { return _flags & 0x800 ; }
int switch_to_get_mode();
streambuf(int flags=0);
public:
static int flush_all();
static void flush_all_linebuffered();
virtual ~streambuf();
virtual int overflow(int c = (-1) );
virtual int underflow();
virtual int uflow();
virtual int pbackfail(int c);
virtual streamsize xsputn(const char* s, streamsize n);
virtual streamsize xsgetn(char* s, streamsize n);
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
streampos pubseekoff(streamoff o, _seek_dir d, int mode=ios::in|ios::out)
{ return _IO_seekoff (this, o, d, mode); }
streampos pubseekpos(streampos pos, int mode = ios::in|ios::out)
{ return _IO_seekpos (this, pos, mode); }
streampos sseekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
streampos sseekpos(streampos pos, int mode = ios::in|ios::out);
virtual streambuf* setbuf(char* p, int len);
virtual int sync();
virtual int doallocate();
int seekmark(streammarker& mark, int delta = 0);
int sputbackc(char c);
int sungetc();
int unbuffered() { return _flags & 2 ? 1 : 0; }
int linebuffered() { return _flags & 0x200 ? 1 : 0; }
void unbuffered(int i)
{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
void linebuffered(int i)
{ if (i) _flags |= 0x200 ; else _flags &= ~0x200 ; }
int allocate() {
if (base() || unbuffered()) return 0;
else return doallocate(); }
void allocbuf() { if (base() == __null ) doallocbuf(); }
void doallocbuf();
int in_avail() { return _IO_read_end - _IO_read_ptr; }
int out_waiting() { return _IO_write_ptr - _IO_write_base; }
streamsize sputn(const char* s, streamsize n) { return xsputn(s, n); }
streamsize padn(char pad, streamsize n) { return _IO_padn(this, pad, n); }
streamsize sgetn(char* s, streamsize n) { return _IO_sgetn(this, s, n); }
int ignore(int);
int get_column();
int set_column(int);
long sgetline(char* buf, _G_size_t n, char delim, int putback_delim);
int sputc(int c) { return ((( this )->_IO_write_ptr >= ( this )->_IO_write_end) ? __overflow( this , (unsigned char)( c )) : (unsigned char)(*( this )->_IO_write_ptr++ = ( c ))) ; }
int sbumpc() { return (( this )->_IO_read_ptr >= ( this )->_IO_read_end ? __uflow( this ) : *(unsigned char*)( this )->_IO_read_ptr++) ; }
int sgetc() { return (( this )->_IO_read_ptr >= ( this )->_IO_read_end && __underflow( this ) == (-1) ? (-1) : *(unsigned char*)( this )->_IO_read_ptr) ; }
int snextc() {
if (_IO_read_ptr >= _IO_read_end && __underflow(this) == (-1) )
return (-1) ;
else return _IO_read_ptr++, sgetc(); }
void stossc() { if (_IO_read_ptr < _IO_read_end) _IO_read_ptr++; }
int vscan(char const *fmt0, _G_va_list ap, ios* stream = __null );
int scan(char const *fmt0 ...);
int vform(char const *fmt0, _G_va_list ap);
int form(char const *fmt0 ...);
virtual streamsize sys_read(char* buf, streamsize size);
virtual streamsize sys_write(const char*, streamsize);
virtual streampos sys_seek(streamoff, _seek_dir);
virtual int sys_close();
virtual int sys_stat(void*);
};
class filebuf : public streambuf {
protected:
void init();
public:
static const int openprot;
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, ios::openmode mode, int prot = 0664);
virtual int underflow();
virtual int overflow(int c = (-1) );
int is_open() const { return _fileno >= 0; }
int fd() const { return is_open() ? _fileno : (-1) ; }
filebuf* close();
virtual int doallocate();
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
virtual streambuf* setbuf(char* p, int len);
streamsize xsputn(const char* s, streamsize n);
streamsize xsgetn(char* s, streamsize n);
virtual int sync();
protected:
int is_reading() { return eback() != egptr(); }
char* cur_ptr() { return is_reading() ? gptr() : pptr(); }
char* file_ptr() { return eGptr(); }
virtual streamsize sys_read(char* buf, streamsize size);
virtual streampos sys_seek(streamoff, _seek_dir);
virtual streamsize sys_write(const char*, streamsize);
virtual int sys_stat(void*);
virtual int sys_close();
};
inline void ios::init(streambuf* sb, ostream* tie_to) {
_state = sb ? ios::goodbit : ios::badbit; _exceptions=0;
_strbuf=sb; _tie = tie_to; _width=0; _fill=' ';
_flags=ios::skipws|ios::dec;
_precision=6; _arrays = 0; }
inline ios::ios(streambuf* sb, ostream* tie_to) { init(sb, tie_to); }
inline ios::~ios() {
if (_arrays) delete [] _arrays;
}
}
# 31 "/export/home/software/new-software/libg++-2.8.0/libio/iostream.h" 2
extern "C++" {
class istream; class ostream;
typedef ios& (*__manip)(ios&);
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 : virtual public ios
{
void do_osfx();
public:
ostream() { }
ostream(streambuf* sb, ostream* tied= __null );
int opfx() {
if (!good()) return 0; else { if (_tie) _tie->flush(); return 1;} }
void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
do_osfx(); }
ostream& flush();
ostream& put(char c) { _strbuf->sputc(c); return *this; }
ostream& write(const char *s, streamsize n);
ostream& write(const unsigned char *s, streamsize n)
{ return write((const char*)s, n);}
ostream& write(const signed char *s, streamsize n)
{ return write((const char*)s, n);}
ostream& write(const void *s, streamsize n)
{ return write((const char*)s, n);}
ostream& seekp(streampos);
ostream& seekp(streamoff, _seek_dir);
streampos tellp();
ostream& form(const char *format ...);
ostream& vform(const char *format, _G_va_list args);
ostream& operator<<(char c);
ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
ostream& operator<<(signed char c) { return (*this) << (char)c; }
ostream& operator<<(const char *s);
ostream& operator<<(const unsigned char *s)
{ return (*this) << (const char*)s; }
ostream& operator<<(const signed char *s)
{ return (*this) << (const char*)s; }
ostream& operator<<(const void *p);
ostream& operator<<(int n);
ostream& operator<<(unsigned int n);
ostream& operator<<(long n);
ostream& operator<<(unsigned long n);
__extension__ ostream& operator<<(long long n);
__extension__ ostream& operator<<(unsigned long long n);
ostream& operator<<(short n) {return operator<<((int)n);}
ostream& operator<<(unsigned short n) {return operator<<((unsigned int)n);}
ostream& operator<<(bool b) { return operator<<((int)b); }
ostream& operator<<(double n);
ostream& operator<<(float n) { return operator<<((double)n); }
ostream& operator<<(long double n) { return operator<<((double)n); }
ostream& operator<<(__omanip func) { return (*func)(*this); }
ostream& operator<<(__manip func) {(*func)(*this); return *this;}
ostream& operator<<(streambuf*);
};
class istream : virtual public ios
{
protected:
_G_size_t _gcount;
int _skip_ws();
public:
istream() { _gcount = 0; }
istream(streambuf* sb, ostream*tied= __null );
istream& get(char* ptr, int len, char delim = '\n');
istream& get(unsigned char* ptr, int len, char delim = '\n')
{ return get((char*)ptr, len, delim); }
istream& get(char& c);
istream& get(unsigned char& c) { return get((char&)c); }
istream& getline(char* ptr, int len, char delim = '\n');
istream& getline(unsigned char* ptr, int len, char delim = '\n')
{ return getline((char*)ptr, len, delim); }
istream& get(signed char& c) { return get((char&)c); }
istream& get(signed char* ptr, int len, char delim = '\n')
{ return get((char*)ptr, len, delim); }
istream& getline(signed char* ptr, int len, char delim = '\n')
{ return getline((char*)ptr, len, delim); }
istream& read(char *ptr, streamsize n);
istream& read(unsigned char *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& read(signed char *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& read(void *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& get(streambuf& sb, char delim = '\n');
istream& gets(char **s, char delim = '\n');
int ipfx(int need = 0) {
if (!good()) { set(ios::failbit); return 0; }
else {
if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
if (!need && (flags() & ios::skipws)) return _skip_ws();
else return 1;
}
}
int ipfx0() {
if (!good()) { set(ios::failbit); return 0; }
else {
if (_tie) _tie->flush();
if (flags() & ios::skipws) return _skip_ws();
else return 1;
}
}
int ipfx1() {
if (!good()) { set(ios::failbit); return 0; }
else {
if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
return 1;
}
}
void isfx() { }
int get() { if (!ipfx1()) return (-1) ;
else { int ch = _strbuf->sbumpc();
if (ch == (-1) ) set(ios::eofbit);
return ch;
} }
int peek();
_G_size_t gcount() { return _gcount; }
istream& ignore(int n=1, int delim = (-1) );
int sync ();
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& scan(const char *format ...);
istream& vscan(const char *format, _G_va_list args);
istream& operator>>(char*);
istream& operator>>(unsigned char* p) { return operator>>((char*)p); }
istream& operator>>(signed char*p) { return operator>>((char*)p); }
istream& operator>>(char& c);
istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
istream& operator>>(signed char& c) {return operator>>((char&)c);}
istream& operator>>(int&);
istream& operator>>(long&);
__extension__ istream& operator>>(long long&);
__extension__ istream& operator>>(unsigned long long&);
istream& operator>>(short&);
istream& operator>>(unsigned int&);
istream& operator>>(unsigned long&);
istream& operator>>(unsigned short&);
istream& operator>>(bool&);
istream& operator>>(float&);
istream& operator>>(double&);
istream& operator>>(long double&);
istream& operator>>( __manip func) {(*func)(*this); return *this;}
istream& operator>>(__imanip func) { return (*func)(*this); }
istream& operator>>(streambuf*);
};
class iostream : public istream, public ostream
{
public:
iostream() { }
iostream(streambuf* sb, ostream*tied= __null );
};
class _IO_istream_withassign : public istream {
public:
_IO_istream_withassign& operator=(istream&);
};
class _IO_ostream_withassign : public ostream {
public:
_IO_ostream_withassign& operator=(ostream&);
};
extern _IO_istream_withassign cin;
extern _IO_ostream_withassign cout, cerr;
extern _IO_ostream_withassign clog
;
struct Iostream_init { } ;
inline ios& dec(ios& i)
{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
inline ios& hex(ios& i)
{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
inline ios& oct(ios& i)
{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
}
# 31 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/iterator.h" 2
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
return input_iterator_tag();
}
inline output_iterator_tag iterator_category(const output_iterator&) {
return output_iterator_tag();
}
template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
return forward_iterator_tag();
}
template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
return bidirectional_iterator_tag();
}
template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
return random_access_iterator_tag();
}
template <class T>
inline random_access_iterator_tag iterator_category(const T*) {
return random_access_iterator_tag();
}
template <class T, class Distance>
inline T* value_type(const input_iterator<T, Distance>&) {
return (T*)(0);
}
template <class T, class Distance>
inline T* value_type(const forward_iterator<T, Distance>&) {
return (T*)(0);
}
template <class T, class Distance>
inline T* value_type(const bidirectional_iterator<T, Distance>&) {
return (T*)(0);
}
template <class T, class Distance>
inline T* value_type(const random_access_iterator<T, Distance>&) {
return (T*)(0);
}
template <class T>
inline T* value_type(const T*) { return (T*)(0); }
template <class T, class Distance>
inline Distance* distance_type(const input_iterator<T, Distance>&) {
return (Distance*)(0);
}
template <class T, class Distance>
inline Distance* distance_type(const forward_iterator<T, Distance>&) {
return (Distance*)(0);
}
template <class T, class Distance>
inline Distance*
distance_type(const bidirectional_iterator<T, Distance>&) {
return (Distance*)(0);
}
template <class T, class Distance>
inline Distance*
distance_type(const random_access_iterator<T, Distance>&) {
return (Distance*)(0);
}
template <class T>
inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }
template <class Container>
class back_insert_iterator {
protected:
Container& container;
public:
back_insert_iterator(Container& x) : container(x) {}
back_insert_iterator<Container>&
operator=(const typename Container::value_type& value) {
container.push_back(value);
return *this;
}
back_insert_iterator<Container>& operator*() { return *this; }
back_insert_iterator<Container>& operator++() { return *this; }
back_insert_iterator<Container>& operator++(int) { return *this; }
};
template <class Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<Container>&)
{
return output_iterator_tag();
}
template <class Container>
back_insert_iterator<Container> back_inserter(Container& x) {
return back_insert_iterator<Container>(x);
}
template <class Container>
class front_insert_iterator {
protected:
Container& container;
public:
front_insert_iterator(Container& x) : container(x) {}
front_insert_iterator<Container>&
operator=(const typename Container::value_type& value) {
container.push_front(value);
return *this;
}
front_insert_iterator<Container>& operator*() { return *this; }
front_insert_iterator<Container>& operator++() { return *this; }
front_insert_iterator<Container>& operator++(int) { return *this; }
};
template <class Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<Container>&)
{
return output_iterator_tag();
}
template <class Container>
front_insert_iterator<Container> front_inserter(Container& x) {
return front_insert_iterator<Container>(x);
}
template <class Container>
class insert_iterator {
protected:
Container& container;
typename Container::iterator iter;
public:
insert_iterator(Container& x, typename Container::iterator i)
: container(x), iter(i) {}
insert_iterator<Container>&
operator=(const typename Container::value_type& value) {
iter = container.insert(iter, value);
++iter;
return *this;
}
insert_iterator<Container>& operator*() { return *this; }
insert_iterator<Container>& operator++() { return *this; }
insert_iterator<Container>& operator++(int) { return *this; }
};
template <class Container>
inline output_iterator_tag
iterator_category(const insert_iterator<Container>&)
{
return output_iterator_tag();
}
template <class Container, class Iterator>
insert_iterator<Container> inserter(Container& x, Iterator i) {
return insert_iterator<Container>(x, typename Container::iterator(i));
}
template <class BidirectionalIterator, class T, class Reference = T&,
class Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
Distance> self;
friend bool operator==(const self& x, const self& y);
protected:
BidirectionalIterator current;
public:
reverse_bidirectional_iterator() {}
reverse_bidirectional_iterator(BidirectionalIterator x) : current(x) {}
BidirectionalIterator base() { return current; }
Reference operator*() const {
BidirectionalIterator tmp = current;
return *--tmp;
}
self& operator++() {
--current;
return *this;
}
self operator++(int) {
self tmp = *this;
--current;
return tmp;
}
self& operator--() {
++current;
return *this;
}
self operator--(int) {
self tmp = *this;
++current;
return tmp;
}
};
template <class BidirectionalIterator, class T, class Reference,
class Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<BidirectionalIterator, T,
Reference, Distance>&) {
return bidirectional_iterator_tag();
}
template <class BidirectionalIterator, class T, class Reference,
class Distance>
inline T*
value_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
Reference, Distance>&) {
return (T*) 0;
}
template <class BidirectionalIterator, class T, class Reference,
class Distance>
inline Distance*
distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
Reference, Distance>&) {
return (Distance*) 0;
}
template <class BidirectionalIterator, class T, class Reference,
class Distance>
inline bool operator==(
const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
Distance>& x,
const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
Distance>& y) {
return x.current == y.current;
}
template <class RandomAccessIterator, class T, class Reference = T&,
class Distance = ptrdiff_t>
class reverse_iterator {
typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
self;
friend bool operator==(const self& x, const self& y);
friend bool operator<(const self& x, const self& y);
friend Distance operator-(const self& x, const self& y);
friend self operator+(Distance n, const self& x);
protected:
RandomAccessIterator current;
public:
reverse_iterator() {}
reverse_iterator(RandomAccessIterator x) : current(x) {}
RandomAccessIterator base() { return current; }
Reference operator*() const { return *(current - 1); }
self& operator++() {
--current;
return *this;
}
self operator++(int) {
self tmp = *this;
--current;
return tmp;
}
self& operator--() {
++current;
return *this;
}
self operator--(int) {
self tmp = *this;
++current;
return tmp;
}
self operator+(Distance n) const {
return self(current - n);
}
self& operator+=(Distance n) {
current -= n;
return *this;
}
self operator-(Distance n) const {
return self(current + n);
}
self& operator-=(Distance n) {
current += n;
return *this;
}
Reference operator[](Distance n) { return *(*this + n); }
};
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>&) {
return random_access_iterator_tag();
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline T* value_type(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>&) {
return (T*) 0;
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>&) {
return (Distance*) 0;
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline bool operator==(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& x,
const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& y) {
return x.current == y.current;
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline bool operator<(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& x,
const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& y) {
return y.current < x.current;
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline Distance operator-(const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& x,
const reverse_iterator<RandomAccessIterator, T,
Reference, Distance>& y) {
return y.current - x.current;
}
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline reverse_iterator<RandomAccessIterator, T, Reference, Distance>
operator+(Distance n,
const reverse_iterator<RandomAccessIterator, T, Reference,
Distance>& x) {
return reverse_iterator<RandomAccessIterator, T, Reference, Distance>
(x.current - n);
}
template <class ForwardIterator, class T>
class raw_storage_iterator {
protected:
ForwardIterator iter;
public:
raw_storage_iterator(ForwardIterator x) : iter(x) {}
raw_storage_iterator<ForwardIterator, T>& operator*() { return *this; }
raw_storage_iterator<ForwardIterator, T>& operator=(const T& element) {
construct(&*iter, element);
return *this;
}
raw_storage_iterator<ForwardIterator, T>& operator++() {
++iter;
return *this;
}
raw_storage_iterator<ForwardIterator, T> operator++(int) {
raw_storage_iterator<ForwardIterator, T> tmp = *this;
++iter;
return tmp;
}
};
template <class ForwardIterator, class T>
inline output_iterator_tag
iterator_category(const raw_storage_iterator<ForwardIterator, T>&)
{
return output_iterator_tag();
}
template <class T, class Distance = ptrdiff_t>
class istream_iterator {
friend bool operator==(const istream_iterator<T, Distance>& x,
const istream_iterator<T, Distance>& y);
protected:
istream* stream;
T value;
bool end_marker;
void read() {
end_marker = (*stream) ? true : false;
if (end_marker) *stream >> value;
end_marker = (*stream) ? true : false;
}
public:
istream_iterator() : stream(&cin), end_marker(false) {}
istream_iterator(istream& s) : stream(&s) { read(); }
const T& operator*() const { return value; }
istream_iterator<T, Distance>& operator++() {
read();
return *this;
}
istream_iterator<T, Distance> operator++(int) {
istream_iterator<T, Distance> tmp = *this;
read();
return tmp;
}
};
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const istream_iterator<T, Distance>&) {
return input_iterator_tag();
}
template <class T, class Distance>
inline T* value_type(const istream_iterator<T, Distance>&) { return (T*) 0; }
template <class T, class Distance>
inline Distance* distance_type(const istream_iterator<T, Distance>&) {
return (Distance*) 0;
}
template <class T, class Distance>
bool operator==(const istream_iterator<T, Distance>& x,
const istream_iterator<T, Distance>& y) {
return x.stream == y.stream && x.end_marker == y.end_marker ||
x.end_marker == false && y.end_marker == false;
}
template <class T>
class ostream_iterator {
protected:
ostream* stream;
char* string;
public:
ostream_iterator(ostream& s) : stream(&s), string(0) {}
ostream_iterator(ostream& s, char* c) : stream(&s), string(c) {}
ostream_iterator<T>& operator=(const T& value) {
*stream << value;
if (string) *stream << string;
return *this;
}
ostream_iterator<T>& operator*() { return *this; }
ostream_iterator<T>& operator++() { return *this; }
ostream_iterator<T>& operator++(int) { return *this; }
};
template <class T>
inline output_iterator_tag
iterator_category(const ostream_iterator<T>&) {
return output_iterator_tag();
}
# 34 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/new.h" 1 3 4
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/new" 1 3 4
#pragma interface "new"
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 1 3 4
# 327 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
# 8 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/new" 2 3 4
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/exception" 1 3 4
#pragma interface "exception"
extern "C++" {
class exception {
public:
exception () { }
virtual ~exception () { }
virtual const char* what () const;
};
class bad_exception : public exception {
public:
bad_exception () { }
virtual ~bad_exception () { }
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate (terminate_handler);
void terminate (void);
unexpected_handler set_unexpected (unexpected_handler);
void unexpected (void);
bool uncaught_exception ();
}
# 9 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/new" 2 3 4
extern "C++" {
class bad_alloc : public exception {
public:
virtual const char* what() const throw() { return "bad_alloc"; }
};
struct nothrow_t {};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
extern "C" new_handler set_new_handler (new_handler);
extern new_handler __new_handler;
extern "C" void __default_new_handler (void);
void *operator new (size_t);
void *operator new (size_t, const nothrow_t&) throw();
void *operator new[] (size_t);
void *operator new[] (size_t, const nothrow_t&) throw();
void operator delete (void *) throw();
void operator delete[] (void *) throw();
inline void *operator new(size_t, void *place) throw() { return place; }
inline void *operator new[](size_t, void *place) throw() { return place; }
}
# 6 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/new.h" 2 3 4
# 35 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/algobase.h" 2
template <class ForwardIterator1, class ForwardIterator2, class T>
inline void __iter_swap(ForwardIterator1 a, ForwardIterator2 b, T*) {
T tmp = *a;
*a = *b;
*b = tmp;
}
template <class ForwardIterator1, class ForwardIterator2>
inline void iter_swap(ForwardIterator1 a, ForwardIterator2 b) {
__iter_swap(a, b, value_type(a));
}
template <class T>
inline void swap(T& a, T& b) {
T tmp = a;
a = b;
b = tmp;
}
template <class T>
inline const T& min(const T& a, const T& b) {
return b < a ? b : a;
}
template <class T>
inline const T& max(const T& a, const T& b) {
return a < b ? b : a;
}
template <class T, class Compare>
inline const T& min(const T& a, const T& b, Compare comp) {
return comp(b, a) ? b : a;
}
template <class T, class Compare>
inline const T& max(const T& a, const T& b, Compare comp) {
return comp(a, b) ? b : a;
}
template <class InputIterator, class Distance>
inline void __distance(InputIterator first, InputIterator last, Distance& n,
input_iterator_tag) {
while (first != last) { ++first; ++n; }
}
template <class ForwardIterator, class Distance>
inline void __distance(ForwardIterator first, ForwardIterator last,
Distance& n,
forward_iterator_tag) {
while (first != last) { ++first; ++n; }
}
template <class BidirectionalIterator, class Distance>
inline void __distance(BidirectionalIterator first, BidirectionalIterator last,
Distance& n, bidirectional_iterator_tag) {
while (first != last) { ++first; ++n; }
}
template <class RandomAccessIterator, class Distance>
inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
Distance& n, random_access_iterator_tag) {
n += last - first;
}
template <class InputIterator, class Distance>
inline void distance(InputIterator first, InputIterator last, Distance& n) {
__distance(first, last, n, iterator_category(first));
}
template <class InputIterator, class Distance>
inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
while (n--) ++i;
}
template <class ForwardIterator, class Distance>
inline void __advance(ForwardIterator& i, Distance n, forward_iterator_tag) {
while (n--) ++i;
}
template <class BidirectionalIterator, class Distance>
inline void __advance(BidirectionalIterator& i, Distance n,
bidirectional_iterator_tag) {
if (n >= 0)
while (n--) ++i;
else
while (n++) --i;
}
template <class RandomAccessIterator, class Distance>
inline void __advance(RandomAccessIterator& i, Distance n,
random_access_iterator_tag) {
i += n;
}
template <class InputIterator, class Distance>
inline void advance(InputIterator& i, Distance n) {
__advance(i, n, iterator_category(i));
}
template <class T>
inline void destroy(T* pointer) {
pointer->~T();
}
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
new (p) T1(value);
}
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
while (first != last) {
destroy(&*first);
++first;
}
}
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result) {
while (first != last) construct(&*result++, *first++);
return result;
}
template <class ForwardIterator, class T>
void uninitialized_fill(ForwardIterator first, ForwardIterator last,
const T& x) {
while (first != last) construct(&*first++, x);
}
template <class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
const T& x) {
while (n--) construct(&*first++, x);
return first;
}
template <class InputIterator, class OutputIterator>
inline OutputIterator __copy(InputIterator first, InputIterator last,
OutputIterator result, input_iterator_tag)
{
while (first != last) *result++ = *first++;
return result;
}
template <class InputIterator, class OutputIterator>
inline OutputIterator __copy(InputIterator first, InputIterator last,
OutputIterator result, forward_iterator_tag)
{
return __copy(first, last, result, input_iterator_tag());
}
template <class InputIterator, class OutputIterator>
inline OutputIterator __copy(InputIterator first, InputIterator last,
OutputIterator result, bidirectional_iterator_tag)
{
return __copy(first, last, result, input_iterator_tag());
}
template <class RandomAccessIterator, class OutputIterator, class Distance>
inline OutputIterator
__copy_d(RandomAccessIterator first, RandomAccessIterator last,
OutputIterator result, Distance*)
{
for (Distance n = last - first; n > 0; --n)
*result++ = *first++;
return result;
}
template <class RandomAccessIterator, class OutputIterator>
inline OutputIterator
__copy(RandomAccessIterator first, RandomAccessIterator last,
OutputIterator result, random_access_iterator_tag)
{
return __copy_d(first, last, result, distance_type(first));
}
template <class InputIterator, class OutputIterator>
inline OutputIterator copy(InputIterator first, InputIterator last,
OutputIterator result)
{
return __copy(first, last, result, iterator_category(first));
}
template <class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward(BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 result) {
while (first != last) *--result = *--last;
return result;
}
template <class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value) {
while (first != last) *first++ = value;
}
template <class OutputIterator, class Size, class T>
OutputIterator fill_n(OutputIterator first, Size n, const T& value) {
while (n-- > 0) *first++ = value;
return first;
}
template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
InputIterator1 last1,
InputIterator2 first2) {
while (first1 != last1 && *first1 == *first2) {
++first1;
++first2;
}
return pair<InputIterator1, InputIterator2>(first1, first2);
}
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
InputIterator1 last1,
InputIterator2 first2,
BinaryPredicate binary_pred) {
while (first1 != last1 && binary_pred(*first1, *first2)) {
++first1;
++first2;
}
return pair<InputIterator1, InputIterator2>(first1, first2);
}
template <class InputIterator1, class InputIterator2>
inline bool equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2) {
for ( ; first1 != last1; ++first1, ++first2)
if (*first1 != *first2)
return false;
return true;
}
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
inline bool equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate binary_pred) {
for ( ; first1 != last1; ++first1, ++first2)
if (!binary_pred(*first1, *first2))
return false;
return true;
}
template <class InputIterator1, class InputIterator2>
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2) {
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2) return true;
if (*first2++ < *first1++) return false;
}
return first1 == last1 && first2 != last2;
}
template <class InputIterator1, class InputIterator2, class Compare>
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
Compare comp) {
while (first1 != last1 && first2 != last2) {
if (comp(*first1, *first2)) return true;
if (comp(*first2++, *first1++)) return false;
}
return first1 == last1 && first2 != last2;
}
inline bool
lexicographical_compare(unsigned char* first1, unsigned char* last1,
unsigned char* first2, unsigned char* last2)
{
const size_t len1 = last1 - first1;
const size_t len2 = last2 - first2;
const int result = memcmp(first1, first2, min(len1, len2));
return result != 0 ? result < 0 : len1 < len2;
}
inline bool lexicographical_compare(char* first1, char* last1,
char* first2, char* last2)
{
return lexicographical_compare((signed char*) first1, (signed char*) last1,
(signed char*) first2, (signed char*) last2);
}
# 31 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h" 2
# 1 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h" 1
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 1 3 4
# 327 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stddef.h" 3 4
# 49 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h" 2
# 1 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stdlib.h" 1 3 4
#pragma ident "@(#)stdlib.h 1.27 95/08/28 SMI"
extern "C" {
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef struct {
long long quot;
long long rem;
} lldiv_t;
typedef long uid_t;
extern unsigned char __ctype[];
extern double atof(const char *);
extern int atoi(const char *);
extern long int atol(const char *);
extern double strtod(const char *, char **);
extern long int strtol(const char *, char **, int);
extern unsigned long int strtoul(const char *, char **, int);
extern int rand(void);
extern void srand(unsigned int);
extern void *calloc(size_t, size_t);
extern void free(void *);
extern void *malloc(size_t);
extern void *realloc(void *, size_t);
extern void abort(void);
extern int atexit(void (*)(void));
extern void exit(int);
extern char *getenv(const char *);
extern int system(const char *);
extern void *bsearch(const void *, const void *, size_t, size_t,
int (*)(const void *, const void *));
extern void qsort(void *, size_t, size_t,
int (*)(const void *, const void *));
extern int abs(int);
extern div_t div(int, int);
extern long int labs(long);
extern ldiv_t ldiv(long, long);
extern int mbtowc(wchar_t *, const char *, size_t);
extern int mblen(const char *, size_t);
extern int wctomb(char *, wchar_t);
extern size_t mbstowcs(wchar_t *, const char *, size_t);
extern size_t wcstombs(char *, const wchar_t *, size_t);
extern double drand48(void);
extern double erand48(unsigned short *);
extern long jrand48(unsigned short *);
extern void lcong48(unsigned short *);
extern long lrand48(void);
extern long mrand48(void);
extern long nrand48(unsigned short *);
extern unsigned short *seed48(unsigned short *);
extern void srand48(long);
extern int putenv(const char *);
extern void setkey(const char *);
extern void swab(const char *, char *, int);
extern long a64l(const char *);
extern int dup2(int, int);
extern char *ecvt(double, int, int *, int *);
extern char *fcvt(double, int, int *, int *);
extern char *qecvt(long double, int, int *, int *);
extern char *qfcvt(long double, int, int *, int *);
extern char *qgcvt(long double, int, char *);
extern char *getcwd(char *, size_t);
extern char *getlogin(void);
extern int getopt(int, char *const *, const char *);
extern int getsubopt(char **, char *const *, char **);
extern char *optarg;
extern int optind, opterr, optopt;
extern char *getpass(const char *);
extern int getpw(uid_t, char *);
extern char *gcvt(double, int, char *);
extern int isatty(int);
extern char *l64a(long);
extern void *memalign(size_t, size_t);
extern char *mktemp(char *);
extern char *realpath(char *, char *);
extern char *ttyname(int);
extern int ttyslot(void);
extern void *valloc(size_t);
extern char *ptsname(int);
extern int grantpt(int);
extern int unlockpt(int);
extern long long atoll(const char *);
extern long long llabs(long long);
extern lldiv_t lldiv(long long, long long);
extern char *lltostr(long long, char *);
extern long long strtoll(const char *, char **, int);
extern unsigned long long strtoull(const char *, char **, int);
extern char *ulltostr(unsigned long long, char *);
# 282 "/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include/stdlib.h" 3 4
}
# 50 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h" 2
# 86 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h"
# 98 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h"
# 110 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h"
static void (* __malloc_alloc_oom_handler)();
template <int instance_no>
class __malloc_alloc_template {
private:
static void *oom_malloc(size_t);
static void *oom_realloc(void *, size_t);
public:
static void * allocate(size_t n)
{
void *result = malloc(n);
if (0 == result) result = oom_malloc(n);
return result;
}
static void deallocate(void *p, size_t )
{
free(p);
}
static void * reallocate(void *p, size_t , size_t new_sz)
{
void * result = realloc(p, new_sz);
if (0 == result) result = oom_realloc(p, new_sz);
return result;
}
static void (* set_malloc_handler(void (*f)()))()
{
void (* old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return(old);
}
};
template <int instance_no>
void * __malloc_alloc_template<instance_no>::oom_malloc(size_t n)
{
void (* my_malloc_handler)();
void *result;
for (;;) {
my_malloc_handler = __malloc_alloc_oom_handler;
if (0 == my_malloc_handler) { cerr << "out of memory" << endl; exit(1) ; }
(*my_malloc_handler)();
result = malloc(n);
if (result) return(result);
}
}
template <int instance_no>
void * __malloc_alloc_template<instance_no>::oom_realloc(void *p, size_t n)
{
void (* my_malloc_handler)();
void *result;
for (;;) {
my_malloc_handler = __malloc_alloc_oom_handler;
if (0 == my_malloc_handler) { cerr << "out of memory" << endl; exit(1) ; }
(*my_malloc_handler)();
result = realloc(p, n);
if (result) return(result);
}
}
typedef __malloc_alloc_template<0> malloc_alloc;
template<class T, class alloc>
class simple_alloc {
public:
static T *allocate(size_t n)
{ return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
static T *allocate(void)
{ return (T*) alloc::allocate(sizeof (T)); }
static void deallocate(T *p, size_t n)
{ if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
static void deallocate(T *p)
{ alloc::deallocate(p, sizeof (T)); }
};
template <bool threads, int instance_no>
class __default_alloc_template {
private:
enum X1 {__ALIGN = 8};
const unsigned int __MAX_BYTES = 128;
enum X3 {__NFREELISTS = __MAX_BYTES/__ALIGN};
static size_t ROUND_UP(size_t bytes) {
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
private :
union obj {
union obj * free_list_link;
char client_data[1];
};
private:
static obj * free_list[__NFREELISTS];
static size_t FREELIST_INDEX(size_t bytes) {
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}
static void *refill(size_t n);
static char *chunk_alloc(size_t size, int &nobjs);
static char *start_free;
static char *end_free;
static size_t heap_size;
class lock {
public:
lock() { ; }
~lock() { ; }
};
friend class lock;
public:
static void * allocate(size_t n)
{
obj * * my_free_list;
obj * result;
if (n > __MAX_BYTES) {
return(malloc_alloc::allocate(n));
}
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
if (result == 0) {
void *r = refill(ROUND_UP(n));
return r;
}
*my_free_list = result -> free_list_link;
return (result);
};
static void deallocate(void *p, size_t n)
{
obj *q = (obj *)p;
obj * * my_free_list;
if (n > __MAX_BYTES) {
malloc_alloc::deallocate(p, n);
return;
}
my_free_list = free_list + FREELIST_INDEX(n);
q -> free_list_link = *my_free_list;
*my_free_list = q;
}
static void * reallocate(void *p, size_t old_sz, size_t new_sz);
} ;
typedef __default_alloc_template< false , 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;
template <bool threads, int instance_no>
char *__default_alloc_template<threads, instance_no>
::chunk_alloc(size_t size, int &nobjs)
{
char * result;
size_t total_bytes = size * nobjs;
size_t bytes_left = end_free - start_free;
if (bytes_left >= total_bytes) {
result = start_free;
start_free += total_bytes;
return(result);
} else if (bytes_left >= size) {
nobjs = bytes_left/size;
total_bytes = size * nobjs;
result = start_free;
start_free += total_bytes;
return(result);
} else {
size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
if (bytes_left > 0) {
obj * * my_free_list =
free_list + FREELIST_INDEX(bytes_left);
((obj *)start_free) -> free_list_link = *my_free_list;
*my_free_list = (obj *)start_free;
}
start_free = (char *)malloc(bytes_to_get);
if (0 == start_free) {
int i;
obj * * my_free_list, *p;
for (i = size; i <= int(__MAX_BYTES); i += __ALIGN) {
my_free_list = free_list + FREELIST_INDEX(i);
p = *my_free_list;
if (0 != p) {
*my_free_list = p -> free_list_link;
start_free = (char *)p;
end_free = start_free + i;
return(chunk_alloc(size, nobjs));
}
}
start_free = (char *)malloc_alloc::allocate(bytes_to_get);
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
return(chunk_alloc(size, nobjs));
}
}
template <bool threads, int instance_no>
void *__default_alloc_template<threads, instance_no>
::refill(size_t n)
{
int nobjs = 20;
char * chunk = chunk_alloc(n, nobjs);
obj * * my_free_list;
obj * result;
obj * current_obj, * next_obj;
int i;
if (1 == nobjs) return(chunk);
my_free_list = free_list + FREELIST_INDEX(n);
result = (obj *)chunk;
*my_free_list = next_obj = (obj *)(chunk + n);
for (i = 1; ; i++) {
current_obj = next_obj;
next_obj = (obj *)((char *)next_obj + n);
if (nobjs - 1 == i) {
current_obj -> free_list_link = 0;
break;
} else {
current_obj -> free_list_link = next_obj;
}
}
return(result);
}
template <bool threads, int instance_no>
void *__default_alloc_template<threads, instance_no>
::reallocate(void *p, size_t old_sz, size_t new_sz)
{
void * result;
size_t copy_sz;
if (old_sz > __MAX_BYTES && new_sz > __MAX_BYTES) {
return(realloc(p, new_sz));
}
if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p);
result = allocate(new_sz);
copy_sz = new_sz > old_sz? old_sz : new_sz;
memcpy(result, p, copy_sz);
deallocate(p, old_sz);
return(result);
}
# 570 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h"
template <bool threads, int instance_no>
char *__default_alloc_template<threads, instance_no>
::start_free = 0;
template <bool threads, int instance_no>
char *__default_alloc_template<threads, instance_no>
::end_free = 0;
template <bool threads, int instance_no>
size_t __default_alloc_template<threads, instance_no>
::heap_size = 0;
template <bool threads, int instance_no>
__default_alloc_template<threads, instance_no>::obj *
__default_alloc_template<threads, instance_no> ::free_list[
__default_alloc_template<threads, instance_no>::__NFREELISTS
] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
# 32 "/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h" 2
template <class T, class Alloc = alloc>
class vector {
public:
typedef T value_type;
typedef value_type* pointer;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
protected:
typedef simple_alloc<value_type, Alloc> data_allocator;
iterator start;
iterator finish;
iterator end_of_storage;
void insert_aux(iterator position, const T& x);
void deallocate() {
if (start) data_allocator::deallocate(start, end_of_storage - start);
}
public:
iterator begin() { return start; }
const_iterator begin() const { return start; }
iterator end() { return finish; }
const_iterator end() const { return finish; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
size_type size() const { return size_type(end() - begin()); }
size_type max_size() const { return size_type(-1); }
size_type capacity() const { return size_type(end_of_storage - begin()); }
bool empty() const { return begin() == end(); }
reference operator[](size_type n) { return *(begin() + n); }
const_reference operator[](size_type n) const { return *(begin() + n); }
vector() : start(0), finish(0), end_of_storage(0) {}
vector(size_type n, const T& value) {
start = data_allocator::allocate(n);
uninitialized_fill_n(start, n, value);
finish = start + n;
end_of_storage = finish;
}
vector(size_type n) {
start = data_allocator::allocate(n);
uninitialized_fill_n(start, n, T());
finish = start + n;
end_of_storage = finish;
}
vector(const vector<T, Alloc>& x) {
start = data_allocator::allocate(x.end() - x.begin());
finish = uninitialized_copy(x.begin(), x.end(), start);
end_of_storage = finish;
}
vector(const_iterator first, const_iterator last) {
size_type n = 0;
distance(first, last, n);
start = data_allocator::allocate(n);
finish = uninitialized_copy(first, last, start);
end_of_storage = finish;
}
~vector() {
destroy(start, finish);
deallocate();
}
vector<T, Alloc>& operator=(const vector<T, Alloc>& x);
void reserve(size_type n) {
if (capacity() < n) {
iterator tmp = data_allocator::allocate(n);
uninitialized_copy(begin(), end(), tmp);
destroy(start, finish);
deallocate();
finish = tmp + size();
start = tmp;
end_of_storage = begin() + n;
}
}
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
reference back() { return *(end() - 1); }
const_reference back() const { return *(end() - 1); }
void push_back(const T& x) {
if (finish != end_of_storage) {
construct(finish, x);
finish++;
} else
insert_aux(end(), x);
}
void swap(vector<T, Alloc>& x) {
::swap(start, x.start);
::swap(finish, x.finish);
::swap(end_of_storage, x.end_of_storage);
}
iterator insert(iterator position, const T& x) {
size_type n = position - begin();
if (finish != end_of_storage && position == end()) {
construct(finish, x);
finish++;
} else
insert_aux(position, x);
return begin() + n;
}
iterator insert(iterator position) { return insert(position, T()); }
void insert (iterator position, const_iterator first,
const_iterator last);
void insert (iterator position, size_type n, const T& x);
void pop_back() {
--finish;
destroy(finish);
}
void erase(iterator position) {
if (position + 1 != end())
copy(position + 1, end(), position);
--finish;
destroy(finish);
}
void erase(iterator first, iterator last) {
vector<T, Alloc>::iterator i = copy(last, end(), first);
destroy(i, finish);
finish = finish - (last - first);
}
};
template <class T, class Alloc>
inline bool operator==(const vector<T, Alloc>& x, const vector<T, Alloc>& y) {
return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
}
template <class T, class Alloc>
inline bool operator<(const vector<T, Alloc>& x, const vector<T, Alloc>& y) {
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}
template <class T, class Alloc>
vector<T, Alloc>& vector<T, Alloc>::operator=(const vector<T, Alloc>& x) {
if (&x == this) return *this;
if (x.size() > capacity()) {
destroy(start, finish);
deallocate();
start = data_allocator::allocate(x.end() - x.begin());
end_of_storage = uninitialized_copy(x.begin(), x.end(), start);
} else if (size() >= x.size()) {
vector<T, Alloc>::iterator i = copy(x.begin(), x.end(), begin());
destroy(i, finish);
} else {
copy(x.begin(), x.begin() + size(), begin());
uninitialized_copy(x.begin() + size(), x.end(), begin() + size());
}
finish = begin() + x.size();
return *this;
}
template <class T, class Alloc>
void vector<T, Alloc>::insert_aux(iterator position, const T& x) {
if (finish != end_of_storage) {
construct(finish, *(finish - 1));
copy_backward(position, finish - 1, finish);
*position = x;
++finish;
} else {
size_type len = size() ? 2 * size() : 1;
iterator tmp = data_allocator::allocate(len);
uninitialized_copy(begin(), position, tmp);
construct(tmp + (position - begin()), x);
uninitialized_copy(position, end(), tmp + (position - begin()) + 1);
destroy(begin(), end());
deallocate();
end_of_storage = tmp + len;
finish = tmp + size() + 1;
start = tmp;
}
}
template <class T, class Alloc>
void vector<T, Alloc>::insert(iterator position, size_type n, const T& x) {
if (n == 0) return;
if (size_type (end_of_storage - finish) >= n) {
if (size_type (end() - position) > n) {
uninitialized_copy(end() - n, end(), end());
copy_backward(position, end() - n, end());
fill(position, position + n, x);
} else {
uninitialized_copy(position, end(), position + n);
fill(position, end(), x);
uninitialized_fill_n(end(), n - (end() - position), x);
}
finish += n;
} else {
size_type len = size() + max(size(), n);
iterator tmp = data_allocator::allocate(len);
uninitialized_copy(begin(), position, tmp);
uninitialized_fill_n(tmp + (position - begin()), n, x);
uninitialized_copy(position, end(), tmp + (position - begin() + n));
destroy(begin(), end());
deallocate();
end_of_storage = tmp + len;
finish = tmp + size() + n;
start = tmp;
}
}
template <class T, class Alloc>
void vector<T, Alloc>::insert(iterator position,
const_iterator first,
const_iterator last) {
if (first == last) return;
size_type n = 0;
distance(first, last, n);
if (size_type (end_of_storage - finish) >= n) {
if (size_type (end() - position) > n) {
uninitialized_copy(end() - n, end(), end());
copy_backward(position, end() - n, end());
copy(first, last, position);
} else {
uninitialized_copy(position, end(), position + n);
copy(first, first + (end() - position), position);
uninitialized_copy(first + (end() - position), last, end());
}
finish += n;
} else {
size_type len = size() + max(size(), n);
iterator tmp = data_allocator::allocate(len);
uninitialized_copy(begin(), position, tmp);
uninitialized_copy(first, last, tmp + (position - begin()));
uninitialized_copy(position, end(), tmp + (position - begin() + n));
destroy(begin(), end());
deallocate();
end_of_storage = tmp + len;
finish = tmp + size() + n;
start = tmp;
}
}
# 6 "/export/home/software/new-software/libg++-2.8.0/libstdc++/vector" 2
# 1 "b2.cc" 2
template <class T>
void
del(vector<T*>* const v)
{
delete v;
}
template <>
void
del(vector<char*>* const args)
{
delete args;
}
***** Compilation:
Reading specs from /export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/specs
gcc version egcs-2.90.12 971008 (gcc2-970802 experimental)
/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/cpp -lang-c++ -v -I/export/home/software/new-software/libg++-2.8.0/libstdc++/stl -I/export/home/software/new-software/libg++-2.8.0/libg++/src -I/export/home/software/new-software/gmake[1]: Leaving directory `/export/home/joseph/egbugs'
ibg++-2.8.0/libstdc++ -I/export/home/software/new-software/libg++-2.8.0/libstdc++/stl -undef -D__GNUC__=2 -D__GNUG__=2 -D__cplusplus -D__GNUC_MINOR__=90 -Dsun -Dsparc -Dunix -D__svr4__ -D__SVR4 -D__GCC_NEW_VARARGS__ -D__sun__ -D__sparc__ -D__unix__ -D__svr4__ -D__SVR4 -D__GCC_NEW_VARARGS__ -D__sun -D__sparc -D__unix -Asystem(unix) -Asystem(svr4) -Acpu(sparc) -Amachine(sparc) -D__EXCEPTIONS -g b2.cc /var/tmp/cca001YN.ii
GNU CPP version egcs-2.90.12 971008 (gcc2-970802 experimental) (sparc)
#include "..." search starts here:
#include <...> search starts here:
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl
/export/home/software/new-software/libg++-2.8.0/libg++/src
/export/home/software/new-software/libg++-2.8.0/libio
/export/home/software/new-software/libg++-2.8.0/libstdc++
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl
/export/home/users/joseph/egcs-971008/include/g++
/usr/local/include
/export/home/users/joseph/egcs-971008/sparc-sun-solaris2.5/include
/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/include
/usr/include
End of search list.
/export/home/users/joseph/egcs-971008/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.90.12/cc1plus /var/tmp/cca001YN.ii -quiet -dumpbase b2.cc -g -version -o /var/tmp/cca001YN.s
GNU C++ version egcs-2.90.12 971008 (gcc2-970802 experimental) (sparc-sun-solaris2.5) compiled by GNU C version 2.7.2.2.
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h:56: No member template `simple_alloc' declared in `simple_alloc<char *,__default_alloc_template<false,0> >'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h:56: No member template `simple_alloc' declared in `simple_alloc<char *,__default_alloc_template<false,0> >'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/vector.h:56: Specialization of `__as' does not match any template declaration.
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:205: No member template `__default_alloc_template' declared in `__default_alloc_template<false,0>'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:205: No member template `__default_alloc_template' declared in `__default_alloc_template<false,0>'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:205: Specialization of `__as' does not match any template declaration.
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:361: No member template `obj' declared in `__default_alloc_template<false,0>::obj'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:361: No member template `obj' declared in `__default_alloc_template<false,0>::obj'
/export/home/software/new-software/libg++-2.8.0/libstdc++/stl/alloc.h:361: Specialization of `__as' does not match any template declaration.
gmake[1]: *** [b2.o] Error 1
More information about the Gcc-bugs
mailing list