allen@MDTF05.FNAL.GOV (Michael Allen) (12/14/89)
(Please respond to mccrory@mdtf05.fnal.gov) g++ bug report follows. Output from compilation: **************************************** cd /home/mccrory/ /home/gnu/bin/g++ -v -g -Dsun4 -DEBUG -I/home/gnu/lib/g++-include -o test test-raw.C g++ version 1.35.0 /home/gnu/lib/gcc-cpp -+ -v -Dsun4 -DEBUG -I/home/gnu/lib/g++-include -undef -D__GNU__ -D__GNUG__ -D__cplusplus -Dsparc -Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ test-raw.C /tmp/cca01741.cpp GNU CPP version 1.35 /home/gnu/lib/gcc-cc1plus /tmp/cca01741.cpp -quiet -dumpbase test-raw.C -noreg -version -G -o /tmp/cca01741.s GNU C++ version 1.35.0 (sparc) compiled by GNU C version 1.35. /usr/include/malloc.h:34: conflicting types for `char *malloc ()' /usr/include/malloc.h:35: conflicting types for `char *realloc ()' /usr/include/malloc.h:37: warning: type declaration of mallinfo shadowed In method enum Boolean ListType::is_readable (): /usr/include/ac/BadInclude.h:104: Segmentation violation /home/gnu/bin/g++: Program cc1plus got fatal signal 11. Compilation finished at Tue Dec 5 16:27:47 **************************************** I certainly understand the malloc problem (stupid Sun include file!). Its the segmentation violation that's got me bugged. I get the same problem on my Sun 4/260 and a friend's Sun 4/110. I've pared it down a bit. The segmentation violation always occurs on the second Boolean method defined in the ListType class. In the un-pared version (not included), there are lots of other Boolean methods (probably 20-ish) which compile just fine. Source file: (/home/mccrory/test-raw.C; from a -E g++ run) **************************************** # 1 "test.C" # 1 "/home/gnu/lib/g++-include/stream.h" #pragma once # 1 "/home/gnu/lib/g++-include/File.h" #pragma once # 1 "/home/gnu/lib/g++-include/builtin.h" #pragma once overload clearbit; overload dec; overload gcd; overload hex; overload lcm; overload lg; overload oct; overload setbit; overload sign; overload sqr; overload testbit; overload even; overload odd; # 1 "/home/gnu/lib/g++-include/std.h" #pragma once #pragma once overload abs; overload atoi; extern "C" { void _exit(int); void abort(void); int abs(int); int access(const char*, int); int acct(const char*); unsigned alarm(unsigned); void* alloca(int); double atof(const char*); int atoi(const char*); long atol(const char*); int bcmp(const void*, const void*, int); void bcopy(const void*, void*, int); void* brk(void*); void bzero(void*, int); 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*, 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 exit(int); int fchmod(int, int); int fchown(int, int, int); int fcntl(int, 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, char**, 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* index(const char*, int); 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 lock(int, int, long); long lrand48(void); long lseek(int, long, int); void* malloc(unsigned); 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 pause(void); void perror(const char*); int pipe(int*); void 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*); char* rindex(const char*, int); 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 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 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 char** environ; extern int errno; extern char* sys_errlist[]; extern int sys_nerr; extern char* optarg; extern int opterr; extern int optind; # 48 "/home/gnu/lib/g++-include/builtin.h" # 1 "/home/gnu/lib/g++-include/stddef.h" #pragma once enum bool { FALSE = 0, TRUE = 1 }; typedef void (*one_arg_error_handler_t)(const char*); typedef void (*two_arg_error_handler_t)(const char*, const char*); # 49 "/home/gnu/lib/g++-include/builtin.h" # 1 "/home/gnu/lib/g++-include/math.h" #pragma once overload acos; overload acosh; overload asin; overload asinh; overload atan2; overload atanh; overload ceil; overload cos; overload cosh; overload exp; overload floor; overload gamma; overload hypot; overload log; overload log10; overload pow; overload sin; overload sinh; overload sqrt; overload tan; overload tanh; 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); } struct exception { int type; char* name; double arg1, arg2, retval; }; extern "C" int matherr(exception*); # 1 "/home/gnu/lib/g++-include/values.h" #pragma once # 108 "/home/gnu/lib/g++-include/values.h" # 126 "/home/gnu/lib/g++-include/math.h" # 50 "/home/gnu/lib/g++-include/builtin.h" long abs(long); double abs(double); void clearbit(long&, long); void setbit(long&, long); int testbit(long, long); int even(long); long gcd(long, long); long lg(long); long lcm(long, long); int odd(long); double pow(double, long); long pow(long, long); int sign(long); int sign(double); long sqr(long); double sqr(double); long sqrt(long); double start_timer(); double return_elapsed_time(double); char* itoa(long x, int base = 10, int width = 0); char* hex(long x, int width = 0); char* oct(long x, int width = 0); char* dec(long x, int width = 0); char* form(const char* fmt ...); char* chr(char ch); 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); inline double abs(double _arg) { return (_arg < 0.0)? -_arg : _arg; } inline long abs(long _arg) { return (_arg < 0)? -_arg : _arg; } inline int sign(long _arg) { return (_arg == 0) ? 0 : ( (_arg > 0) ? 1 : -1 ); } inline int sign(double _arg) { return (_arg == 0.0) ? 0 : ( (_arg > 0.0) ? 1 : -1 ); } inline long sqr(long _arg) { return _arg * _arg; } inline double sqr(double _arg) { return _arg * _arg; } inline int even(long _arg) { return !(_arg & 1); } inline int odd(long _arg) { return (_arg & 1); } inline long lcm(long _x, long _y) { return _x / gcd(_x, _y) * _y; } inline void setbit(long& _x, long _b) { _x |= (1 << _b); } inline void clearbit(long& _x, long _b) { _x &= ~(1 << _b); } inline int testbit(long _x, long _b) { return ((_x & (1 << _b)) != 0); } # 28 "/home/gnu/lib/g++-include/File.h" # 1 "/home/gnu/lib/g++-include/stdio.h" #pragma once extern struct _iobuf { int _cnt; char* _ptr; char* _base; int _bufsiz; short _flag; char _file; } _iob[]; extern "C" { int _doprnt(const char*, void*, struct _iobuf *); int _doscan( struct _iobuf *, const char*, void*); int _filbuf( struct _iobuf *); int _flsbuf(unsigned, struct _iobuf *); int fclose( struct _iobuf *); struct _iobuf * fdopen(int, const char*); int fflush( struct _iobuf *); int fgetc( struct _iobuf *); char* fgets(char*, int, struct _iobuf *); struct _iobuf * fopen(const char*, const char*); int fprintf( struct _iobuf *, const char* ...); int fputc(int, struct _iobuf *); int fputs(const char*, struct _iobuf *); int fread(void*, int, int, struct _iobuf *); struct _iobuf * freopen(const char*, const char*, struct _iobuf *); int fscanf( struct _iobuf *, const char* ...); int fseek( struct _iobuf *, long, int); long ftell( struct _iobuf *); int fwrite(const void*, int, int, struct _iobuf *); char* gets(char*); int getw( struct _iobuf *); int pclose( struct _iobuf *); struct _iobuf * popen(const char*, const char*); int printf(const char* ...); void puts(const char*); int putw(int, struct _iobuf *); int scanf(const char* ...); void setbuf( struct _iobuf *, char*); void setbuffer( struct _iobuf *, char*, int); void setlinebuf( struct _iobuf *); void setvbuf( struct _iobuf *, char*, int, int); int sscanf(char*, const char* ...); struct _iobuf * tmpfile(); int ungetc(int, struct _iobuf *); int vfprintf( struct _iobuf *, const char*, void* ap); int vprintf(const char*, void* ap); int vsprintf(char*, const char*, void* ap); int sprintf(char*, const char* ...); } # 29 "/home/gnu/lib/g++-include/File.h" 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 File { protected: struct _iobuf * 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( struct _iobuf * 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( struct _iobuf * 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(); void* operator void*(); void error(); void clear(state_value f = 0); 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& seek(long pos, int seek_mode=0); long tell(); File& flush(); 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 int File::readable() { if (fp != 0) { if ( (((fp)->_flag& 00020 )!=0) ) state |= _eof; if ( (((fp)->_flag& 00040 )!=0) ) state |= _bad;} return (state == _good && (rw & 01)); } inline int File::writable() { if (fp != 0 && (((fp)->_flag& 00040 )!=0) ) state |= _bad; return ((state & (_fail|_bad)) == 0 && (rw & 02)); } inline int File::is_open() { return (fp != 0); } inline void File::clear(state_value flag = 0) { state = flag; } inline File& File::raw() { return this->File::setbuf( 00004 ); } inline void File::check_state() { if (fp != 0) { if ( (((fp)->_flag& 00020 )!=0) ) state |= _eof; else state &= ~_eof; if ( (((fp)->_flag& 00040 )!=0) ) state |= _bad; } } inline File& File::failif(int cond) { if (cond) state |= _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::seek(long pos, int seek_mode = 0) { 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 void* File::operator void*() { check_state(); return (state & (_bad|_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; } # 28 "/home/gnu/lib/g++-include/stream.h" class whitespace { char filler; }; class ostream: private File { public: File::open; File::close; File::remove; File::filedesc; File::is_open; File::raw; File::put; File::check_state; File::iocount; File::error; File::name; File::setname; File::rdstate; File::flush; File::eof; File::fail; File::bad; File::good; File::clear; File::failif; File::setbuf; File::writable; File::readable; ostream(); ostream(const char* filename, io_mode m, access_mode a); ostream(const char* filename, const char* m); ostream(int filedesc, io_mode m = io_writeonly); ostream( struct _iobuf * fileptr); ostream(int sz, char* buf); ~ostream(); void* operator void*(); ostream& form(const char* fmt, ...); ostream& operator << (char c); 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 << (float n); ostream& operator << (double n); ostream& operator << (const char* s); }; class istream: private File { protected: ostream* tied_to; void _flush(); public: File::open; File::close; File::get; File::gets; File::remove; File::filedesc; File::is_open; File::raw; File::unget; File::getline; File::iocount; File::error; File::name; File::setname; File::rdstate; File::putback; File::eof; File::fail; File::bad; File::good; File::clear; File::failif; File::setbuf; File::writable; File::readable; File::check_state; istream(); istream(const char* filename, io_mode m, access_mode a); istream(const char* filename, const char* m); istream(int filedesc, io_mode m = io_readonly); istream( struct _iobuf * fileptr); istream(int sz, char* buf); ~istream(); void* operator void*(); ostream* tie(ostream* s); istream& scan(const char* fmt, ...); 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 >> (float& n); istream& operator >> (double& n); istream& operator >> (char* s); istream& operator >> (whitespace& w); }; void eatwhite(istream& s); extern istream cin; extern ostream cout; extern ostream cerr; extern whitespace WS; inline void* ostream::operator void*() { check_state(); return (state & (_bad|_fail))? 0 : this ; } inline ostream& ostream::operator<<(char c) { put(c); return *this; } inline void* istream::operator void*() { check_state(); return (state & (_bad|_fail))? 0 : this ; } inline void istream::_flush() { if (tied_to) tied_to->flush(); } # 1 "test.C" # 1 "/usr/include/ac/BadInclude.h" # 1 "/usr/include/malloc.h" struct mallinfo { int arena; int ordblks; int smblks; int hblks; int hblkhd; int usmblks; int fsmblks; int uordblks; int fordblks; int keepcost; int mxfast; int nlblks; int grain; int uordbytes; int allocated; int treeoverhead; }; extern char *malloc(); extern char *realloc(); extern int mallopt(); extern struct mallinfo mallinfo(); # 5 "/usr/include/ac/BadInclude.h" # 1 "/usr/include/StdDefs.h" typedef char Byte; typedef short Word; typedef long LongWord; typedef unsigned char UnsignedByte; typedef unsigned short UnsignedWord; typedef unsigned long UnsignedLongWord; typedef void* Pvoid; typedef char* Pchar; typedef Byte* PByte; typedef UnsignedByte* PUnsignedByte; typedef short* Pshort; typedef Word* PWord; typedef UnsignedWord* PUnsignedWord; typedef int* Pint; typedef long* Plong; typedef LongWord* PLongWord; typedef UnsignedLongWord* PUnsignedLongWord; typedef float* Pfloat; typedef double* Pdouble; enum Boolean { false = 0, true }; inline Word hiword(UnsignedLongWord foo) { return Word((foo>>16)&0xFFFF); } inline Word loword(UnsignedLongWord foo) { return Word(foo & 0xFFFF); } inline Byte hibyte(UnsignedWord foo) { return Byte((foo>>8)&0xFF); } inline Byte lobyte(UnsignedWord foo) { return Byte(foo & 0xFF); } inline Byte hinibble(UnsignedByte foo) { return Byte((foo>>4)&0xF); } inline Byte lonibble(UnsignedByte foo) { return Byte(foo & 0xF); } inline UnsignedWord unsigned_hiword(UnsignedLongWord foo) { return UnsignedWord((foo>>16)&0xFFFF); } inline UnsignedWord unsigned_loword(UnsignedLongWord foo) { return UnsignedWord(foo & 0xFFFF); } inline UnsignedByte unsigned_hibyte(UnsignedWord foo) { return UnsignedByte((foo>>8)&0xFF); } inline UnsignedByte unsigned_lobyte(UnsignedWord foo) { return Byte(foo & 0xFF); } inline UnsignedByte unsigned_hinibble(UnsignedByte foo) { return UnsignedByte((foo>>4)&0xF); } inline UnsignedByte unsigned_lonibble(UnsignedByte foo) { return UnsignedByte(foo & 0xF); } inline void memcopy(void* from, void* to,unsigned int count,unsigned int size =1) { for ( int i = 0; i < count*size; i++) PByte(to)[i] = PByte(from)[i]; } # 6 "/usr/include/ac/BadInclude.h" enum IDENTTYPE { CHAN = 1, BIT, ADDR, NAME, BYTE, SVAR, RDAT, PAGE, GID, SIO, DSBK }; class IdentType { IDENTTYPE type; public: IdentType(IDENTTYPE t) { type = t; } int size(); operator IDENTTYPE() { return type; } friend ostream& operator<<(ostream&,IdentType&); }; enum LISTTYPE { READING = 0, SETTING = 1, NOMINAL = 2, TOLERANCE = 3, ANALOG_ALARM_TRIPS = 4, ANALOG_ASSOC_DIGITAL_STATUS = 5, MOTOR_COUNTDOWN = 6, KNOB_SCALED_RELATIVE_SETTING = 7, ADESC_ANALOG_CONTROL = 8, ADESC_ASSOC_DIGITAL_STATUS = 9, ADESC_ASSOC_DIGITAL_CONTROL = 10, ADESC_CONVERSION_TYPE = 11, ADESC_SCALE_FACTORS = 12, ADESC_TITLE = 13, ADESC_ASSOC_DIGITAL_STATUS_TEXT = 14, ADESC_NAME = 15, ADESC_UNITS = 16, ADESC_NEXT_SIBLING = 17, ADESC_MOD_DATE = 18, CHAN_BY_NAME = 19, MEMORY_BYTE_WISE = 20, DIO_BIT_WISE = 21, ASSOC_DIGITAL_CONTROL_CHAN_WISE = 22, DIGITAL_BIT_TITLE = 23, DIGITAL_ALARM_TRIPS = 24, DIO_BYTE_WISE = 25, SYSTEM_GLOBAL_VARIABLES = 26, MEMORY_WORD_WISE = 29, READ_DATA_ACCESS_TABLE = 30, BYTE_ADDR_TABLE = 34, SERIAL_PORT_IO = 36, MEMORY_FIFO_WISE = 38, UNSCALED_RELATIVE_SETTING = 39, FLOAT_READING = 40, FLOAT_SETTING = 41, FLOAT_NOMINAL = 42, FLOAT_TOLERANCE = 43, FLOAT_UNSCALED_RELATIVE = 44, DEVICE_FAMILY = 49, DATA_STREAM_NOW = 50, DATA_STREAM_HISTORY = 51, DATA_STREAM_FORMAT = 52, DATA_STREAM_TABLE = 53, DATA_STREAM_NAME = 54 }; enum ACCESSMODE { R = 1, W, RW }; class ListType { char type; public: ListType(int); operator Byte() { return Byte(type); } Boolean is_settable() { return ((access_mode() == R) ? false : true); } Boolean is_readable() { return ((access_mode() == W) ? false : true); } Boolean is_valid() { return (type < 0) ? false : true; } int ident_type(); int access_mode(); int nominal_size(); friend ostream& operator<<(ostream&, const ListType&); }; # 2 "test.C" int main(int argc, char* argv[]) { cout << "Hello world!\n" ; } ********** end of input file ********** Elliott McCrory Fermi National Accelerator Lab Batavia, IL 708-840-4414 Happy Holidays!