Changeset 181148 in git

Timestamp:

May 15, 2006, 11:03:07 AM (17 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')

Children:

f0daaa2ae00a1c211020bcbe4eca9c6fe7947a71

Parents:

1dc6163f5dbd22ee9839decb93a02494ac071aca

Message:

*hannes: ISTREAM, OSTREAM, CERR


git-svn-id: file:///usr/local/Singular/svn/trunk@9135 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

factory

Files:

• bifac.cc (modified) (1 diff)
• canonicalform.cc (modified) (6 diffs)
• canonicalform.h (modified) (3 diffs)
• cf_eval.cc (modified) (2 diffs)
• cf_eval.h (modified) (3 diffs)
• cf_map.cc (modified) (6 diffs)
• cf_map.h (modified) (4 diffs)
• fac_iterfor.cc (modified) (2 diffs)
• fac_iterfor.h (modified) (3 diffs)
• factory.template (modified) (2 diffs)
• ftmpl_inst.cc (modified) (2 diffs)
• ftmpl_list.h (modified) (1 diff)
• ftmpl_matrix.h (modified) (6 diffs)
• gfops.h (modified) (3 diffs)
• imm.h (modified) (3 diffs)
• int_cf.h (modified) (3 diffs)
• int_int.cc (modified) (2 diffs)
• int_int.h (modified) (3 diffs)
• int_poly.cc (modified) (2 diffs)
• int_poly.h (modified) (3 diffs)
• int_pp.cc (modified) (2 diffs)
• int_pp.h (modified) (3 diffs)
• int_rat.cc (modified) (2 diffs)
• int_rat.h (modified) (3 diffs)
• readcf.cc (modified) (10 diffs)
• readcf.y (modified) (7 diffs)
• templates/ftmpl_array.cc (modified) (3 diffs)
• templates/ftmpl_array.h (modified) (4 diffs)
• templates/ftmpl_factor.cc (modified) (3 diffs)
• templates/ftmpl_factor.h (modified) (4 diffs)
• templates/ftmpl_list.cc (modified) (4 diffs)
• templates/ftmpl_list.h (modified) (6 diffs)
• templates/ftmpl_matrix.cc (modified) (4 diffs)
• templates/ftmpl_matrix.h (modified) (6 diffs)
• variable.cc (modified) (2 diffs)
• variable.h (modified) (3 diffs)

factory/bifac.cc

@@ -79 +79 @@
   }
 #ifndef NOSTREAMIO
