Warning: This is a message in MIME format. Your mail reader does not
support MIME. Some parts of this message will be readable as plain text.
To see the rest, you will need to upgrade your mail reader.

This message was composed on an Amiga using the YAM mailer.
YAM is available at http://bitcom.ch/~mbeck/

--BOUNDARY.7060.2466.128232408.1
Content-Type: text/plain

Sorry folks,

my problem was solved, but just temporarily. All binaries being
used after removing gcc, g++ and cc from /usr/bin have been
from an earlier installed gcc2.7.2bin11-distribution because
they had symbolic links at /usr/local/bin. After removing all
gcc-related symbolic links from /usr/local/bin and renaming all
gcc-related binaries from /usr/bin, no gcc, cc, g++ or CC was
in my path (!for sure!).
After reinstalling comp12-binaries completely with --unlink zxvf- -C / options
(yes, i tared everything together) i've been able to reproduce
the kernelpanic again.

By invoking g++ with the option -v -E i got the attached panic3.txt output but
no kernel-panic.

A kernel panic with all the trace output described before happened
after invoking g++ with option -v. That output file is named panic3_1.txt.

It seems that gcc2.7.2 only worked before, because i used the bin11-version.
Also it makes me feel strange to see the very different sizes of gcc and g++
binaries in the bin11 and bin12-versions...

Have to add, that libc.so.12.5 is the latest one on my system.

Have to reinstall the bin11 gcc2.7.2 again, but i really like to do some more
tests if it isn't possible to reproduce the kernelpanic. BTW, g++2.7.2bin11
has just compiled the latest xpdf successfully on my NetBSD1.2.1. 
So it seems to work well at the moment...

Regards

-- 
              Juergen Schmitz
       E-Mail: Ju.Schmitz@fh-trier.de
      http://www.fh-trier.de/~schmitju
    -- Public-key available on demand --
--BOUNDARY.7060.2466.128232408.1
Content-Type: text/plain; charset=iso-8859-1; name="panic3.txt"
Content-Transfer-Encoding: quoted-printable

 /usr/bin/cc -v -E hello.cpp
gcc version 2.7.2
 /usr/libexec/cpp -lang-c++ -v -undef -D__GNUC__=3D2 -D__GNUG__=3D2 -D__c=
plusplus -D__GNUC_MINOR__=3D7 -Dunix -Dm68k -Dmc68000 -Dmc68020 -D__NetBS=
D__ -D__KPRINTF_ATTRIBUTE__ -D__unix__ -D__m68k__ -D__mc68000__ -D__mc680=
20__ -D__NetBSD__ -D__KPRINTF_ATTRIBUTE__ -D__unix -D__m68k -D__mc68000 -=
D__mc68020 -Asystem(unix) -Asystem(NetBSD) -Acpu(m68k) -Amachine(m68k) -D=
__HAVE_68881__ -D__HAVE_FPU__ hello.cpp
GNU CPP version 2.7.2 (68k, MIT syntax)
#include "..." search starts here:
#include <...> search starts here:
 /usr/include/g++
 /usr/include
End of search list.
# 1 "hello.cpp"
# 1 "/usr/include/g++/iostream.h" 1 3
 =


























#pragma interface



# 1 "/usr/include/g++/streambuf.h" 1 3
 =



























#pragma interface


   =




