sorensen@IMAGER.MIT.EDU (Greg Sorensen) (06/18/89)
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";
}