Convert explicit template arguments to dummy arguments to try to make older gcc

versions happy.

diff --git a/BigInteger.cc b/BigInteger.cc
index 3b23aa1..dac50d9 100644 (file)
--- a/BigInteger.cc
+++ b/BigInteger.cc
@@ -85,23 +85,23 @@ BigInteger::BigInteger(short x) : sign(signOf(x)), mag(magOf<short, unsigned sho
  * BigInteger::convertToUnsignedPrimitive to avoid requiring BigUnsigned to
  * declare BigInteger. */
 template <class X>
-inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a) {
-       return a.convertToPrimitive<X>();
+inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a, X dummyX) {
+       return a.convertToPrimitive(dummyX);
 }
 
 template <class X>
-X BigInteger::convertToUnsignedPrimitive() const {
+X BigInteger::convertToUnsignedPrimitive(X dummyX) const {
        if (sign == negative)
                throw "BigInteger::to<Primitive>: "
                        "Cannot convert a negative integer to an unsigned type";
        else
-               return convertBigUnsignedToPrimitiveAccess<X>(mag);
+               return convertBigUnsignedToPrimitiveAccess(mag, dummyX);
 }
 
 /* Similar to BigUnsigned::convertToPrimitive, but split into two cases for
  * nonnegative and negative numbers. */
 template <class X, class UX>
-X BigInteger::convertToSignedPrimitive() const {
+X BigInteger::convertToSignedPrimitive(X /*dummyX*/, UX /*dummyUX*/) const {
        if (sign == zero)
                return 0;
        else if (mag.getLength() == 1) {
@@ -124,12 +124,12 @@ X BigInteger::convertToSignedPrimitive() const {
                "Value is too big to fit in the requested type";
 }
 
-unsigned long  BigInteger::toUnsignedLong () const { return convertToUnsignedPrimitive<unsigned long >       (); }
-unsigned int   BigInteger::toUnsignedInt  () const { return convertToUnsignedPrimitive<unsigned int  >       (); }
-unsigned short BigInteger::toUnsignedShort() const { return convertToUnsignedPrimitive<unsigned short>       (); }
-long           BigInteger::toLong         () const { return convertToSignedPrimitive  <long , unsigned long> (); }
-int            BigInteger::toInt          () const { return convertToSignedPrimitive  <int  , unsigned int>  (); }
-short          BigInteger::toShort        () const { return convertToSignedPrimitive  <short, unsigned short>(); }
+unsigned long  BigInteger::toUnsignedLong () const { return convertToUnsignedPrimitive((unsigned long )0)          ; }
+unsigned int   BigInteger::toUnsignedInt  () const { return convertToUnsignedPrimitive((unsigned int  )0)          ; }
+unsigned short BigInteger::toUnsignedShort() const { return convertToUnsignedPrimitive((unsigned short)0)          ; }
+long           BigInteger::toLong         () const { return convertToSignedPrimitive  ((long )0, (unsigned long )0); }
+int            BigInteger::toInt          () const { return convertToSignedPrimitive  ((int  )0, (unsigned int  )0); }
+short          BigInteger::toShort        () const { return convertToSignedPrimitive  ((short)0, (unsigned short)0); }
 
 // COMPARISON
 BigInteger::CmpRes BigInteger::compareTo(const BigInteger &x) const {

diff --git a/BigInteger.hh b/BigInteger.hh
index cf6e910..e1bbfe0 100644 (file)
--- a/BigInteger.hh
+++ b/BigInteger.hh
@@ -72,8 +72,8 @@ public:
        short          toShort        () const;
 protected:
        // Helper
-       template <class X> X convertToUnsignedPrimitive() const;
-       template <class X, class UX> X convertToSignedPrimitive() const;
+       template <class X> X convertToUnsignedPrimitive(X dummyX) const;
+       template <class X, class UX> X convertToSignedPrimitive(X dummyX, UX dummyUX) const;
 public:
 
        // ACCESSORS

diff --git a/BigUnsigned.cc b/BigUnsigned.cc
index ffb6c6c..aa7e691 100644 (file)
--- a/BigUnsigned.cc
+++ b/BigUnsigned.cc
@@ -12,12 +12,12 @@ BigUnsigned::BigUnsigned(         long  x) { initFromSignedPrimitive(x); }
 BigUnsigned::BigUnsigned(         int   x) { initFromSignedPrimitive(x); }
 BigUnsigned::BigUnsigned(         short x) { initFromSignedPrimitive(x); }
 
-unsigned long  BigUnsigned::toUnsignedLong () const { return convertToPrimitive      <unsigned long >(); }
-unsigned int   BigUnsigned::toUnsignedInt  () const { return convertToPrimitive      <unsigned int  >(); }
-unsigned short BigUnsigned::toUnsignedShort() const { return convertToPrimitive      <unsigned short>(); }
-long           BigUnsigned::toLong         () const { return convertToSignedPrimitive<         long >(); }
-int            BigUnsigned::toInt          () const { return convertToSignedPrimitive<         int  >(); }
-short          BigUnsigned::toShort        () const { return convertToSignedPrimitive<         short>(); }
+unsigned long  BigUnsigned::toUnsignedLong () const { return convertToPrimitive      ((unsigned long )0); }
+unsigned int   BigUnsigned::toUnsignedInt  () const { return convertToPrimitive      ((unsigned int  )0); }
+unsigned short BigUnsigned::toUnsignedShort() const { return convertToPrimitive      ((unsigned short)0); }
+long           BigUnsigned::toLong         () const { return convertToSignedPrimitive((         long )0); }
+int            BigUnsigned::toInt          () const { return convertToSignedPrimitive((         int  )0); }
+short          BigUnsigned::toShort        () const { return convertToSignedPrimitive((         short)0); }
 
 // BIT/BLOCK ACCESSORS
 

diff --git a/BigUnsigned.hh b/BigUnsigned.hh
index 683ac8b..f2b5787 100644 (file)
--- a/BigUnsigned.hh
+++ b/BigUnsigned.hh
@@ -77,8 +77,8 @@ public:
        short          toShort        () const;
 protected:
        // Helpers
-       template <class X> X convertToSignedPrimitive() const;
-       template <class X> X convertToPrimitive      () const;
+       template <class X> X convertToSignedPrimitive(X dummyX) const;
+       template <class X> X convertToPrimitive      (X dummyX) const;
 public:
 
        // BIT/BLOCK ACCESSORS
@@ -237,7 +237,7 @@ public:
 
        // See BigInteger.cc.
        template <class X>
-       friend X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a);
+       friend X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a, X dummyX);
 };
 
 /* Implementing the return-by-value and assignment operators in terms of the
@@ -384,7 +384,7 @@ void BigUnsigned::initFromSignedPrimitive(X x) {
  * slower than the previous version with the masks, but it's much shorter and
  * clearer, which is the library's stated goal. */
 template <class X>
-X BigUnsigned::convertToPrimitive() const {
+X BigUnsigned::convertToPrimitive(X /*dummyX*/) const {
        if (len == 0)
                // The number is zero; return zero.
                return 0;
@@ -406,8 +406,8 @@ X BigUnsigned::convertToPrimitive() const {
  * one.  (E.g., catch incorrect conversion of 2^31 to the long -2^31.)  Again,
  * separated to avoid a g++ warning. */
 template <class X>
-X BigUnsigned::convertToSignedPrimitive() const {
-       X x = convertToPrimitive<X>();
+X BigUnsigned::convertToSignedPrimitive(X dummyX) const {
+       X x = convertToPrimitive(dummyX);
        if (x >= 0)
                return x;
        else