extern "C" {
# 1 "/usr/include/g++/libio.h" 1 3
 =
























 =





# 1 "/usr/include/g++/_G_config.h" 1 3
  =








typedef unsigned long _G_clock_t;
typedef int _G_dev_t;
typedef long long _G_fpos_t;
typedef unsigned int _G_gid_t;
typedef unsigned int _G_ino_t;
typedef unsigned short _G_mode_t;
typedef unsigned short _G_nlink_t;
typedef long long _G_off_t;
typedef int _G_pid_t;



typedef int _G_ptrdiff_t;
typedef unsigned int _G_sigset_t;



typedef unsigned int _G_size_t;
typedef long _G_time_t;
typedef unsigned int _G_uid_t;
typedef int _G_wchar_t;
typedef int _G_ssize_t;
typedef int   _G_wint_t;
typedef char * _G_va_list;




typedef          int   _G_int8_t __attribute__((__mode__(__QI__)));
typedef unsigned int  _G_uint8_t __attribute__((__mode__(__QI__)));
typedef          int  _G_int16_t __attribute__((__mode__(__HI__)));
typedef unsigned int _G_uint16_t __attribute__((__mode__(__HI__)));
typedef          int  _G_int32_t __attribute__((__mode__(__SI__)));
typedef unsigned int _G_uint32_t __attribute__((__mode__(__SI__)));
typedef          int  _G_int64_t __attribute__((__mode__(__DI__)));
typedef unsigned int _G_uint64_t __attribute__((__mode__(__DI__)));


































# 30 "/usr/include/g++/libio.h" 2 3













# 51 "/usr/include/g++/libio.h" 3




# 1 "/usr/include/sys/cdefs.h" 1 3 4
 =


 =









































# 1 "/usr/include/machine/cdefs.h" 1 3 4
 =





# 1 "/usr/include/m68k/cdefs.h" 1 3 4
 =


 =

































# 6 "/usr/include/machine/cdefs.h" 2 3 4



# 44 "/usr/include/sys/cdefs.h" 2 3 4










 =























# 101 "/usr/include/sys/cdefs.h" 3 4


 =























 =







# 55 "/usr/include/g++/libio.h" 2 3










 =





































 =
























 =


















 =


struct _IO_jump_t;  struct _IO_FILE;

struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;
   =


   =

  int _pos;
# 164 "/usr/include/g++/libio.h" 3

};

struct _IO_FILE {
  int _flags;		 =



   =

  char* _IO_read_ptr;	 =

  char* _IO_read_end;	 =

  char* _IO_read_base;	 =

  char* _IO_write_base;	 =

  char* _IO_write_ptr;	 =

  char* _IO_write_end;	 =

  char* _IO_buf_base;	 =

  char* _IO_buf_end;	 =

   =

  char *_IO_save_base;  =

  char *_IO_backup_base;   =

  char *_IO_save_end;  =


  struct _IO_marker *_markers;
  =

  struct _IO_FILE *_chain;
  =

  int _fileno;
  int _blksize;
  _G_off_t  _offset;
  =


   =

  unsigned short _cur_column;
  char _unused;
  char _shortbuf[1];
  =

   =

};





struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_stdin_, _IO_stdout_, _IO_stderr_;





extern "C" {


extern int __underflow  (_IO_FILE*)  ;
extern int __uflow  (_IO_FILE*)  ;
extern int __overflow  (_IO_FILE*, int)  ;

















 =




extern int _IO_vfscanf  (_IO_FILE*, const char*, _G_va_list , int*)  ;
extern int _IO_vfprintf  (_IO_FILE*, const char*, _G_va_list )  ;
extern _G_ssize_t  _IO_padn  (_IO_FILE *, int, _G_ssize_t )  ;
extern _G_size_t  _IO_sgetn  (_IO_FILE *, void*, _G_size_t )  ;

extern _G_fpos_t  _IO_seekoff  (_IO_FILE*, _G_off_t , int, int)  ;
extern _G_fpos_t  _IO_seekpos  (_IO_FILE*, _G_fpos_t , int)  ;

extern void _IO_free_backup_area  (_IO_FILE*)  ;


}



# 36 "/usr/include/g++/streambuf.h" 2 3

}
 =