-  friend ostream & operator<< ( ostream & s, const PolyVector& V ){
+  friend OSTREAM & operator<< ( OSTREAM & s, const PolyVector& V ){
     for (int i=0;i<=V.m;i++)
     {

factory/canonicalform.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: canonicalform.cc,v 1.39 2005-12-12 12:17:35 Singular Exp $ */
+/* $Id: canonicalform.cc,v 1.40 2006-05-15 09:03:04 Singular Exp $ */
 
 #include <config.h>
@@ -21 +21 @@
 
 #ifndef NOSTREAMIO
-CanonicalForm readCF( istream& );
+CanonicalForm readCF( ISTREAM& );
 #endif /* NOSTREAMIO */
 
@@ -1615 +1615 @@
 #ifndef NOSTREAMIO
 void
-CanonicalForm::print( ostream & os, char * str ) const
+CanonicalForm::print( OSTREAM & os, char * str ) const
 {
     if ( is_imm( value ) )
@@ -1624 +1624 @@
 
 void
-CanonicalForm::print( ostream & os ) const
+CanonicalForm::print( OSTREAM & os ) const
 {
     if ( is_imm( value ) )
@@ -1632 +1632 @@
 }
 
-ostream&
-operator << ( ostream & os, const CanonicalForm & cf )
+OSTREAM&
+operator << ( OSTREAM & os, const CanonicalForm & cf )
 {
     cf.print( os, "" );
@@ -1639 +1639 @@
 }
 
-istream&
-operator >> ( istream & is, CanonicalForm & cf )
+ISTREAM&
+operator >> ( ISTREAM & is, CanonicalForm & cf )
 {
 #ifndef SINGULAR

factory/canonicalform.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: canonicalform.h,v 1.31 2006-05-15 08:17:49 Singular Exp $ */
+/* $Id: canonicalform.h,v 1.32 2006-05-15 09:03:04 Singular Exp $ */
 
 #ifndef INCL_CANONICALFORM_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
 #endif
 #endif /* NOSTREAMIO */
@@ -158 +162 @@
     // input/output
 #ifndef NOSTREAMIO
-    void print( ostream&, char * ) const;
-    void print( ostream& ) const;
-    friend ostream& operator << ( ostream&, const CanonicalForm& );
-    friend istream& operator >> ( istream&, CanonicalForm& );
+    void print( OSTREAM&, char * ) const;
+    void print( OSTREAM& ) const;
+    friend OSTREAM& operator << ( OSTREAM&, const CanonicalForm& );
+    friend ISTREAM& operator >> ( ISTREAM&, CanonicalForm& );
 #endif /* NOSTREAMIO */
 

factory/cf_eval.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: cf_eval.cc,v 1.5 2000-05-29 15:05:20 Singular Exp $ */
+/* $Id: cf_eval.cc,v 1.6 2006-05-15 09:03:04 Singular Exp $ */
 
 #include <config.h>
@@ -48 +48 @@
 
 #ifndef NOSTREAMIO
-ostream&
-operator<< ( ostream& s, const Evaluation &e )
+OSTREAM&
+operator<< ( OSTREAM& s, const Evaluation &e )
 {
     e.values.print(s);

factory/cf_eval.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: cf_eval.h,v 1.4 2006-05-15 08:17:50 Singular Exp $ */
+/* $Id: cf_eval.h,v 1.5 2006-05-15 09:03:04 Singular Exp $ */
 
 #ifndef INCL_CF_EVAL_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -37 +39 @@
     virtual void nextpoint();
 #ifndef NOSTREAMIO
-    friend ostream& operator<< ( ostream& s, const Evaluation &e );
+    friend OSTREAM& operator<< ( OSTREAM& s, const Evaluation &e );
 #endif /* NOSTREAMIO */
 };

factory/cf_map.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: cf_map.cc,v 1.13 2006-01-31 09:40:48 pohl Exp $ */
+/* $Id: cf_map.cc,v 1.14 2006-05-15 09:03:04 Singular Exp $ */
 
 //{{{ docu
@@ -35 +35 @@
 
 #ifndef NOSTREAMIO
-//{{{ ostream & operator << ( ostream & s, const MapPair & p )
+//{{{ OSTREAM & operator << ( OSTREAM & s, const MapPair & p )
 //{{{ docu
 //
@@ -41 +41 @@
 //
 //}}}
-ostream &
-operator << ( ostream & s, const MapPair & p )
+OSTREAM &
+operator << ( OSTREAM & s, const MapPair & p )
 {
     s << p.var() << " -> " << p.subst();
@@ -49 +49 @@
 //}}}
 
-void MapPair::print( ostream&) const
+void MapPair::print( OSTREAM&) const
 {
 }
@@ -198 +198 @@
 
 #ifndef NOSTREAMIO
-//{{{ ostream & operator << ( ostream & s, const CFMap & m )
+//{{{ OSTREAM & operator << ( OSTREAM & s, const CFMap & m )
 //{{{ docu
 //
@@ -204 +204 @@
 //
 //}}}
-ostream &
-operator << ( ostream & s, const CFMap & m )
+OSTREAM &
+operator << ( OSTREAM & s, const CFMap & m )
 {
     m.P.print(s);

factory/cf_map.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: cf_map.h,v 1.13 2006-05-15 08:17:50 Singular Exp $ */
+/* $Id: cf_map.h,v 1.14 2006-05-15 09:03:04 Singular Exp $ */
 
 #ifndef INCL_CF_MAP_H
@@ -16 +16 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -60 +62 @@
     CanonicalForm subst () const { return S; }
 #ifndef NOSTREAMIO
-    void print( ostream&) const;
-    friend ostream & operator << ( ostream & s, const MapPair & p );
+    void print( OSTREAM&) const;
+    friend OSTREAM & operator << ( OSTREAM & s, const MapPair & p );
 #endif /* NOSTREAMIO */
 };
@@ -99 +101 @@
   CanonicalForm operator () ( const CanonicalForm & f ) const;
 #ifndef NOSTREAMIO
-  friend ostream & operator << ( ostream & s, const CFMap & m );
+  friend OSTREAM & operator << ( OSTREAM & s, const CFMap & m );
 #endif /* NOSTREAMIO */
 };

factory/fac_iterfor.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: fac_iterfor.cc,v 1.5 1997-12-08 18:24:31 schmidt Exp $ */
+/* $Id: fac_iterfor.cc,v 1.6 2006-05-15 09:03:04 Singular Exp $ */
 
 #include <config.h>
@@ -98 +98 @@
 
 #ifndef NOSTREAMIO
-ostream& operator<< ( ostream& os, const IteratedFor & I )
+OSTREAM& operator<< ( OSTREAM& os, const IteratedFor & I )
 {
     os << "( " << I[I.from()];

factory/fac_iterfor.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: fac_iterfor.h,v 1.5 2006-05-15 08:17:52 Singular Exp $ */
+/* $Id: fac_iterfor.h,v 1.6 2006-05-15 09:03:04 Singular Exp $ */
 
 #ifndef INCL_FAC_ITERFOR_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -43 +45 @@
 
 #ifndef NOSTREAMIO
-ostream& operator<< ( ostream &, const IteratedFor & );
+OSTREAM& operator<< ( OSTREAM &, const IteratedFor & );
 #endif /* NOSTREAMIO */
 

factory/factory.template

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: factory.template,v 1.17 2006-01-05 13:38:18 Singular Exp $ */
+/* $Id: factory.template,v 1.18 2006-05-15 09:03:04 Singular Exp $ */
 
 #ifndef INCL_FACTORY_H
@@ -25 +25 @@
 
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#endif
 #endif /* ! NOSTREAMIO */
 

factory/ftmpl_inst.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_inst.cc,v 1.9 1998-06-30 16:25:47 schmidt Exp $ */
+/* $Id: ftmpl_inst.cc,v 1.10 2006-05-15 09:03:05 Singular Exp $ */
 
 //{{{ docu
@@ -50 +50 @@
 //{{{ explicit template function instantiations
 #ifndef NOSTREAMIO
-template ostream & operator << ( ostream &, const List<CanonicalForm> & );
-template ostream & operator << ( ostream &, const List<CFFactor> & );
-template ostream & operator << ( ostream &, const List<MapPair> & );
-template ostream & operator << ( ostream &, const Array<CanonicalForm> & );
-template ostream & operator << ( ostream &, const Factor<CanonicalForm> & );
-template ostream & operator << ( ostream &, const Matrix<CanonicalForm> & );
-template ostream & operator << ( ostream &, const Array<REvaluation> & );
+template OSTREAM & operator << ( OSTREAM &, const List<CanonicalForm> & );
+template OSTREAM & operator << ( OSTREAM &, const List<CFFactor> & );
+template OSTREAM & operator << ( OSTREAM &, const List<MapPair> & );
+template OSTREAM & operator << ( OSTREAM &, const Array<CanonicalForm> & );
+template OSTREAM & operator << ( OSTREAM &, const Factor<CanonicalForm> & );
+template OSTREAM & operator << ( OSTREAM &, const Matrix<CanonicalForm> & );
+template OSTREAM & operator << ( OSTREAM &, const Array<REvaluation> & );
 #endif /* NOSTREAMIO */
 

factory/ftmpl_list.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_list.h,v 1.1 1998-03-10 14:43:26 schmidt Exp $ */
+/* $Id: ftmpl_list.h,v 1.2 2006-05-15 09:03:05 Singular Exp $ */
 
 #ifndef INCL_LIST_H
+#define INCL_LIST_H
 
-//{{{ docu
-//
-// ftmpl_list.h - wrapper for `templates/ftmpl_list.h'.
-//
-// This file exists for convenience only.
-//
-// `INCL_LIST_H' is defined in `templates/ftmpl_list.h'.
-//
-//}}}
+#include <factoryconf.h>
 
-#ifdef macintosh
-#include <:templates:ftmpl_list.h>
-#else
-#include "templates/ftmpl_list.h"
+#ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#elif defined(HAVE_IOSTREAM_H)
+#include <iostream.h>
+#define OSTREAM ostream
+#endif
+#endif /* NOSTREAMIO */
+
+template <class T>
+class ListIterator;
+
+template <class T>
+class List;
+
+#ifndef NOSTREAMIO
+template <class T>
+OSTREAM& operator<< ( OSTREAM &, const List<T> &);
 #endif
 
+template <class T>
+class ListItem
+{
+private:
+    ListItem * next;
+    ListItem * prev;
+    T * item;
+public:
+    ListItem( const ListItem<T>& );
+    ListItem( const T&, ListItem<T>*, ListItem<T>* );
+    ListItem( T* , ListItem<T>* , ListItem<T>* );
+    ~ListItem();
+    ListItem<T>& operator= ( const ListItem<T>& );
+    ListItem<T>* getNext();
+    ListItem<T>* getPrev();
+    T& getItem();
+#ifndef NOSTREAMIO
+    void print ( OSTREAM& );
+#endif /* NOSTREAMIO */
+    friend class ListIterator<T>;
+    friend class List<T>;
+};
+
+template <class T>
+class List
+{
+private:
+    ListItem<T> *first;
+    ListItem<T> *last;
+    int _length;
+public:
+    List();
+    List( const List<T>& );
+    List( const T& );
+    ~List();
+    List<T>& operator= ( const List<T>& );
+    void insert ( const T& );
+    void insert ( const T&, int (*cmpf)( const T&, const T& ) );
+    void insert ( const T&, int (*cmpf)( const T&, const T& ), void (*insf)( T&, const T& ) );
+    void append ( const T& );
+    int isEmpty() const;
+    int length() const;
+    T getFirst() const;
+    void removeFirst();
+    T getLast() const;
+    void removeLast();
+    void sort ( int (*) ( const T&, const T& ) );
+#ifndef NOSTREAMIO
+    void print ( OSTREAM & ) const;
+    friend OSTREAM& operator<< <T>( OSTREAM & os, const List<T> & l );
+#endif /* NOSTREAMIO */
+    friend class ListIterator<T>;
+};
+
+#ifndef NOSTREAMIO
+template <class T>
+OSTREAM& operator<< ( OSTREAM & os, const List<T> & l );
+#endif /* NOSTREAMIO */
+
+template <class T>
+class ListIterator {
+private:
+    List<T> *theList;
+    ListItem<T> *current;
+public:
+    ListIterator();
+    ListIterator( const ListIterator<T>& );
+    ListIterator( const List<T>& );
+    ~ListIterator();
+    ListIterator<T>& operator = ( const ListIterator<T>& );
+    ListIterator<T>& operator = ( const List<T>& );
+    T& getItem() const;
+    int hasItem();
+    void operator++();
+    void operator--();
+    void operator++( int );
+    void operator--( int );
+    void firstItem();
+    void lastItem();
+    void insert( const T& );
+    void append( const T& );
+    void remove( int moveright );
+};
+
+template <class T>
+List<T> Union ( const List<T>&, const List<T>& );
+
+template <class T>
+List<T> Difference ( const List<T>&, const List<T>& );
+
+template <class T>
+List<T> Union ( const List<T>&, const List<T>&, int (*cmpf)( const T&, const T& ), void (*insf)( T&, const T& ) );
+
+template <class T>
+T prod ( const List<T>& );
+
 #endif /* ! INCL_LIST_H */

factory/ftmpl_matrix.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_matrix.h,v 1.3 2006-05-15 08:17:53 Singular Exp $ */
+/* $Id: ftmpl_matrix.h,v 1.4 2006-05-15 09:03:05 Singular Exp $ */
 
 #ifndef INCL_MATRIX_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -23 +25 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<< (ostream &, const Matrix<T> &);
+OSTREAM& operator<< (OSTREAM &, const Matrix<T> &);
 #endif
 
@@ -33 +35 @@
     T ** elems;
 #ifndef NOSTREAMIO
-    void printrow ( ostream & s, int i ) const;
+    void printrow ( OSTREAM & s, int i ) const;
 #endif /* NOSTREAMIO */
     typedef T* T_ptr;
@@ -53 +55 @@
     void swapColumn( int i, int j );
 #ifndef NOSTREAMIO
-    void print( ostream& s ) const;
-    friend ostream & operator<< <T>( ostream & s, const Matrix<T>& M );
+    void print( OSTREAM& s ) const;
+    friend OSTREAM & operator<< <T>( OSTREAM & s, const Matrix<T>& M );
 #endif /* NOSTREAMIO */
     friend class SubMatrix<T>;
@@ -89 +91 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream & operator<< ( ostream & s, const Matrix<T>& M );
+OSTREAM & operator<< ( OSTREAM & s, const Matrix<T>& M );
 #endif /* NOSTREAMIO */
 

factory/gfops.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: gfops.h,v 1.7 2006-05-15 08:17:53 Singular Exp $ */
+/* $Id: gfops.h,v 1.8 2006-05-15 09:03:05 Singular Exp $ */
 
 #ifndef INCL_GFOPS_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -159 +161 @@
 //{{{ input/output
 #ifndef NOSTREAMIO
-inline void gf_print ( ostream & os, int a )
+inline void gf_print ( OSTREAM & os, int a )
 {
     if ( a == gf_q )

factory/imm.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: imm.h,v 1.21 2006-05-15 08:17:53 Singular Exp $ */
+/* $Id: imm.h,v 1.22 2006-05-15 09:03:05 Singular Exp $ */
 
 #ifndef INCL_IMM_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -424 +426 @@
 //{{{ input/output
 #ifndef NOSTREAMIO
-inline void imm_print ( ostream & os, const InternalCF * const op, const char * const str )
+inline void imm_print ( OSTREAM & os, const InternalCF * const op, const char * const str )
 {
     if ( is_imm( op ) == FFMARK )

factory/int_cf.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_cf.h,v 1.11 2006-05-15 08:17:54 Singular Exp $ */
+/* $Id: int_cf.h,v 1.12 2006-05-15 09:03:05 Singular Exp $ */
 
 #ifndef INCL_INT_CF_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -47 +49 @@
     virtual Variable variable() const { return Variable(); }
 #ifndef NOSTREAMIO
-    virtual void print( ostream&, char* ) PVIRT_VOID("print");
+    virtual void print( OSTREAM&, char* ) PVIRT_VOID("print");
 #endif /* NOSTREAMIO */
     virtual bool inBaseDomain() const { return true; }

factory/int_int.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_int.cc,v 1.17 2003-10-15 17:19:40 Singular Exp $ */
+/* $Id: int_int.cc,v 1.18 2006-05-15 09:03:06 Singular Exp $ */
 
 #include <config.h>
@@ -45 +45 @@
 
 #ifndef NOSTREAMIO
-void InternalInteger::print( ostream & os, char * c )
+void InternalInteger::print( OSTREAM & os, char * c )
 {
     if ( *c == '*' && mpz_cmp_si( &thempi, 1 ) == 0 )

factory/int_int.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_int.h,v 1.13 2006-05-15 08:17:54 Singular Exp $ */
+/* $Id: int_int.h,v 1.14 2006-05-15 09:03:06 Singular Exp $ */
 
 #ifndef INCL_INT_INT_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -73 +75 @@
     const char * const classname() const { return "InternalInteger"; }
 #ifndef NOSTREAMIO
-    void print( ostream&, char* );
+    void print( OSTREAM&, char* );
 #endif /* NOSTREAMIO */
     InternalCF* genZero();

factory/int_poly.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_poly.cc,v 1.17 2006-04-21 15:37:10 Singular Exp $ */
+/* $Id: int_poly.cc,v 1.18 2006-05-15 09:03:06 Singular Exp $ */
 
 #include <config.h>
@@ -169 +169 @@
 #ifndef NOSTREAMIO
 void
-InternalPoly::print(ostream &aStream, char * aString )
+InternalPoly::print(OSTREAM &aStream, char * aString )
 {
     if ( ! firstTerm )

factory/int_poly.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_poly.h,v 1.9 2006-05-15 08:17:54 Singular Exp $ */
+/* $Id: int_poly.h,v 1.10 2006-05-15 09:03:06 Singular Exp $ */
 
 #ifndef INCL_INT_POLY_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -95 +97 @@
     CanonicalForm coeff( int i );
 #ifndef NOSTREAMIO
-    void print( ostream&, char* );
+    void print( OSTREAM&, char* );
 #endif /* NOSTREAMIO */
     bool inBaseDomain() const { return false; }

factory/int_pp.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_pp.cc,v 1.10 2003-10-15 17:19:41 Singular Exp $ */
+/* $Id: int_pp.cc,v 1.11 2006-05-15 09:03:06 Singular Exp $ */
 
 #include <config.h>
@@ -110 +110 @@
 
 #ifndef NOSTREAMIO
-void InternalPrimePower::print( ostream & os, char * c )
+void InternalPrimePower::print( OSTREAM & os, char * c )
 {
     if ( *c == '*' && mpz_cmp_si( &thempi, 1 ) == 0 )

factory/int_pp.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_pp.h,v 1.5 2006-05-15 08:17:54 Singular Exp $ */
+/* $Id: int_pp.h,v 1.6 2006-05-15 09:03:06 Singular Exp $ */
 
 #ifndef INCL_INT_PP_H
@@ -12 +12 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -46 +48 @@
     const char * const classname() const { return "InternalPrimePower"; }
 #ifndef NOSTREAMIO
-    void print( ostream&, char* );
+    void print( OSTREAM&, char* );
 #endif /* NOSTREAMIO */
     bool isZero() const;

factory/int_rat.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_rat.cc,v 1.12 1999-09-24 08:43:29 Singular Exp $ */
+/* $Id: int_rat.cc,v 1.13 2006-05-15 09:03:06 Singular Exp $ */
 
 #include <config.h>
@@ -95 +95 @@
 
 #ifndef NOSTREAMIO
-void InternalRational::print( ostream & os, char * c )
+void InternalRational::print( OSTREAM & os, char * c )
 {
     char * str = new char[mpz_sizeinbase( &_num, 10 ) + 2];

factory/int_rat.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: int_rat.h,v 1.7 2006-05-15 08:17:55 Singular Exp $ */
+/* $Id: int_rat.h,v 1.8 2006-05-15 09:03:06 Singular Exp $ */
 
 #ifndef INCL_INT_RAT_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -47 +49 @@
     const char * const classname() const { return "InternalRational"; }
 #ifndef NOSTREAMIO
-    void print( ostream&, char* );
+    void print( OSTREAM&, char* );
 #endif /* NOSTREAMIO */
     InternalCF* genZero();

factory/readcf.cc

@@ -1 @@
-
-/*  A Bison parser, made from readcf.y
-    by GNU Bison version 1.28  */
-
-#define YYBISON 1  /* Identify Bison output.  */
-
-#define NUM     257
-#define NEG     258
-
+/* A Bison parser, made by GNU Bison 2.1.  */
+
+/* Skeleton parser for Yacc-like parsing with Bison,
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* Written by Richard Stallman by simplifying the original so called
+   ``semantic'' parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.1"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     NUM = 258,
+     NEG = 259
+   };
+#endif
+/* Tokens.  */
+#define NUM 258
+#define NEG 259
+
+
+
+
+/* Copy the first part of user declarations.  */
 #line 4 "readcf.y"
 
@@ -22 +83 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define ISTREAM std::istream
+#define CERR std::cerr
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define ISTREAM istream
+#define CERR cerr
 #endif
 
@@ -42 +107 @@
 #endif
 
-static char* readString( istream& );
+static char* readString( ISTREAM& );
 
 #ifndef BISONPP
@@ -49 +114 @@
 #endif
 
-static istream * defaultin = 0;
+static ISTREAM * defaultin = 0;
 
 static CanonicalForm * retvalue = 0;
 
-#ifndef YYSTYPE
-#define YYSTYPE int
-#endif
-#include <stdio.h>
-
-#ifndef __cplusplus
-#ifndef __STDC__
-#define const
-#endif
-#endif
-
-
-
-#define YYFINAL         25
-#define YYFLAG          -32768
-#define YYNTBASE        13
-
-#define YYTRANSLATE(x) ((unsigned)(x) <= 258 ? yytranslate[x] : 16)
-
-static const char yytranslate[] = {     0,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,    11,
-    12,     6,     5,     2,     4,     2,     7,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,    10,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     9,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     1,     3,     8
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+typedef int YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+/* Copy the second part of user declarations.  */
+
+
+/* Line 219 of yacc.c.  */
+#line 154 "readcf.cc"
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+#if ! defined (yyoverflow) || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if defined (__STDC__) || defined (__cplusplus)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     define YYINCLUDED_STDLIB_H
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning. */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
+#  endif
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
+        && (defined (__STDC__) || defined (__cplusplus)))
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
+        && (defined (__STDC__) || defined (__cplusplus)))
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+
+
+#if (! defined (yyoverflow) \
+     && (! defined (__cplusplus) \
+         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  short int yyss;
+  YYSTYPE yyvs;
+  };
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
+      + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined (__GNUC__) && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (To)[yyi] = (From)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)                                        \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
+        Stack = &yyptr->Stack;                                          \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined (__STDC__) || defined (__cplusplus)
+   typedef signed char yysigned_char;
+#else
+   typedef short int yysigned_char;
+#endif
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL  2
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   44
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS  13
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS  4
+/* YYNRULES -- Number of rules. */
+#define YYNRULES  14
+/* YYNRULES -- Number of states. */
+#define YYNSTATES  25
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   259
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const unsigned char yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+      11,    12,     6,     5,     2,     4,     2,     7,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,    10,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     9,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     8
 };
 
-#if YYDEBUG != 0
-static const short yyprhs[] = {     0,
-     0,     1,     4,     6,     9,    11,    15,    19,    23,    27,
-    30,    33,    37
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const unsigned char yyprhs[] =
+{
+       0,     0,     3,     4,     7,     9,    12,    14,    18,    22,
+      26,    30,    33,    36,    40
 };
 
-static const short yyrhs[] = {    -1,
-    13,    14,     0,    10,     0,    15,    10,     0,     3,     0,
-    15,     5,    15,     0,    15,     4,    15,     0,    15,     6,
-    15,     0,    15,     7,    15,     0,     4,    15,     0,     5,
-    15,     0,    15,     9,     3,     0,    11,    15,    12,     0
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yysigned_char yyrhs[] =
+{
+      14,     0,    -1,    -1,    14,    15,    -1,    10,    -1,    16,
+      10,    -1,     3,    -1,    16,     5,    16,    -1,    16,     4,
+      16,    -1,    16,     6,    16,    -1,    16,     7,    16,    -1,
+       4,    16,    -1,     5,    16,    -1,    16,     9,     3,    -1,
+      11,    16,    12,    -1
 };
 
-#endif
-
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
-    61,    62,    65,    66,    69,    70,    71,    72,    73,    74,
-    75,    76,    77
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const unsigned char yyrline[] =
+{
+       0,    65,    65,    66,    69,    70,    73,    74,    75,    76,
+      77,    78,    79,    80,    81
 };
 #endif
 
-
-#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
-
-static const char * const yytname[] = {   "$","error","$undefined.","NUM","'-'",
-"'+'","'*'","'/'","NEG","'^'","';'","'('","')'","input","line","exp", NULL
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "NUM", "'-'", "'+'", "'*'", "'/'", "NEG",
+  "'^'", "';'", "'('", "')'", "$accept", "input", "line", "exp", 0
 };
 #endif
 
-static const short yyr1[] = {     0,
-    13,    13,    14,    14,    15,    15,    15,    15,    15,    15,
-    15,    15,    15
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const unsigned short int yytoknum[] =
+{
+       0,   256,   257,   258,    45,    43,    42,    47,   259,    94,
+      59,    40,    41
 };
-
-static const short yyr2[] = {     0,
-     0,     2,     1,     2,     1,     3,     3,     3,     3,     2,
-     2,     3,     3
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const unsigned char yyr1[] =
+{
+       0,    13,    14,    14,    15,    15,    16,    16,    16,    16,
+      16,    16,    16,    16,    16
 };
 
-static const short yydefact[] = {     1,
-     0,     5,     0,     0,     3,     0,     2,     0,    10,    11,
-     0,     0,     0,     0,     0,     0,     4,    13,     7,     6,
-     8,     9,    12,     0,     0
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const unsigned char yyr2[] =
+{
+       0,     2,     0,     2,     1,     2,     1,     3,     3,     3,
+       3,     2,     2,     3,     3
 };
 
-static const short yydefgoto[] = {     1,
-     7,     8
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const unsigned char yydefact[] =
+{
+       2,     0,     1,     6,     0,     0,     4,     0,     3,     0,
+      11,    12,     0,     0,     0,     0,     0,     0,     5,    14,
+       8,     7,     9,    10,    13
 };
 
-static const short yypact[] = {-32768,
-    13,-32768,     3,     3,-32768,     3,-32768,    30,    -7,    -7,
-    21,     3,     3,     3,     3,     1,-32768,-32768,    35,    35,
-    -7,    -7,-32768,     5,-32768
+/* YYDEFGOTO[NTERM-NUM]. */
+static const yysigned_char yydefgoto[] =
+{
+      -1,     1,     8,     9
 };
 
-static const short yypgoto[] = {-32768,
--32768,    -3
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -8
+static const yysigned_char yypact[] =
+{
+      -8,    13,    -8,    -8,     3,     3,    -8,     3,    -8,    30,
+      -7,    -7,    21,     3,     3,     3,     3,     1,    -8,    -8,
+      35,    35,    -7,    -7,    -8
 };
 
-
-#define YYLAST          44
-
-
-static const short yytable[] = {     9,
-    10,    16,    11,    23,    25,     2,     3,     4,    19,    20,
-    21,    22,    24,     6,     0,     2,     3,     4,     0,     0,
-     0,     0,     5,     6,    12,    13,    14,    15,     0,    16,
-     0,     0,    18,    12,    13,    14,    15,     0,    16,    17,
-    14,    15,     0,    16
+/* YYPGOTO[NTERM-NUM].  */
+static const yysigned_char yypgoto[] =
+{
+      -8,    -8,    -8,    -4
 };
 
-static const short yycheck[] = {     3,
-     4,     9,     6,     3,     0,     3,     4,     5,    12,    13,
-    14,    15,     0,    11,    -1,     3,     4,     5,    -1,    -1,
-    -1,    -1,    10,    11,     4,     5,     6,     7,    -1,     9,
-    -1,    -1,    12,     4,     5,     6,     7,    -1,     9,    10,
-     6,     7,    -1,     9
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -1
+static const unsigned char yytable[] =
+{
+      10,    11,    17,    12,    24,     0,     3,     4,     5,    20,
+      21,    22,    23,     2,     7,     0,     3,     4,     5,     0,
+       0,     0,     0,     6,     7,    13,    14,    15,    16,     0,
+      17,     0,     0,    19,    13,    14,    15,    16,     0,    17,
+      18,    15,    16,     0,    17
 };
-/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "/usr/lib/bison.simple"
-/* This file comes from bison-1.28.  */
-
-/* Skeleton output parser for bison,
-   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-/* This is the parser code that is written into each bison parser
-  when the %semantic_parser declaration is not specified in the grammar.
-  It was written by Richard Stallman by simplifying the hairy parser
-  used when %semantic_parser is specified.  */
-
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
-#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#else /* not GNU C.  */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
-#include <alloca.h>
-#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C.  */
-/* This used to test MSDOS, but that is a bad idea
-   since that symbol is in the user namespace.  */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
-         instead, just don't use alloca.  */
-#include <malloc.h>
-#endif
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
-   So I turned it off.   rms, 2 May 1997.  */
-/* #include <malloc.h>  */
- #pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
-                 and on HPUX 10.  Eventually we can turn this on.  */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#endif /* __hpux */
-#endif
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
-
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
-#else
-#define YYSTACK_ALLOC malloc
-#endif
-
-/* Note: there must be only one dollar sign in this file.
-   It is replaced by the list of actions, each action
-   as one case of the switch.  */
+
+static const yysigned_char yycheck[] =
+{
+       4,     5,     9,     7,     3,    -1,     3,     4,     5,    13,
+      14,    15,    16,     0,    11,    -1,     3,     4,     5,    -1,
+      -1,    -1,    -1,    10,    11,     4,     5,     6,     7,    -1,
+       9,    -1,    -1,    12,     4,     5,     6,     7,    -1,     9,
+      10,     6,     7,    -1,     9
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const unsigned char yystos[] =
+{
+       0,    14,     0,     3,     4,     5,    10,    11,    15,    16,
+      16,    16,    16,     4,     5,     6,     7,     9,    10,    12,
+      16,    16,    16,    16,     3
+};
 
 #define yyerrok         (yyerrstatus = 0)
 #define yyclearin       (yychar = YYEMPTY)
-#define YYEMPTY         -2
+#define YYEMPTY         (-2)
 #define YYEOF           0
+
 #define YYACCEPT        goto yyacceptlab
-#define YYABORT         goto yyabortlab
-#define YYERROR         goto yyerrlab1
-/* Like YYERROR except do call yyerror.
-   This remains here temporarily to ease the
-   transition to the new meaning of YYERROR, for GCC.
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
    Once GCC version 2 has supplanted version 1, this can go.  */
+
 #define YYFAIL          goto yyerrlab
+
 #define YYRECOVERING()  (!!yyerrstatus)
-#define YYBACKUP(token, value) \
+
+#define YYBACKUP(Token, Value)                                  \
 do                                                              \
   if (yychar == YYEMPTY && yylen == 1)                          \
-    { yychar = (token), yylval = (value);                       \
-      yychar1 = YYTRANSLATE (yychar);                           \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      yytoken = YYTRANSLATE (yychar);                           \
       YYPOPSTACK;                                               \
       goto yybackup;                                            \
     }                                                           \
   else                                                          \
-    { yyerror ("syntax error: cannot back up"); YYERROR; }      \
+    {                                                           \
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
 while (0)
+
 
 #define YYTERROR        1
 #define YYERRCODE       256
 
-#ifndef YYPURE
-#define YYLEX           yylex()
-#endif
-
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
+    while (0)
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)                  \
+     fprintf (File, "%d.%d-%d.%d",                      \
+              (Loc).first_line, (Loc).first_column,     \
+              (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
 #ifdef YYLEX_PARAM
-#define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
+# define YYLEX yylex (YYLEX_PARAM)
 #else
-#define YYLEX           yylex(&yylval, &yylloc)
-#endif
-#else /* not YYLSP_NEEDED */
-#ifdef YYLEX_PARAM
-#define YYLEX           yylex(&yylval, YYLEX_PARAM)
+# define YYLEX yylex ()
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
+do {                                                            \
+  if (yydebug)                                                  \
+    {                                                           \
+      YYFPRINTF (stderr, "%s ", Title);                         \
+      yysymprint (stderr,                                       \
+                  Type, Value); \
+      YYFPRINTF (stderr, "\n");                                 \
+    }                                                           \
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_stack_print (short int *bottom, short int *top)
 #else
-#define YYLEX           yylex(&yylval)
-#endif
-#endif /* not YYLSP_NEEDED */
-#endif
-
-/* If nonreentrant, generate the variables here */
-
-#ifndef YYPURE
-
-int     yychar;                 /*  the lookahead symbol                */
-YYSTYPE yylval;                 /*  the semantic value of the           */
-                                /*  lookahead symbol                    */
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc;                 /*  location data for the lookahead     */
-                                /*  symbol                              */
-#endif
-
-int yynerrs;                    /*  number of parse errors so far       */
-#endif  /* not YYPURE */
-
-#if YYDEBUG != 0
-int yydebug;                    /*  nonzero means print parse trace     */
-/* Since this is uninitialized, it does not stop multiple parsers
-   from coexisting.  */
-#endif
-
-/*  YYINITDEPTH indicates the initial size of the parser's stacks       */
-
+static void
+yy_stack_print (bottom, top)
+    short int *bottom;
+    short int *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_reduce_print (int yyrule)
+#else
+static void
+yy_reduce_print (yyrule)
+    int yyrule;
+#endif
+{
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
+             yyrule - 1, yylno);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (Rule);             \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef YYINITDEPTH
-#define YYINITDEPTH 200
-#endif
-
-/*  YYMAXDEPTH is the maximum size the stacks can grow to
-    (effective only if the built-in stack extension method is used).  */
-
-#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
-#endif
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
 
 #ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
-#endif
-
-
-/* Define __yy_memcpy.  Note that the size argument
-   should be passed with type unsigned int, because that is what the non-GCC
-   definitions require.  With GCC, __builtin_memcpy takes an arg
-   of type size_t, but it can handle unsigned int.  */
-
-#if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
-#define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
-#else                           /* not GNU C or C++ */
-#ifndef __cplusplus
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined (__GLIBC__) && defined (_STRING_H)
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+#   if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+#   else
+yystrlen (yystr)
+     const char *yystr;
+#   endif
+{
+  const char *yys = yystr;
+
+  while (*yys++ != '\0')
+    continue;
+
+  return yys - yystr - 1;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+#   if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+#   else
+yystpcpy (yydest, yysrc)
+     char *yydest;
+     const char *yysrc;
+#   endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      size_t yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+#endif /* YYERROR_VERBOSE */
+
+
+
+
+#if YYDEBUG
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
 static void
-__yy_memcpy (to, from, count)
-     char *to;
-     char *from;
-     unsigned int count;
-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
+yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yysymprint (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvaluep;
+
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  switch (yytype)
+    {
+      default:
+        break;
+    }
+  YYFPRINTF (yyoutput, ")");
 }
 
-#else /* __cplusplus */
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
+#endif /* ! YYDEBUG */
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
 static void
-__yy_memcpy (char *to, char *from, unsigned int count)
-{
-  register char *t = to;
-  register char *f = from;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvaluep;
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+
+      default:
+        break;
+    }
 }
 
-#endif
-#endif
-
-
-#line 217 "/usr/lib/bison.simple"
-
-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
 
 #ifdef YYPARSE_PARAM
-#ifdef __cplusplus
-#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else /* not __cplusplus */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
-#define YYPARSE_PARAM_ARG
-#define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM);
+# else
+int yyparse ();
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+/* The look-ahead symbol.  */
+int yychar;
+
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
 #ifdef YYPARSE_PARAM
-int yyparse (void *);
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM)
+# else
+int yyparse (YYPARSE_PARAM)
+  void *YYPARSE_PARAM;
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
+int
+yyparse (void)
 #else
-int yyparse (void);
-#endif
-#endif
-
 int
-yyparse(YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
-{
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
-  int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
-  int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
-
-  short yyssa[YYINITDEPTH];     /*  the state stack                     */
-  YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
-
-  short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
-  YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
-
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-
-#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
-#else
+yyparse ()
+    ;
+#endif
+#endif
+{
+  
+  int yystate;
+  int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  short int *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
 #define YYPOPSTACK   (yyvsp--, yyssp--)
-#endif
-
-  int yystacksize = YYINITDEPTH;
-  int yyfree_stacks = 0;
-
-#ifdef YYPURE
-  int yychar;
-  YYSTYPE yylval;
-  int yynerrs;
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylloc;
-#endif
-#endif
-
-  YYSTYPE yyval;                /*  the variable used to return         */
-                                /*  semantic values from the action     */
-                                /*  routines                            */
-
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
+  /* When reducing, the number of symbols on the RHS of the reduced
+     rule.  */
   int yylen;
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Starting parse\n");
-#endif
+  YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
@@ -487 +957 @@
      The wasted elements are never initialized.  */
 
-  yyssp = yyss - 1;
+  yyssp = yyss;
   yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
-  yylsp = yyls;
-#endif
-
-/* Push a new state, which is found in  yystate  .  */
-/* In all cases, when you get here, the value and location stacks
-   have just been pushed. so pushing a state here evens the stacks.  */
-yynewstate:
-
-  *++yyssp = yystate;
-
-  if (yyssp >= yyss + yystacksize - 1)
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed. so pushing a state here evens the stacks.
+     */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
     {
-      /* Give user a chance to reallocate the stack */
-      /* Use copies of these so that the &'s don't force the real ones into memory. */
-      YYSTYPE *yyvs1 = yyvs;
-      short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
-      YYLTYPE *yyls1 = yyls;
-#endif
-
       /* Get the current used size of the three stacks, in elements.  */
-      int size = yyssp - yyss + 1;
+      YYSIZE_T yysize = yyssp - yyss + 1;
 
 #ifdef yyoverflow
-      /* Each stack pointer address is followed by the size of
-         the data in use in that stack, in bytes.  */
-#ifdef YYLSP_NEEDED
-      /* This used to be a conditional around just the two extra args,
-         but that might be undefined if yyoverflow is a macro.  */
-      yyoverflow("parser stack overflow",
-                 &yyss1, size * sizeof (*yyssp),
-                 &yyvs1, size * sizeof (*yyvsp),
-                 &yyls1, size * sizeof (*yylsp),
-                 &yystacksize);
-#else
-      yyoverflow("parser stack overflow",
-                 &yyss1, size * sizeof (*yyssp),
-                 &yyvs1, size * sizeof (*yyvsp),
-                 &yystacksize);
-#endif
-
-      yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
-      yyls = yyls1;
-#endif
+      {
+        /* Give user a chance to reallocate the stack. Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        short int *yyss1 = yyss;
+
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
 #else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
       /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-        {
-          yyerror("parser stack overflow");
-          if (yyfree_stacks)
-            {
-              free (yyss);
-              free (yyvs);
-#ifdef YYLSP_NEEDED
-              free (yyls);
-#endif
-            }
-          return 2;
-        }
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
       yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)
         yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
-      yyfree_stacks = 1;
-#endif
-      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
-      __yy_memcpy ((char *)yyss, (char *)yyss1,
-                   size * (unsigned int) sizeof (*yyssp));
-      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
-      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
-                   size * (unsigned int) sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
-      __yy_memcpy ((char *)yyls, (char *)yyls1,
-                   size * (unsigned int) sizeof (*yylsp));
-#endif
+
+      {
+        short int *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss);
+        YYSTACK_RELOCATE (yyvs);
+
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
 #endif /* no yyoverflow */
 
-      yyssp = yyss + size - 1;
-      yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
-      yylsp = yyls + size - 1;
-#endif
-
-#if YYDEBUG != 0
-      if (yydebug)
-        fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
-
-      if (yyssp >= yyss + yystacksize - 1)
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
     }
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Entering state %d\n", yystate);
-#endif
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
   goto yybackup;
- yybackup:
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
 
 /* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
+/* Read a look-ahead token if we need one and don't already have one.  */
 /* yyresume: */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
 
   yyn = yypact[yystate];
-  if (yyn == YYFLAG)
+  if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
+  /* Not known => get a look-ahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
-#if YYDEBUG != 0
-      if (yydebug)
-        fprintf(stderr, "Reading a token: ");
-#endif
+      YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with */
-
-  if (yychar <= 0)              /* This means end of input. */
+  if (yychar <= YYEOF)
     {
-      yychar1 = 0;
-      yychar = YYEOF;           /* Don't call YYLEX any more */
-
-#if YYDEBUG != 0
-      if (yydebug)
-        fprintf(stderr, "Now at end of input.\n");
-#endif
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      yychar1 = YYTRANSLATE(yychar);
-
-#if YYDEBUG != 0
-      if (yydebug)
-        {
-          fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-          /* Give the individual parser a way to print the precise meaning
-             of a token, for further debugging info.  */
-#ifdef YYPRINT
-          YYPRINT (stderr, yychar, yylval);
-#endif
-          fprintf (stderr, ")\n");
-        }
-#endif
-    }
-
-  yyn += yychar1;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;
-
   yyn = yytable[yyn];
-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
+  if (yyn <= 0)
     {
-      if (yyn == YYFLAG)
+      if (yyn == 0 || yyn == YYTABLE_NINF)
         goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
-  else if (yyn == 0)
-    goto yyerrlab;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
   /* Discard the token being shifted unless it is eof.  */
@@ -684 +1103 @@
 
   *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  /* count tokens shifted since error; after three, turn off error status.  */
-  if (yyerrstatus) yyerrstatus--;
+
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
 
   yystate = yyn;
   goto yynewstate;
 
-/* Do the default action for the current state.  */
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
 yydefault:
-
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
-
-/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
 yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];
-  if (yylen > 0)
-    yyval = yyvsp[1-yylen]; /* implement default value of the action */
-
-#if YYDEBUG != 0
-  if (yydebug)
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
     {
-      int i;
-
-      fprintf (stderr, "Reducing via rule %d (line %d), ",
-               yyn, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-        fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
-
-
-  switch (yyn) {
-
-case 4:
-#line 66 "readcf.y"
-{ *retvalue = yyvsp[-1].getval(); return 0; ;
-    break;}
-case 5:
-#line 69 "readcf.y"
-{ yyval = yyvsp[0]; ;
-    break;}
-case 6:
+        case 5:
 #line 70 "readcf.y"
-{ yyval = yyvsp[-2].getval() + yyvsp[0].getval(); ;
-    break;}
-case 7:
-#line 71 "readcf.y"
-{ yyval = yyvsp[-2].getval() - yyvsp[0].getval(); ;
-    break;}
-case 8:
-#line 72 "readcf.y"
-{ yyval = yyvsp[-2].getval() * yyvsp[0].getval(); ;
-    break;}
-case 9:
+    { *retvalue = (yyvsp[-1]).getval(); return 0; ;}
+    break;
+
+  case 6:
 #line 73 "readcf.y"
-{ yyval = yyvsp[-2].getval() / yyvsp[0].getval(); ;
-    break;}
-case 10:
+    { (yyval) = (yyvsp[0]); ;}
+    break;
+
+  case 7:
 #line 74 "readcf.y"
-{ yyval = -yyvsp[0].getval(); ;
-    break;}
-case 11:
+    { (yyval) = (yyvsp[-2]).getval() + (yyvsp[0]).getval(); ;}
+    break;
+
+  case 8:
 #line 75 "readcf.y"
-{ yyval = yyvsp[0].getval(); ;
-    break;}
-case 12:
+    { (yyval) = (yyvsp[-2]).getval() - (yyvsp[0]).getval(); ;}
+    break;
+
+  case 9:
 #line 76 "readcf.y"
-{ yyval = power( yyvsp[-2].getval(), yyvsp[0].getintval() ); ;
-    break;}
-case 13:
+    { (yyval) = (yyvsp[-2]).getval() * (yyvsp[0]).getval(); ;}
+    break;
+
+  case 10:
 #line 77 "readcf.y"
-{ yyval = yyvsp[-1].getval(); ;
-    break;}
-}
-   /* the action file gets copied in in place of this dollarsign */
-#line 543 "/usr/lib/bison.simple"
+    { (yyval) = (yyvsp[-2]).getval() / (yyvsp[0]).getval(); ;}
+    break;
+
+  case 11:
+#line 78 "readcf.y"
+    { (yyval) = -(yyvsp[0]).getval(); ;}
+    break;
+
+  case 12:
+#line 79 "readcf.y"
+    { (yyval) = (yyvsp[0]).getval(); ;}
+    break;
+
+  case 13:
+#line 80 "readcf.y"
+    { (yyval) = power( (yyvsp[-2]).getval(), (yyvsp[0]).getintval() ); ;}
+    break;
+
+  case 14:
+#line 81 "readcf.y"
+    { (yyval) = (yyvsp[-1]).getval(); ;}
+    break;
+
+
+      default: break;
+    }
+
+/* Line 1126 of yacc.c.  */
+#line 1200 "readcf.cc"
 
 
   yyvsp -= yylen;
   yyssp -= yylen;
-#ifdef YYLSP_NEEDED
-  yylsp -= yylen;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-        fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
+
+
+  YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
 
-#ifdef YYLSP_NEEDED
-  yylsp++;
-  if (yylen == 0)
-    {
-      yylsp->first_line = yylloc.first_line;
-      yylsp->first_column = yylloc.first_column;
-      yylsp->last_line = (yylsp-1)->last_line;
-      yylsp->last_column = (yylsp-1)->last_column;
-      yylsp->text = 0;
-    }
-  else
-    {
-      yylsp->last_line = (yylsp+yylen-1)->last_line;
-      yylsp->last_column = (yylsp+yylen-1)->last_column;
-    }
-#endif
-
-  /* Now "shift" the result of the reduction.
-     Determine what state that goes to,
-     based on the state we popped back to
-     and the rule number reduced by.  */
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
 
   yyn = yyr1[yyn];
 
-  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     yystate = yytable[yystate];
   else
-    yystate = yydefgoto[yyn - YYNTBASE];
+    yystate = yydefgoto[yyn - YYNTOKENS];
 
   goto yynewstate;
 
-yyerrlab:   /* here on detecting error */
-
-  if (! yyerrstatus)
-    /* If not already recovering from an error, report this error.  */
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
     {
       ++yynerrs;
-
-#ifdef YYERROR_VERBOSE
+#if YYERROR_VERBOSE
       yyn = yypact[yystate];
 
-      if (yyn > YYFLAG && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn < YYLAST)
         {
-          int size = 0;
-          char *msg;
-          int x, count;
-
-          count = 0;
-          /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
-          for (x = (yyn < 0 ? -yyn : 0);
-               x < (sizeof(yytname) / sizeof(char *)); x++)
-            if (yycheck[x + yyn] == x)
-              size += strlen(yytname[x]) + 15, count++;
-          msg = (char *) malloc(size + 15);
-          if (msg != 0)
+          int yytype = YYTRANSLATE (yychar);
+          YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+          YYSIZE_T yysize = yysize0;
+          YYSIZE_T yysize1;
+          int yysize_overflow = 0;
+          char *yymsg = 0;
+#         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
+          char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+          int yyx;
+
+#if 0
+          /* This is so xgettext sees the translatable formats that are
+             constructed on the fly.  */
+          YY_("syntax error, unexpected %s");
+          YY_("syntax error, unexpected %s, expecting %s");
+          YY_("syntax error, unexpected %s, expecting %s or %s");
+          YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+          YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+#endif
+          char *yyfmt;
+          char const *yyf;
+          static char const yyunexpected[] = "syntax error, unexpected %s";
+          static char const yyexpecting[] = ", expecting %s";
+          static char const yyor[] = " or %s";
+          char yyformat[sizeof yyunexpected
+                        + sizeof yyexpecting - 1
+                        + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+                           * (sizeof yyor - 1))];
+          char const *yyprefix = yyexpecting;
+
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yycount = 1;
+
+          yyarg[0] = yytname[yytype];
+          yyfmt = yystpcpy (yyformat, yyunexpected);
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    yyformat[sizeof yyunexpected - 1] = '\0';
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+                yysize_overflow |= yysize1 < yysize;
+                yysize = yysize1;
+                yyfmt = yystpcpy (yyfmt, yyprefix);
+                yyprefix = yyor;
+              }
+
+          yyf = YY_(yyformat);
+          yysize1 = yysize + yystrlen (yyf);
+          yysize_overflow |= yysize1 < yysize;
+          yysize = yysize1;
+
+          if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
+            yymsg = (char *) YYSTACK_ALLOC (yysize);
+          if (yymsg)
             {
-              strcpy(msg, "parse error");
-
-              if (count < 5)
+              /* Avoid sprintf, as that infringes on the user's name space.
+                 Don't have undefined behavior even if the translation
+                 produced a string with the wrong number of "%s"s.  */
+              char *yyp = yymsg;
+              int yyi = 0;
+              while ((*yyp = *yyf))
                 {
-                  count = 0;
-                  for (x = (yyn < 0 ? -yyn : 0);
-                       x < (sizeof(yytname) / sizeof(char *)); x++)
-                    if (yycheck[x + yyn] == x)
-                      {
-                        strcat(msg, count == 0 ? ", expecting `" : " or `");
-                        strcat(msg, yytname[x]);
-                        strcat(msg, "'");
-                        count++;
-                      }
+                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+                    {
+                      yyp += yytnamerr (yyp, yyarg[yyi++]);
+                      yyf += 2;
+                    }
+                  else
+                    {
+                      yyp++;
+                      yyf++;
+                    }
                 }
-              yyerror(msg);
-              free(msg);
+              yyerror (yymsg);
+              YYSTACK_FREE (yymsg);
             }
           else
-            yyerror ("parse error; also virtual memory exceeded");
+            {
+              yyerror (YY_("syntax error"));
+              goto yyexhaustedlab;
+            }
         }
       else
 #endif /* YYERROR_VERBOSE */
-        yyerror("parse error");
-    }
-
-  goto yyerrlab1;
-yyerrlab1:   /* here on error raised explicitly by an action */
+        yyerror (YY_("syntax error"));
+    }
+
+
 
   if (yyerrstatus == 3)
     {
-      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
-
-      /* return failure if at end of input */
-      if (yychar == YYEOF)
+      /* If just tried and failed to reuse look-ahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding", yytoken, &yylval);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse look-ahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (0)
+     goto yyerrorlab;
+
+yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
         YYABORT;
 
-#if YYDEBUG != 0
-      if (yydebug)
-        fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
-
-      yychar = YYEMPTY;
-    }
-
-  /* Else will try to reuse lookahead token
-     after shifting the error token.  */
-
-  yyerrstatus = 3;              /* Each real token shifted decrements this */
-
-  goto yyerrhandle;
-
-yyerrdefault:  /* current state does not do anything special for the error token. */
-
-#if 0
-  /* This is wrong; only states that explicitly want error tokens
-     should shift them.  */
-  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
-  if (yyn) goto yydefault;
-#endif
-
-yyerrpop:   /* pop the current state because it cannot handle the error token */
-
-  if (yyssp == yyss) YYABORT;
-  yyvsp--;
-  yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
-  yylsp--;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-        fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-yyerrhandle:
-
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yyerrdefault;
-
-  yyn += YYTERROR;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-    goto yyerrdefault;
-
-  yyn = yytable[yyn];
-  if (yyn < 0)
-    {
-      if (yyn == YYFLAG)
-        goto yyerrpop;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-  else if (yyn == 0)
-    goto yyerrpop;
+
+      yydestruct ("Error: popping", yystos[yystate], yyvsp);
+      YYPOPSTACK;
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting error token, ");
-#endif
-
   *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
+
+
+  /* Shift the error token. */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
   yystate = yyn;
   goto yynewstate;
 
- yyacceptlab:
-  /* YYACCEPT comes here.  */
-  if (yyfree_stacks)
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+                 yytoken, &yylval);
+  while (yyssp != yyss)
     {
-      free (yyss);
-      free (yyvs);
-#ifdef YYLSP_NEEDED
-      free (yyls);
-#endif
-    }
-  return 0;
-
- yyabortlab:
-  /* YYABORT comes here.  */
-  if (yyfree_stacks)
-    {
-      free (yyss);
-      free (yyvs);
-#ifdef YYLSP_NEEDED
-      free (yyls);
-#endif
-    }
-  return 1;
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp);
+      YYPOPSTACK;
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+  return yyresult;
 }
-#line 80 "readcf.y"
+
+
+#line 84 "readcf.y"
 
 
@@ -997 +1478 @@
 #endif
 {
-    cerr << s << endl;
+    CERR << s << "\n";
 }
 
@@ -1055 +1536 @@
 }
 
-CanonicalForm readCF( istream& str )
+CanonicalForm readCF( ISTREAM& str )
 {
     CanonicalForm theRetvalue;
@@ -1085 +1566 @@
 }
 
-char* readString( istream& s )
+char* readString( ISTREAM& s )
 {
     static char * buffer = 0;
@@ -1116 +1597 @@
     return buffer;
 }
+
+

factory/readcf.y

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: readcf.y,v 1.9 2006-05-15 08:17:55 Singular Exp $ */
+/* $Id: readcf.y,v 1.10 2006-05-15 09:03:07 Singular Exp $ */
 
 %{
@@ -15 +15 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define ISTREAM std::istream
+#define CERR std::cerr
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define ISTREAM istream
+#define CERR cerr
 #endif
 
@@ -35 +39 @@
 #endif
 
-static char* readString( istream& );
+static char* readString( ISTREAM& );
 
 #ifndef BISONPP
@@ -42 +46 @@
 #endif
 
-static istream * defaultin = 0;
+static ISTREAM * defaultin = 0;
 
 static CanonicalForm * retvalue = 0;
@@ -86 +90 @@
 #endif
 {
-    cerr << s << endl;
+    CERR << s << "\n";
 }
 
@@ -144 +148 @@
 }
 
-CanonicalForm readCF( istream& str )
+CanonicalForm readCF( ISTREAM& str )
 {
     CanonicalForm theRetvalue;
@@ -174 +178 @@
 }
 
-char* readString( istream& s )
+char* readString( ISTREAM& s )
 {
     static char * buffer = 0;

factory/templates/ftmpl_array.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_array.cc,v 1.8 1998-03-10 14:51:21 schmidt Exp $ */
+/* $Id: ftmpl_array.cc,v 1.9 2006-05-15 09:03:07 Singular Exp $ */
 
 #include <factoryconf.h>
@@ -143 +143 @@
 #ifndef NOSTREAMIO
 template <class T>
-void Array<T>::print ( ostream & os ) const
+void Array<T>::print ( OSTREAM & os ) const
 {
     if ( _size == 0 )
@@ -156 +156 @@
 
 template <class T>
-ostream& operator<< ( ostream & os, const Array<T> & a )
+OSTREAM& operator<< ( OSTREAM & os, const Array<T> & a )
 {
     a.print( os );

factory/templates/ftmpl_array.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_array.h,v 1.6 2006-05-15 08:17:56 Singular Exp $ */
+/* $Id: ftmpl_array.h,v 1.7 2006-05-15 09:03:07 Singular Exp $ */
 
 #ifndef INCL_ARRAY_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -34 +36 @@
     int max() const;
 #ifndef NOSTREAMIO
-    void print ( ostream& ) const;
+    void print ( OSTREAM& ) const;
 #endif /* NOSTREAMIO */
 };
@@ -40 +42 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<< ( ostream & os, const Array<T> & a );
+OSTREAM& operator<< ( OSTREAM & os, const Array<T> & a );
 #endif /* NOSTREAMIO */
 

factory/templates/ftmpl_factor.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_factor.cc,v 1.7 1998-03-10 14:51:26 schmidt Exp $ */
+/* $Id: ftmpl_factor.cc,v 1.8 2006-05-15 09:03:07 Singular Exp $ */
 
 #include <factoryconf.h>
@@ -36 +36 @@
 #ifndef NOSTREAMIO
 template <class T>
-void Factor<T>::print ( ostream& s ) const
+void Factor<T>::print ( OSTREAM& s ) const
 {
     if ( exp() == 1 )
@@ -45 +45 @@
 
 template <class T>
-ostream& operator<< ( ostream & os, const Factor<T> & f )
+OSTREAM& operator<< ( OSTREAM & os, const Factor<T> & f )
 {
     f.print( os );

factory/templates/ftmpl_factor.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_factor.h,v 1.6 2006-05-15 08:17:56 Singular Exp $ */
+/* $Id: ftmpl_factor.h,v 1.7 2006-05-15 09:03:07 Singular Exp $ */
 
 #ifndef INCL_FACTOR_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -36 +38 @@
     Factor<T>& operator*= ( const T & f ) { _factor *= f; return *this; }
 #ifndef NOSTREAMIO
-    void print ( ostream& ) const;
+    void print ( OSTREAM& ) const;
 #endif /* NOSTREAMIO */
 };
@@ -45 +47 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<< ( ostream & os, const Factor<T> & f );
+OSTREAM& operator<< ( OSTREAM & os, const Factor<T> & f );
 #endif /* NOSTREAMIO */
 

factory/templates/ftmpl_list.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_list.cc,v 1.8 2003-02-11 16:28:51 Singular Exp $ */
+/* $Id: ftmpl_list.cc,v 1.9 2006-05-15 09:03:07 Singular Exp $ */
 
 #include <factoryconf.h>
@@ -78 +78 @@
 #ifndef NOSTREAMIO
 template <class T>
-void ListItem<T>::print( ostream & os )
+void ListItem<T>::print( OSTREAM & os )
 {
     if ( item )
@@ -331 +331 @@
 #ifndef NOSTREAMIO
 template <class T>
-void List<T>::print ( ostream & os ) const
+void List<T>::print ( OSTREAM & os ) const
 {
     ListItem<T> *cur = first;
@@ -510 +510 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<<( ostream & os, const List<T> & l )
+OSTREAM& operator<<( OSTREAM & os, const List<T> & l )
 {
     l.print( os );

factory/templates/ftmpl_list.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_list.h,v 1.9 2006-05-15 08:17:56 Singular Exp $ */
+/* $Id: ftmpl_list.h,v 1.10 2006-05-15 09:03:07 Singular Exp $ */
 
 #ifndef INCL_LIST_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -23 +25 @@
 #ifndef NOSTREAMIO
 template <class T>
-std::ostream& operator<< ( std::ostream &, const List<T> &);
+OSTREAM& operator<< ( OSTREAM &, const List<T> &);
 #endif
 
@@ -43 +45 @@
     T& getItem();
 #ifndef NOSTREAMIO
-    void print ( ostream& );
+    void print ( OSTREAM& );
 #endif /* NOSTREAMIO */
     friend class ListIterator<T>;
@@ -74 +76 @@
     void sort ( int (*) ( const T&, const T& ) );
 #ifndef NOSTREAMIO
-    void print ( ostream & ) const;
-    friend ostream& operator<< <T>( ostream & os, const List<T> & l );
+    void print ( OSTREAM & ) const;
+    friend OSTREAM& operator<< <T>( OSTREAM & os, const List<T> & l );
 #endif /* NOSTREAMIO */
     friend class ListIterator<T>;
@@ -82 +84 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<< ( ostream & os, const List<T> & l );
+OSTREAM& operator<< ( OSTREAM & os, const List<T> & l );
 #endif /* NOSTREAMIO */
 

factory/templates/ftmpl_matrix.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_matrix.cc,v 1.10 2001-06-27 13:20:39 Singular Exp $ */
+/* $Id: ftmpl_matrix.cc,v 1.11 2006-05-15 09:03:07 Singular Exp $ */
 
 #include <factoryconf.h>
@@ -143 +143 @@
 #ifndef NOSTREAMIO
 template <class T>
-void Matrix<T>::printrow ( ostream & s, int i ) const
+void Matrix<T>::printrow ( OSTREAM & s, int i ) const
 {
     s << "( " << elems[i][0];
@@ -152 +152 @@
 
 template <class T>
-void Matrix<T>::print( ostream& s ) const
+void Matrix<T>::print( OSTREAM& s ) const
 {
     if ( NR == 0 )
@@ -319 +319 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream & operator<< ( ostream & s, const Matrix<T>& M )
+OSTREAM & operator<< ( OSTREAM & s, const Matrix<T>& M )
 {
    M.print( s );

factory/templates/ftmpl_matrix.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: ftmpl_matrix.h,v 1.12 2006-05-15 08:17:57 Singular Exp $ */
+/* $Id: ftmpl_matrix.h,v 1.13 2006-05-15 09:03:07 Singular Exp $ */
 
 #ifndef INCL_MATRIX_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -23 +25 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream& operator<< (ostream &, const Matrix<T> &);
+OSTREAM& operator<< (OSTREAM &, const Matrix<T> &);
 #endif
 
@@ -33 +35 @@
     T ** elems;
 #ifndef NOSTREAMIO
-    void printrow ( ostream & s, int i ) const;
+    void printrow ( OSTREAM & s, int i ) const;
 #endif /* NOSTREAMIO */
     typedef T* T_ptr;
@@ -53 +55 @@
     void swapColumn( int i, int j );
 #ifndef NOSTREAMIO
-    void print( ostream& s ) const;
-    friend ostream & operator<< <T>( ostream & s, const Matrix<T>& M );
+    void print( OSTREAM& s ) const;
+    friend OSTREAM & operator<< <T>( OSTREAM & s, const Matrix<T>& M );
 #endif /* NOSTREAMIO */
     friend class SubMatrix<T>;
@@ -89 +91 @@
 #ifndef NOSTREAMIO
 template <class T>
-ostream & operator<< ( ostream & s, const Matrix<T>& M );
+OSTREAM & operator<< ( OSTREAM & s, const Matrix<T>& M );
 #endif /* NOSTREAMIO */
 

factory/variable.cc

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: variable.cc,v 1.5 2005-04-13 15:01:53 Singular Exp $ */
+/* $Id: variable.cc,v 1.6 2006-05-15 09:03:07 Singular Exp $ */
 
 #include <config.h>
@@ -130 +130 @@
 
 #ifndef NOSTREAMIO
-ostream & operator << ( ostream & os, const Variable & v )
+OSTREAM & operator << ( OSTREAM & os, const Variable & v )
 {
     if ( v._level == LEVELBASE )

factory/variable.h

@@ -1 +1 @@
 /* emacs edit mode for this file is -*- C++ -*- */
-/* $Id: variable.h,v 1.6 2006-05-15 08:17:55 Singular Exp $ */
+/* $Id: variable.h,v 1.7 2006-05-15 09:03:07 Singular Exp $ */
 
 #ifndef INCL_VARIABLE_H
@@ -10 +10 @@
 #ifdef HAVE_IOSTREAM
 #include <iostream>
+#define OSTREAM std::ostream
 #elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
 #endif
 #endif /* NOSTREAMIO */
@@ -67 +69 @@
     }
 #ifndef NOSTREAMIO
-    friend ostream & operator << ( ostream & os, const Variable & v );
+    friend OSTREAM & operator << ( OSTREAM & os, const Variable & v );
 #endif /* NOSTREAMIO */
     friend void swap_levels();