🚀 go-pugleaf

Hello,
    I'm writing to question a possible bug in your g++ compiler.
The version of g++ is 1.39.1.
The code is appended at the end of this file.
The command I used to compile it was :
	g++ -o u.o -I/app1/local/lib/g++-include -c fub.cc

tm.h = tm-sparc.h  md = ??? (Sorry)

I'm using a SPARCStation 1, SunOS release 4.1.1 (GENERIC)


I am trying to sub class a generic list to make it "polymorphic"
ala Stroustrup. I typed in Stroustrup's code but that didn't seem
to work. I should clarify. It worked TOO well. The compiler did
not seem to check for type safety. I could still add ANY pointer
to the list. I then created an actual class, thinking perhaps
the macro's were screwing something up, but I could still put
any pointer onto the list.
    So, to sum up, I have a basic inheritance model here : a
class that is based on another and the methods of the derived
class are simply used to cast the pointers coming into and off
of the list. I noticed that the names in my derived class were
the same as the methods in my base class.
    OK, so what I did was to change the name from 'insert' to
'add' in the derived class while still calling 'insert' in the
base class. Lo and behold, I suddenly had type safety!
    It is my understanding that this is a problem. The methods of
the derived class should take precedence over the methods of the
base class.


Bruce Henderson
hendeb@aldebaran.informatik.mathematik.uni-marburg.de
Phillips Universitaet
Fachbereich Mathematik
D-3550 Marburg
Germany



/*--------------------------------------------------------
fub.cc

*/

# 1 "gsltest.cc"
 
# 1 "./stream.hpp" 1
# 2 "gsltest.cc" 2

# 1 "./gslist.hpp" 1


# 1 "./generic.hpp" 1





# 3 "./gslist.hpp" 2

# 1 "./slist.hpp" 1


# 1 "/app1/lib/g++-include/stddef.h" 1
 
 























#pragma once
#pragma interface




 



typedef unsigned int size_t;





typedef long int	 ptrdiff_t;






typedef	unsigned short	wchar_t;






 




# 3 "./slist.hpp" 2

# 1 "/app1/lib/g++-include/errno.h" 1


#pragma once
#pragma interface


extern "C" {



# 1 "//usr/include/errno.h" 1
 

 






# 1 "/usr/include/sys/errno.h" 1
 

 




 







































 



 



 

	 













	 













	 



 




 




 



 






 


 



 











 



# 10 "//usr/include/errno.h" 2

extern int errno;


# 11 "/app1/lib/g++-include/errno.h" 2


}





# 1 "/app1/lib/g++-include/std.h" 1
 
 
























#pragma once
#pragma interface




# 1 "/app1/lib/g++-include/stdio.h" 1
 
 





















 





























#pragma once
#pragma interface



 












# 106 "/app1/lib/g++-include/stdio.h"





# 142 "/app1/lib/g++-include/stdio.h"














 


























# 192 "/app1/lib/g++-include/stdio.h"


 
 

 







# 222 "/app1/lib/g++-include/stdio.h"

extern  struct  _iobuf {
    int      _cnt;
    char*    _ptr;
    char*    _base;
    int _bufsiz; 
    short 	_flag;
    char 	_file;
     
} _iob[];



typedef struct _iobuf FILE;












# 271 "/app1/lib/g++-include/stdio.h"































# 331 "/app1/lib/g++-include/stdio.h"


extern "C" {







int    _doprnt(const char*, void*, FILE*);
int    _doscan(FILE*, const char*, ...);
int    _filbuf(FILE*);
int    _flsbuf(unsigned, FILE*);

int    fclose(FILE*);
FILE*  fdopen(int, const char*);
int    fflush(FILE*);
int    fgetc(FILE*);
char*  fgets(char*, int, FILE *);
FILE*  fopen(const char*, const char*);
int    fprintf(FILE*, const char* ...);
int    fputc(int, FILE*);
int    fputs(const char*, FILE*);
int    fread(void*, int, int, FILE*);



FILE*  freopen(const char*, const char*, FILE*);

int    fscanf(FILE*, const char* ...);
int    fseek(FILE*, long, int);
long   ftell(FILE *);
int    fwrite(const void*, int, int, FILE*);
char*  gets(char*);
int    getw(FILE*);
int    pclose(FILE*);
FILE*  popen(const char*, const char*);
int    printf(const char* ...);
int    puts(const char*);
int    putw(int, FILE*);
int    rewind(FILE*);
int    scanf(const char* ...);
int    setbuf(FILE*, char*);
int    setbuffer(FILE*, char*, int);
int    setlinebuf(FILE*);
int    setvbuf(FILE*, char*, int, int);
int    sscanf(char*, const char* ...);
FILE*  tmpfile();
int    ungetc(int, FILE*);
int    vfprintf(FILE*, const char*, ...);

 
 

int    vprintf(const char*, ... );





char*  sprintf(char*, const char* ...);
char*  vsprintf(char*, const char*, ...);


}
