extern "C++" {
class istream;  =

class ostream; class streambuf;

 =




typedef _G_off_t  streamoff;
typedef _G_fpos_t  streampos;
typedef _G_ssize_t  streamsize;

typedef unsigned long __fmtflags;
typedef unsigned char __iostate;

struct _ios_fields
{  =

    streambuf *_strbuf;
    ostream* _tie;
    int _width;
    __fmtflags _flags;
    short  _fill;
    __iostate _state;
    __iostate _exceptions;
    int _precision;

    void *_arrays;  =

};















# 115 "/usr/include/g++/streambuf.h" 3


class ios : public _ios_fields {
  ios& operator=3D(ios&);   =

  public:
    typedef __fmtflags fmtflags;
    typedef int iostate;
    typedef int openmode;
    typedef int streamsize;
    enum io_state {
	goodbit =3D 0 ,
	eofbit =3D 1 ,
	failbit =3D 2 ,
	badbit =3D 4  };
    enum open_mode {
	in =3D 1 ,
	out =3D 2 ,
	ate =3D 4 ,
	app =3D 8 ,
	trunc =3D 16 ,
	nocreate =3D 32 ,
	noreplace =3D 64 ,
	bin =3D 128  };
    enum seek_dir { beg, cur, end};
     =

     =

    enum { skipws=3D 01 ,
	   left=3D 02 , right=3D 04 , internal=3D 010 ,
	   dec=3D 020 , oct=3D 040 , hex=3D 0100 ,
	   showbase=3D 0200 , showpoint=3D 0400 ,
	   uppercase=3D 01000 , showpos=3D 02000 ,
	   scientific=3D 04000 , fixed=3D 010000 ,
	   unitbuf=3D 020000 , stdio=3D 040000 =




	   };
    enum {  =

	basefield=3Ddec+oct+hex,
	floatfield =3D scientific+fixed,
	adjustfield =3D left+right+internal
    };

# 166 "/usr/include/g++/streambuf.h" 3


    ostream* tie() const { return _tie; }
    ostream* tie(ostream* val) { ostream* save=3D_tie; _tie=3Dval; return=
 save; }

     =

    short  fill() const { return (short )_fill; }
    short  fill(short  newf)
	{short  oldf =3D (short )_fill; _fill =3D (char)newf; return oldf;}
    fmtflags flags() const { return _flags; }
    fmtflags flags(fmtflags new_val) {
	fmtflags old_val =3D _flags; _flags =3D new_val; return old_val; }
    int precision() const { return _precision; }
    int precision(int newp) {
	unsigned short oldp =3D _precision; _precision =3D (unsigned short)newp;=

	return oldp; }
    fmtflags setf(fmtflags val) {
	fmtflags oldbits =3D _flags;
	_flags |=3D val; return oldbits; }
    fmtflags setf(fmtflags val, fmtflags mask) {
	fmtflags oldbits =3D _flags;
	_flags =3D (_flags & ~mask) | (val & mask); return oldbits; }
    fmtflags unsetf(fmtflags mask) {
	fmtflags oldbits =3D _flags;
	_flags &=3D ~mask; return oldbits; }
    int width() const { return _width; }
    int width(int val) { int save =3D _width; _width =3D val; return save=
; }




    void _throw_failure() const { }

    void clear(iostate state =3D 0) {
	_state =3D _strbuf ? state : state|badbit;
	if (_state & _exceptions) _throw_failure(); }
    void set(iostate flag) { _state |=3D flag;
	if (_state & _exceptions) _throw_failure(); }
    void setstate(iostate flag) { _state |=3D flag;  =

	if (_state & _exceptions) _throw_failure(); }
    int good() const { return _state =3D=3D 0; }
    int eof() const { return _state & ios::eofbit; }
    int fail() const { return _state & (ios::badbit|ios::failbit); }
    int bad() const { return _state & ios::badbit; }
    iostate rdstate() const { return _state; }
    operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
    int operator!() const { return fail(); }
    iostate exceptions() const { return _exceptions; }
    void exceptions(iostate enable) {
	_exceptions =3D enable;
	if (_state & _exceptions) _throw_failure(); }

    streambuf* rdbuf() const { return _strbuf; }
    streambuf* rdbuf(streambuf *_s) {
      streambuf *_old =3D _strbuf; _strbuf =3D _s; clear (); return _old;=
 }

    static int sync_with_stdio(int on);
    static void sync_with_stdio() { sync_with_stdio(1); }
    static fmtflags bitalloc();
    static int xalloc();
    void*& pword(int);
    void* pword(int) const;
    long& iword(int);
    long iword(int) const;









     =

    class Init {
    public:
      Init () { }
    };

  protected:
    inline ios(streambuf* sb =3D 0, ostream* tie_to =3D 0);
    inline virtual ~ios();
    inline void init(streambuf* sb, ostream* tie =3D 0);
};




typedef ios::seek_dir _seek_dir;


 =

 =

 =

 =

 =


 =

 =

class streammarker : private _IO_marker {
    friend class streambuf;
    void set_offset(int offset) { _pos =3D offset; }
  public:
    streammarker(streambuf *sb);
    ~streammarker();
    int saving() { return  1; }
    int delta(streammarker&);
    int delta();
};

struct streambuf : public _IO_FILE {  =

    friend class ios;
    friend class istream;
    friend class ostream;
    friend class streammarker;
    const void *&_vtable() { return *(const void**)((_IO_FILE*)this + 1);=
 }
  protected:
    static streambuf* _list_all;  =

    _IO_FILE*& xchain() { return _chain; }
    void _un_link();
    void _link_in();
    char* gptr() const
      { return _flags  & 0x100  ? _IO_save_base : _IO_read_ptr; }
    char* pptr() const { return _IO_write_ptr; }
    char* egptr() const
      { return _flags  & 0x100  ? _IO_save_end : _IO_read_end; }
    char* epptr() const { return _IO_write_end; }
    char* pbase() const { return _IO_write_base; }
    char* eback() const
      { return _flags  & 0x100  ? _IO_save_base : _IO_read_base;}
    char* base() const { return _IO_buf_base; }
    char* ebuf() const { return _IO_buf_end; }
    int blen() const { return _IO_buf_end - _IO_buf_base; }
    void xput_char(char c) { *_IO_write_ptr++ =3D c; }
    int xflags() { return _flags ; }
    int xflags(int f) {int fl =3D _flags ; _flags  =3D f; return fl;}
    void xsetflags(int f) { _flags  |=3D f; }
    void xsetflags(int f, int mask)
      { _flags  =3D (_flags  & ~mask) | (f & mask); }
    void gbump(int n)
      { _flags  & 0x100  ? (_IO_save_base+=3Dn):(_IO_read_ptr+=3Dn);}
    void pbump(int n) { _IO_write_ptr +=3D n; }
    void setb(char* b, char* eb, int a=3D0);
    void setp(char* p, char* ep)
      { _IO_write_base=3D_IO_write_ptr=3Dp; _IO_write_end=3Dep; }
    void setg(char* eb, char* g, char *eg) {
      if (_flags  & 0x100 ) _IO_free_backup_area(this); =

      _IO_read_base =3D eb; _IO_read_ptr =3D g; _IO_read_end =3D eg; }
    char *shortbuf() { return _shortbuf; }

    int in_backup() { return _flags & 0x100 ; }
     =

    char *Gbase() { return in_backup() ? _IO_save_base : _IO_read_base; }=

     =

    char *eGptr() { return in_backup() ? _IO_save_end : _IO_read_end; }
     =

    char *Bbase() { return in_backup() ? _IO_read_base : _IO_save_base; }=

    char *Bptr() { return _IO_backup_base; }
     =

    char *eBptr() { return in_backup() ? _IO_read_end : _IO_save_end; }
    char *Nbase() { return _IO_save_base; }
    char *eNptr() { return _IO_save_end; }
    int have_backup() { return _IO_save_base !=3D ((void*)0) ; }
    int have_markers() { return _markers !=3D ((void*)0) ; }
    void free_backup_area();
    void unsave_markers();  =

    int put_mode() { return _flags & 0x800 ; }
    int switch_to_get_mode();
    =

    streambuf(int flags=3D0);
  public:
    static int flush_all();
    static void flush_all_linebuffered();  =

    virtual ~streambuf();
    virtual int overflow(int c =3D (-1) );  =

    virtual int underflow();  =

    virtual int uflow();  =

    virtual int pbackfail(int c);
 =

    virtual streamsize xsputn(const char* s, streamsize n);
    virtual streamsize xsgetn(char* s, streamsize n);
    virtual streampos seekoff(streamoff, _seek_dir, int mode=3Dios::in|io=
s::out);
    virtual streampos seekpos(streampos pos, int mode =3D ios::in|ios::ou=
t);

    streampos pubseekoff(streamoff o, _seek_dir d, int mode=3Dios::in|ios=
::out)
      { return _IO_seekoff (this, o, d, mode); }
    streampos pubseekpos(streampos pos, int mode =3D ios::in|ios::out)
      { return _IO_seekpos (this, pos, mode); }
    streampos sseekoff(streamoff, _seek_dir, int mode=3Dios::in|ios::out)=
;
    streampos sseekpos(streampos pos, int mode =3D ios::in|ios::out);
    virtual streambuf* setbuf(char* p, int len);
    virtual int sync();
    virtual int doallocate();

    int seekmark(streammarker& mark, int delta =3D 0);
    int sputbackc(char c);
    int sungetc();
    int unbuffered() { return _flags & 2  ? 1 : 0; }
    int linebuffered() { return _flags & 0x200  ? 1 : 0; }
    void unbuffered(int i)
	{ if (i) _flags |=3D 2 ; else _flags &=3D ~2 ; }
    void linebuffered(int i)
	{ if (i) _flags |=3D 0x200 ; else _flags &=3D ~0x200 ; }
    int allocate() {  =

	if (base() || unbuffered()) return 0;
	else return doallocate(); }
     =

    void allocbuf() { if (base() =3D=3D ((void*)0) ) doallocbuf(); }
    void doallocbuf();
    int in_avail() { return _IO_read_end - _IO_read_ptr; }
    int out_waiting() { return _IO_write_ptr - _IO_write_base; }
    streamsize sputn(const char* s, streamsize n) { return xsputn(s, n); =
}
    streamsize padn(char pad, streamsize n) { return _IO_padn(this, pad, =
n); }
    streamsize sgetn(char* s, streamsize n) { return _IO_sgetn(this, s, n=
); }
    int ignore(int);
    int get_column();
    int set_column(int);
    long sgetline(char* buf, _G_size_t  n, char delim, int putback_delim)=
;
    int sputc(int c) { return (((  this )->_IO_write_ptr >=3D (  this )->=
_IO_write_end) ? __overflow(  this , (unsigned char)( c )) : (unsigned ch=
ar)(*(  this )->_IO_write_ptr++ =3D ( c ))) ; }
    int sbumpc() { return (( this )->_IO_read_ptr >=3D ( this )->_IO_read=
_end ? __uflow( this ) : *(unsigned char*)( this )->_IO_read_ptr++) ; }
    int sgetc() { return (( this )->_IO_read_ptr >=3D ( this )->_IO_read_=
end && __underflow( this ) =3D=3D (-1)  ? (-1)  : *(unsigned char*)( this=
 )->_IO_read_ptr) ; }
    int snextc() {
	if (_IO_read_ptr >=3D _IO_read_end && __underflow(this) =3D=3D (-1) )
	  return (-1) ;
	else return _IO_read_ptr++, sgetc(); }
    void stossc() { if (_IO_read_ptr < _IO_read_end) _IO_read_ptr++; }
    int vscan(char const *fmt0, _G_va_list  ap, ios* stream =3D ((void*)0=
) );
    int scan(char const *fmt0 ...);
    int vform(char const *fmt0, _G_va_list  ap);
    int form(char const *fmt0 ...);




    virtual streamsize sys_read(char* buf, streamsize size);
    virtual streamsize sys_write(const char*, streamsize);
    virtual streampos sys_seek(streamoff, _seek_dir);
    virtual int sys_close();
    virtual int sys_stat(void*);  =

};

 =

 =


class filebuf : public streambuf {
  protected:
    void init();
  public:
    static const int openprot;  =

    filebuf();
    filebuf(int fd);
    filebuf(int fd, char* p, int len);



    ~filebuf();
    filebuf* attach(int fd);
    filebuf* open(const char *filename, const char *mode);
    filebuf* open(const char *filename, ios::openmode mode, int prot =3D =
0664);
    virtual int underflow();
    virtual int overflow(int c =3D (-1) );
    int is_open() const { return _fileno >=3D 0; }
    int fd() const { return is_open() ? _fileno : (-1) ; }
    filebuf* close();
    virtual int doallocate();
    virtual streampos seekoff(streamoff, _seek_dir, int mode=3Dios::in|io=
s::out);
    virtual streambuf* setbuf(char* p, int len);
    streamsize xsputn(const char* s, streamsize n);
    streamsize xsgetn(char* s, streamsize n);
    virtual int sync();
  protected:  =

 =

    int is_reading() { return eback() !=3D egptr(); }
    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
     =

    char* file_ptr() { return eGptr(); }
     =

    virtual streamsize sys_read(char* buf, streamsize size);
    virtual streampos sys_seek(streamoff, _seek_dir);
    virtual streamsize sys_write(const char*, streamsize);
    virtual int sys_stat(void*);  =

    virtual int sys_close();




};

inline void ios::init(streambuf* sb, ostream* tie_to) {
		_state =3D sb ? ios::goodbit : ios::badbit; _exceptions=3D0;
		_strbuf=3Dsb; _tie =3D tie_to; _width=3D0; _fill=3D' ';

		_flags=3Dios::skipws|ios::dec;



		_precision=3D6; _arrays =3D 0; }

inline ios::ios(streambuf* sb, ostream* tie_to) { init(sb, tie_to); }

inline ios::~ios() {



    if (_arrays) delete [] _arrays;
}
}  =


