meb@MULLIAN.EE.MU.OZ.AU (Matthew Barry) (02/02/90)
The following code should generate an redefinition error:
#include <stream.h>
char str[ 50 ]; // conflict with str in builtin.h
main()
{
ostream out( sizeof str, str );
out << "Hello World\n";
return 0;
}
-------
This is run on a SparcStation1
g++ -v t.cc
g++ version 1.36.4 (based on GCC 1.36.93)
/usr/local/lib/gcc-cpp -+ -v -undef -D__GNUC__ -D__GNUG__ -D__cplusplus -Dsparc -Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ t.cc /tmp/cca20294.cpp
GNU CPP version 1.36.93
/usr/local/lib/gcc-cc1plus /tmp/cca20294.cpp -quiet -dumpbase t.cc -version -o /tmp/cca20294.s
GNU C++ version 1.36.4 (based on GCC 1.36.93) (sparc) compiled by GNU C version 1.36.93.
default target switches: -mfpu -mepilogue
t.cc: In function int main ():
t.cc:8: too many arguments for constructor `ostream'
t.cc:8: in base initialization for class `ostream'
--------
The preprocessed output is:
# 1 "t.cc"
# 1 "/usr/local/lib/g++-include/stream.h" 1
#pragma once
# 1 "/usr/local/lib/g++-include/File.h" 1
#pragma once
# 1 "/usr/local/lib/g++-include/builtin.h" 1
#pragma once
typedef void (*one_arg_error_handler_t)(const char*);
typedef void (*two_arg_error_handler_t)(const char*, const char*);
# 1 "/usr/local/lib/g++-include/stddef.h" 1
#pragma once
typedef unsigned long size_t;
typedef long int ptrdiff_t;
typedef unsigned char wchar_t;
# 40 "/usr/local/lib/g++-include/builtin.h" 2
# 1 "/usr/local/lib/g++-include/std.h" 1
#pragma once
# 1 "/usr/local/lib/g++-include/stdio.h" 1
#pragma once
# 79 "/usr/local/lib/g++-include/stdio.h"
# 114 "/usr/local/lib/g++-include/stdio.h"
# 156 "/usr/local/lib/g++-include/stdio.h"
extern struct _iobuf {
int _cnt;
char* _ptr;
char* _base;
int _bufsiz;
short _flag;
char _file;
} _iob[];
typedef struct _iobuf FILE;
# 193 "/usr/local/lib/g++-include/stdio.h"
extern "C" {
int _doprnt(const char*, void*, FILE*);
int _doscan(FILE*, const char*, ...);
int _filbuf(FILE*);
int _flsbuf(unsigned, FILE*);
int fclose(FILE*);
FILE* fdopen(int, const char*);
int fflush(FILE*);
int fgetc(FILE*);
char* fgets(char*, int, FILE *);
FILE* fopen(const char*, const char*);
int fprintf(FILE*, const char* ...);
int fputc(int, FILE*);
int fputs(const char*, FILE*);
int fread(void*, int, int, FILE*);
FILE* freopen(const char*, const char*, FILE*);
int fscanf(FILE*, const char* ...);
int fseek(FILE*, long, int);
long ftell(FILE *);
int fwrite(const void*, int, int, FILE*);
char* gets(char*);
int getw(FILE*);
int pclose(FILE*);
FILE* popen(const char*, const char*);
int printf(const char* ...);
int puts(const char*);
int putw(int, FILE*);
int rewind(FILE*);
int scanf(const char* ...);
int setbuf(FILE*, char*);
int setbuffer(FILE*, char*, int);
int setlinebuf(FILE*);
int setvbuf(FILE*, char*, int, int);
int sscanf(char*, const char* ...);
FILE* tmpfile();
int ungetc(int, FILE*);
int vfprintf(FILE*, const char*, ...);
int vprintf(const char*, ... );
char* sprintf(char*, const char* ...);
char* vsprintf(char*, const char*, ...);
}
# 30 "/usr/local/lib/g++-include/std.h" 2
extern "C" {
void volatile _exit(int);
void volatile abort(void);
int abs(int);
int access(const char*, int);
int acct(const char*);
unsigned alarm(unsigned);
double atof(const char*);
int atoi(const char*);
long atol(const char*);
int bind(int, void*, int);
int brk(void*);
int bsearch (const void *, const void *, unsigned long,
unsigned long, auto int (*ptf)(const void*, const void*));
void* calloc(unsigned, unsigned);
void cfree(void*);
int chdir(const char*);
int chmod(const char*, int);
int chown(const char*, int, int);
long clock(void);
int close(int);
int creat(const char*, unsigned long int);
char* crypt(const char*, const char*);
char* ctermid(char*);
char* cuserid(char*);
double drand48(void);
int dup(int);
int dup2(int, int);
int dysize(int);
char* ecvt(double, int, int*, int*);
char* encrypt(char*, int);
double erand(short*);
int execl(const char*, const char *, ...);
int execle(const char*, const char *, ...);
int execlp(const char*, const char*, ...);
int exect(const char*, const char**, char**);
int execv(const char*, const char**);
int execve(const char*, const char**, char**);
int execvp(const char*, const char**);
void volatile exit(int);
int fchmod(int, int);
int fchown(int, int, int);
int fcntl(int, int, ...);
char* fcvt(double, int, int*, int*);
int ffs(int);
int flock(int, int);
int fork(void);
void free(void*);
int fsync(int);
long ftok(const char*, int);
int ftruncate(int, unsigned long);
char* gcvt(double, int, char*);
char* getcwd(char*, int);
int getdomainname(char*, int);
int getdtablesize(void);
int getegid(void);
char* getenv(const char*);
int geteuid(void);
int getgid(void);
int getgroups(int, int*);
long gethostid(void);
int gethostname(char*, int);
char* getlogin(void);
int getopt(int, const char**, const char*);
int getpagesize(void);
char* getpass(const char*);
int getpgrp(void);
int getpid(void);
int getppid(void);
int getpriority(int, int);
int getpw(int, char*);
unsigned getuid(void);
char* getwd(char*);
char* initstate(unsigned, char*, int);
int ioctl(int, int, char*);
int isatty(int);
long jrand48(short*);
int kill(int, int);
int killpg(int, int);
void lcong48(short*);
int link(const char*, const char*);
int listen(int, int);
int lock(int, int, long);
long lrand48(void);
long lseek(int, long, int);
void* malloc(unsigned);
unsigned malloc_usable_size(void*);
void* memalign(unsigned, unsigned);
void* memccpy(void*, const void*, int, int);
void* memchr(const void*, int, int);
int memcmp(const void*, const void*, int);
void* memcpy(void*, const void*, int);
void* memset(void*, int, int);
int mkdir(const char*, int);
int mknod(const char*, int, int);
int mkstemp(char*);
char* mktemp(char*);
long mrand48(void);
int nice(int);
long nrand48(short*);
int open(const char*, int, ...);
void volatile pause(void);
void perror(const char*);
int pipe(int*);
int profil(char*, int, int, int);
int psignal(unsigned, char*);
int ptrace(int, int, int, int);
int putenv(const char*);
int qsort(void*, int, unsigned, auto (*ptf)(void*,void*));
int rand(void);
long random(void);
int read(int, void*, unsigned);
int readlink(const char*, char*, int);
void* realloc(void*, unsigned);
int rename(const char*, const char*);
int rmdir(const char*);
void* sbrk(int);
short* seed48(short*);
int send(int, char*, int, int);
int setgid(int);
int sethostname(char*, int);
int setkey(const char*);
int setpgrp(int, int);
int setpriority(int, int, int);
int setregid(int, int);
int setreuid(int, int);
char* setstate(char*);
int setuid(int);
int sigblock(int);
int siginterrupt(int, int);
int sigpause(int);
int sigsetmask(int);
unsigned sleep(unsigned);
int socket(int, int, int);
int srand(int);
void srand48(long);
void srandom(int);
int stime(long*);
char* strcat(char*, const char*);
char* strchr(const char*, int);
int strcmp(const char*, const char*);
char* strcpy(char*, const char*);
int strcspn(const char*, const char*);
char* strdup(const char*);
int strlen(const char*);
char* strncat(char*, const char*, int);
int strncmp(const char*, const char*, int);
char* strncpy(char*, const char*, int);
char* strpbrk(const char*, const char*);
char* strrchr(const char*, int);
int strspn(const char*, const char*);
double strtod(const char*, char**);
char* strtok(char*, const char*);
long strtol(const char*, char**, int);
void swab(void*, void*, int);
int symlink(const char*, const char*);
int syscall(int, ...);
int system(const char*);
char* tempnam(char*, char*);
int tgetent(char*, char*);
int tgetnum(char*);
int tgetflag(char*);
char* tgetstr(char *, char **);
char* tgoto(char*, int, int);
long time(long*);
char* tmpnam(char*);
int tputs(char *, int, auto int (*)());
int truncate(const char*, unsigned long);
char* ttyname(int);
int ttyslot(void);
unsigned ualarm(unsigned, unsigned);
long ulimit(int, long);
int umask(int);
int unlink(const char*);
unsigned usleep(unsigned);
int vadvise(int);
void* valloc(unsigned);
int vfork(void);
int vhangup(void);
int wait(int*);
int write(int, const void*, unsigned);
}
extern "C" {
int bcmp(const void*, const void*, int);
void bcopy(const void*, void*, int);
void bzero(void*, int);
char* index(const char*, int);
char* rindex(const char*, int);
}
extern char** environ;
extern volatile int errno;
extern char* sys_errlist[];
extern int sys_nerr;
extern char* optarg;
extern int opterr;
extern int optind;
extern "C" void* alloca(unsigned long);
# 41 "/usr/local/lib/g++-include/builtin.h" 2
# 1 "/usr/local/lib/g++-include/math.h" 1
#pragma once
# 64 "/usr/local/lib/g++-include/math.h"
extern "C" {
double acos(double);
double acosh(double);
double asin(double);
double asinh(double);
double atan(double);
double atan2(double, double);
double atanh(double);
double cbrt(double);
double ceil(double);
double copysign(double,double);
double cos(double);
double cosh(double);
double drem(double,double);
double erf(double);
double erfc(double);
double exp(double);
double expm1(double);
double fabs(double);
double finite(double);
double floor(double);
double frexp(double, int*);
double gamma(double);
double hypot(double,double);
double infnan(int);
int isinf(double);
int isnan(double);
double j0(double);
double j1(double);
double jn(int, double);
double ldexp(double, int);
double lgamma(double);
double log(double);
double log10(double);
double log1p(double);
double logb(double);
double modf(double, double*);
double pow(double, double);
double rint(double);
double scalb(double, int);
double sin(double);
double sinh(double);
double sqrt(double);
double tan(double);
double tanh(double);
double y0(double);
double y1(double);
double yn(int, double);
double aint(double);
double anint(double);
int irint(double);
int nint(double);
}
struct libm_exception
{
int type;
char* name;
double arg1, arg2, retval;
};
extern "C" int matherr(libm_exception*);
# 1 "/usr/local/lib/g++-include/values.h" 1
#pragma once
# 161 "/usr/local/lib/g++-include/values.h"
# 148 "/usr/local/lib/g++-include/math.h" 2
# 42 "/usr/local/lib/g++-include/builtin.h" 2
long gcd(long, long);
long lg(unsigned long);
double pow(double, long);
long pow(long, long);
double start_timer();
double return_elapsed_time(double last_time = 0.0);
char* itoa(long x, int base = 10, int width = 0);
char* itoa(unsigned long x, int base = 10, int width = 0);
char* itoa(long long x, int base = 10, int width = 0);
char* itoa(unsigned long long x, int base = 10, int width = 0);
char* dtoa(double x, char cvt = 'g', int width = 0, int prec = 6);
char* hex(long x, int width = 0);
char* hex(unsigned long x, int width = 0);
char* oct(long x, int width = 0);
char* oct(unsigned long x, int width = 0);
char* dec(long x, int width = 0);
char* dec(unsigned long x, int width = 0);
char* form(const char* fmt ...);
char* chr(char ch, int width = 0);
char* str(const char* s, int width = 0);
unsigned int hashpjw(const char*);
unsigned int multiplicativehash(int);
unsigned int foldhash(double);
extern void default_one_arg_error_handler(const char*);
extern void default_two_arg_error_handler(const char*, const char*);
extern two_arg_error_handler_t lib_error_handler;
extern two_arg_error_handler_t
set_lib_error_handler(two_arg_error_handler_t f);
static inline double abs(double arg)
{
return (arg < 0.0)? -arg : arg;
}
static inline float abs(float arg)
{
return (arg < 0.0)? -arg : arg;
}
static inline short abs(short arg)
{
return (arg < 0)? -arg : arg;
}
static inline long abs(long arg)
{
return (arg < 0)? -arg : arg;
}
static inline int sign(long arg)
{
return (arg == 0) ? 0 : ( (arg > 0) ? 1 : -1 );
}
static inline int sign(double arg)
{
return (arg == 0.0) ? 0 : ( (arg > 0.0) ? 1 : -1 );
}
static inline long sqr(long arg)
{
return arg * arg;
}
static inline double sqr(double arg)
{
return arg * arg;
}
static inline int even(long arg)
{
return !(arg & 1);
}
static inline int odd(long arg)
{
return (arg & 1);
}
static inline long lcm(long x, long y)
{
return x / gcd(x, y) * y;
}
static inline void setbit(long& x, long b)
{
x |= (1 << b);
}
static inline void clearbit(long& x, long b)
{
x &= ~(1 << b);
}
static inline int testbit(long x, long b)
{
return ((x & (1 << b)) != 0);
}
# 28 "/usr/local/lib/g++-include/File.h" 2
enum io_mode
{
io_readonly = 0,
io_writeonly = 1,
io_readwrite = 2,
io_appendonly = 3,
io_append = 4,
};
enum access_mode
{
a_createonly = 0,
a_create = 1,
a_useonly = 2,
a_use = 3,
};
enum state_value
{
_good = 0,
_eof = 1,
_fail = 2,
_bad = 4
};
class Filebuf;
class File
{
friend class Filebuf;
protected:
FILE* fp;
char* nm;
char rw;
state_value state;
long stat;
void initialize();
void reinitialize(const char*);
char *readline (int chunk_number, char terminator);
public:
File();
File(const char* filename, io_mode m, access_mode a);
File(const char* filename, const char* m);
File(int filedesc, io_mode m);
File(FILE* fileptr);
File(int sz, char* buf, io_mode m);
~File();
File& open(const char* filename, io_mode m, access_mode a);
File& open(const char* filename, const char* m);
File& open(int filedesc, io_mode m);
File& open(FILE* fileptr);
File& close();
File& remove();
int filedesc();
const char* name();
void setname(const char* newname);
int iocount();
int rdstate();
int eof();
int fail();
int bad();
int good();
int readable();
int writable();
int is_open();
operator void*();
void error();
void clear(state_value f = _good);
void set(state_value f);
void unset(state_value f);
File& failif(int cond);
void check_state();
File& get(char& c);
File& put(char c);
File& unget(char c);
File& putback(char c);
File& put(const char* s);
File& get (char* s, int n, char terminator = '\n');
File& getline(char* s, int n, char terminator = '\n');
File& gets (char **s, char terminator = '\n');
File& read(void* x, int sz, int n);
File& write(void* x, int sz, int n);
File& form(const char* ...);
File& scan(const char* ...);
File& flush();
File& flush(char ch);
int fill();
File& seek(long pos, int seek_mode=0);
long tell();
File& setbuf(int buffer_kind);
File& setbuf(int size, char* buf);
File& raw();
};
extern void verbose_File_error_handler(char*);
extern void quiet_File_error_handler(char*);
extern void fatal_File_error_handler(char*);
extern one_arg_error_handler_t File_error_handler;
extern one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t);
inline int File::filedesc()
{
return ((fp)->_file) ;
}
inline const char* File::name()
{
return nm;
}
inline int File::iocount()
{
return stat;
}
inline void File::clear(state_value flag)
{
state = flag;
}
inline void File::set(state_value flag)
{
state = state_value(int(state) | int(flag));
}
inline void File::unset(state_value flag)
{
state = state_value(int(state) & ~int(flag));
}
inline int File::readable()
{
if (fp != 0) { if ( (((fp)->_flag& 00020 )!=0) ) set(_eof); if ( (((fp)->_flag& 00040 )!=0) ) set(_bad);}
return (state == _good && (rw & 01));
}
inline int File::writable()
{
if (fp != 0 && (((fp)->_flag& 00040 )!=0) ) set(_bad);
return ((int(state) & (int(_fail)|int(_bad))) == 0 && (rw & 02));
}
inline int File::is_open()
{
return (fp != 0);
}
inline File& File::raw()
{
return this->File::setbuf( 00004 );
}
inline void File::check_state()
{
if (fp != 0)
{
if ( (((fp)->_flag& 00020 )!=0) )
set(_eof);
else
unset(_eof);
if ( (((fp)->_flag& 00040 )!=0) )
set(_bad);
}
}
inline File& File::failif(int cond)
{
if (cond) set(_fail); return *this;
}
inline File& File::get(char& c)
{
if (readable())
{
int ch = (--(fp)->_cnt>=0?(int)(*(unsigned char*)(fp)->_ptr++):_filbuf(fp)) ;
c = ch;
failif (ch == (-1) );
}
return *this;
}
inline File& File::put(char c)
{
return failif (!writable() || (--( fp)->_cnt>=0? ((int)((unsigned char)((*( fp)->_ptr++=(unsigned)(c))))):_flsbuf((unsigned)(c), fp)) == (-1) );
}
inline File& File::unget(char c)
{
return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == (-1) );
}
inline File& File::putback(char c)
{
return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == (-1) );
}
inline File& File::read(void* x, int sz, int n)
{
return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
}
inline File& File::write(void* x, int sz, int n)
{
return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
}
inline File& File::flush()
{
return failif(!is_open() || fflush(fp) == (-1) );
}
inline File& File::flush(char ch)
{
return failif(!is_open() || _flsbuf(ch, fp) == (-1) );
}
inline int File::fill()
{
failif(!is_open() || (stat = _filbuf(fp)) == (-1) );
return stat;
}
inline File& File::seek(long pos, int seek_mode)
{
return failif (!is_open() || fseek(fp, pos, seek_mode) < 0);
}
inline long File::tell()
{
failif (!is_open() || ((stat = ftell(fp)) < 0));
return stat;
}
inline int File::rdstate()
{
check_state(); return state;
}
inline File::operator void*()
{
check_state(); return (int(state) & (int(_bad)|int(_fail)))? 0 : this ;
}
inline int File::eof()
{
check_state(); return state & _eof;
}
inline int File::fail()
{
check_state(); return state & _fail;
}
inline int File::bad()
{
check_state(); return state & _bad;
}
inline int File::good()
{
check_state(); return rdstate() == _good;
}
# 34 "/usr/local/lib/g++-include/stream.h" 2
# 1 "/usr/local/lib/g++-include/streambuf.h" 1
#pragma once
enum open_mode
{
input=0,
output=1,
append=2
};
class streambuf
{
public:
char* base;
char* pptr;
char* gptr;
char* eptr;
char alloc;
streambuf();
streambuf(char* buf, int buflen);
virtual ~streambuf();
int doallocate();
int allocate();
int must_overflow(int ch);
virtual int overflow(int c = (-1) );
virtual int underflow();
int sgetc();
int snextc();
void stossc();
int sputback(char);
int sputc(int c = (-1) );
virtual streambuf* setbuf(char* buf, int buflen, int preloaded_count = 0);
int sputs(const char* s);
int sputsn(const char* s, int len);
virtual const char* name();
virtual streambuf* open(const char* name, open_mode m);
virtual streambuf* open(const char* filename, io_mode m, access_mode a);
virtual streambuf* open(const char* filename, const char* m);
virtual streambuf* open(int filedesc, io_mode m);
virtual streambuf* open(FILE* fileptr);
virtual int is_open();
virtual int close();
virtual void error();
};
class filebuf: public streambuf
{
public:
int fd;
char opened;
int overflow(int c = (-1) );
int underflow();
filebuf();
filebuf(int newfd);
filebuf(int newfd, char* buf, int buflen);
~filebuf();
streambuf* open(const char* name, open_mode m);
int is_open();
int close();
};
class Filebuf: public streambuf
{
public:
File* Fp;
void init_streambuf_ptrs();
int overflow(int c = (-1) );
int underflow();
Filebuf();
Filebuf(const char* filename, io_mode m, access_mode a);
Filebuf(const char* filename, const char* m);
Filebuf(int filedesc, io_mode m);
Filebuf(FILE* fileptr);
~Filebuf();
const char* name();
streambuf* setbuf(char* buf, int buflen, int preloaded_count = 0);
streambuf* open(const char* filename, io_mode m, access_mode a);
streambuf* open(const char* filename, const char* m);
streambuf* open(int filedesc, io_mode m);
streambuf* open(FILE* fileptr);
int is_open();
int close();
void error();
};
inline int streambuf::must_overflow(int ch)
{
return pptr >= eptr || ch == '\n';
}
inline int streambuf::allocate()
{
return (base == 0)? doallocate() : 0;
}
inline int streambuf::sgetc()
{
return (gptr >= pptr)? underflow() : int(*gptr);
}
inline int streambuf::snextc()
{
++gptr;
return (gptr >= pptr)? underflow() : int(*gptr);
}
inline void streambuf::stossc()
{
if (gptr >= pptr) underflow(); else gptr++;
}
inline int streambuf::sputback(char ch)
{
return (gptr > base)? (*--gptr = ch) : (-1) ;
}
inline int streambuf::sputc(int ch)
{
return must_overflow(ch)? overflow(ch) : (*pptr++ = char(ch));
}
# 35 "/usr/local/lib/g++-include/stream.h" 2
class whitespace
{
char filler;
};
class istream;
class ostream
{
friend class istream;
protected:
streambuf* bp;
state_value state;
char ownbuf;
public:
ostream(const char* filename, io_mode m, access_mode a);
ostream(const char* filename, const char* m);
ostream(int filedesc, io_mode m);
ostream(FILE* fileptr);
ostream(int sz, char* buf);
ostream(int filedesc, char* buf, int buflen);
ostream(int filedesc);
ostream(streambuf* s);
~ostream();
ostream& open(const char* filename, io_mode m, access_mode a);
ostream& open(const char* filename, const char* m);
ostream& open(int filedesc, io_mode m);
ostream& open(FILE* fileptr);
ostream& open(const char* filenam, open_mode m);
ostream& close();
ostream& flush();
int rdstate();
int eof();
int fail();
int bad();
int good();
int readable();
int writable();
int is_open();
operator void*();
int operator !();
const char* name();
char* bufptr();
void error();
void clear(state_value f = _good);
void set(state_value f);
void unset(state_value);
ostream& failif(int cond);
ostream& put(char c);
ostream& put(const char* s);
ostream& put(const char* s, int slen);
ostream& form(const char* fmt, ...);
ostream& operator << (short n);
ostream& operator << (unsigned short n);
ostream& operator << (int n);
ostream& operator << (unsigned int n);
ostream& operator << (long n);
ostream& operator << (unsigned long n);
ostream& operator << (long long n);
ostream& operator << (unsigned long long n);
ostream& operator << (float n);
ostream& operator << (double n);
ostream& operator << (const char* s);
ostream& operator << (char c);
};
class istream
{
friend void eatwhite(istream& s);
protected:
streambuf* bp;
state_value state;
ostream* tied_to;
char skipws;
char ownbuf;
void _flush();
char* readline (int chunk_number, char terminator);
public:
istream(const char* filename, io_mode m, access_mode a,
int sk=1, ostream* t = 0);
istream(const char* filename, const char* m,
int sk=1, ostream* t = 0);
istream(int filedesc, io_mode m, int sk=1, ostream* t = 0);
istream(FILE* fileptr, int sk=1, ostream* t = 0);
istream(int sz, char* buf, int sk=1, ostream* t = 0);
istream(int filedesc, int sk=1, ostream* t = 0);
istream(int filedesc, char* buf, int buflen,
int sk=1, ostream* t = 0);
istream(streambuf* s, int sk=1, ostream* t = 0);
~istream();
istream& open(const char* filename, io_mode m, access_mode a);
istream& open(const char* filename, const char* m);
istream& open(int filedesc, io_mode m);
istream& open(FILE* fileptr);
istream& open(const char* filenam, open_mode m);
istream& close();
ostream* tie(ostream* s);
int skip(int);
int rdstate();
int eof();
int fail();
int bad();
int good();
int readable();
int writable();
int is_open();
operator void*();
int operator !();
const char* name();
char* bufptr();
void error();
void clear(state_value f = _good);
void set(state_value f);
void unset(state_value f);
istream& failif(int cond);
istream& get(char& c);
istream& unget(char c);
istream& putback(char c);
istream& get (char* s, int n, char terminator = '\n');
istream& getline(char* s, int n, char terminator = '\n');
istream& gets (char **s, char terminator = '\n');
istream& operator >> (char& c);
istream& operator >> (short& n);
istream& operator >> (unsigned short& n);
istream& operator >> (int& n);
istream& operator >> (unsigned int& n);
istream& operator >> (long& n);
istream& operator >> (unsigned long& n);
istream& operator >> (long long& n);
istream& operator >> (unsigned long long& n);
istream& operator >> (float& n);
istream& operator >> (double& n);
istream& operator >> (char* s);
istream& operator >> (whitespace& w);
};
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern whitespace WS;
inline void ostream::clear(state_value flag)
{
state = flag;
}
inline void ostream::set(state_value flag)
{
state = state_value(int(state) | int(flag));
}
inline void ostream::unset(state_value flag)
{
state = state_value(int(state) & ~int(flag));
}
inline int ostream::rdstate()
{
return int(state);
}
inline int ostream::good()
{
return state == _good;
}
inline int ostream::eof()
{
return int(state) & int(_eof);
}
inline int ostream::fail()
{
return int(state) & int(_fail);
}
inline int ostream::bad()
{
return int(state) & int(_bad);
}
inline ostream::operator void*()
{
return (state == _good)? this : 0;
}
inline int ostream::operator !()
{
return (state != _good);
}
inline ostream& ostream::failif(int cond)
{
if (cond) set(_fail); return *this;
}
inline int ostream::is_open()
{
return bp->is_open();
}
inline int ostream::readable()
{
return 0;
}
inline int ostream::writable()
{
return (bp != 0) && (state == _good);
}
inline char* ostream::bufptr()
{
return bp->base;
}
inline ostream& ostream::flush()
{
bp->overflow(); return *this;
}
inline ostream& ostream::close()
{
bp->overflow(); bp->close(); return *this;
}
inline ostream& ostream::put(char ch)
{
return failif((state != _good) || bp->sputc(ch) == (-1) );
}
inline ostream& ostream::operator << (char ch)
{
return failif((state != _good) || bp->sputc(ch) == (-1) );
}
inline ostream& ostream::put(const char* s)
{
return failif((state != _good) || bp->sputs(s) == (-1) );
}
inline ostream& ostream::put(const char* s, int len)
{
return failif((state != _good) || bp->sputsn(s, len) == (-1) );
}
inline ostream& ostream::operator << (const char* s)
{
return failif((state != _good) || bp->sputs(s) == (-1) );
}
inline void istream::clear(state_value flag)
{
state = flag;
}
inline void istream::set(state_value flag)
{
state = state_value(int(state) | int(flag));
}
inline void istream::unset(state_value flag)
{
state = state_value(int(state) & ~int(flag));
}
inline int istream::rdstate()
{
return int(state);
}
inline int istream::good()
{
return state == _good;
}
inline int istream::eof()
{
return int(state) & int(_eof);
}
inline int istream::fail()
{
return int(state) & int(_fail);
}
inline int istream::bad()
{
return int(state) & int(_bad);
}
inline istream::operator void*()
{
return (state == _good)? this : 0;
}
inline int istream::operator !()
{
return (state != _good);
}
inline istream& istream::failif(int cond)
{
if (cond) set(_fail); return *this;
}
inline int istream::is_open()
{
return bp->is_open();
}
inline int istream::readable()
{
return (bp != 0) && (bp->is_open()) && (state == _good);
}
inline int istream::writable()
{
return 0;
}
inline void istream::_flush()
{
if(tied_to != 0) tied_to->flush();
}
inline char* istream::bufptr()
{
return bp->base;
}
inline istream& istream::close()
{
bp->close(); return *this;
}
inline int istream::skip(int sk)
{
int was = skipws; skipws = sk; return was;
}
inline ostream* istream::tie(ostream* s)
{
ostream* was = tied_to; tied_to = s; return was;
}
inline istream& istream::unget(char c)
{
if (bp->sputback(c) == (-1) ) set(_fail); return *this;
}
inline istream& istream::putback(char c)
{
if (bp->sputback(c) == (-1) ) set(_fail); return *this;
}
inline void eatwhite(istream& s)
{
s >> WS;
}
# 1 "t.cc" 2
char str[ 50 ];
main()
{
ostream out( sizeof str, str );
out << "Hello World\n";
return 0;
}
------------
If the program is modified as below a signal 6 is generated and the core is
dumped:
#include <stream.h>
char str[ 50 ];
main()
{
ostream out( sizeof str, &str[0] );
out << "Hello World\n";
return 0;
}
-----------
g++ -v t.cc
g++ version 1.36.4 (based on GCC 1.36.93)
/usr/local/lib/gcc-cpp -+ -v -undef -D__GNUC__ -D__GNUG__ -D__cplusplus -Dsparc -Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ t.cc /tmp/cca20305.cpp
GNU CPP version 1.36.93
/usr/local/lib/gcc-cc1plus /tmp/cca20305.cpp -quiet -dumpbase t.cc -version -o /tmp/cca20305.s
GNU C++ version 1.36.4 (based on GCC 1.36.93) (sparc) compiled by GNU C version 1.36.93.
default target switches: -mfpu -mepilogue
t.cc: In function int main ():
t.cc:8: [] applied to non-pointer type
t.cc:8: warning: argument passing of non-const * pointer from const *
g++: Program cc1plus got fatal signal 6.