Thread View: gnu.g++.bug
1 messages
1 total messages
Started by Greg Sorensen
Sat, 17 Jun 1989 19:42
Fatal signal 6.
Author: Greg Sorensen
Date: Sat, 17 Jun 1989 19:42
Date: Sat, 17 Jun 1989 19:42
2052 lines
37272 bytes
37272 bytes
This code got this signal when I changed previously compiling code to
use multiple inheritances.
Sun4/280, running OS 4.0. g++ 1.35.0. I'm sure that I could pare this
file down to the smallest envelope, but I don't have time, and, as the
manual says on p. 71, "simplification is not necessary."
I've included a typescript, which includes listings of the code that does
this, after which I've appended the results of
g++ -E testi.C > outfile
as asked to on p 70-71.
Greg Sorensen
Script started on Sat Jun 17 15:35:35 1989
imager.mit.edu:~/code/++/simp > g++ -v
g++ version 1.35.0
imager.mit.edu:~/code/++/simp > g++ testi.C
g++: Program cc1plus got fatal signal 6.
imager.mit.edu:~/code/++/simp > cat im*
/*
image.h: C++ classes for image handling.
$Revision: 1.11 $
$Date: 89/06/17 13:40:51 $
$Id: image.h,v 1.11 89/06/17 13:40:51 sorensen Exp $
$Source: /home/sorensen/code/++/simp/RCS/image.h,v $
*/
#include "img_global.h"
class base
{
private:
int tmp=0;
};
class img : public base {
friend class int_image;
private:
fund_type img_type;
public:
img() {;}
img(img& ii);
~img() { cout << "lowest-level base destructor\n"; }
virtual void print() { cout << "The abstract print.\n"; }
virtual void getnext() {;}
virtual void putnext() {;}
//virtual img& operator+(img&) = 0; // C++ 2.0 trick
};
class OneD : public base {
friend class int1D;
private:
int x_dim;
public:
virtual int& operator[](int ii) = 0;
};
img::img(img& ii)
{
img_type = ii.img_type;
}
class TwoD : public base {
friend class int2D;
private:
int x_dim;
int y_dim;
public:
virtual OneD& operator[](int ii) = 0;
};
class int_image: public img {
friend class int1D;
friend class int2D;
private:
int * int_base;
int * int_cur_ptr;
int int_length;
int int_index;
int int_max= -MAXINT;
int int_min=MAXINT;
void check_int_val(int value);
public:
int_image();
int_update(int * start, int length);
int_image(int * start, int length);
int_image(int_image& ii);
int getnext(int index);
int putnext(int value, int index);
};
int_image::int_image()
{
img_type = INT;
int_base = 0;
int_cur_ptr = 0;
int_length = 0;
int_index = -1;
}
int_image::int_update(int * start, int length)
{
int_base = start;
int_cur_ptr = int_base;
int_length = length;
int_index = 0;
int_max = int_max_of(start,length);
int_min = int_min_of(start,length);
}
int_image::int_image(int * start, int length)
{
img_type = INT;
int_base = start;
int_cur_ptr = int_base;
int_length = length;
int_index = 0;
int_max = int_max_of(start,length);
int_min = int_min_of(start,length);
}
int_image::int_image(int_image& ii)
{
if(debug) { cout << "Creating an int_image from an int_image\n"; }
int_length = ii.int_length;
// BSD-DEPENDANT CODE: next 2 lines?
char * temp_int = calloc(int_length, sizeof(int));
int_base = memcpy( temp_int, ii.int_base, int_length * sizeof(int) );
int_cur_ptr = int_base;
int_max = int_max_of(int_base,int_length);
int_min = int_min_of(int_base,int_length);
}
int_image::getnext(int index = -1)
{
if(index==0)
{
int_cur_ptr = int_base;
int_index=0;
return(*int_cur_ptr);
}
else if(index == -1)
{
int_index++;
return *(int_cur_ptr++);
}
else if(index > 0 && index < (int_length - 1) )
{
int_index = index;
int_cur_ptr = int_base + index;
return *int_cur_ptr;
}
else
{
cerr << "int_image boundary overrun. Fatal error.\n";
exit(-1); // REPLACE with less drastic code...
}
}
void int_image::check_int_val(int value)
{
if(value > int_max) int_max = value;
else if(value < int_min) int_min = value;
}
int_image::putnext(int value, int index = -1)
{
if(index==0)
{
int_cur_ptr = int_base;
int_index = 0;
*int_cur_ptr = value;
return 1;
}
else if(index == -1)
{
*int_cur_ptr = value;
check_int_val(value);
int_cur_ptr++;
int_index++;
return 1;
}
else if(index > 0 && index < (int_length - 1) )
{
int_index = index;
int_cur_ptr = int_base;
int_cur_ptr += index;
*int_cur_ptr = value;
check_int_val(value);
}
else
{
cerr << "int_image boundary overrun. Fatal error.\n";
exit(-1); // REPLACE with less drastic code...
}
}
class int1D: public int_image, OneD
{
friend class int2D;
//private:
//int x_dim;
public:
void print();
int1D();
int1D_update(int * start, int xlength);
int1D(int * start, int xlength);
int1D(int1D& ii);
int& operator[](int ii);
};
int1D::int1D()
{
x_dim = 0;
}
int1D::int1D(int * start,int xlength) : (start, xlength)
{
x_dim = xlength;
}
int1D::int1D_update(int * start,int xlength)
{
int_image::int_update(start, xlength);
x_dim = xlength;
}
int1D::int1D(int1D& ii) : ((int_image&) ii)
{
x_dim = ii.x_dim;
}
void int1D::print()
{
getnext(0);
for(int i=0; i < x_dim; i++) cout << getnext();
}
int& int1D::operator[](int ii)
{
return *(int_base + ii);
}
class int2D : public int_image, TwoD
{
private:
//int x_dim;
//int y_dim;
int1D * int1D_list;
int1D * cur_1D;
public:
void print(){;}
int2D(int * start, int xlength, int ylength);
int2D(int2D& ii);
OneD& operator[](int ii);
};
int2D::int2D(int * start, int xlength, int ylength): (start,(xlength * ylength))
{
x_dim = xlength;
y_dim = ylength;
int1D int1Dstuff[y_dim]; // GCC construct...will it work?
int1D_list = (int1D *) calloc(y_dim,sizeof(int1D));
cur_1D = int1D_list;
for(int i=0; i < y_dim; i++)
{
(int1Dstuff[i]).int1D_update(start + (i * x_dim), x_dim);
// since int1Dstuff will be deallocated, copy this stuff to a safe place...
cur_1D = (int1D *) memcpy(cur_1D, &int1Dstuff[i], sizeof(int1D));
cur_1D++;
}
}
OneD& int2D::operator[](int ii)
{
return *(int1D_list + ii);
}
/*
img_global.h: global include files...
$Revision: 1.2 $
$Date: 89/06/16 19:02:26 $
$Id: img_global.h,v 1.2 89/06/16 19:02:26 sorensen Exp $
$Source: /home/sorensen/code/++/simp/RCS/img_global.h,v $
*/
#include <std.h>
#include <stream.h>
#define debug 1
enum fund_type { INT, SHORT, LONG, BYTE, FLOAT, DOUBLE, BIT };
// int_max_of, int_min_of: simple max and min finders.
// Probably small enough to be inline.
int int_max_of(int * point, int length){
int * localpoint;
int maxint;
maxint = -MAXINT;
localpoint = point;
for(int i=0;i<length;i++){
if(maxint < *localpoint) maxint = *localpoint;
localpoint++;
}
return maxint;
}
int int_min_of(int * point, int length){
int * localpoint;
int minint;
minint = MAXINT;
localpoint = point;
for(int i=0;i<length;i++){
if(minint < *localpoint) minint = *localpoint;
localpoint++;
}
return minint;
}
imager.mit.edu:~/code/++/simp > cat testi.C
#include "image.h"
main()
{
int array[10];
for(int i=0;i<10;i++) array[i] = i;
int1D biff(array,10);
img &base = biff;
cout << sizeof(int1D) << "\n";
biff.print();
int1D fred = biff;
fred.print();
cout << "testing: ";
for(i=0;i<10;i++) cout << fred[i];
cout << "\n";
/*
for(i=0;i<10;i++) base[i] = 2*i;
cout << "testing2: ";
for(i=0;i<10;i++) cout << base[i];
cout << "\n";
*/
}
imager.mit.edu:~/code/++/simp > exit
imager.mit.edu:~/code/++/simp >
script done on Sat Jun 17 15:36:19 1989
---------------
# 1 "testi.C"
# 1 "image.h"
# 1 "img_global.h"
# 1 "/usr/local/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;
# 12 "img_global.h"
# 1 "/usr/local/lib/g++-include/stream.h"
#pragma once
# 1 "/usr/local/lib/g++-include/File.h"
#pragma once
# 1 "/usr/local/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/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 "/usr/local/lib/g++-include/builtin.h"
# 1 "/usr/local/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 "/usr/local/lib/g++-include/values.h"
#pragma once
# 108 "/usr/local/lib/g++-include/values.h"
# 126 "/usr/local/lib/g++-include/math.h"
# 50 "/usr/local/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/lib/g++-include/File.h"
# 1 "/usr/local/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 "/usr/local/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 "/usr/local/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();
}
# 13 "img_global.h"
enum fund_type { INT, SHORT, LONG, BYTE, FLOAT, DOUBLE, BIT };
int int_max_of(int * point, int length){
int * localpoint;
int maxint;
maxint = - (~ (1 << ( (8 * (int)sizeof(int)) - 1)) ) ;
localpoint = point;
for(int i=0;i<length;i++){
if(maxint < *localpoint) maxint = *localpoint;
localpoint++;
}
return maxint;
}
int int_min_of(int * point, int length){
int * localpoint;
int minint;
minint = (~ (1 << ( (8 * (int)sizeof(int)) - 1)) ) ;
localpoint = point;
for(int i=0;i<length;i++){
if(minint < *localpoint) minint = *localpoint;
localpoint++;
}
return minint;
}
# 11 "image.h"
class base
{
private:
int tmp=0;
};
class img : public base {
friend class int_image;
private:
fund_type img_type;
public:
img() {;}
img(img& ii);
~img() { cout << "lowest-level base destructor\n"; }
virtual void print() { cout << "The abstract print.\n"; }
virtual void getnext() {;}
virtual void putnext() {;}
};
class OneD : public base {
friend class int1D;
private:
int x_dim;
public:
virtual int& operator[](int ii) = 0;
};
img::img(img& ii)
{
img_type = ii.img_type;
}
class TwoD : public base {
friend class int2D;
private:
int x_dim;
int y_dim;
public:
virtual OneD& operator[](int ii) = 0;
};
class int_image: public img {
friend class int1D;
friend class int2D;
private:
int * int_base;
int * int_cur_ptr;
int int_length;
int int_index;
int int_max= - (~ (1 << ( (8 * (int)sizeof(int)) - 1)) ) ;
int int_min= (~ (1 << ( (8 * (int)sizeof(int)) - 1)) ) ;
void check_int_val(int value);
public:
int_image();
int_update(int * start, int length);
int_image(int * start, int length);
int_image(int_image& ii);
int getnext(int index);
int putnext(int value, int index);
};
int_image::int_image()
{
img_type = INT;
int_base = 0;
int_cur_ptr = 0;
int_length = 0;
int_index = -1;
}
int_image::int_update(int * start, int length)
{
int_base = start;
int_cur_ptr = int_base;
int_length = length;
int_index = 0;
int_max = int_max_of(start,length);
int_min = int_min_of(start,length);
}
int_image::int_image(int * start, int length)
{
img_type = INT;
int_base = start;
int_cur_ptr = int_base;
int_length = length;
int_index = 0;
int_max = int_max_of(start,length);
int_min = int_min_of(start,length);
}
int_image::int_image(int_image& ii)
{
if(1 ) { cout << "Creating an int_image from an int_image\n"; }
int_length = ii.int_length;
char * temp_int = calloc(int_length, sizeof(int));
int_base = memcpy( temp_int, ii.int_base, int_length * sizeof(int) );
int_cur_ptr = int_base;
int_max = int_max_of(int_base,int_length);
int_min = int_min_of(int_base,int_length);
}
int_image::getnext(int index = -1)
{
if(index==0)
{
int_cur_ptr = int_base;
int_index=0;
return(*int_cur_ptr);
}
else if(index == -1)
{
int_index++;
return *(int_cur_ptr++);
}
else if(index > 0 && index < (int_length - 1) )
{
int_index = index;
int_cur_ptr = int_base + index;
return *int_cur_ptr;
}
else
{
cerr << "int_image boundary overrun. Fatal error.\n";
exit(-1);
}
}
void int_image::check_int_val(int value)
{
if(value > int_max) int_max = value;
else if(value < int_min) int_min = value;
}
int_image::putnext(int value, int index = -1)
{
if(index==0)
{
int_cur_ptr = int_base;
int_index = 0;
*int_cur_ptr = value;
return 1;
}
else if(index == -1)
{
*int_cur_ptr = value;
check_int_val(value);
int_cur_ptr++;
int_index++;
return 1;
}
else if(index > 0 && index < (int_length - 1) )
{
int_index = index;
int_cur_ptr = int_base;
int_cur_ptr += index;
*int_cur_ptr = value;
check_int_val(value);
}
else
{
cerr << "int_image boundary overrun. Fatal error.\n";
exit(-1);
}
}
class int1D: public int_image, OneD
{
friend class int2D;
public:
void print();
int1D();
int1D_update(int * start, int xlength);
int1D(int * start, int xlength);
int1D(int1D& ii);
int& operator[](int ii);
};
int1D::int1D()
{
x_dim = 0;
}
int1D::int1D(int * start,int xlength) : (start, xlength)
{
x_dim = xlength;
}
int1D::int1D_update(int * start,int xlength)
{
int_image::int_update(start, xlength);
x_dim = xlength;
}
int1D::int1D(int1D& ii) : ((int_image&) ii)
{
x_dim = ii.x_dim;
}
void int1D::print()
{
getnext(0);
for(int i=0; i < x_dim; i++) cout << getnext();
}
int& int1D::operator[](int ii)
{
return *(int_base + ii);
}
class int2D : public int_image, TwoD
{
private:
int1D * int1D_list;
int1D * cur_1D;
public:
void print(){;}
int2D(int * start, int xlength, int ylength);
int2D(int2D& ii);
OneD& operator[](int ii);
};
int2D::int2D(int * start, int xlength, int ylength): (start,(xlength * ylength))
{
x_dim = xlength;
y_dim = ylength;
int1D int1Dstuff[y_dim];
int1D_list = (int1D *) calloc(y_dim,sizeof(int1D));
cur_1D = int1D_list;
for(int i=0; i < y_dim; i++)
{
(int1Dstuff[i]).int1D_update(start + (i * x_dim), x_dim);
cur_1D = (int1D *) memcpy(cur_1D, &int1Dstuff[i], sizeof(int1D));
cur_1D++;
}
}
OneD& int2D::operator[](int ii)
{
return *(int1D_list + ii);
}
# 1 "testi.C"
main()
{
int array[10];
for(int i=0;i<10;i++) array[i] = i;
int1D biff(array,10);
img &base = biff;
cout << sizeof(int1D) << "\n";
biff.print();
int1D fred = biff;
fred.print();
cout << "testing: ";
for(i=0;i<10;i++) cout << fred[i];
cout << "\n";
}
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