dsouza@MCC.COM (D'Souza Desmond) (08/26/89)
Hello Michael.
The g++ 1.35.1 COMPILER CRASHES (fatal signal 11) with a segmentation violation when
compiling the source file below. The 2 includes are:
<string.h> from the standard C library and
<stream.h> from the libg++.
I've included:
1. diagnostic messaged received
2. original source file
3. file produced by C preprocessor, using: "g++ -v -E"
I encountered the problem on a:
SunOS Release 4.0 (CAD4_110) #1: Thu Feb 9 12:10:18 CST 1989
ARCH: sun4
MACHINE ARCH: sparc
and have duplicated it on a:
SunOS Release 4.0 (CAD60) #1: Wed Jun 14 13:19:05 CDT 1989
ARCH: sun3
MACHINE ARCH: mc68020
For the SUN-4:
tm.h -> config/tm-sparc+.h
md -> config/sparc.md
Thanks --- Desmond D'Souza
(dsouza@mcc.com)
#============== THE FAILURE =======================
optima%
optima% g++ -g -v hash.cc
g++ version 1.35.1-
/usr/local/gnu/lib/gcc-cpp -+ -v -undef -D__GNU__ -D__GNUG__ -D__cplusplus -Dsparc -Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ hash.cc /tmp/cca07110.cpp
GNU CPP version 1.35
/usr/local/gnu/lib/gcc-cc1plus /tmp/cca07110.cpp -quiet -dumpbase hash.cc -noreg -version -G -o /tmp/cca07110.s
GNU C++ version 1.35.1- (sparc) compiled by GNU C version 1.35.
In method unsigned int hashTable::hash (char *):
hash.cc:31: Segmentation violation
/usr/local/gnu/bin/g++: Program cc1plus got fatal signal 11.
optima%
optima%
optima%
optima%
optima% cat hash.cc
#=================== BEGIN: SOURCE FILE ===============================
#include<string.h>
#include<stream.h>
// Goal: Common Lisp Hash capability (fake multiple values with Ref arguments)
// make-hash-table (test size rehash-size rehash-threshold) -> table
// gethash(key default) -> val, found-p
// puthash(key value) -> T/nil for new-key/old-key
// remhash(key) -> T/nil for found-p
// maphash(func) -> table (func: item,key -> void)
// clrhash() -> table (clearing all entries)
const int HASHSIZE = 401; // size of hash table: PRIMEs work better.
class hashTable {
private:
struct hashNode // internally: build linked list of shared objects
{ char* sharedString; hashNode* next; };
typedef hashNode* hashNodePtr;
unsigned hash (char*); // hash function from string
int size;
hashNodePtr *table; // pointer to array of pointers to hashNodes
public:
hashTable(int sz = HASHSIZE);
~hashTable();
hashNode** lookup(char*);
hashNode* install(hashNode**, char*);
};
unsigned hashTable::hash (char *s)
{ unsigned hashval;
for (hashval = 0; *s != '\0'; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
hashTable::hashTable(int sz = HASHSIZE)
{ size = sz;
table = new hashNodePtr [sz];
for (int i = 0; i++ < sz; table[i] = 0); }
hashTable::~hashTable () {
delete [size] table;}
/* LOOKUP returns a REF. to a POINTER to a shared hashNode i.e. may be ASSIGNED if null */
hashNode** hashTable::lookup(char* s) {
hashNodePtr *p;
for (p = &table[hash(s)]; *p != 0; p = &((*p)->next))
if (strcmp(s, (*p)->sharedString) == 0) // FOUND
break;
return p;
}
/* INSTALL must always be preceeded with a (failed) call to LOOKUP,
which will provide a "p" pointing to the last pointer of a hash bucket */
//Make a hashNode have a VALUE of type void*;
hashNode* hashTable::install(hashNode** p, char* s) {
hashNode* hN = new hashNode;
char* str = new char[strlen(s) + 1];
strcpy(str,s);
hN->sharedString = str;
*p = hN;
return hN;
}
main () {
hashTable table = hashTable(600);
char buf[100];
int i;
for (i = 0; i < 100; )
{ hashNode **p;
cout << "\n Enter word: ";
cin >> buf;
cout << " ... read " << buf;
p = table.lookup(buf);
if (*p != 0)
cout << " FOUND";
else { table.install(p, buf);
cout << " ... NOT FOUND";
}
}}
#==================== END: SOURCE FILE ==========================
optima%
optima%
optima%
optima% g++ -g -E hash.cc > hash.cpp
optima%
optima%
optima% cat hash.cpp
#=================== BEGIN: OUTFILE CREATED BY "g++ -E" ==============
# 1 "hash.cc"
# 1 "/usr/local/gnu/lib/g++-include/string.h"
# 1 "/usr/local/gnu/lib/g++-include/std.h"
#pragma once
#pragma once
overload abs;
overload atoi;
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);
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);
int bind(int, void*, int);
int 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 volatile 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 listen(int, int);
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 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 char** environ;
extern int errno;
extern char* sys_errlist[];
extern int sys_nerr;
extern char* optarg;
extern int opterr;
extern int optind;
# 1 "/usr/local/gnu/lib/g++-include/string.h"
# 1 "hash.cc"
# 1 "/usr/local/gnu/lib/g++-include/stream.h"
#pragma once
# 1 "/usr/local/gnu/lib/g++-include/File.h"
#pragma once
# 1 "/usr/local/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 "/usr/local/gnu/lib/g++-include/stddef.h"
#pragma once
typedef unsigned char wchar_t;
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 "/usr/local/gnu/lib/g++-include/builtin.h"
# 1 "/usr/local/gnu/lib/g++-include/math.h"
#pragma once
overload acos;
overload acosh;
overload asin;
overload asinh;
overload atan;
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;
# 79 "/usr/local/gnu/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);
}
struct exception
{
int type;
char* name;
double arg1, arg2, retval;
};
extern "C" int matherr(exception*);
# 1 "/usr/local/gnu/lib/g++-include/values.h"
#pragma once
# 108 "/usr/local/gnu/lib/g++-include/values.h"
# 156 "/usr/local/gnu/lib/g++-include/math.h"
# 50 "/usr/local/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 "/usr/local/gnu/lib/g++-include/File.h"
# 1 "/usr/local/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);
char* sprintf(char*, const char* ...);
char* vsprintf(char*, const char*, void* ap);
}
# 29 "/usr/local/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 Filebuf;
class File
{
friend class Filebuf;
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& 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 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::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 = 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;
}
# 34 "/usr/local/gnu/lib/g++-include/stream.h"
# 1 "/usr/local/gnu/lib/g++-include/streambuf.h"
#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();
virtual int overflow(int c = (-1) );
virtual int underflow();
int sgetc();
int snextc();
void stossc();
void 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( struct _iobuf * 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( struct _iobuf * 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( struct _iobuf * fileptr);
int is_open();
int close();
void error();
};
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 void streambuf::sputback(char ch)
{
if (gptr > base) *--gptr = ch;
}
inline int streambuf::sputc(int ch = (-1) )
{
return (pptr < eptr)? (*pptr++ = (char)(ch)) : overflow(ch);
}
# 35 "/usr/local/gnu/lib/g++-include/stream.h"
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( struct _iobuf * 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( struct _iobuf * 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();
void* operator void*();
int operator !();
const char* name();
char* bufptr();
void error();
void clear(state_value f = 0);
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 << (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( struct _iobuf * 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( struct _iobuf * 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();
void* operator void*();
int operator !();
const char* name();
char* bufptr();
void error();
void clear(state_value f = 0);
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 >> (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 = _good)
{
state = 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 void* ostream::operator void*()
{
return (state == _good)? this : 0;
}
inline int ostream::operator !()
{
return (state != _good);
}
inline ostream& ostream::failif(int cond)
{
if (cond) state |= _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 = _good)
{
state = 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 void* istream::operator void*()
{
return (state == _good)? this : 0;
}
inline int istream::operator !()
{
return (state != _good);
}
inline istream& istream::failif(int cond)
{
if (cond) state |= _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)
{
bp->sputback(c); return *this;
}
inline istream& istream::putback(char c)
{
bp->sputback(c); return *this;
}
inline void eatwhite(istream& s)
{
s >> WS;
}
# 2 "hash.cc"
const int HASHSIZE = 401;
class hashTable {
private:
struct hashNode
{ char* sharedString; hashNode* next; };
typedef hashNode* hashNodePtr;
unsigned hash (char*);
int size;
hashNodePtr *table;
public:
hashTable(int sz = HASHSIZE);
~hashTable();
hashNode** lookup(char*);
hashNode* install(hashNode**, char*);
};
unsigned hashTable::hash (char *s)
{ unsigned hashval;
for (hashval = 0; *s != '\0'; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
hashTable::hashTable(int sz = HASHSIZE)
{ size = sz;
table = new hashNodePtr [sz];
for (int i = 0; i++ < sz; table[i] = 0); }
hashTable::~hashTable () {
delete [size] table;}
hashNode** hashTable::lookup(char* s) {
hashNodePtr *p;
for (p = &table[hash(s)]; *p != 0; p = &((*p)->next))
if (strcmp(s, (*p)->sharedString) == 0)
break;
return p;
}
hashNode* hashTable::install(hashNode** p, char* s) {
hashNode* hN = new hashNode;
char* str = new char[strlen(s) + 1];
strcpy(str,s);
hN->sharedString = str;
*p = hN;
return hN;
}
main () {
hashTable table = hashTable(600);
char buf[100];
int i;
for (i = 0; i < 100; )
{ hashNode **p;
cout << "\n Enter word: ";
cin >> buf;
cout << " ... read " << buf;
p = table.lookup(buf);
if (*p != 0)
cout << " FOUND";
else { table.install(p, buf);
cout << " ... NOT FOUND";
}
}}
#=================== END : OUTFILE CREATED BY "g++ -E" ==============
optima%
optima%
optima%
optima% optima%
-- D'Souza Desmond