Michael Reifenberger's libg++ port

Submitted by:	mr

46 files changed, 446 insertions, 430 deletions

diff --git a/gnu/lib/libg++/Makefile b/gnu/lib/libg++/Makefile
index 519c317..007dc4c 100644
--- a/gnu/lib/libg++/Makefile
+++ b/gnu/lib/libg++/Makefile
@@ -2,17 +2,19 @@
 # $FreeBSD$
 #
 
-SRCS=	vasprintf.c strerror.c strsignal.c
-SRCS+=	filedoalloc.c floatconv.c genops.c fileops.c iovfprintf.c iovfscanf.c ioignore.c iopadn.c iofgetpos.c iofread.c iofscanf.c iofsetpos.c iogetline.c ioprintf.c ioseekoff.c ioseekpos.c outfloat.c strops.c iofclose.c iopopen.c ioungetc.c builtinbuf.cc filebuf.cc fstream.cc indstream.cc isgetline.cc isgetsb.cc isscan.cc ioextend.cc iomanip.cc iostream.cc osform.cc procbuf.cc sbform.cc sbgetline.cc sbscan.cc stdiostream.cc stdstrbufs.cc stdstreams.cc stream.cc streambuf.cc strstream.cc PlotFile.cc SFile.cc parsestream.cc pfstream.cc editbuf.cc ioprims.c iostrerror.c cleanup.c
-SRCS+=	AllocRing.cc Obstack.cc builtin.cc regex.cc Regex.cc String.cc Intdouble.cc Integer.cc Rational.cc Complex.cc Random.cc BitSet.cc BitString.cc LogNorm.cc SmplHist.cc SmplStat.cc Normal.cc NegExp.cc Weibull.cc Erlang.cc DiscUnif.cc Uniform.cc Poisson.cc HypGeom.cc Geom.cc Binomial.cc RNG.cc ACG.cc MLCG.cc RndInt.cc Fix.cc Fix16.cc Fix24.cc CursesW.cc GetOpt.cc new.cc chr.cc error.cc gcd.cc hash.cc lg.cc fmtq.cc ioob.cc pow.cc sqrt.cc str.cc timer.c math.cc compare.cc bitand.c bitany.c bitblt.c bitclear.c bitcopy.c bitcount.c bitinvert.c bitlcomp.c bitset1.c bitxor.c SLList.cc DLList.cc
-LIB=	libg++
+SRCS=	strerror.c strsignal.c
+SRCS+=	filedoalloc.c floatconv.c genops.c fileops.c iovfprintf.c iovfscanf.c ioignore.c iopadn.c iofgetpos.c iofread.c iofscanf.c iofsetpos.c iogetdelim.c iogetline.c ioprintf.c ioseekoff.c ioseekpos.c outfloat.c strops.c iofclose.c iopopen.c ioungetc.c builtinbuf.cc filebuf.cc fstream.cc indstream.cc ioassign.cc ioextend.cc iomanip.cc iostream.cc isgetline.cc isgetsb.cc isscan.cc osform.cc procbuf.cc sbform.cc sbgetline.cc sbscan.cc stdiostream.cc stdstrbufs.cc stdstreams.cc stream.cc streambuf.cc strstream.cc PlotFile.cc SFile.cc parsestream.cc pfstream.cc editbuf.cc ioprims.c iostrerror.c cleanup.c
+SRCS+=	AllocRing.cc Obstack.cc builtin.cc Regex.cc String.cc Intdouble.cc Integer.cc Rational.cc Complex.cc Random.cc BitSet.cc BitString.cc LogNorm.cc SmplHist.cc SmplStat.cc Normal.cc NegExp.cc Weibull.cc Erlang.cc DiscUnif.cc Uniform.cc Poisson.cc HypGeom.cc Geom.cc Binomial.cc RNG.cc ACG.cc MLCG.cc RndInt.cc Fix.cc Fix16.cc Fix24.cc CursesW.cc GetOpt.cc except.c new.cc chr.cc error.cc gcd.cc hash.cc lg.cc fmtq.cc ioob.cc pow.cc sqrt.cc str.cc timer.c math.cc compare.cc bitand.c bitany.c bitblt.c bitclear.c bitcopy.c bitcount.c bitinvert.c bitlcomp.c bitset1.c bitxor.c SLList.cc DLList.cc
+SRCS+=	rx.c 
+LIB=	g++
 NOMAN=	noman
 CFLAGS+=	-nostdinc -I${.CURDIR}/include -I/usr/include
-CXXFLAGS+=	-fexternal-templates
-.PATH:	${.CURDIR}/libiberty ${.CURDIR}/libio ${.CURDIR}/libg++
+CXXFLAGS+=	-I${.CURDIR}/include -I/usr/include/g++ -I/usr/include -nostdinc++
+LDADD+=	-lcurses
+.PATH:	${.CURDIR}/libiberty ${.CURDIR}/libio ${.CURDIR}/libg++ ${.CURDIR}/librx
 
 beforeinstall:
 	@-if [ ! -d ${DESTDIR}/usr/include/g++ ]; then  mkdir ${DESTDIR}/usr/include/g++;  chown ${BINOWN}.${BINGRP} ${DESTDIR}/usr/include/g++;  chmod 755 ${DESTDIR}/usr/include/g++;  fi
-	@(cd include ; for j in *.h; do  cmp -s $$j ${DESTDIR}/usr/include/g++/$$j ||  install -c -o ${BINOWN} -g ${BINGRP} -m 444 $$j  ${DESTDIR}/usr/include/$$j;  done)
+	@(cd ${.CURDIR}/include ; for j in *.h; do  cmp -s $$j ${DESTDIR}/usr/include/g++/$$j ||  install -c -o ${BINOWN} -g ${BINGRP} -m 444 $$j  ${DESTDIR}/usr/include/g++/$$j;  done)
 
 .include <bsd.lib.mk>
diff --git a/gnu/lib/libg++/include/ACG.h b/gnu/lib/libg++/include/ACG.h
index d7101c7..8093800 100644
--- a/gnu/lib/libg++/include/ACG.h
+++ b/gnu/lib/libg++/include/ACG.h
@@ -42,26 +42,26 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
 class ACG : public RNG {
 
-    unsigned long initialSeed;	// used to reset generator
+    _G_uint32_t initialSeed;	// used to reset generator
     int initialTableEntry;
 
-    unsigned long *state;
-    unsigned long *auxState;
+    _G_uint32_t *state;
+    _G_uint32_t *auxState;
     short stateSize;
     short auxSize;
-    unsigned long lcgRecurr;
+    _G_uint32_t lcgRecurr;
     short j;
     short k;
 
 protected:
 
 public:
-    ACG(unsigned long seed = 0, int size = 55);
+    ACG(_G_uint32_t seed = 0, int size = 55);
     virtual ~ACG();
     //
     // Return a long-words word of random bits
     //
-    virtual unsigned long asLong();
+    virtual _G_uint32_t asLong();
     virtual void reset();
 };
 
diff --git a/gnu/lib/libg++/include/Complex.h b/gnu/lib/libg++/include/Complex.h
index 385ea606d7..9b7e378 100644
--- a/gnu/lib/libg++/include/Complex.h
+++ b/gnu/lib/libg++/include/Complex.h
@@ -87,33 +87,6 @@ Complex   sqrt(const Complex& x);
 istream&  operator >> (istream& s, Complex& x);
 ostream&  operator << (ostream& s, const Complex& x);
 
-// other functions defined as inlines
-
-int  operator == (const Complex& x, const Complex& y);
-int  operator == (const Complex& x, double y);
-int  operator != (const Complex& x, const Complex& y);
-int  operator != (const Complex& x, double y);
-
-Complex  operator - (const Complex& x);
-Complex  conj(const Complex& x);
-Complex  operator + (const Complex& x, const Complex& y);
-Complex  operator + (const Complex& x, double y);
-Complex  operator + (double x, const Complex& y);
-Complex  operator - (const Complex& x, const Complex& y);
-Complex  operator - (const Complex& x, double y);
-Complex  operator - (double x, const Complex& y);
-Complex  operator * (const Complex& x, const Complex& y);
-Complex  operator * (const Complex& x, double y);
-Complex  operator * (double x, const Complex& y);
-
-double  real(const Complex& x);
-double  imag(const Complex& x);
-double  abs(const Complex& x);
-double  norm(const Complex& x);
-double  arg(const Complex& x);
-
-Complex  polar(double r, double t = 0.0);
-
 
 // inline members
 
diff --git a/gnu/lib/libg++/include/CursesW.h b/gnu/lib/libg++/include/CursesW.h
index 4f367fd..1df2e8a 100644
--- a/gnu/lib/libg++/include/CursesW.h
+++ b/gnu/lib/libg++/include/CursesW.h
@@ -25,7 +25,11 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
 #include   <_G_config.h>
 #if _G_HAVE_CURSES
+// Even many system which mostly have C++-ready header files,
+// do not have C++-ready curses.h.
+extern "C" {
 #include   <curses.h>
+}
 
 /* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
    Undefine it here, because CursesWindow uses lines as a method.  */
@@ -148,8 +152,9 @@ inline int (winch)(WINDOW* win) { return winch(win); }
 
 /* deal with conflicting macros in ncurses.h  which is SYSV based*/
 #ifdef box
-inline (box)(WINDOW* win, chtype v, chtype h) {return box(win, v, h); }
+inline _G_box(WINDOW* win, chtype v, chtype h) {return box(win, v, h); }
 #undef box
+inline box(WINDOW* win, chtype v, chtype h) {return _G_box(win, v, h); }
 #endif
 #ifdef scroll
 inline (scroll)(WINDOW* win) { return scroll(win); }