# 31 "/usr/include/g++/iostream.h" 2 3


extern "C++" {
class istream; class ostream;
typedef ios& (*__manip)(ios&);
typedef istream& (*__imanip)(istream&);
typedef ostream& (*__omanip)(ostream&);

extern istream& ws(istream& ins);
extern ostream& flush(ostream& outs);
extern ostream& endl(ostream& outs);
extern ostream& ends(ostream& outs);

class ostream : virtual public ios
{
     =

    void do_osfx();
  public:
    ostream() { }
    ostream(streambuf* sb, ostream* tied=3D ((void*)0) );
    int opfx() {
	if (!good()) return 0; else { if (_tie) _tie->flush(); return 1;} }
    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
		      do_osfx(); }
    ostream& flush();
    ostream& put(char c) { _strbuf->sputc(c); return *this; }





    ostream& write(const char *s, streamsize n);
    ostream& write(const unsigned char *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& write(const signed char *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& write(const void *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& seekp(streampos);
    ostream& seekp(streamoff, _seek_dir);
    streampos tellp();
    ostream& form(const char *format ...);
    ostream& vform(const char *format, _G_va_list  args);

    ostream& operator<<(char c);
    ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
    ostream& operator<<(signed char c) { return (*this) << (char)c; }
    ostream& operator<<(const char *s);
    ostream& operator<<(const unsigned char *s)
	{ return (*this) << (const char*)s; }
    ostream& operator<<(const signed char *s)
	{ return (*this) << (const char*)s; }
    ostream& operator<<(const void *p);
    ostream& operator<<(int n);
    ostream& operator<<(unsigned int n);
    ostream& operator<<(long n);
    ostream& operator<<(unsigned long n);

    ostream& operator<<(long long n);
    ostream& operator<<(unsigned long long n);

    ostream& operator<<(short n) {return operator<<((int)n);}
    ostream& operator<<(unsigned short n) {return operator<<((unsigned in=
t)n);}

    ostream& operator<<(bool b) { return operator<<((int)b); }

    ostream& operator<<(double n);
    ostream& operator<<(float n) { return operator<<((double)n); }
    ostream& operator<<(long double n) { return operator<<((double)n); }
    ostream& operator<<(__omanip func) { return (*func)(*this); }
    ostream& operator<<(__manip func) {(*func)(*this); return *this;}
    ostream& operator<<(streambuf*);



};

class istream : virtual public ios
{
     =

protected:
    _G_size_t  _gcount;

    int _skip_ws();
  public:
    istream() { _gcount =3D 0; }
    istream(streambuf* sb, ostream*tied=3D ((void*)0) );
    istream& get(char* ptr, int len, char delim =3D '\n');
    istream& get(unsigned char* ptr, int len, char delim =3D '\n')
	{ return get((char*)ptr, len, delim); }
    istream& get(char& c);
    istream& get(unsigned char& c) { return get((char&)c); }
    istream& getline(char* ptr, int len, char delim =3D '\n');
    istream& getline(unsigned char* ptr, int len, char delim =3D '\n')
	{ return getline((char*)ptr, len, delim); }
    istream& get(signed char& c)  { return get((char&)c); }
    istream& get(signed char* ptr, int len, char delim =3D '\n')
	{ return get((char*)ptr, len, delim); }
    istream& getline(signed char* ptr, int len, char delim =3D '\n')
	{ return getline((char*)ptr, len, delim); }
    istream& read(char *ptr, streamsize n);
    istream& read(unsigned char *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& read(signed char *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& read(void *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& get(streambuf& sb, char delim =3D '\n');
    istream& gets(char **s, char delim =3D '\n');
    int ipfx(int need =3D 0) {
	if (!good()) { set(ios::failbit); return 0; }
	else {
	  if (_tie && (need =3D=3D 0 || rdbuf()->in_avail() < need)) _tie->flush=
();
	  if (!need && (flags() & ios::skipws)) return _skip_ws();
	  else return 1;
	}
    }
    int ipfx0() {  =

	if (!good()) { set(ios::failbit); return 0; }
	else {
	  if (_tie) _tie->flush();
	  if (flags() & ios::skipws) return _skip_ws();
	  else return 1;
	}
    }
    int ipfx1() {  =

	if (!good()) { set(ios::failbit); return 0; }
	else {
	  if (_tie && rdbuf()->in_avail() =3D=3D 0) _tie->flush();
	  return 1;
	}
    }
    void isfx() { }
    int get() { if (!ipfx1()) return (-1) ;
		else { int ch =3D _strbuf->sbumpc();
		       if (ch =3D=3D (-1) ) set(ios::eofbit);
		       return ch;
		     } }
    int peek();
    _G_size_t  gcount() { return _gcount; }
    istream& ignore(int n=3D1, int delim =3D (-1) );
    int sync ();
    istream& seekg(streampos);
    istream& seekg(streamoff, _seek_dir);
    streampos tellg();
    istream& putback(char ch) {
	if (good() && _strbuf->sputbackc(ch) =3D=3D (-1) ) clear(ios::badbit);
	return *this;}
    istream& unget() {
	if (good() && _strbuf->sungetc() =3D=3D (-1) ) clear(ios::badbit);
	return *this;}
    istream& scan(const char *format ...);
    istream& vscan(const char *format, _G_va_list  args);






    istream& operator>>(char*);
    istream& operator>>(unsigned char* p) { return operator>>((char*)p); =
}
    istream& operator>>(signed char*p) { return operator>>((char*)p); }
    istream& operator>>(char& c);
    istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
    istream& operator>>(signed char& c) {return operator>>((char&)c);}
    istream& operator>>(int&);
    istream& operator>>(long&);

    istream& operator>>(long long&);
    istream& operator>>(unsigned long long&);

    istream& operator>>(short&);
    istream& operator>>(unsigned int&);
    istream& operator>>(unsigned long&);
    istream& operator>>(unsigned short&);

    istream& operator>>(bool&);

    istream& operator>>(float&);
    istream& operator>>(double&);
    istream& operator>>(long double&);
    istream& operator>>( __manip func) {(*func)(*this); return *this;}
    istream& operator>>(__imanip func) { return (*func)(*this); }
    istream& operator>>(streambuf*);
};

class iostream : public istream, public ostream
{
  public:
    iostream() { }
    iostream(streambuf* sb, ostream*tied=3D ((void*)0) );
};

class _IO_istream_withassign : public istream {
public:
  _IO_istream_withassign& operator=3D(istream&);
};

class _IO_ostream_withassign : public ostream {
public:
  _IO_ostream_withassign& operator=3D(ostream&);
};

extern _IO_istream_withassign cin;
 =

extern _IO_ostream_withassign cout, cerr, clog;

struct Iostream_init { } ;   =


inline ios& dec(ios& i)
{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
inline ios& hex(ios& i)
{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
inline ios& oct(ios& i)
{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
}  =



# 1 "hello.cpp" 2


void main(void)

{
cout << "Hello NetBSD";
}

--BOUNDARY.7060.2466.128232408.1
Content-Type: text/plain; charset=iso-8859-1; name="panic3_1.txt"
Content-Transfer-Encoding: quoted-printable

 /usr/bin/cc -v hello.cpp -lg++ -lstdc++ -lm
gcc version 2.7.2
 /usr/libexec/cpp -lang-c++ -v -undef -D__GNUC__=3D2 -D__GNUG__=3D2 -D__c=
plusplus -D__GNUC_MINOR__=3D7 -Dunix -Dm68k -Dmc68000 -Dmc68020 -D__NetBS=
D__ -D__KPRINTF_ATTRIBUTE__ -D__unix__ -D__m68k__ -D__mc68000__ -D__mc680=
20__ -D__NetBSD__ -D__KPRINTF_ATTRIBUTE__ -D__unix -D__m68k -D__mc68000 -=
D__mc68020 -Asystem(unix) -Asystem(NetBSD) -Acpu(m68k) -Amachine(m68k) -D=
__HAVE_68881__ -D__HAVE_FPU__ hello.cpp /var/tmp/cc000186.ii
GNU CPP version 2.7.2 (68k, MIT syntax)
#include "..." search starts here:
#include <...> search starts here:
 /usr/include/g++
 /usr/include
End of search list.
 /usr/libexec/cc1plus /var/tmp/cc000186.ii -quiet -dumpbase hello.cc -ver=
sion -o /var/tmp/cc000186.s
GNU C++ version 2.7.2 (68k, MIT syntax) compiled by GNU C version 2.7.2.

--BOUNDARY.7060.2466.128232408.1--