Thread View: gnu.g++.bug
1 messages
1 total messages
Started by Michael Allen
Wed, 13 Dec 1989 18:47
g++ bug?
Author: Michael Allen
Date: Wed, 13 Dec 1989 18:47
Date: Wed, 13 Dec 1989 18:47
1632 lines
30375 bytes
30375 bytes
(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!
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads