From 2eeb8e77d77e2f7bd6cce05a96eed7985e5bb937 Mon Sep 17 00:00:00 2001 From: Matt McCutchen Date: Thu, 2 Oct 2008 21:46:35 -0400 Subject: [PATCH] Convert explicit template arguments to dummy arguments to try to make older gcc versions happy. --- BigInteger.cc | 22 +++++++++++----------- BigInteger.hh | 4 ++-- BigUnsigned.cc | 12 ++++++------ BigUnsigned.hh | 12 ++++++------ 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/BigInteger.cc b/BigInteger.cc index 3b23aa1..dac50d9 100644 --- a/BigInteger.cc +++ b/BigInteger.cc @@ -85,23 +85,23 @@ BigInteger::BigInteger(short x) : sign(signOf(x)), mag(magOf -inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a) { - return a.convertToPrimitive(); +inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a, X dummyX) { + return a.convertToPrimitive(dummyX); } template -X BigInteger::convertToUnsignedPrimitive() const { +X BigInteger::convertToUnsignedPrimitive(X dummyX) const { if (sign == negative) throw "BigInteger::to: " "Cannot convert a negative integer to an unsigned type"; else - return convertBigUnsignedToPrimitiveAccess(mag); + return convertBigUnsignedToPrimitiveAccess(mag, dummyX); } /* Similar to BigUnsigned::convertToPrimitive, but split into two cases for * nonnegative and negative numbers. */ template -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 int BigInteger::toUnsignedInt () const { return convertToUnsignedPrimitive (); } -unsigned short BigInteger::toUnsignedShort() const { return convertToUnsignedPrimitive (); } -long BigInteger::toLong () const { return convertToSignedPrimitive (); } -int BigInteger::toInt () const { return convertToSignedPrimitive (); } -short BigInteger::toShort () const { return convertToSignedPrimitive (); } +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 --- a/BigInteger.hh +++ b/BigInteger.hh @@ -72,8 +72,8 @@ public: short toShort () const; protected: // Helper - template X convertToUnsignedPrimitive() const; - template X convertToSignedPrimitive() const; + template X convertToUnsignedPrimitive(X dummyX) const; + template X convertToSignedPrimitive(X dummyX, UX dummyUX) const; public: // ACCESSORS diff --git a/BigUnsigned.cc b/BigUnsigned.cc index ffb6c6c..aa7e691 100644 --- 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 int BigUnsigned::toUnsignedInt () const { return convertToPrimitive (); } -unsigned short BigUnsigned::toUnsignedShort() const { return convertToPrimitive (); } -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 --- a/BigUnsigned.hh +++ b/BigUnsigned.hh @@ -77,8 +77,8 @@ public: short toShort () const; protected: // Helpers - template X convertToSignedPrimitive() const; - template X convertToPrimitive () const; + template X convertToSignedPrimitive(X dummyX) const; + template X convertToPrimitive (X dummyX) const; public: // BIT/BLOCK ACCESSORS @@ -237,7 +237,7 @@ public: // See BigInteger.cc. template - 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 -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 -X BigUnsigned::convertToSignedPrimitive() const { - X x = convertToPrimitive(); +X BigUnsigned::convertToSignedPrimitive(X dummyX) const { + X x = convertToPrimitive(dummyX); if (x >= 0) return x; else -- 2.34.1