# 33 "/app1/lib/g++-include/std.h" 2


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);
double    atof(const char*);
int       atoi(const char*);
long      atol(const char*);
int       bind(int, void*, int);
void      bcopy(const void*, void*, int);  
int       brk(void*);
int       bsearch (const void *, const void *, unsigned long, 
                   unsigned long, auto int (*ptf)(const void*, const void*));
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*, unsigned long 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, ...);
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, const char**, const char*);
int       getpagesize(void);
char*     getpass(const char*);
int       getpgrp(...);
int       getpid(void);
int       getppid(void);
int       getpriority(int, int);
int       getpw(int, char*);
unsigned  getuid(void);
char*     getwd(char*);
char*     initstate(unsigned, char*, int);
int       ioctl(int, int, void*);
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);
unsigned  malloc_usable_size(void*);
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 volatile pause(void);
void      perror(const char*);
int       pipe(int*);
int       profil(char*, int, int, int);
int       psignal(unsigned, char*);
int       ptrace(int, int, int, int);
int       putenv(const char*);
void      qsort(void*, unsigned int, unsigned, auto int (*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*);
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       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(unsigned 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(const char*, const char*);
int       tgetent(const char*, const char*);
int       tgetnum(const char*);
int       tgetflag(const char*);
char*     tgetstr(const char *, char **);
char*     tgoto(const char*, int, int);
long      time(long*);
char*     tmpnam(char*);
int       tputs(const 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       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);


}


# 252 "/app1/lib/g++-include/std.h"


extern "C" {
int       bcmp(const void*, const void*, int);
void      bzero(void*, int);
char*     index(const char*, int);
char*     rindex(const char*, int);
}



extern char**   environ;
extern volatile int errno;
extern char*    sys_errlist[];
extern int      sys_nerr;                  
extern char*    optarg;
extern int      opterr;
extern int      optind;


extern "C" void* alloca(unsigned long);









# 19 "/app1/lib/g++-include/errno.h" 2



# 4 "./slist.hpp" 2

typedef void* ent;

enum slist_errors {
    SLIST_OK,
    SLIST_EMPTY = 40
};

 
 
 
class zSLink {
    friend class zSList;              
    friend class zSListIterator;      

 
 
 
    zSLink(ent a) {e = a; next = 0; }
    zSLink* next;
    ent e;
};

 
class zSList {
    friend class zSListIterator;

public:

 
 
 
 
 
 
 
 
 
    zSList(int p = 0);
    zSList(ent a, int p = 0);

 
 
    int insert(ent );

 
 
    int append(ent );

 
 
    ent get();

    int error()
        { int e = err; err = 0; return e; }
    ~zSList() { cleanup(); }
private:

 
    zSLink* last;                     
    unsigned char err;
    unsigned char purging;
    void cleanup();                  
};

 
 
 
class zSListIterator {
public:

 
 
    zSListIterator(zSList& s) { cs = &s; ce = 0; }
    ent operator()(void);
private:
    zSLink* ce;
    zSList* cs;
};

# 4 "./gslist.hpp" 2





 
 
 
 

# 22 "./gslist.hpp"

 








# 3 "gsltest.cc" 2


 
 
 
struct any {
    int len;
    char *cp;
};

 
 
struct zGSListany  : zSList {
 public:
	int insert(any *a);
	int append(any *a);
	any *get();
	zGSListany  (int p = 0);
	zGSListany  (any *a, int p = 0);
};

int zGSListany::insert(any *a)
{
	return zSList::insert(a);
}

int zGSListany::append(any *a)
{
	return zSList::append(a);
}

any *zGSListany::get()
{
	return (any *) zSList::get();
}

zGSListany::zGSListany(int p = 0) : ((zSList)p)
{
}

zGSListany::zGSListany(any *a, int p = 0) : ((ent ) a,p)
{
}

 
any  xx[] = {
    5,"first",
    6,"second",
    5,"third",
    6,"fourth",
    5,"fifth"
};

main()
{
    zGSListany   w;

    int i = 0;
 
     w.insert(&xx[i]);

    w.insert(i);   // Try it twice, this is ALWAYS an error.
			// but &i works.

			// Then try changing zGSList's insert to add...
}