diff --git a/gnu/lib/libg++/include/DLList.h b/gnu/lib/libg++/include/DLList.h
index 0c3adc2..36f73bc 100644
--- a/gnu/lib/libg++/include/DLList.h
+++ b/gnu/lib/libg++/include/DLList.h
@@ -66,9 +66,9 @@ class BaseDLList {
     int                   empty() const { return h == 0; }
     int                   length() const;
     void                  clear();
-    void                  error(const char* msg);
-    int                   owns(Pix p);
-    int                   OK();
+    void                  error(const char* msg) const;
+    int                   owns(Pix p) const;
+    int                   OK() const;
     void                  del(Pix& p, int dir = 1);
     void                  del_after(Pix& p);
     void                  del_front();
@@ -104,6 +104,13 @@ class DLList : public BaseDLList {
 	if (h == 0) error("rear: empty list");
 	return ((DLNode<T>*)h->bk)->hd;
     }
+    const T& front() const {
+	if (h == 0) error("front: empty list");
+	return ((DLNode<T>*)h)->hd; }
+    const T& rear() const {
+	if (h == 0) error("rear: empty list");
+	return ((DLNode<T>*)h->bk)->hd;
+    }
     T remove_front() { T dst; BaseDLList::remove_front(&dst); return dst; }
     T remove_rear() { T dst; BaseDLList::remove_rear(&dst); return dst; }
 
@@ -111,11 +118,15 @@ class DLList : public BaseDLList {
 	if (p == 0) error("null Pix");
 	return ((DLNode<T>*)p)->hd;
     }
-    Pix                   first() {  return Pix(h); }
-    Pix                   last() { return (h == 0)? 0 : Pix(h->bk); }
-    void                  next(Pix& p)
+    const T&              operator () (Pix p) const {
+	if (p == 0) error("null Pix");
+	return ((DLNode<T>*)p)->hd;
+    }
+    Pix                   first() const { return Pix(h); }
+    Pix                   last()  const { return (h == 0) ? 0 : Pix(h->bk); }
+    void                  next(Pix& p) const
 	{ p = (p == 0 || p == h->bk)? 0 : Pix(((DLNode<T>*)p)->fd); }
-    void                  prev(Pix& p)
+    void                  prev(Pix& p) const
 	{ p = (p == 0 || p == h)? 0 : Pix(((DLNode<T>*)p)->bk); }
     Pix ins_after(Pix p, const T& item)
       {return BaseDLList::ins_after(p, &item); }
diff --git a/gnu/lib/libg++/include/Fix16.h b/gnu/lib/libg++/include/Fix16.h
index 36728b4..e598113 100644
--- a/gnu/lib/libg++/include/Fix16.h
+++ b/gnu/lib/libg++/include/Fix16.h
@@ -40,11 +40,11 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #define Fix16_min	(-1.)
 
 
-#define Fix32_fs 	((double)((unsigned long)(1 << 31)))
+#define Fix32_fs 	((double)((_G_uint32_t)(1 << 31)))
 
-#define Fix32_msb	((unsigned long)(1 << 31))
-#define Fix32_m_max	((long)((1 << 31) - 1))
-#define Fix32_m_min	((long)(1 << 31))
+#define Fix32_msb	((_G_uint32_t)(1 << 31))
+#define Fix32_m_max	((_G_int32_t)((1 << 31) - 1))
+#define Fix32_m_min	((_G_int32_t)(1 << 31))
 
 #define Fix32_mult	Fix32_fs
 #define Fix32_div	(1./Fix32_fs)
@@ -135,12 +135,12 @@ class Fix32
 { 
   friend class         Fix16;
 
-  long                 m;
+  _G_int32_t           m;
 
-  long                 round(double d);
-  long                 assign(double d);
+  _G_int32_t           round(double d);
+  _G_int32_t           assign(double d);
 
-                       Fix32(long i);
+                       Fix32(_G_int32_t i);
                        operator double() const;
 
 
@@ -155,8 +155,8 @@ public:
   Fix32&               operator =  (const Fix16&  f);
   Fix32&               operator =  (double d);
 
-  friend long&         mantissa(Fix32& f);
-  friend const long&   mantissa(const Fix32& f);
+  friend _G_int32_t&         mantissa(Fix32& f);
+  friend const _G_int32_t&   mantissa(const Fix32& f);
   friend double        value(const Fix32& f);
 
   Fix32                operator +  () const;
@@ -188,8 +188,8 @@ public:
   friend istream&      operator >> (istream& s, Fix32& f);
   friend ostream&      operator << (ostream& s, const Fix32& f);
 
-  void                 overflow(long& i) const;
-  void                 range_error(long& i) const;
+  void                 overflow(_G_int32_t& i) const;
+  void                 range_error(_G_int32_t& i) const;
 
   friend Fix32          operator *  (const Fix32&  f, int g);
   friend Fix32          operator *  (int g, const Fix32&  f);
@@ -199,7 +199,7 @@ public:
 // active error handler declarations
 
 typedef void (*Fix16_peh)(short&);
-typedef void (*Fix32_peh)(long&);
+typedef void (*Fix32_peh)(_G_int32_t&);
 
 extern Fix16_peh Fix16_overflow_handler;
 extern Fix32_peh Fix32_overflow_handler;
@@ -231,11 +231,11 @@ extern void
   Fix16_abort(short&);
 
 extern void
-  Fix32_ignore(long&),
-  Fix32_overflow_saturate(long&),
-  Fix32_overflow_warning_saturate(long&),
-  Fix32_warning(long&),
-  Fix32_abort(long&);
+  Fix32_ignore(_G_int32_t&),
+  Fix32_overflow_saturate(_G_int32_t&),
+  Fix32_overflow_warning_saturate(_G_int32_t&),
+  Fix32_warning(_G_int32_t&),
+  Fix32_abort(_G_int32_t&);
 
 
 inline Fix16::~Fix16() {}
@@ -294,7 +294,7 @@ inline Fix32::Fix32()
   m = 0;
 }
 
-inline Fix32::Fix32(long i)		
+inline Fix32::Fix32(_G_int32_t i)		
 { 
   m = i;
 }
@@ -312,7 +312,7 @@ inline Fix32::Fix32(const Fix32& f)
 
 inline Fix32::Fix32(const Fix16&  f)    
 { 
-  m = long(f.m) << 16;
+  m = _G_int32_t(f.m) << 16;
 }
 
 inline Fix32::Fix32(double d)		
@@ -340,7 +340,7 @@ inline Fix32& Fix32::operator=(const Fix32& f)
 
 inline Fix32& Fix32::operator=(const Fix16&  f)	
 { 
-  m = long(f.m) << 16;
+  m = _G_int32_t(f.m) << 16;
   return *this;
 }
 
@@ -393,7 +393,7 @@ inline Fix16 operator-(const Fix16&  f, const Fix16&  g)
 
 inline Fix32 operator*(const Fix16&  f, const Fix16&  g)
 { 
-  return Fix32( long( long(f.m) * long(g.m) << 1)); 
+  return Fix32( _G_int32_t( _G_int32_t(f.m) * _G_int32_t(g.m) << 1)); 
 }
 
 inline Fix16 operator<<(const Fix16& a, int b) 	
@@ -498,17 +498,17 @@ inline Fix16& Fix16::operator*=(int g)
 
 inline Fix32::~Fix32() {}
 
-inline long Fix32::round(double d)
+inline _G_int32_t Fix32::round(double d)
 { 
-  return long( (d >= 0)? d + 0.5 : d - 0.5);
+  return _G_int32_t( (d >= 0)? d + 0.5 : d - 0.5);
 }
 
-inline long& mantissa(Fix32& f)	
+inline _G_int32_t& mantissa(Fix32& f)	
 { 
   return f.m;
 }
 
-inline const long& mantissa(const Fix32& f)	
+inline const _G_int32_t& mantissa(const Fix32& f)	
 { 
   return f.m;
 }
@@ -530,7 +530,7 @@ inline Fix32 Fix32::operator-() const
 
 inline Fix32 operator+(const Fix32& f, const Fix32& g) 
 {
-  long sum = f.m + g.m;
+  _G_int32_t sum = f.m + g.m;
   if ( (f.m ^ sum) & (g.m ^ sum) & Fix32_msb )
     f.overflow(sum);
   return sum;
@@ -538,7 +538,7 @@ inline Fix32 operator+(const Fix32& f, const Fix32& g)
 
 inline Fix32 operator-(const Fix32& f, const Fix32& g) 
 {
-  long sum = f.m - g.m;
+  _G_int32_t sum = f.m - g.m;
   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix32_msb )
     f.overflow(sum);
   return sum;
@@ -630,7 +630,7 @@ inline ostream& operator<<(ostream& s, const Fix32& f)
 
 inline Fix32 operator*(const Fix32&  f, int g)
 {
-  return Fix32(long(f.m * g));
+  return Fix32(_G_int32_t(f.m * g));
 }
 
 inline Fix32 operator*(int g, const Fix32&  f)
diff --git a/gnu/lib/libg++/include/Fix24.h b/gnu/lib/libg++/include/Fix24.h
index 56d1191..5db346e 100644
--- a/gnu/lib/libg++/include/Fix24.h
+++ b/gnu/lib/libg++/include/Fix24.h
@@ -29,8 +29,8 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 // extra type definitions 
 
 typedef struct {
-  long                 u;
-  unsigned long	       l;
+  _G_int32_t		u;
+  _G_uint32_t		l;
 } twolongs;
 
 // constant definitions
@@ -45,7 +45,7 @@ static const double
   Fix24_max = 1. - .5/Fix24_fs,
   Fix24_min = -1.;
 	  
-static const unsigned long
+static const _G_uint32_t
   Fix24_msb = 0x80000000L,
   Fix24_lsb = 0x00000100L,
   Fix24_m_max = 0x7fffff00L,
@@ -74,9 +74,9 @@ class Fix24
 { 
   friend class          Fix48;
 
-  long                  m;
+  _G_int32_t            m;
 
-  long                  assign(double d);
+  _G_int32_t            assign(double d);
          operator       double() const;
                         Fix24(long i);
                         Fix24(int i);
@@ -94,8 +94,8 @@ public:
   Fix24&                operator=(double d);
   Fix24&                operator=(const Fix48& f);
 
-  friend long&          mantissa(Fix24&  f);
-  friend const long&    mantissa(const Fix24&  f);
+  friend _G_int32_t&    mantissa(Fix24&  f);
+  friend const _G_int32_t&    mantissa(const Fix24&  f);
   friend double         value(const Fix24&  f);
 
   Fix24                 operator +  () const;
@@ -129,8 +129,8 @@ public:
   friend istream&       operator >> (istream& s, Fix24&  f);
   friend ostream&       operator << (ostream& s, const Fix24&  f);
 
-  void                  overflow(long&) const;
-  void                  range_error(long&) const;
+  void                  overflow(_G_int32_t&) const;
+  void                  range_error(_G_int32_t&) const;
 };
 
  
@@ -200,7 +200,7 @@ public:
 
 // active error handler declarations
 
-typedef void (*Fix24_peh)(long&);
+typedef void (*Fix24_peh)(_G_int32_t&);
 typedef void (*Fix48_peh)(twolongs&);
 
 extern Fix24_peh Fix24_overflow_handler;
@@ -226,11 +226,11 @@ extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
 extern void set_range_error_handler(Fix24_peh, Fix48_peh);
 
 extern void
-  Fix24_ignore(long&),
-  Fix24_overflow_saturate(long&),
-  Fix24_overflow_warning_saturate(long&),
-  Fix24_warning(long&),
-  Fix24_abort(long&);
+  Fix24_ignore(_G_int32_t&),
+  Fix24_overflow_saturate(_G_int32_t&),
+  Fix24_overflow_warning_saturate(_G_int32_t&),
+  Fix24_warning(_G_int32_t&),
+  Fix24_abort(_G_int32_t&);
 
 extern void
   Fix48_ignore(twolongs&),
@@ -295,12 +295,12 @@ inline Fix24&  Fix24::operator=(const Fix48& f)
   return *this; 
 }
 
-inline long& mantissa(Fix24&  f)
+inline _G_int32_t& mantissa(Fix24&  f)
 { 
   return f.m; 
 }
 
-inline const long& mantissa(const Fix24&  f)
+inline const _G_int32_t& mantissa(const Fix24&  f)
 { 
   return f.m; 
 }
@@ -322,7 +322,7 @@ inline Fix24 Fix24::operator-() const
 
 inline Fix24 operator+(const Fix24&  f, const Fix24&  g) 
 {
-  long sum = f.m + g.m;
+  _G_int32_t sum = f.m + g.m;
   if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
     f.overflow(sum);
   return sum;
@@ -330,7 +330,7 @@ inline Fix24 operator+(const Fix24&  f, const Fix24&  g)
 
 inline Fix24 operator-(const Fix24&  f, const Fix24&  g) 
 {
-  long sum = f.m - g.m;
+  _G_int32_t sum = f.m - g.m;
   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
     f.overflow(sum);
   return sum;
@@ -353,7 +353,7 @@ inline Fix24 operator<<(const Fix24& a, int b)
 
 inline Fix24 operator>>(const Fix24& a, int b) 	
 { 
-  return (a.m >> b) & (long)0xffffff00; 
+  return (a.m >> b) & ~0xff;
 }
 
 inline  Fix24&  Fix24:: operator+=(const Fix24&  f)
@@ -448,7 +448,7 @@ inline Fix48:: operator double() const
  * m.u is signed and m.l is unsigned.
  */
   return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
-      (Fix48_div_u * ((unsigned long)(m.u & 0xffffff00)) 
+      (Fix48_div_u * ((_G_uint32_t)(m.u & 0xffffff00)) 
 	  + Fix48_div_l * m.l) - 2;
 }
 
diff --git a/gnu/lib/libg++/include/MLCG.h b/gnu/lib/libg++/include/MLCG.h
index 8f104a1..8fa08a8 100644
--- a/gnu/lib/libg++/include/MLCG.h
+++ b/gnu/lib/libg++/include/MLCG.h
@@ -41,7 +41,7 @@ public:
     //
     // Return a long-words word of random bits
     //
-    virtual unsigned long asLong();
+    virtual _G_uint32_t asLong();
     virtual void reset();
     _G_int32_t seed1();
     void seed1(_G_int32_t);
diff --git a/gnu/lib/libg++/include/RNG.h b/gnu/lib/libg++/include/RNG.h
index 43d95b7..b924fb6 100644
--- a/gnu/lib/libg++/include/RNG.h
+++ b/gnu/lib/libg++/include/RNG.h
@@ -46,7 +46,7 @@ public:
     //
     // Return a long-words word of random bits
     //
-    virtual unsigned long asLong() = 0;
+    virtual _G_uint32_t asLong() = 0;
     virtual void reset() = 0;
     //
     // Return random bits converted to either a float or a double
diff --git a/gnu/lib/libg++/include/SLList.h b/gnu/lib/libg++/include/SLList.h
index c613674..8c133d7 100644
--- a/gnu/lib/libg++/include/SLList.h
+++ b/gnu/lib/libg++/include/SLList.h
@@ -64,10 +64,10 @@ class BaseSLList {
     void clear();
     Pix                   prepend(BaseSLNode*);
     Pix                   append(BaseSLNode*);
-    int                   OK();
-    void                  error(const char* msg);
+    int                   OK() const;
+    void                  error(const char* msg) const;
     void                  del_after(Pix p);
-    int                   owns(Pix p);
+    int                   owns(Pix p) const;
     void                  del_front();
 };
 
@@ -95,9 +95,12 @@ public:
     T& operator () (Pix p) {
 	if (p == 0) error("null Pix");
 	return ((SLNode<T>*)(p))->hd; }
-    inline Pix first() { return (last == 0)? 0 : Pix(last->tl); }
-    void next(Pix& p)
-	{ p = (p == 0 || p == last)? 0 : Pix(((SLNode<T>*)(p))->tl); }
+    const T& operator () (Pix p) const {
+	if (p == 0) error("null Pix");
+	return ((SLNode<T>*)(p))->hd; }
+    inline Pix first() const { return (last == 0) ? 0 : Pix(last->tl); }
+    void next(Pix& p) const
+	{ p = (p == 0 || p == last) ? 0 : Pix(((SLNode<T>*)(p))->tl); }
     Pix ins_after(Pix p, const T& item)
       { return BaseSLList::ins_after(p, &item); }
     void join(SLList<T>& a) { BaseSLList::join(a); }
@@ -108,6 +111,12 @@ public:
     T& rear() {
 	if (last == 0) error("rear: empty list");
 	return ((SLNode<T>*)last)->hd; }
+    const T& front() const {
+	if (last == 0) error("front: empty list");
+	return ((SLNode<T>*)last->tl)->hd; }
+    const T& rear() const {
+	if (last == 0) error("rear: empty list");
+	return ((SLNode<T>*)last)->hd; }
     int remove_front(T& x) { return BaseSLList::remove_front(&x); }
     T remove_front() { T dst; BaseSLList::remove_front(&dst, 1); return dst; }
 };
diff --git a/gnu/lib/libg++/include/String.h b/gnu/lib/libg++/include/String.h
index 9537ba6..95b2bdf 100644
--- a/gnu/lib/libg++/include/String.h
+++ b/gnu/lib/libg++/include/String.h
@@ -39,7 +39,6 @@ struct StrRep                     // internal String representations
 
 StrRep*     Salloc(StrRep*, const char*, int, int);
 StrRep*     Scopy(StrRep*, const StrRep*);
-StrRep*     Sresize(StrRep*, int);
 StrRep*     Scat(StrRep*, const char*, int, const char*, int);
 StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
 StrRep*     Sprepend(StrRep*, const char*, int);
@@ -155,50 +154,50 @@ public:
 // procedural versions:
 // concatenate first 2 args, store result in last arg
 
-  friend void     cat(const String&, const String&, String&);
-  friend void     cat(const String&, const SubString&, String&);
-  friend void     cat(const String&, const char*, String&);
-  friend void     cat(const String&, char, String&);
+  friend inline void     cat(const String&, const String&, String&);
+  friend inline void     cat(const String&, const SubString&, String&);
+  friend inline void     cat(const String&, const char*, String&);
+  friend inline void     cat(const String&, char, String&);
 
-  friend void     cat(const SubString&, const String&, String&);
-  friend void     cat(const SubString&, const SubString&, String&);
-  friend void     cat(const SubString&, const char*, String&);
-  friend void     cat(const SubString&, char, String&);
+  friend inline void     cat(const SubString&, const String&, String&);
+  friend inline void     cat(const SubString&, const SubString&, String&);
+  friend inline void     cat(const SubString&, const char*, String&);
+  friend inline void     cat(const SubString&, char, String&);
 
-  friend void     cat(const char*, const String&, String&);
-  friend void     cat(const char*, const SubString&, String&);
-  friend void     cat(const char*, const char*, String&);
-  friend void     cat(const char*, char, String&);
+  friend inline void     cat(const char*, const String&, String&);
+  friend inline void     cat(const char*, const SubString&, String&);
+  friend inline void     cat(const char*, const char*, String&);
+  friend inline void     cat(const char*, char, String&);
 
 // double concatenation, by request. (yes, there are too many versions, 
 // but if one is supported, then the others should be too...)
 // Concatenate first 3 args, store in last arg
 
-  friend void     cat(const String&,const String&, const String&,String&);
-  friend void     cat(const String&,const String&,const SubString&,String&);
-  friend void     cat(const String&,const String&, const char*, String&);
-  friend void     cat(const String&,const String&, char, String&);
-  friend void     cat(const String&,const SubString&,const String&,String&);
-  friend void     cat(const String&,const SubString&,const SubString&,String&);
-  friend void     cat(const String&,const SubString&, const char*, String&);
-  friend void     cat(const String&,const SubString&, char, String&);
-  friend void     cat(const String&,const char*, const String&,    String&);
-  friend void     cat(const String&,const char*, const SubString&, String&);
-  friend void     cat(const String&,const char*, const char*, String&);
-  friend void     cat(const String&,const char*, char, String&);
-
-  friend void     cat(const char*, const String&, const String&,String&);
-  friend void     cat(const char*,const String&,const SubString&,String&);
-  friend void     cat(const char*,const String&, const char*, String&);
-  friend void     cat(const char*,const String&, char, String&);
-  friend void     cat(const char*,const SubString&,const String&,String&);
-  friend void     cat(const char*,const SubString&,const SubString&,String&);
-  friend void     cat(const char*,const SubString&, const char*, String&);
-  friend void     cat(const char*,const SubString&, char, String&);
-  friend void     cat(const char*,const char*, const String&,    String&);
-  friend void     cat(const char*,const char*, const SubString&, String&);
-  friend void     cat(const char*,const char*, const char*, String&);
-  friend void     cat(const char*,const char*, char, String&);
+  friend inline void     cat(const String&,const String&, const String&,String&);
+  friend inline void     cat(const String&,const String&,const SubString&,String&);
+  friend inline void     cat(const String&,const String&, const char*, String&);
+  friend inline void     cat(const String&,const String&, char, String&);
+  friend inline void     cat(const String&,const SubString&,const String&,String&);
+  inline friend void     cat(const String&,const SubString&,const SubString&,String&);
+  friend inline void     cat(const String&,const SubString&, const char*, String&);
+  friend inline void     cat(const String&,const SubString&, char, String&);
+  friend inline void     cat(const String&,const char*, const String&,    String&);
+  friend inline void     cat(const String&,const char*, const SubString&, String&);
+  friend inline void     cat(const String&,const char*, const char*, String&);
+  friend inline void     cat(const String&,const char*, char, String&);
+
+  friend inline void     cat(const char*, const String&, const String&,String&);
+  friend inline void     cat(const char*,const String&,const SubString&,String&);
+  friend inline void     cat(const char*,const String&, const char*, String&);
+  friend inline void     cat(const char*,const String&, char, String&);
+  friend inline void     cat(const char*,const SubString&,const String&,String&);
+  friend inline void     cat(const char*,const SubString&,const SubString&,String&);
+  friend inline void     cat(const char*,const SubString&, const char*, String&);
+  friend inline void     cat(const char*,const SubString&, char, String&);
+  friend inline void     cat(const char*,const char*, const String&,    String&);
+  friend inline void     cat(const char*,const char*, const SubString&, String&);
+  friend inline void     cat(const char*,const char*, const char*, String&);
+  friend inline void     cat(const char*,const char*, char, String&);
 
 
 // searching & matching
@@ -327,10 +326,10 @@ public:
 
 // simple builtin transformations
 
-  friend String     reverse(const String& x);
-  friend String     upcase(const String& x);
-  friend String     downcase(const String& x);
-  friend String     capitalize(const String& x);
+  friend inline String     reverse(const String& x);
+  friend inline String     upcase(const String& x);
+  friend inline String     downcase(const String& x);
+  friend inline String     capitalize(const String& x);
 
 // in-place versions of above
 
@@ -342,6 +341,7 @@ public:
 // element extraction
 
   char&             operator [] (int i);
+  const char&       operator [] (int i) const;
   char              elem(int i) const;
   char              firstchar() const;
   char              lastchar() const;
@@ -354,7 +354,7 @@ public:
 
 // IO
 
-  friend ostream&   operator<<(ostream& s, const String& x);
+  friend inline ostream&   operator<<(ostream& s, const String& x);
   friend ostream&   operator<<(ostream& s, const SubString& x);
   friend istream&   operator>>(istream& s, String& x);
 
@@ -395,64 +395,12 @@ int        fcompare(const String&   x, const String&     y); // ignore case
 extern StrRep  _nilStrRep;
 extern String _nilString;
 
-// other inlines
-
-String operator + (const String& x, const String& y);
-String operator + (const String& x, const SubString& y);
-String operator + (const String& x, const char* y);
-String operator + (const String& x, char y);
-String operator + (const SubString& x, const String& y);
-String operator + (const SubString& x, const SubString& y);
-String operator + (const SubString& x, const char* y);
-String operator + (const SubString& x, char y);
-String operator + (const char* x, const String& y);
-String operator + (const char* x, const SubString& y);
-
-int operator==(const String& x, const String& y); 
-int operator!=(const String& x, const String& y);
-int operator> (const String& x, const String& y);
-int operator>=(const String& x, const String& y);
-int operator< (const String& x, const String& y);
-int operator<=(const String& x, const String& y);
-int operator==(const String& x, const SubString&  y);
-int operator!=(const String& x, const SubString&  y);
-int operator> (const String& x, const SubString&  y);
-int operator>=(const String& x, const SubString&  y);
-int operator< (const String& x, const SubString&  y);
-int operator<=(const String& x, const SubString&  y);
-int operator==(const String& x, const char* t);
-int operator!=(const String& x, const char* t);
-int operator> (const String& x, const char* t);
-int operator>=(const String& x, const char* t);
-int operator< (const String& x, const char* t);
-int operator<=(const String& x, const char* t);
-int operator==(const SubString& x, const String& y);
-int operator!=(const SubString& x, const String& y);
-int operator> (const SubString& x, const String& y);
-int operator>=(const SubString& x, const String& y);
-int operator< (const SubString& x, const String& y);
-int operator<=(const SubString& x, const String& y);
-int operator==(const SubString& x, const SubString&  y);
-int operator!=(const SubString& x, const SubString&  y);
-int operator> (const SubString& x, const SubString&  y);
-int operator>=(const SubString& x, const SubString&  y);
-int operator< (const SubString& x, const SubString&  y);
-int operator<=(const SubString& x, const SubString&  y);
-int operator==(const SubString& x, const char* t);
-int operator!=(const SubString& x, const char* t);
-int operator> (const SubString& x, const char* t);
-int operator>=(const SubString& x, const char* t);
-int operator< (const SubString& x, const char* t);
-int operator<=(const SubString& x, const char* t);
-
-
 // status reports, needed before defining other things
 
 inline unsigned int String::length() const {  return rep->len; }
 inline int         String::empty() const { return rep->len == 0; }
 inline const char* String::chars() const { return &(rep->s[0]); }
 inline int         String::allocation() const { return rep->sz; }
-inline void        String::alloc(int newsize) { rep = Sresize(rep, newsize); }
 
 inline unsigned int SubString::length() const { return len; }
 inline int         SubString::empty() const { return len == 0; }
@@ -948,6 +896,12 @@ inline char&  String::operator [] (int i)
   return rep->s[i];
 }
 
+inline const char&  String::operator [] (int i) const
+{ 
+  if (((unsigned)i) >= length()) error("invalid index");
+  return rep->s[i];
+}
+
 inline char  String::elem (int i) const
 { 
   if (((unsigned)i) >= length()) error("invalid index");
diff --git a/gnu/lib/libg++/include/_G_config.h b/gnu/lib/libg++/include/_G_config.h
index 2b73e90..1e5e28d 100644
--- a/gnu/lib/libg++/include/_G_config.h
+++ b/gnu/lib/libg++/include/_G_config.h
@@ -1,9 +1,10 @@
 /* AUTOMATICALLY GENERATED; DO NOT EDIT! */ 
+#include <sys/types.h>
 #ifndef _G_config_h
 #define _G_config_h
-#define _G_LIB_VERSION "0.65"
+#define _G_LIB_VERSION "0.66"
 #define _G_NAMES_HAVE_UNDERSCORE 1
-#define _G_VTABLE_LABEL_HAS_LENGTH 0
+#define _G_VTABLE_LABEL_HAS_LENGTH 1
 #define _G_VTABLE_LABEL_PREFIX "__vt$"
 #define _G_HAVE_ST_BLKSIZE 1
 typedef unsigned long _G_clock_t;
@@ -31,7 +32,7 @@ typedef unsigned long _G_uid_t;
 #endif
 typedef __WCHAR_TYPE__ _G_wchar_t;
 typedef int _G_ssize_t;
-typedef int _G_wint_t;
+typedef int /* default */ _G_wint_t;
 typedef char* /* default */ _G_va_list;
 #define _G_signal_return_type void
 #define _G_sprintf_return_type int
@@ -55,9 +56,12 @@ typedef unsigned  _G_uint64_t;
 #else
 #define _G_ARGS(ARGLIST) ()
 #endif
-#if defined (__GNUG__) && defined (__STRICT_ANSI__)
+#if !defined (__GNUG__) || defined (__STRICT_ANSI__)
 #define _G_NO_NRV
 #endif
+#if !defined (__GNUG__)
+#define _G_NO_EXTERN_TEMPLATES
+#endif
 #define _G_HAVE_ATEXIT 1
 #define _G_HAVE_SYS_RESOURCE 0
 #define _G_HAVE_SYS_SOCKET 1
@@ -66,5 +70,5 @@ typedef unsigned  _G_uint64_t;
 #define _G_HAVE_DIRENT 1
 #define _G_HAVE_CURSES 1
 #define _G_MATH_H_INLINES 0
-#define _G_HAVE_BOOL 0
+#define _G_HAVE_BOOL 1
 #endif /* !_G_config_h */
diff --git a/gnu/lib/libg++/include/bitprims.h b/gnu/lib/libg++/include/bitprims.h
index 771acd9..24b3051 100644
--- a/gnu/lib/libg++/include/bitprims.h
+++ b/gnu/lib/libg++/include/bitprims.h
@@ -122,4 +122,4 @@ extern void _BS_xor __P((_BS_word*,int, const _BS_word*,int, _BS_size_t));
 }
 #endif
 
-#endif _BS_PRIMS
+#endif /* !_BS_PRIMS */
diff --git a/gnu/lib/libg++/include/builtin.h b/gnu/lib/libg++/include/builtin.h
index 7f8299c..73bb431 100644
--- a/gnu/lib/libg++/include/builtin.h
+++ b/gnu/lib/libg++/include/builtin.h
@@ -64,21 +64,6 @@ extern two_arg_error_handler_t
        set_lib_error_handler(two_arg_error_handler_t f);
 
 
-double abs(double arg);
-float abs(float arg);
-short abs(short arg);
-long abs(long arg);
-int sign(long arg);
-int sign(double arg);
-long sqr(long arg);
-double sqr(double arg);
-int even(long arg);
-int odd(long arg);
-long lcm(long x, long y);
-void (setbit)(long& x, long b);
-void clearbit(long& x, long b);
-int testbit(long x, long b);
-
 #if !defined(IV)
 
 #if ! _G_MATH_H_INLINES /* hpux and SCO define this in math.h */
diff --git a/gnu/lib/libg++/include/defines.h b/gnu/lib/libg++/include/defines.h
index ddb76e9..0f2fb3b 100644
--- a/gnu/lib/libg++/include/defines.h
+++ b/gnu/lib/libg++/include/defines.h
@@ -30,4 +30,6 @@ typedef void fvoid_t();
 typedef _G_wint_t wint_t;
 #endif
 
+enum capacity { default_size, reserve };
+
 #endif
diff --git a/gnu/lib/libg++/include/iolibio.h b/gnu/lib/libg++/include/iolibio.h
index 2a7c145..08040fa 100644
--- a/gnu/lib/libg++/include/iolibio.h
+++ b/gnu/lib/libg++/include/iolibio.h
@@ -3,6 +3,10 @@
 /* These emulate stdio functionality, but with a different name
    (_IO_ungetc instead of ungetc), and using _IO_FILE instead of FILE. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern int _IO_fclose __P((_IO_FILE*));
 extern _IO_FILE *_IO_fdopen __P((int, const char*));
 extern int _IO_fflush __P((_IO_FILE*));
@@ -17,6 +21,7 @@ extern _IO_size_t _IO_fwrite __P((const void*,
 				      _IO_size_t, _IO_size_t, _IO_FILE*));
 extern char* _IO_gets __P((char*));
 extern void _IO_perror __P((const char*));
+extern int _IO_printf __P((const char*, ...));
 extern int _IO_puts __P((const char*));
 extern int _IO_scanf __P((const char*, ...));
 extern void _IO_setbuffer __P((_IO_FILE *, char*, _IO_size_t));
@@ -30,8 +35,6 @@ extern int _IO_vsprintf __P((char*, const char*, _IO_va_list));
 #define _IO_pos_BAD ((_IO_fpos_t)(-1))
 #endif
 #define _IO_clearerr(FP) ((FP)->_flags &= ~(_IO_ERR_SEEN|_IO_EOF_SEEN))
-#define _IO_feof(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
-#define _IO_ferror(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
 #define _IO_fseek(__fp, __offset, __whence) \
   (_IO_seekoff(__fp, __offset, (_IO_off_t)(__whence)) == _IO_pos_BAD ? EOF : 0)
 #define _IO_rewind(FILE) (void)_IO_seekoff(FILE, 0, 0)
@@ -44,3 +47,6 @@ extern _IO_FILE* _IO_popen __P((const char*, const char*));
 #define _IO_setbuf(_FP, _BUF) _IO_setbuffer(_FP, _BUF, _IO_BUFSIZ)
 #define _IO_setlinebuf(_FP) _IO_setvbuf(_FP, NULL, 1, 0)
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/gnu/lib/libg++/include/iomanip.h b/gnu/lib/libg++/include/iomanip.h
index cab4b97..bf3d6f4 100644
--- a/gnu/lib/libg++/include/iomanip.h
+++ b/gnu/lib/libg++/include/iomanip.h
@@ -130,7 +130,7 @@ public:
     omanip(ostream& (*f)(ostream&, TP), TP a) : _f(f), _a(a) {}
     //
     friend
-      ostream& operator<<(ostream& o, omanip<TP>& m)
+      ostream& operator<<(ostream& o, const omanip<TP>& m)
 	{ return (*m._f)(o, m._a); }
 };
 
diff --git a/gnu/lib/libg++/include/iostream.h b/gnu/lib/libg++/include/iostream.h
index 7348ce2..e370be2 100644
--- a/gnu/lib/libg++/include/iostream.h
+++ b/gnu/lib/libg++/include/iostream.h
@@ -92,6 +92,7 @@ class ostream : virtual public ios
 #endif
     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*);
@@ -103,6 +104,7 @@ class ostream : virtual public ios
 class istream : virtual public ios
 {
     // NOTE: If fields are changed, you must fix _fake_istream in stdstreams.C!
+protected:
     _IO_size_t _gcount;
 
     int _skip_ws();
@@ -198,22 +200,32 @@ class istream : virtual public ios
 #endif
     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
 {
-    _IO_size_t _gcount;
   public:
-    iostream() { _gcount = 0; }
+    iostream() { }
     iostream(streambuf* sb, ostream*tied=NULL);
 };
 
-extern istream cin;
-extern ostream cout, cerr, clog; // clog->rdbuf() == cerr->rdbuf()
+class _IO_istream_withassign : public istream {
+public:
+  _IO_istream_withassign& operator=(istream&);
+};
+
+class _IO_ostream_withassign : public ostream {
+public:
+  _IO_ostream_withassign& operator=(ostream&);
+};
+
+extern _IO_istream_withassign cin;
+// clog->rdbuf() == cerr->rdbuf()
+extern _IO_ostream_withassign cout, cerr, clog;
 
 struct Iostream_init { } ;  // Compatibility hack for AT&T library.
 
diff --git a/gnu/lib/libg++/include/libiberty.h b/gnu/lib/libg++/include/libiberty.h
index 9854b4c..0a71c52 100644
--- a/gnu/lib/libg++/include/libiberty.h
+++ b/gnu/lib/libg++/include/libiberty.h
@@ -61,6 +61,13 @@ extern int strtoerrno PARAMS ((const char *));
 
 extern int signo_max PARAMS ((void));
 
+/* Return a signal message string for a signal number
+   (e.g., strsignal (SIGHUP) returns something like "Hangup").  */
+/* This is commented out as it can conflict with one in system headers.
+   We still document its existence though.  */
+
+/*extern const char *strsignal PARAMS ((int));*/
+
 /* Return the name of a signal number (e.g., strsigno (SIGHUP) returns
    "SIGHUP").  */
 
diff --git a/gnu/lib/libg++/include/libio.h b/gnu/lib/libg++/include/libio.h
index a064197..8a9c25b 100644
--- a/gnu/lib/libg++/include/libio.h
+++ b/gnu/lib/libg++/include/libio.h
@@ -73,7 +73,7 @@ typedef _IO_fpos_t _IO_pos_t;
 #ifndef __STDC__
 #define const
 #endif
-#define USE_DTOA
+#define _IO_USE_DTOA
 
 #if 0
 #ifdef _IO_NEED_STDARG_H
@@ -236,6 +236,9 @@ extern unsigned __adjust_column __P((unsigned start, const char *line, int count
     ? __overflow(_fp, (unsigned char)(_ch)) \
     : (unsigned char)(*(_fp)->_IO_write_ptr++ = (_ch)))
 
+#define _IO_feof(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
+#define _IO_ferror(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
+
 /* This one is for Emacs. */
 #define _IO_PENDING_OUTPUT_COUNT(_fp)	\
 	((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
diff --git a/gnu/lib/libg++/include/libioP.h b/gnu/lib/libg++/include/libioP.h
index 11d90f5..ca87047 100644
--- a/gnu/lib/libg++/include/libioP.h
+++ b/gnu/lib/libg++/include/libioP.h
@@ -146,9 +146,9 @@ extern struct _IO_jump_t _IO_streambuf_jumps;
 extern struct _IO_jump_t _IO_proc_jumps;
 extern struct _IO_jump_t _IO_str_jumps;
 extern int _IO_do_write __P((_IO_FILE*, const char*, _IO_size_t));
-extern int _IO_flush_all __P(());
-extern void _IO_cleanup __P(());
-extern void _IO_flush_all_linebuffered __P(());
+extern int _IO_flush_all __P((void));
+extern void _IO_cleanup __P((void));
+extern void _IO_flush_all_linebuffered __P((void));
 
 #define _IO_do_flush(_f) \
   _IO_do_write(_f, (_f)->_IO_write_base, \
@@ -205,6 +205,7 @@ extern void _IO_str_init_readonly __P((_IO_FILE *, const char*, int));
 extern _IO_ssize_t _IO_str_count __P ((_IO_FILE*));
 
 extern _IO_size_t _IO_getline __P((_IO_FILE*,char*,_IO_size_t,int,int));
+extern _IO_ssize_t _IO_getdelim __P((char**, _IO_size_t*, int, _IO_FILE*));
 extern double _IO_strtod __P((const char *, char **));
 extern char * _IO_dtoa __P((double __d, int __mode, int __ndigits,
 				int *__decpt, int *__sign, char **__rve));
@@ -213,7 +214,7 @@ extern int _IO_outfloat __P((double __value, _IO_FILE *__sb, int __type,
 				 int __sign_mode, int __fill));
 
 extern _IO_FILE *_IO_list_all;
-extern void (*_IO_cleanup_registration_needed)();
+extern void (*_IO_cleanup_registration_needed) __P ((void));
 
 #ifndef EOF
 #define EOF (-1)
@@ -306,3 +307,20 @@ extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf;
   (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \
     && (FILE) = *(FILE**)&((int*)fp)[1])
 #endif
+
+#ifdef EINVAL
+#define MAYBE_SET_EINVAL errno = EINVAL
+#else
+#define MAYBE_SET_EINVAL /* nothing */
+#endif
+
+#ifdef DEBUG
+#define CHECK_FILE(FILE,RET) \
+	if ((FILE) == NULL) { MAYBE_SET_EINVAL; return RET; } \
+	else { COERCE_FILE(FILE); \
+	       if (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \
+	  { errno = EINVAL; return RET; }}
+#else
+#define CHECK_FILE(FILE,RET) \
+	COERCE_FILE(FILE)
+#endif
diff --git a/gnu/lib/libg++/include/streambuf.h b/gnu/lib/libg++/include/streambuf.h
index 60181a4..efbab12 100644
--- a/gnu/lib/libg++/include/streambuf.h
+++ b/gnu/lib/libg++/include/streambuf.h
@@ -117,6 +117,7 @@ enum open_mode {
 #endif
 
 class ios : public _ios_fields {
+  ios& operator=(ios&);  /* Not allowed! */
   public:
     typedef __fmtflags fmtflags;
     typedef int iostate;
@@ -200,10 +201,8 @@ class ios : public _ios_fields {
     void _IO_fix_vtable();  /* TEMPORARY - for binary compatibility */
     void _IO_fix_vtable() const; /* TEMPORARY - for binary compatibility */
 #endif
-#if 0
     streambuf* rdbuf(streambuf *_s) {
-      streambuf *_old = _strbuf; _strbuf = _s; return _old; }
-#endif
+      streambuf *_old = _strbuf; _strbuf = _s; clear (); return _old; }
     void clear(iostate state = 0) {
 	_state = _strbuf ? state : state|badbit;
 	if (_state & _exceptions) _throw_failure(); }
diff --git a/gnu/lib/libg++/libg++/ACG.cc b/gnu/lib/libg++/libg++/ACG.cc
index 27e7aa2..6206080 100644
--- a/gnu/lib/libg++/libg++/ACG.cc
+++ b/gnu/lib/libg++/libg++/ACG.cc
@@ -123,7 +123,7 @@ static randomStateTable[][3] = {
 //
 
 #define RANDOM_PERM_SIZE 64
-unsigned long randomPermutations[RANDOM_PERM_SIZE] = {
+_G_uint32_t randomPermutations[RANDOM_PERM_SIZE] = {
 0xffffffff, 0x00000000,  0x00000000,  0x00000000,  // 3210
 0x0000ffff, 0x00ff0000,  0x00000000,  0xff000000,  // 2310
 0xff0000ff, 0x0000ff00,  0x00000000,  0x00ff0000,  // 3120
@@ -149,7 +149,7 @@ unsigned long randomPermutations[RANDOM_PERM_SIZE] = {
 //	SEED_TABLE_SIZE must be a power of 2
 //
 #define SEED_TABLE_SIZE 32
-static unsigned long seedTable[SEED_TABLE_SIZE] = {
+static _G_uint32_t seedTable[SEED_TABLE_SIZE] = {
 0xbdcc47e5, 0x54aea45d, 0xec0df859, 0xda84637b,
 0xc8c6cb4f, 0x35574b01, 0x28260b7d, 0x0d07fdbf,
 0x9faaeeb0, 0x613dd169, 0x5ce2d818, 0x85b9e706,
@@ -171,15 +171,15 @@ static unsigned long seedTable[SEED_TABLE_SIZE] = {
 // LC_C = result of a long trial & error series = 3907864577
 //
 
-static const unsigned long LC_A = 66049;
-static const unsigned long LC_C = 3907864577;
-static inline unsigned long LCG(unsigned long x)
+static const _G_uint32_t LC_A = 66049;
+static const _G_uint32_t LC_C = 3907864577;
+static inline _G_uint32_t LCG(_G_uint32_t x)
 {
     return( x * LC_A + LC_C );
 }
 
 
-ACG::ACG(unsigned long seed, int size)
+ACG::ACG(_G_uint32_t seed, int size)
 {
 
     initialSeed = seed;
@@ -205,7 +205,7 @@ ACG::ACG(unsigned long seed, int size)
     //	Allocate the state table & the auxillary table in a single malloc
     //
     
-    state = new unsigned long[stateSize + auxSize];
+    state = new _G_uint32_t[stateSize + auxSize];
     auxState = &state[stateSize];
 
     reset();
@@ -217,7 +217,7 @@ ACG::ACG(unsigned long seed, int size)
 void
 ACG::reset()
 {
-    register unsigned long u;
+    register _G_uint32_t u;
 
     if (initialSeed < SEED_TABLE_SIZE) {
 	u = seedTable[ initialSeed ];
@@ -247,7 +247,7 @@ ACG::reset()
     
     lcgRecurr = u;
     
-    assert(sizeof(double) == 2 * sizeof(long));
+    assert(sizeof(double) == 2 * sizeof(_G_int32_t));
 }
 
 ACG::~ACG()
@@ -261,15 +261,16 @@ ACG::~ACG()
 //	Returns 32 bits of random information.
 //
 
-unsigned long ACG::asLong()
+_G_uint32_t
+ACG::asLong()
 {
-    unsigned long result = state[k] + state[j];
+    _G_uint32_t result = state[k] + state[j];
     state[k] = result;
     j = (j <= 0) ? (stateSize-1) : (j-1);
     k = (k <= 0) ? (stateSize-1) : (k-1);
     
     short int auxIndex = (result >> 24) & (auxSize - 1);
-    register unsigned long auxACG = auxState[auxIndex];
+    register _G_uint32_t auxACG = auxState[auxIndex];
     auxState[auxIndex] = lcgRecurr = LCG(lcgRecurr);
     
     //
@@ -277,7 +278,7 @@ unsigned long ACG::asLong()
     // do not want to run off the end of the permutation table.
     // This insures that we have always got four entries left.
     //
-    register unsigned long *perm = & randomPermutations[result & 0x3c];
+    register _G_uint32_t *perm = & randomPermutations[result & 0x3c];
     
     result =  *(perm++) & auxACG;
     result |= *(perm++) & ((auxACG << 24)
diff --git a/gnu/lib/libg++/libg++/DLList.cc b/gnu/lib/libg++/libg++/DLList.cc
index 87874c3..ff8a81b 100644
--- a/gnu/lib/libg++/libg++/DLList.cc
+++ b/gnu/lib/libg++/libg++/DLList.cc
@@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <builtin.h>
 #include "DLList.h"
 
-void BaseDLList::error(const char* msg)
+void BaseDLList::error(const char* msg) const
 {
   (*lib_error_handler)("DLList", msg);
 }
@@ -164,7 +164,7 @@ void BaseDLList::join(BaseDLList& b)
   }
 }
 
-int BaseDLList::owns(Pix p)
+int BaseDLList::owns(Pix p) const
 {
   BaseDLNode* t = h;
   if (t != 0 && p != 0)
@@ -207,7 +207,7 @@ void BaseDLList::del(Pix& p, int dir)
     t->fd->bk = t->bk;
     if (t == h) h = t->fd;
   }
-  delete t;
+  delete_node(t);
 }
 
 void BaseDLList::del_after(Pix& p)
@@ -305,7 +305,7 @@ void BaseDLList::del_rear()
 }
 
 
-int BaseDLList::OK()
+int BaseDLList::OK() const
 {
   int v = 1;
   if (h != 0)
diff --git a/gnu/lib/libg++/libg++/Fix.cc b/gnu/lib/libg++/libg++/Fix.cc
index f067eb3..7e9e474 100644
--- a/gnu/lib/libg++/libg++/Fix.cc
+++ b/gnu/lib/libg++/libg++/Fix.cc
@@ -347,7 +347,7 @@ Fix::multiply(const Rep* x, int y, Rep* r)
   a = (_G_int32_t) (_G_int16_t )x->s[0] * y + carry;
   r->s[0] = a;
   a &= 0xffff8000L;
-  if ( a != 0xffff8000L && a != 0L ) {
+  if ( a != (_G_int32_t)0xffff8000L && a != (_G_int32_t)0L ) {
     r->s[0] = 0x8000 ^ x->s[0] ^ y;
     overflow_handler(r);
   }
@@ -419,7 +419,7 @@ Fix::shift(const Rep* x, int y, Rep* r)
       return r;
     }
 
-  int ay = abs((long) y),
+  int ay = abs((_G_int32_t) y),
     ayh = ay >> 4,
     ayl = ay & 0x0f;
   int xl, u, ilow, ihigh;
@@ -492,7 +492,7 @@ Fix::printon(ostream& s, int width) const
 {
   double val = value(*this);
   int old_precision = s.precision(width-3);
-  long old_flags = s.setf(ios::fixed, ios::fixed|ios::scientific);
+  _G_int32_t old_flags = s.setf(ios::fixed, ios::fixed|ios::scientific);
   if (val >= 0)
       s << ' ';
   s.width(width-2);
diff --git a/gnu/lib/libg++/libg++/Fix16.cc b/gnu/lib/libg++/libg++/Fix16.cc
index a66bfbf..3974fb3 100644
--- a/gnu/lib/libg++/libg++/Fix16.cc
+++ b/gnu/lib/libg++/libg++/Fix16.cc
@@ -48,19 +48,19 @@ short Fix16::assign(double d)
     return round(Fix16_mult * d);
 }
 
-long Fix32::assign(double d) 
+_G_int32_t Fix32::assign(double d) 
 { 
   if (d == 1.0)
     return Fix32_m_max;
   else if (d > Fix32_max)
   {
-    long i = Fix32_m_max;
+    _G_int32_t i = Fix32_m_max;
     range_error(i);
     return i;
   }
   else if (d < Fix32_min)
   {
-    long i = Fix32_m_min;
+    _G_int32_t i = Fix32_m_min;
     range_error(i);
     return i;
   }
@@ -75,20 +75,20 @@ Fix32 operator * (const Fix32& a, const Fix32& b)
 // multiply, with rounding
 
   int apos = (a.m >= 0);
-  unsigned long ua = (apos)? a.m : - a.m;
+  _G_uint32_t ua = (apos)? a.m : - a.m;
   ua <<= 1; // ua is biased so result will be 31 bit mantissa, not 30:
-  unsigned long hi_a = (ua >> 16) & ((1 << 16) - 1);
-  unsigned long lo_a = ua & ((1 << 16) - 1);
+  _G_uint32_t hi_a = (ua >> 16) & ((1 << 16) - 1);
+  _G_uint32_t lo_a = ua & ((1 << 16) - 1);
 
   int bpos = (b.m >= 0);
-  unsigned long ub = (bpos)? b.m : -b.m;
-  unsigned long hi_b = (ub >> 16) & ((1 << 16) - 1);
-  unsigned long lo_b = ub & ((1 << 16) - 1);
+  _G_uint32_t ub = (bpos)? b.m : -b.m;
+  _G_uint32_t hi_b = (ub >> 16) & ((1 << 16) - 1);
+  _G_uint32_t lo_b = ub & ((1 << 16) - 1);
 
-  unsigned long r = lo_a * lo_b + (1 << 15);
+  _G_uint32_t r = lo_a * lo_b + (1 << 15);
   r = (r >> 16) + hi_a * lo_b + lo_a * hi_b + (1 << 15);
   r = (r >> 16) + hi_a * hi_b;
-  long p = (apos != bpos)? -r : r;
+  _G_int32_t p = (apos != bpos)? -r : r;
   return Fix32(p);
 }
 
@@ -96,8 +96,8 @@ Fix16 operator / (const Fix16& a, const Fix16& b)
 {
   short q;
   int apos = (a.m >= 0);
-  long la = (apos)? a.m : -a.m;
-  long scaled_a = la << 15;
+  _G_int32_t la = (apos)? a.m : -a.m;
+  _G_int32_t scaled_a = la << 15;
   int bpos = (b.m >= 0);
   short sb = (bpos)? b.m: -b.m;
   if (la >= sb)
@@ -116,11 +116,11 @@ Fix16 operator / (const Fix16& a, const Fix16& b)
 
 Fix32 operator / (const Fix32& a, const Fix32& b)
 {
-  long q;
+  _G_int32_t q;
   int apos = (a.m >= 0);
-  unsigned long la = (apos)? a.m : -a.m;
+  _G_uint32_t la = (apos)? a.m : -a.m;
   int bpos = (b.m >= 0);
-  unsigned long lb = (bpos)? b.m: -b.m;
+  _G_uint32_t lb = (bpos)? b.m: -b.m;
   if (la >= lb)
   {
     q = (apos == bpos)? Fix32_m_max: Fix32_m_min;
@@ -129,7 +129,7 @@ Fix32 operator / (const Fix32& a, const Fix32& b)
   else                        // standard shift-based division alg
   {
     q = 0;
-    long r = la;
+    _G_int32_t r = la;
 
     for (int i = 32; i > 0; i--)
     {
@@ -155,7 +155,7 @@ void Fix16::overflow(short& i) const
   (*Fix16_overflow_handler)(i);
 }
 
-void Fix32::overflow(long& i) const
+void Fix32::overflow(_G_int32_t& i) const
 {
   (*Fix32_overflow_handler)(i);
 }
@@ -165,7 +165,7 @@ void Fix16::range_error(short& i) const
   (*Fix16_range_error_handler)(i);
 }
 
-void Fix32::range_error(long& i) const
+void Fix32::range_error(_G_int32_t& i) const
 {
   (*Fix32_range_error_handler)(i);
 }
@@ -225,14 +225,14 @@ void Fix16_overflow_warning_saturate(short& i)
 void Fix16_abort(short&)
   { cerr << "error: Fix16 result out of range\n"; abort(); }
 
-void Fix32_ignore(long&) {}
-void Fix32_overflow_saturate(long& i)
+void Fix32_ignore(_G_int32_t&) {}
+void Fix32_overflow_saturate(_G_int32_t& i)
   { i = (i > 0 ? Fix32_m_min : Fix32_m_max); }
-void Fix32_warning(long&)
+void Fix32_warning(_G_int32_t&)
   { cerr << "warning: Fix32 result out of range\n"; }
-void Fix32_overflow_warning_saturate(long& i)
+void Fix32_overflow_warning_saturate(_G_int32_t& i)
   { cerr << "warning: Fix32 result out of range\n"; 
    Fix32_overflow_saturate(i); }
-void Fix32_abort(long&)
+void Fix32_abort(_G_int32_t&)
   { cerr << "error: Fix32 result out of range\n"; abort(); }
 
diff --git a/gnu/lib/libg++/libg++/Fix24.cc b/gnu/lib/libg++/libg++/Fix24.cc
index 22e23dc..84cb834 100644
--- a/gnu/lib/libg++/libg++/Fix24.cc
+++ b/gnu/lib/libg++/libg++/Fix24.cc
@@ -28,25 +28,27 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
 // basic operators too large to be inline
 
-long Fix24::assign(double d) 
+_G_int32_t Fix24::assign(double d) 
 { 
   if (d == 1.0)
     return Fix24_m_max;
   else if (d > Fix24_max)
   {
-    long i = Fix24_m_max;
+    _G_int32_t i = Fix24_m_max;
     range_error(i);
     return i;
   }
   else if (d < Fix24_min)
   {
-    long i = Fix24_m_min;
+    _G_int32_t i = Fix24_m_min;
     range_error(i);
     return i;
   }
   else {
-    d = (long) (d * (1 << 24) + ((d >= 0)? 0.5 : -0.5)); // Round to 24 bits
-    return ((long) d) << (Fix24_shift - 24); 	/* Convert to integer format */
+    // Round to 24 bits
+    d = (_G_int32_t) (d * (1 << 24) + ((d >= 0)? 0.5 : -0.5));
+    /* Convert to integer format */
+    return ((_G_int32_t) d) << (Fix24_shift - 24);
   }
 }
 
@@ -72,14 +74,14 @@ twolongs Fix48::assign(double d)
 
 /* First, convert the absolute value of d to a 48-bit integer format */
     if (d < 0) d = -d;
-    i.u = ((long)(d *= Fix24_mult)) & 0xffffff00;
-    i.l = ((unsigned long)((d - i.u)* (Fix24_mult / (1 << 7)))) & 0xffffff00;
+    i.u = ((_G_int32_t)(d *= Fix24_mult)) & 0xffffff00;
+    i.l = ((_G_uint32_t)((d - i.u)* (Fix24_mult / (1 << 7)))) & 0xffffff00;
 
 /* Calculate the two's complement if d was negative */
     if (sign) {
-	unsigned long oldlower = i.l;
+	_G_uint32_t oldlower = i.l;
 	i.l = (~i.l + 1) & 0xffffff00;
-	i.u = (~i.u + (((oldlower ^ i.l) & Fix24_msb)? 0 : 1)) & 0xffffff00;
+	i.u = (~i.u + (((oldlower ^ i.l) & Fix24_msb)? 0 : 1)) & ~0xffL;
     }
     return i;
   }
@@ -92,17 +94,17 @@ Fix48 operator * (const Fix24& a, const Fix24& b)
 // multiply, with rounding
 
   int apos = (a.m >= 0);
-  unsigned long ua = (apos)? a.m : - a.m;
+  _G_uint32_t ua = (apos)? a.m : - a.m;
   ua <<= 1; // ua is biased so result will be 47 bit mantissa, not 46:
-  unsigned long hi_a = (ua >> 16) & ((1 << 16) - 1);
-  unsigned long lo_a = ua & ((1 << 16) - 1);
+  _G_uint32_t hi_a = (ua >> 16) & ((1 << 16) - 1);
+  _G_uint32_t lo_a = ua & ((1 << 16) - 1);
 
   int bpos = (b.m >= 0);
-  unsigned long ub = (bpos)? b.m : -b.m;
-  unsigned long hi_b = (ub >> 16) & ((1 << 16) - 1);
-  unsigned long lo_b = ub & ((1 << 16) - 1);
+  _G_uint32_t ub = (bpos)? b.m : -b.m;
+  _G_uint32_t hi_b = (ub >> 16) & ((1 << 16) - 1);
+  _G_uint32_t lo_b = ub & ((1 << 16) - 1);
 
-  unsigned long 
+  _G_uint32_t 
     hi_r = hi_a * hi_b,
     mi_r = hi_a * lo_b + lo_a * hi_b,
     lo_r = lo_a * lo_b,
@@ -113,7 +115,7 @@ Fix48 operator * (const Fix24& a, const Fix24& b)
   r.l = rl << 8;
 
   if ( apos != bpos ) {
-    unsigned long l = r.l;
+    _G_uint32_t l = r.l;
     r.l = -r.l;
     r.u = (~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb)) & 0xffffff00;
   }
@@ -122,11 +124,11 @@ Fix48 operator * (const Fix24& a, const Fix24& b)
 
 Fix24 operator / (const Fix24& a, const Fix24& b)
 {
-  long q;
+  _G_int32_t q;
   int apos = (a.m >= 0);
-  unsigned long la = (apos)? a.m : -a.m;
+  _G_uint32_t la = (apos)? a.m : -a.m;
   int bpos = (b.m >= 0);
-  unsigned long lb = (bpos)? b.m: -b.m;
+  _G_uint32_t lb = (bpos)? b.m: -b.m;
   if (la >= lb)
   {
     q = (apos == bpos)? Fix24_m_max: Fix24_m_min;
@@ -135,7 +137,7 @@ Fix24 operator / (const Fix24& a, const Fix24& b)
   else                        // standard shift-based division alg
   {
     q = 0;
-    long r = la;
+    _G_int32_t r = la;
 
     for (int i = 32; i > 0; i--)
     {
@@ -151,13 +153,13 @@ Fix24 operator / (const Fix24& a, const Fix24& b)
     q += 0x80;			// Round result to 24 bits
     if (apos != bpos) q = -q;	// Fix sign
   }
-  return (q & ~0xFF);
+  return (q & ~0xff);
 }
 
 
 Fix48 operator + (const Fix48&  f, const Fix48&  g)
 {
-  long lo_r = (f.m.l >> 8) + (g.m.l >> 8);
+  _G_int32_t lo_r = (f.m.l >> 8) + (g.m.l >> 8);
   twolongs r;
   r.u = f.m.u + g.m.u + (lo_r & 0x01000000L ? 0x00000100L : 0);
   r.l =  lo_r << 8;
@@ -189,15 +191,15 @@ Fix48 operator * (const Fix48& a, int b)
     a.range_error(r);
   }
   else {
-    unsigned long 
+    _G_uint32_t 
       lo_r = (a.m.l & 0xffff) * ub,
       mi_r = ((a.m.l >> 16) & 0xffff) * ub,
       hi_r = a.m.u * ub;
     r.l = lo_r + (mi_r << 16);
     r.u = hi_r + ((mi_r >> 8) & 0x00ffff00L);
     if ( !bpos ) {
-      unsigned long l = r.l;
-      r.l = -r.l;
+      _G_uint32_t l = r.l;
+      r.l = -r.l & 0xffffffff;
       r.u = ~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb);
     }
   }
@@ -223,15 +225,15 @@ Fix48 operator >> (const Fix48& a, int b)
   twolongs r; r.u = 0; r.l = 0;
   if ( b >= 0 )
     if ( b < 24 ) {
-      r.l = (a.m.u << (24 - b)) + ((a.m.l >> b) & 0xffffff00L);
-      r.u = (a.m.u >> b) & 0xffffff00L;
+      r.l = ((a.m.u << (24 - b)) & 0xffffffffL) + ((a.m.l >> b) & 0xffffff00L);
+      r.u = (a.m.u >> b) & ~0xffL;
     }
     else if ( b < 48 ) {
       r.l = (a.m.u >> (b - 24)) & 0xffffff00L;
-      r.u = (a.m.u >> 24) & 0xffffff00L;
+      r.u = (a.m.u >> 24) & ~0xffL;
     }
     else {
-      r.l = (a.m.u >> 24) & 0xffffff00L;
+      r.l = (a.m.u >> 24) & ~0xffL;
       r.u = r.l;
     }
   return r;
@@ -239,7 +241,7 @@ Fix48 operator >> (const Fix48& a, int b)
 
 // error handling
 
-void Fix24::overflow(long& i) const
+void Fix24::overflow(_G_int32_t& i) const
 {
   (*Fix24_overflow_handler)(i);
 }
@@ -249,7 +251,7 @@ void Fix48::overflow(twolongs& i) const
   (*Fix48_overflow_handler)(i);
 }
 
-void Fix24::range_error(long& i) const
+void Fix24::range_error(_G_int32_t& i) const
 {
   (*Fix24_range_error_handler)(i);
 }
@@ -303,15 +305,15 @@ void set_range_error_handler(Fix24_peh handler24, Fix48_peh handler48) {
   set_Fix48_range_error_handler(handler48);
 }
 
-void Fix24_overflow_saturate(long& i)
+void Fix24_overflow_saturate(_G_int32_t& i)
   { i = (i > 0 ? Fix24_m_min : Fix24_m_max); }
-void Fix24_ignore(long&) {}
-void Fix24_warning(long&)
+void Fix24_ignore(_G_int32_t&) {}
+void Fix24_warning(_G_int32_t&)
   { cerr << "warning: Fix24 result out of range\n"; }
-void Fix24_overflow_warning_saturate(long& i)
+void Fix24_overflow_warning_saturate(_G_int32_t& i)
   { cerr << "warning: Fix24 result out of range\n"; 
    Fix24_overflow_saturate(i); }
-void Fix24_abort(long&)
+void Fix24_abort(_G_int32_t&)
   { cerr << "error: Fix24 result out of range\n"; abort(); }
 
 void Fix48_ignore(twolongs&) {}
diff --git a/gnu/lib/libg++/libg++/MLCG.cc b/gnu/lib/libg++/libg++/MLCG.cc
index cdc1165..053325e 100644
--- a/gnu/lib/libg++/libg++/MLCG.cc
+++ b/gnu/lib/libg++/libg++/MLCG.cc
@@ -79,7 +79,7 @@ MLCG::reset()
     seedTwo = (seedTwo % 2147483397) + 1;
 }
 
-unsigned long MLCG::asLong()
+_G_uint32_t MLCG::asLong()
 {
     _G_int32_t k = seedOne % 53668;
 
diff --git a/gnu/lib/libg++/libg++/Regex.cc b/gnu/lib/libg++/libg++/Regex.cc
index 990f7b8..db9cdc3 100644
--- a/gnu/lib/libg++/libg++/Regex.cc
+++ b/gnu/lib/libg++/libg++/Regex.cc
@@ -28,7 +28,11 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <builtin.h>
 
 extern "C" {
+#if 1
+#include <rx.h>
+#else
 #include <regex.h>
+#endif
 }
 
 #include <Regex.h>
@@ -46,17 +50,18 @@ Regex::Regex(const char* t, int fast, int bufsize,
 {
   int tlen = (t == 0)? 0 : strlen(t);
   buf = new re_pattern_buffer;
+  memset (buf, 0, sizeof(re_pattern_buffer));
   reg = new re_registers;
   if (fast)
     buf->fastmap = (char*)malloc(256);
   else
     buf->fastmap = 0;
-  buf->translate = (char*)transtable;
+  buf->translate = (unsigned char*)transtable;
   if (tlen > bufsize)
     bufsize = tlen;
   buf->allocated = bufsize;
   buf->buffer = (char *)malloc(buf->allocated);
-  char* msg = re_compile_pattern((const char*)t, tlen, buf);
+  const char* msg = re_compile_pattern((const char*)t, tlen, buf);
   if (msg != 0)
     (*lib_error_handler)("Regex", msg);
   else if (fast)
diff --git a/gnu/lib/libg++/libg++/SLList.cc b/gnu/lib/libg++/libg++/SLList.cc
index 6efd997..7c19b3c 100644
--- a/gnu/lib/libg++/libg++/SLList.cc
+++ b/gnu/lib/libg++/libg++/SLList.cc
@@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <builtin.h>
 #include "SLList.h"
 
-void BaseSLList::error(const char* msg)
+void BaseSLList::error(const char* msg) const
 {
   (*lib_error_handler)("SLList", msg);
 }
@@ -184,7 +184,7 @@ void BaseSLList::del_after(Pix p)
   delete_node(t);
 }
 
-int BaseSLList::owns(Pix p)
+int BaseSLList::owns(Pix p) const
 {
   BaseSLNode* t = last;
   if (t != 0 && p != 0)
@@ -227,7 +227,7 @@ void BaseSLList::del_front()
   delete_node(t);
 }
 
-int BaseSLList::OK()
+int BaseSLList::OK() const
 {
   int v = 1;
   if (last != 0)
diff --git a/gnu/lib/libg++/libg++/String.cc b/gnu/lib/libg++/libg++/String.cc
index ad86079..cb2c524 100644
--- a/gnu/lib/libg++/libg++/String.cc
+++ b/gnu/lib/libg++/libg++/String.cc
@@ -29,10 +29,6 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <new.h>
 #include <builtin.h>
 
-// extern "C" {
-#include <regex.h>
-// }
-
 void String::error(const char* msg) const
 {
   (*lib_error_handler)("String", msg);
@@ -171,7 +167,8 @@ StrRep* Salloc(StrRep* old, const char* src, int srclen, int newlen)
 // generally be faster in the long run to get new space & copy
 // than to call realloc
 
-StrRep* Sresize(StrRep* old, int newlen)
+static StrRep*
+Sresize(StrRep* old, int newlen)
 {
   if (old == &_nilStrRep) old = 0;
   StrRep* rep;
@@ -191,6 +188,14 @@ StrRep* Sresize(StrRep* old, int newlen)
   return rep;
 }
 
+void
+String::alloc (int newsize)
+{
+  unsigned short old_len = rep->len;
+  rep = Sresize(rep, newsize);
+  rep->len = old_len;
+}
+
 // like allocate, but we know that src is a StrRep
 
 StrRep* Scopy(StrRep* old, const StrRep* s)
@@ -960,41 +965,25 @@ int split(const String& src, String results[], int n, const Regex& r)
 
 
 #if defined(__GNUG__) && !defined(_G_NO_NRV)
+#define RETURN(r) return
+#define RETURNS(r) return r;
+#define RETURN_OBJECT(TYPE, NAME) /* nothing */
+#else /* _G_NO_NRV */
+#define RETURN(r) return r
+#define RETURNS(r) /* nothing */
+#define RETURN_OBJECT(TYPE, NAME) TYPE NAME;
+#endif
 
-String join(String src[], int n, const String& separator) return x;
-{
-  String sep = separator;
-  int xlen = 0;
-  for (int i = 0; i < n; ++i)
-    xlen += src[i].length();
-  xlen += (n - 1) * sep.length();
-
-  x.alloc(xlen);
-
-  int j = 0;
-  
-  for (i = 0; i < n - 1; ++i)
-  {
-    ncopy(src[i].chars(), &(x.rep->s[j]), src[i].length());
-    j += src[i].length();
-    ncopy(sep.chars(), &(x.rep->s[j]), sep.length());
-    j += sep.length();
-  }
-  ncopy0(src[i].chars(), &(x.rep->s[j]), src[i].length());
-}
-
-#else
-
-String join(String src[], int n, const String& separator)
+String join(String src[], int n, const String& separator) RETURNS(x)
 {
-  String x;
+  RETURN_OBJECT(String,x)
   String sep = separator;
   int xlen = 0;
   for (int i = 0; i < n; ++i)
     xlen += src[i].length();
   xlen += (n - 1) * sep.length();
 
-  x.alloc(xlen);
+  x.rep = Sresize (x.rep, xlen);
 
   int j = 0;
   
@@ -1006,10 +995,8 @@ String join(String src[], int n, const String& separator)
     j += sep.length();
   }
   ncopy0(src[i].chars(), &(x.rep->s[j]), src[i].length());
-  return x;
+  RETURN(x);
 }
-
-#endif
   
 /*
  misc
diff --git a/gnu/lib/libg++/libg++/error.cc b/gnu/lib/libg++/libg++/error.cc
index 852b3df..9283d14 100644
--- a/gnu/lib/libg++/libg++/error.cc
+++ b/gnu/lib/libg++/libg++/error.cc
@@ -26,7 +26,7 @@ typedef _VOLATILE_VOID (*NoReturnFunc)(void);
 This is to avoid a warning from g++ that a `volatile' function does return. */
 #define ABORT() ((NoReturnFunc)abort)()
 #else
-#define ABORT abort()
+#define ABORT() abort()
 #endif
 
 _VOLATILE_VOID default_one_arg_error_handler(const char* msg)
diff --git a/gnu/lib/libg++/libg++/timer.c b/gnu/lib/libg++/libg++/timer.c
index 73a856a..6e3432b 100644
--- a/gnu/lib/libg++/libg++/timer.c
+++ b/gnu/lib/libg++/libg++/timer.c
@@ -37,6 +37,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 #if !_G_HAVE_SYS_RESOURCE || !defined(RUSAGE_SELF)
 #define USE_TIMES
 #include <sys/param.h>
+#include <sys/types.h>
 #include <sys/times.h>
 #if !defined (HZ) && defined(CLK_TCK)
 #define HZ CLK_TCK
diff --git a/gnu/lib/libg++/libio/fileops.c b/gnu/lib/libg++/libio/fileops.c
index 47398a8..2bd7c24 100644
--- a/gnu/lib/libg++/libio/fileops.c
+++ b/gnu/lib/libg++/libio/fileops.c
@@ -44,7 +44,8 @@ extern int errno;
 
    The position in the buffer that corresponds to the position
    in external file system is file_ptr().
-   This is normally egptr(), except in putback mode, when it is _save_egptr.
+   This is normally _IO_read_end, except in putback mode,
+   when it is _IO_save_end.
    If the field _fb._offset is >= 0, it gives the offset in
    the file as a whole corresponding to eGptr(). (???)
 
@@ -238,7 +239,7 @@ _IO_do_write(fp, data, to_do)
     fp->_cur_column = _IO_adjust_column(fp->_cur_column - 1, data, to_do) + 1;
   _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
-  fp->_IO_write_end = (fp->_flags & _IO_LINE_BUF+_IO_UNBUFFERED) ? fp->_IO_buf_base
+  fp->_IO_write_end = (fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED)) ? fp->_IO_buf_base
     : fp->_IO_buf_end;
   return count != to_do ? EOF : 0;
 }
@@ -311,7 +312,7 @@ int _IO_file_overflow (f, ch)
       f->_IO_write_end = f->_IO_buf_end;
       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 
-      if (f->_flags & _IO_LINE_BUF+_IO_UNBUFFERED)
+      if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 	f->_IO_write_end = f->_IO_write_ptr;
       f->_flags |= _IO_CURRENTLY_PUTTING;
     }
@@ -389,10 +390,10 @@ _IO_file_seekoff(fp, offset, mode)
   switch (dir)
     {
     case _IO_seek_cur:
-      if (fp->_offset == _IO_pos_BAD)
-	goto dumb;
       /* Adjust for read-ahead (bytes is buffer). */
       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
+      if (fp->_offset == _IO_pos_BAD)
+	goto dumb;
       /* Make offset absolute, assuming current pointer is file_ptr(). */
       offset += _IO_pos_as_off(fp->_offset);
 
@@ -414,24 +415,27 @@ _IO_file_seekoff(fp, offset, mode)
     }
   /* At this point, dir==_IO_seek_set. */
 
-#ifdef TODO
   /* If destination is within current buffer, optimize: */
-  if (fp->_offset != IO_pos_BAD && fp->_IO_read_base != NULL)
+  if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
+      && !_IO_in_backup (fp))
     {
       /* Offset relative to start of main get area. */
-      _IO_pos_t rel_offset = offset - _fb._offset
-	+ (eGptr()-Gbase());
+      _IO_pos_t rel_offset = offset - fp->_offset
+	+ (fp->_IO_read_end - fp->_IO_read_base);
       if (rel_offset >= 0)
 	{
+#if 0
 	  if (_IO_in_backup(fp))
 	    _IO_switch_to_main_get_area(fp);
-	  if (rel_offset <= _IO_read_end - _IO_read_base)
+#endif
+	  if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 	    {
-	      _IO_setg(fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
+	      _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
 		       fp->_IO_read_end);
-	      _IO_setp(fp->_IO_buf_base, fp->_IO_buf_base);
+	      _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
 	      return offset;
 	    }
+#ifdef TODO
 	    /* If we have streammarkers, seek forward by reading ahead. */
 	    if (_IO_have_markers(fp))
 	      {
@@ -441,7 +445,9 @@ _IO_file_seekoff(fp, offset, mode)
 		  goto dumb;
 		return offset;
 	      }
+#endif
 	}
+#ifdef TODO
       if (rel_offset < 0 && rel_offset >= Bbase() - Bptr())
 	{
 	  if (!_IO_in_backup(fp))
@@ -449,8 +455,10 @@ _IO_file_seekoff(fp, offset, mode)
 	  gbump(fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 	  return offset;
 	}
+#endif
     }
 
+#ifdef TODO
   _IO_unsave_markers(fp);
 #endif
 
diff --git a/gnu/lib/libg++/libio/floatconv.c b/gnu/lib/libg++/libio/floatconv.c
index 84eb848..ff300bb 100644
--- a/gnu/lib/libg++/libio/floatconv.c
+++ b/gnu/lib/libg++/libio/floatconv.c
@@ -23,7 +23,7 @@ This exception does not however invalidate any other reasons why
 the executable file might be covered by the GNU General Public License. */
 
 #include <libioP.h>
-#ifdef USE_DTOA
+#ifdef _IO_USE_DTOA
 /****************************************************************
  *
  * The author of this software is David M. Gay.
@@ -489,7 +489,7 @@ s2b
 #endif
 {
   int i, k;
-  long x, y;
+  _G_int32_t x, y;
 
   x = (nd + 8) / 9;
   for(k = 0, y = 1; x > y; y <<= 1, k++) ;
@@ -643,7 +643,7 @@ mult
         xbe = xb + wb;
         xc0 = c->x;
         for(; xb < xbe; xb++, xc0++) {
-                if (y = *xb & 0xffff) {
+                if ((y = *xb & 0xffff)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -657,7 +657,7 @@ mult
                                 while(x < xae);
                         *xc = carry;
                         }
-                if (y = *xb >> 16) {
+                if ((y = *xb >> 16)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -794,9 +794,9 @@ diff
 #endif
 {
         int i, wa, wb;
-        long borrow, y; /* We need signed shifts here. */
+        _G_int32_t borrow, y; /* We need signed shifts here. */
         unsigned32 *xa, *xae, *xb, *xbe, *xc;
-        long z;
+        _G_int32_t z;
 
         i = cmp(a,b);
         if (!i) {
@@ -856,7 +856,7 @@ ulp
         (double x)
 #endif
 {
-        register long L;
+        register _G_int32_t L;
         double a;
 
         L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
@@ -879,7 +879,7 @@ ulp
                 else {
                         word0(a) = 0;
                         L -= Exp_shift;
-                        word1(a) = L >= 31 ? 1 : 1 << 31 - L;
+                        word1(a) = L >= 31 ? 1 : 1 << (31 - L);
                         }
                 }
 #endif
@@ -913,16 +913,16 @@ b2d
         k = hi0bits(y);
         *e = 32 - k;
         if (k < Ebits) {
-                d0 = Exp_1 | y >> Ebits - k;
+                d0 = Exp_1 | y >> (Ebits - k);
                 w = xa > xa0 ? *--xa : 0;
-                d1 = y << (32-Ebits) + k | w >> Ebits - k;
+                d1 = y << ((32-Ebits) + k) | w >> (Ebits - k);
                 goto ret_d;
                 }
         z = xa > xa0 ? *--xa : 0;
         if (k -= Ebits) {
-                d0 = Exp_1 | y << k | z >> 32 - k;
+                d0 = Exp_1 | y << k | z >> (32 - k);
                 y = xa > xa0 ? *--xa : 0;
-                d1 = z << k | y >> 32 - k;
+                d1 = z << k | y >> (32 - k);
                 }
         else {
                 d0 = Exp_1 | y;
@@ -974,9 +974,9 @@ d2b
 	  z |= Exp_msk11;
 #endif
 
-        if (y = d1) {
-                if (k = lo0bits(&y)) {
-                        x[0] = y | z << 32 - k;
+        if ((y = d1)) {
+                if ((k = lo0bits(&y))) {
+                        x[0] = y | z << (32 - k);
                         z >>= k;
                         }
                 else
@@ -1091,7 +1091,7 @@ _IO_strtod
                  e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
         CONST char *s, *s0, *s1;
         double aadj, aadj1, adj, rv, rv0;
-        long L;
+        _G_int32_t L;
         unsigned32 y, z;
 	Bigint _bb, _b_avail, _bd, _bd0, _bs, _delta;
 	Bigint *bb = Binit(&_bb);
@@ -1280,7 +1280,7 @@ _IO_strtod
         /* Get starting approximation = rv * 10**e1 */
 
         if (e1 > 0) {
-                if (i = e1 & 15)
+                if ((i = e1 & 15))
                         rv *= tens[i];
                 if (e1 &= ~15) {
                         if (e1 > DBL_MAX_10_EXP) {
@@ -1320,7 +1320,7 @@ _IO_strtod
                 }
         else if (e1 < 0) {
                 e1 = -e1;
-                if (i = e1 & 15)
+                if ((i = e1 & 15))
                         rv /= tens[i];
                 if (e1 &= ~15) {
                         e1 >>= 4;
@@ -1588,7 +1588,7 @@ _IO_strtod
                 z = word0(rv) & Exp_mask;
                 if (y == z) {
                         /* Can we stop now? */
-                        L = (long)aadj;
+                        L = (_G_int32_t)aadj;
                         aadj -= L;
                         /* The tolerances below are conservative. */
                         if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
@@ -1620,10 +1620,10 @@ quorem
 #endif
 {
         int n;
-        long borrow, y;
+        _G_int32_t borrow, y;
         unsigned32 carry, q, ys;
         unsigned32 *bx, *bxe, *sx, *sxe;
-        long z;
+        _G_int32_t z;
         unsigned32 si, zs;
 
         n = S->wds;
@@ -1777,7 +1777,7 @@ _IO_dtoa
         int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
                 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
                 spec_case, try_quick;
-        long L;
+        _G_int32_t L;
 #ifndef Sudden_Underflow
         int denorm;
 #endif
@@ -1874,8 +1874,8 @@ _IO_dtoa
 		unsigned32 x;
 
                 i = bbits + be + (Bias + (P-1) - 1);
-                x = i > 32  ? word0(d) << 64 - i | word1(d) >> i - 32
-                            : word1(d) << 32 - i;
+                x = i > 32  ? word0(d) << (64 - i) | word1(d) >> (i - 32)
+                            : word1(d) << (32 - i);
                 d2 = x;
                 word0(d2) -= 31*Exp_msk1; /* adjust exponent */
                 i -= (Bias + (P-1) - 1) + 1;
@@ -2006,7 +2006,7 @@ _IO_dtoa
                                         }
                         d /= ds;
                         }
-                else if (j1 = -k) {
+                else if ((j1 = -k)) {
                         d *= tens[j1 & 0xf];
                         for(j = j1 >> 4; j; j >>= 1, i++)
                                 if (j & 1) {
@@ -2039,7 +2039,7 @@ _IO_dtoa
                          */
                         eps = 0.5/tens[ilim-1] - eps;
                         for(i = 0;;) {
-                                L = (long)d;
+                                L = (_G_int32_t)d;
                                 d -= L;
                                 *s++ = '0' + (int)L;
                                 if (d < eps)
@@ -2057,7 +2057,7 @@ _IO_dtoa
                         /* Generate ilim digits, then fix them up. */
                         eps *= tens[ilim-1];
                         for(i = 1;; i++, d *= 10.) {
-                                L = (long)d;
+                                L = (_G_int32_t)d;
                                 d -= L;
                                 *s++ = '0' + (int)L;
                                 if (i == ilim) {
@@ -2092,7 +2092,7 @@ _IO_dtoa
                         goto one_digit;
                         }
                 for(i = 1;; i++) {
-                        L = (long)(d / ds);
+                        L = (_G_int32_t)(d / ds);
                         d -= L*ds;
 #ifdef Check_FLT_ROUNDS
                         /* If FLT_ROUNDS == 2, L will usually be high by 1 */
@@ -2104,7 +2104,7 @@ _IO_dtoa
                         *s++ = '0' + (int)L;
                         if (i == ilim) {
                                 d += d;
-                                if (d > ds || d == ds && L & 1) {
+                                if (d > ds || (d == ds && L & 1)) {
  bump_up:
                                         while(*--s == '9')
                                                 if (s == s0) {
@@ -2169,7 +2169,7 @@ _IO_dtoa
                                 b_avail = b;
                                 b = b_tmp;
                                 }
-                        if (j = b5 - m5)
+                        if ((j = b5 - m5))
                                 b = pow5mult(b, j);
                         }
                 else
@@ -2203,7 +2203,7 @@ _IO_dtoa
          * and for all and pass them and a shift to quorem, so it
          * can do shifts and ors to compute the numerator for q.
          */
-        if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f)
+        if ((i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f))
                 i = 32 - i;
         if (i > 4) {
                 i -= 4;
@@ -2276,15 +2276,15 @@ _IO_dtoa
                                 goto ret;
                                 }
 #endif
-                        if (j < 0 || j == 0 && !mode
+                        if (j < 0 || (j == 0 && !mode
 #ifndef ROUND_BIASED
                                                         && !(word1(d) & 1)
 #endif
-                                        ) {
+                                        )) {
                                 if (j1 > 0) {
                                         b = lshift(b, 1);
                                         j1 = cmp(b, S);
-                                        if ((j1 > 0 || j1 == 0 && dig & 1)
+                                        if ((j1 > 0 || (j1 == 0 && dig & 1))
                                         && dig++ == '9')
                                                 goto round_9_up;
                                         }
@@ -2324,7 +2324,7 @@ _IO_dtoa
 
         b = lshift(b, 1);
         j = cmp(b, S);
-        if (j > 0 || j == 0 && dig & 1) {
+        if (j > 0 || (j == 0 && dig & 1)) {
  roundoff:
                 while(*--s == '9')
                         if (s == s0) {
@@ -2354,4 +2354,4 @@ _IO_dtoa
                 *rve = s;
         return s0;
         }
-#endif /* USE_DTOA */
+#endif /* _IO_USE_DTOA */
diff --git a/gnu/lib/libg++/libio/iofclose.c b/gnu/lib/libg++/libio/iofclose.c
index 44664d9..03be451 100644
--- a/gnu/lib/libg++/libio/iofclose.c
+++ b/gnu/lib/libg++/libio/iofclose.c
@@ -32,9 +32,7 @@ _IO_fclose(fp)
      register _IO_FILE *fp;
 {
   int status = 0;
-  COERCE_FILE(fp);
-  if ((fp->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC)
-    return EOF;
+  CHECK_FILE(fp, EOF);
   if (fp->_IO_file_flags & _IO_IS_FILEBUF)
     status = _IO_file_close_it(fp);
   fp->_jumps->__finish(fp);
diff --git a/gnu/lib/libg++/libio/iofgetpos.c b/gnu/lib/libg++/libio/iofgetpos.c
index 16ecec0..ac417f5 100644
--- a/gnu/lib/libg++/libio/iofgetpos.c
+++ b/gnu/lib/libg++/libio/iofgetpos.c
@@ -32,7 +32,7 @@ _IO_fgetpos(fp, posp)
      _IO_fpos_t *posp;
 {
   _IO_fpos_t pos;
-  COERCE_FILE(fp);
+  CHECK_FILE(fp, EOF);
   pos = _IO_seekoff(fp, 0, _IO_seek_cur|_IO_seek_not_in|_IO_seek_not_out);
   if (pos == _IO_pos_BAD)
     {
diff --git a/gnu/lib/libg++/libio/iofread.c b/gnu/lib/libg++/libio/iofread.c
index c72c70f..4bfe717 100644
--- a/gnu/lib/libg++/libio/iofread.c
+++ b/gnu/lib/libg++/libio/iofread.c
@@ -33,7 +33,7 @@ _IO_fread(buf, size, count, fp)
 {
   _IO_size_t bytes_requested = size*count;
   _IO_size_t bytes_read;
-  COERCE_FILE(fp);
+  CHECK_FILE(fp, 0);
   if (bytes_requested == 0)
     return 0;
   bytes_read = _IO_sgetn(fp, (char *)buf, bytes_requested);
diff --git a/gnu/lib/libg++/libio/iofscanf.c b/gnu/lib/libg++/libio/iofscanf.c
index 7110401..5daef91 100644
--- a/gnu/lib/libg++/libio/iofscanf.c
+++ b/gnu/lib/libg++/libio/iofscanf.c
@@ -40,7 +40,7 @@ _IO_fscanf
 {
   int ret;
   va_list args;
-  COERCE_FILE(fp);
+  CHECK_FILE(fp, EOF);
   _IO_va_start(args, format);
   ret = _IO_vfscanf(fp, format, args, NULL);
   va_end(args);
diff --git a/gnu/lib/libg++/libio/iofsetpos.c b/gnu/lib/libg++/libio/iofsetpos.c
index 763fbe6..0a6fff2 100644
--- a/gnu/lib/libg++/libio/iofsetpos.c
+++ b/gnu/lib/libg++/libio/iofsetpos.c
@@ -30,7 +30,7 @@ _IO_fsetpos(fp, posp)
      _IO_FILE* fp;
      const _IO_fpos_t *posp;
 {
-  COERCE_FILE(fp);
+  CHECK_FILE(fp, EOF);
   if (_IO_seekpos(fp, *posp, 0) == _IO_pos_BAD)
     {
       /*ANSI explicily requires setting errno to a positive value on failure.*/
diff --git a/gnu/lib/libg++/libio/iostream.cc b/gnu/lib/libg++/libio/iostream.cc
index db953d4..0c241f8 100644
--- a/gnu/lib/libg++/libio/iostream.cc
+++ b/gnu/lib/libg++/libio/iostream.cc
@@ -70,6 +70,8 @@ istream& istream::get(char& c)
 	  _gcount = 1;
 	}
     }
+    else
+      _gcount = 0;
     return *this;
 }
 
@@ -87,13 +89,13 @@ int istream::peek()
 
 istream& istream::ignore(int n /* = 1 */, int delim /* = EOF */)
 {
+    _gcount = 0;
     if (ipfx1()) {
 	register streambuf* sb = _strbuf;
 	if (delim == EOF) {
 	    _gcount = sb->ignore(n);
 	    return *this;
 	}
-	_gcount = 0;
 	for (;;) {
 #if 0
 	    if (n != MAXINT) // FIXME
@@ -120,6 +122,8 @@ istream& istream::read(char *s, int n)
 	if (_gcount != n)
 	    set(ios::failbit|ios::eofbit);
     }
+    else
+      _gcount = 0;
     return *this;
 }
 
@@ -307,6 +311,13 @@ READ_INT(unsigned long long)
 READ_INT(bool)
 #endif
 
+istream& istream::operator>>(long double& x)
+{
+    if (ipfx0())
+	scan("%lg", &x);
+    return *this;
+}
+
 istream& istream::operator>>(double& x)
 {
     if (ipfx0())
@@ -552,7 +563,7 @@ ostream& ostream::operator<<(double n)
 	  prec = 6; /* default */
 
 	// Do actual conversion.
-#ifdef USE_DTOA
+#ifdef _IO_USE_DTOA
 	if (_IO_outfloat(n, rdbuf(), format_char, width(0),
 			 prec, flags(),
 			 flags() & ios::showpos ? '+' : 0,
@@ -710,7 +721,7 @@ streampos ostream::tellp()
 
 ostream& ostream::flush()
 {
-    if (_strbuf->_jumps->__sync(_strbuf))
+    if (_strbuf->sync())
 	set(ios::badbit);
     return *this;
 }
diff --git a/gnu/lib/libg++/libio/ioungetc.c b/gnu/lib/libg++/libio/ioungetc.c
index 7b983ed..b52e4a2 100644
--- a/gnu/lib/libg++/libio/ioungetc.c
+++ b/gnu/lib/libg++/libio/ioungetc.c
@@ -29,7 +29,7 @@ _IO_ungetc(c, fp)
      int c;
      _IO_FILE *fp;
 {
-  COERCE_FILE(fp);
+  CHECK_FILE(fp, EOF);
   if (c == EOF)
     return EOF;
   return _IO_sputbackc(fp, (unsigned char)c);
diff --git a/gnu/lib/libg++/libio/iovfprintf.c b/gnu/lib/libg++/libio/iovfprintf.c
index feda569..e3fb2da 100644
--- a/gnu/lib/libg++/libio/iovfprintf.c
+++ b/gnu/lib/libg++/libio/iovfprintf.c
@@ -196,7 +196,7 @@ _IO_vfprintf(fp, fmt0, ap)
 #ifdef FLOATING_POINT
 	int softsign;		/* temporary negative sign for floats */
 	double _double;		/* double precision arguments %[eEfgG] */
-#ifndef USE_DTOA
+#ifndef _IO_USE_DTOA
 	int fpprec;		/* `extra' floating precision in [eEfgG] */
 #endif
 #endif
@@ -256,7 +256,7 @@ _IO_vfprintf(fp, fmt0, ap)
 
 		flags = 0;
 		dprec = 0;
-#if defined(FLOATING_POINT) && !defined (USE_DTOA)
+#if defined(FLOATING_POINT) && !defined (_IO_USE_DTOA)
 		fpprec = 0;
 #endif
 		width = 0;
@@ -362,7 +362,7 @@ reswitch:	switch (ch) {
 		case 'g':
 		case 'G':
 			_double = va_arg(ap, double);
-#ifdef USE_DTOA
+#ifdef _IO_USE_DTOA
 			{
 			    int fmt_flags = 0;
 			    int fill = ' ';
@@ -564,7 +564,7 @@ number:			if ((dprec = prec) >= 0)
 		/*
 		 * compute actual size, so we know how much to pad.
 		 */
-#if defined(FLOATING_POINT) && !defined (USE_DTOA)
+#if defined(FLOATING_POINT) && !defined (_IO_USE_DTOA)
 		fieldsz = size + fpprec;
 #else
 		fieldsz = size;
@@ -602,7 +602,7 @@ number:			if ((dprec = prec) >= 0)
 		/* the string or number proper */
 		PRINT(cp, size);
 
-#if defined(FLOATING_POINT) && !defined (USE_DTOA)
+#if defined(FLOATING_POINT) && !defined (_IO_USE_DTOA)
 		/* trailing f.p. zeroes */
 		PAD_0(fpprec);
 #endif
@@ -622,7 +622,7 @@ error:
 	/* NOTREACHED */
 }
 
-#if defined(FLOATING_POINT) && !defined(USE_DTOA)
+#if defined(FLOATING_POINT) && !defined(_IO_USE_DTOA)
 
 static char *exponent(register char *p, register int exp, int fmtch)
 {
@@ -882,4 +882,4 @@ eformat:	if (expcnt) {
 	return (t - startp);
 }
 
-#endif /* defined(FLOATING_POINT) && !defined(USE_DTOA) */
+#endif /* defined(FLOATING_POINT) && !defined(_IO_USE_DTOA) */
diff --git a/gnu/lib/libg++/libio/iovfscanf.c b/gnu/lib/libg++/libio/iovfscanf.c
index abf1e58..85168af 100644
--- a/gnu/lib/libg++/libio/iovfscanf.c
+++ b/gnu/lib/libg++/libio/iovfscanf.c
@@ -105,7 +105,7 @@ static char sccsid[] = "%W% (Berkeley) %G%";
 extern u_long strtoul __P((const char*, char**, int));
 extern long strtol __P((const char*, char**, int));
 static const u_char *__sccl __P((char *tab, const u_char *fmt));
-#ifndef USE_DTOA
+#ifndef _IO_USE_DTOA
 extern double atof();
 #endif
 
@@ -655,7 +655,7 @@ literal:
 			if ((flags & SUPPRESS) == 0) {
 				double res;
 				*p = 0;
-#ifdef USE_DTOA
+#ifdef _IO_USE_DTOA
 				res = _IO_strtod(buf, NULL);
 #else
 				res = atof(buf);
diff --git a/gnu/lib/libg++/libio/stdiostream.cc b/gnu/lib/libg++/libio/stdiostream.cc
index eb3dd16..f6de524 100644
--- a/gnu/lib/libg++/libio/stdiostream.cc
+++ b/gnu/lib/libg++/libio/stdiostream.cc
@@ -68,6 +68,19 @@ stdiobuf::~stdiobuf()
 
 streamsize stdiobuf::sys_read(char* buf, streamsize size)
 {
+  // A minor optimization, but it makes a noticable difference.
+  // A bigger optimization would be to write stdiobuf::underflow,
+  // but that has some modularity disadvantages.  Re-evaluate that
+  // after we have gotten rid of the double indirection.  FIXME
+  if (size == 1)
+    {
+      register ch = getc(_file);
+      if (ch == EOF)
+	return 0;
+      *buf = (char)ch;
+      return 1;
+    }
+  else
     return fread(buf, 1, size, _file);
 }
 
diff --git a/gnu/lib/libg++/libio/strstream.cc b/gnu/lib/libg++/libio/strstream.cc
index c17d683..e5917f0 100644
--- a/gnu/lib/libg++/libio/strstream.cc
+++ b/gnu/lib/libg++/libio/strstream.cc
@@ -76,7 +76,7 @@ char *strstreambuf::str()
     return base();
 }
 
-_IO_ssize_t strstreambuf::pcount() { return _IO_str_count (this); }
+_IO_ssize_t strstreambuf::pcount () { return _IO_write_ptr - _IO_write_base; }
 
 int strstreambuf::overflow(int c /* = EOF */)
 {