xml-xalan-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbert...@apache.org
Subject cvs commit: xml-xalan/c/src/xalanc/PlatformSupport DoubleSupport.cpp DoubleSupport.hpp PlatformSupportInit.cpp
Date Thu, 29 Jul 2004 20:45:19 GMT
dbertoni    2004/07/29 13:45:19

  Modified:    c/src/xalanc/PlatformSupport DoubleSupport.cpp
                        DoubleSupport.hpp PlatformSupportInit.cpp
  Log:
  Cleaned up and simplified DoubleSupport.
  
  Revision  Changes    Path
  1.5       +481 -500  xml-xalan/c/src/xalanc/PlatformSupport/DoubleSupport.cpp
  
  Index: DoubleSupport.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/xalanc/PlatformSupport/DoubleSupport.cpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- DoubleSupport.cpp	26 Feb 2004 22:34:18 -0000	1.4
  +++ DoubleSupport.cpp	29 Jul 2004 20:45:19 -0000	1.5
  @@ -17,10 +17,6 @@
   
   
   
  -#if !defined(XALAN_NO_STD_NUMERIC_LIMITS)
  -#include <limits>
  -#endif
  -
   #include <clocale>
   #include <cmath>
   
  @@ -35,451 +31,436 @@
   
   
   
  -#if defined(XALAN_NO_STD_NUMERIC_LIMITS)
  -// To circumvent an OS/390 problem
  -#if !defined(OS390)
  -#define XALAN_POSITIVE_INFINITY HUGE_VAL
  -#else
  -
  -static const union
  -{
  -	unsigned char	c[8];
  -	double			d;
  -} theHugeVal = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } };
  +DoubleSupport::NumberUnion          DoubleSupport::s_NaN;
   
  -#define XALAN_POSITIVE_INFINITY (theHugeVal.d)
  +const DoubleSupport::NumberUnion    DoubleSupport::s_positiveInfinity = { HUGE_VAL };
   
  -#endif
  +const DoubleSupport::NumberUnion    DoubleSupport::s_negativeInfinity = { -HUGE_VAL };
   
  -#if defined(_AIX)
  -const DoubleSupport::NumberUnion	DoubleSupport::s_NaN = { DBL_QNAN };
  -#else
  -const DoubleSupport::NumberUnion	DoubleSupport::s_NaN = { sqrt(-2.01) };
  -#endif
  -const double	DoubleSupport::s_positiveInfinity = XALAN_POSITIVE_INFINITY;
  +const DoubleSupport::NumberUnion    DoubleSupport::s_positiveZero = { 0.0 };
   
  -#else
  +const DoubleSupport::NumberUnion    DoubleSupport::s_negativeZero = { -s_positiveZero.d };
   
  -#if defined(__SGI_STL_PORT)
  -const DoubleSupport::NumberUnion	DoubleSupport::s_NaN = { sqrt(-2.01) };
  -#else
  -const DoubleSupport::NumberUnion	DoubleSupport::s_NaN = { std::numeric_limits<double>::quiet_NaN() };
  -#endif
   
  -const double	DoubleSupport::s_positiveInfinity = std::numeric_limits<double>::infinity();
   
  +void
  +DoubleSupport::initialize()
  +{
  +    // We initialize this at here because some
  +    // platforms have had issues with signals
  +    // if we call sqrt(-2.01) during static
  +    // initialization.
  +#if defined(XALAN_STRICT_ANSI_HEADERS)
  +    s_NaN.d = std::sqrt(-2.01);
  +#else
  +    s_NaN.d = sqrt(-2.01);
   #endif
  +}
   
  -const double	DoubleSupport::s_negativeInfinity = -DoubleSupport::s_positiveInfinity;
  -
  -const DoubleSupport::NumberUnion	DoubleSupport::s_positiveZero = { 0.0 };
   
  -#if !defined(_AIX)
  -const DoubleSupport::NumberUnion	DoubleSupport::s_negativeZero = { -DoubleSupport::s_positiveZero.d };
  -#else
  -// Some compiler are overly aggressive and think that there is no such thing as -0,
  -// so we have to get it in a very sneaky way.
  -double	theDummy;
  -
  -const DoubleSupport::NumberUnion	DoubleSupport::s_negativeZero = { modf(-7.0, &theDummy) };
  -#endif
  + 
  +void
  +DoubleSupport::terminate()
  +{
  +    s_NaN.d = 0.0L;
  +}
   
   
   
   bool
   DoubleSupport::equal(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  -	{
  -		return false;
  -	}
  -	else
  -	{
  -		return theLHS == theRHS;
  -	}
  +    if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  +    {
  +        return false;
  +    }
  +    else
  +    {
  +        return theLHS == theRHS;
  +    }
   }
   
   
   
   bool
   DoubleSupport::lessThan(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  -	{
  -		return false;
  -	}
  -	else
  -	{
  -		return theLHS < theRHS;
  -	}
  +    if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  +    {
  +        return false;
  +    }
  +    else
  +    {
  +        return theLHS < theRHS;
  +    }
   }
   
   
   
   bool
   DoubleSupport::lessThanOrEqual(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  -	{
  -		return false;
  -	}
  -	else
  -	{
  -		return theLHS <= theRHS;
  -	}
  +    if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  +    {
  +        return false;
  +    }
  +    else
  +    {
  +        return theLHS <= theRHS;
  +    }
   }
   
   
   
   bool
   DoubleSupport::greaterThan(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  -	{
  -		return false;
  -	}
  -	else
  -	{
  -		return theLHS > theRHS;
  -	}
  +    if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  +    {
  +        return false;
  +    }
  +    else
  +    {
  +        return theLHS > theRHS;
  +    }
   }
   
   
   
   bool
   DoubleSupport::greaterThanOrEqual(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  -	{
  -		return false;
  -	}
  -	else
  -	{
  -		return theLHS >= theRHS;
  -	}
  +    if (isNaN(theLHS) == true || isNaN(theRHS) == true)
  +    {
  +        return false;
  +    }
  +    else
  +    {
  +        return theLHS >= theRHS;
  +    }
   }
   
   
   
   double
   DoubleSupport::add(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true)
  -	{
  -		return theLHS;
  -	}
  -	else if (isNaN(theRHS) == true)
  -	{
  -		return theRHS;
  -	}
  -	else
  -	{
  -		return theLHS + theRHS;
  -	}
  +    if (isNaN(theLHS) == true)
  +    {
  +        return theLHS;
  +    }
  +    else if (isNaN(theRHS) == true)
  +    {
  +        return theRHS;
  +    }
  +    else
  +    {
  +        return theLHS + theRHS;
  +    }
   }
   
   
   
   double
   DoubleSupport::subtract(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true)
  -	{
  -		return theLHS;
  -	}
  -	else if (isNaN(theRHS) == true)
  -	{
  -		return theRHS;
  -	}
  -	else
  -	{
  -		return theLHS - theRHS;
  -	}
  +    if (isNaN(theLHS) == true)
  +    {
  +        return theLHS;
  +    }
  +    else if (isNaN(theRHS) == true)
  +    {
  +        return theRHS;
  +    }
  +    else
  +    {
  +        return theLHS - theRHS;
  +    }
   }
   
   
   
   double
   DoubleSupport::multiply(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true)
  -	{
  -		return theLHS;
  -	}
  -	else if (isNaN(theRHS) == true)
  -	{
  -		return theRHS;
  -	}
  -	else
  -	{
  -		return theLHS * theRHS;
  -	}
  +    if (isNaN(theLHS) == true)
  +    {
  +        return theLHS;
  +    }
  +    else if (isNaN(theRHS) == true)
  +    {
  +        return theRHS;
  +    }
  +    else
  +    {
  +        return theLHS * theRHS;
  +    }
   }
   
   
   
   double
   DoubleSupport::divide(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true)
  -	{
  -		return theLHS;
  -	}
  -	else if (isNaN(theRHS) == true)
  -	{
  -		return theRHS;
  -	}
  -	else if (theRHS != 0.0L)
  -	{
  -		return theLHS / theRHS;
  -	}
  -	else if (theLHS == 0.0L)
  -	{
  -		// This is NaN...
  -		return DoubleSupport::getNaN();
  -	}
  -	else if (theLHS > 0.0L && isPositiveZero(theRHS) == true)
  -	{
  -		// This is positive infinity...
  -		return DoubleSupport::getPositiveInfinity();
  -	}
  -	else
  -	{
  -		// This is negative infinity...
  -		return DoubleSupport::getNegativeInfinity();
  -	}
  +    if (isNaN(theLHS) == true)
  +    {
  +        return theLHS;
  +    }
  +    else if (isNaN(theRHS) == true)
  +    {
  +        return theRHS;
  +    }
  +    else if (theRHS != 0.0L)
  +    {
  +        return theLHS / theRHS;
  +    }
  +    else if (theLHS == 0.0L)
  +    {
  +        // This is NaN...
  +        return DoubleSupport::getNaN();
  +    }
  +    else if (theLHS > 0.0L && isPositiveZero(theRHS) == true)
  +    {
  +        // This is positive infinity...
  +        return DoubleSupport::getPositiveInfinity();
  +    }
  +    else
  +    {
  +        // This is negative infinity...
  +        return DoubleSupport::getNegativeInfinity();
  +    }
   }
   
   
   
   double
   DoubleSupport::modulus(
  -			double	theLHS,
  -			double	theRHS)
  +            double  theLHS,
  +            double  theRHS)
   {
  -	if (isNaN(theLHS) == true)
  -	{
  -		return theLHS;
  -	}
  -	else if (isNaN(theRHS) == true)
  -	{
  -		return theRHS;
  -	}
  -	else if (theRHS == 0.0)
  -	{
  -		return getNaN();
  -	}
  -	else if (long(theLHS) == theLHS && long(theRHS) == theRHS)
  -	{
  -		return long(theLHS) % long(theRHS);
  -	}
  -	else
  -	{
  -		double	theDummy;
  +    if (isNaN(theLHS) == true)
  +    {
  +        return theLHS;
  +    }
  +    else if (isNaN(theRHS) == true)
  +    {
  +        return theRHS;
  +    }
  +    else if (theRHS == 0.0)
  +    {
  +        return getNaN();
  +    }
  +    else if (long(theLHS) == theLHS && long(theRHS) == theRHS)
  +    {
  +        return long(theLHS) % long(theRHS);
  +    }
  +    else
  +    {
  +        double  theDummy;
   
  -		double	theResult = divide(theLHS, theRHS);
  +        double  theResult = divide(theLHS, theRHS);
   
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -		return std::modf(theResult, &theDummy) * theRHS;
  +        return std::modf(theResult, &theDummy) * theRHS;
   #else
  -		return modf(theResult, &theDummy) * theRHS;
  +        return modf(theResult, &theDummy) * theRHS;
   #endif
  -	}
  +    }
   }
   
   
   
   double
  -DoubleSupport::negative(double	theDouble)
  +DoubleSupport::negative(double  theDouble)
   {
  -	if (isNaN(theDouble) == true)
  -	{
  -		return getNaN();
  -	}
  -	else
  -	{
  -		return -theDouble;
  -	}
  +    if (isNaN(theDouble) == true)
  +    {
  +        return getNaN();
  +    }
  +    else
  +    {
  +        return -theDouble;
  +    }
   }
   
   
   
   double
  -DoubleSupport::toDouble(const XalanDOMString&	theString)
  +DoubleSupport::toDouble(const XalanDOMString&   theString)
   {
  -	return toDouble(c_wstr(theString));
  +    return toDouble(c_wstr(theString));
   }
   
   
   
   inline void
  -consumeWhitespace(const XalanDOMChar*&	theString)
  +consumeWhitespace(const XalanDOMChar*&  theString)
   {
  -	while(*theString != 0 &&
  -		  isXMLWhitespace(*theString))
  -	{
  -		++theString;
  -	}
  +    while(*theString != 0 &&
  +          isXMLWhitespace(*theString))
  +    {
  +        ++theString;
  +    }
   }
   
   
   
   inline void
   consumeWhitespace(
  -			const XalanDOMChar*&		theString,
  -			XalanDOMString::size_type&	theLength)
  +            const XalanDOMChar*&        theString,
  +            XalanDOMString::size_type&  theLength)
   {
  -	while(*theString != 0 &&
  -		  isXMLWhitespace(*theString))
  -	{
  -		++theString;
  -		--theLength;
  -	}
  +    while(*theString != 0 &&
  +          isXMLWhitespace(*theString))
  +    {
  +        ++theString;
  +        --theLength;
  +    }
   }
   
   
   
   inline static void
  -consumeNumbers(const XalanDOMChar*&	theString)
  +consumeNumbers(const XalanDOMChar*& theString)
   {
  -	while(*theString &&
  -		  *theString >= XalanUnicode::charDigit_0 &&
  -		  *theString <= XalanUnicode::charDigit_9)
  -	{
  -			++theString;
  -	}
  +    while(*theString &&
  +          *theString >= XalanUnicode::charDigit_0 &&
  +          *theString <= XalanUnicode::charDigit_9)
  +    {
  +            ++theString;
  +    }
   }
   
   
   
   static bool
   doValidate(
  -			const XalanDOMChar*		theString,
  -			bool&					fGotDecimalPoint)
  +            const XalanDOMChar*     theString,
  +            bool&                   fGotDecimalPoint)
   {
  -	assert(theString != 0);
  +    assert(theString != 0);
   
  -	bool	fError = false;
  -	bool	fGotDigit = false;
  -	bool	fGotMinus = false;
  -	bool	fGotWhitespace = false;
  -
  -	const XalanDOMChar*		theCurrent = theString;
  -
  -	// trim any whitespace
  -	consumeWhitespace(theCurrent);
  -
  -	while(*theCurrent != 0 && fError == false)
  -	{
  -		switch(*theCurrent)
  -		{
  -		case XalanUnicode::charFullStop:
  -			if (fGotDecimalPoint == true ||	// can't have more than one...
  -				fGotWhitespace == true)	// can't have one after whitespace...
  -			{
  -				fError = true;
  -			}
  -			else
  -			{
  -				fGotDecimalPoint = true;
  -
  -				++theCurrent;
  -			}
  -			break;
  -
  -		case XalanUnicode::charHyphenMinus:
  -			if (fGotDecimalPoint == true ||
  -				fGotMinus == true ||
  -				fGotDigit == true ||
  -				fGotWhitespace == true)
  -			{
  -				// Error -- more than one, or in bad position.
  -				fError = true;
  -			}
  -			else
  -			{
  -				fGotMinus = true;
  -
  -				++theCurrent;
  -			}
  -			break;
  -
  -		case XalanUnicode::charDigit_0:
  -		case XalanUnicode::charDigit_1:
  -		case XalanUnicode::charDigit_2:
  -		case XalanUnicode::charDigit_3:
  -		case XalanUnicode::charDigit_4:
  -		case XalanUnicode::charDigit_5:
  -		case XalanUnicode::charDigit_6:
  -		case XalanUnicode::charDigit_7:
  -		case XalanUnicode::charDigit_8:
  -		case XalanUnicode::charDigit_9:
  -			if (fGotWhitespace == true)
  -			{
  -				fError = true;
  -			}
  -			else
  -			{
  -				fGotDigit = true;
  -
  -				consumeNumbers(theCurrent);
  -			}
  -			break;
  -
  -		case XalanUnicode::charSpace:
  -		case XalanUnicode::charCR:
  -		case XalanUnicode::charHTab:
  -		case XalanUnicode::charLF:
  -			if (fGotWhitespace == true)
  -			{
  -				fError = true;
  -			}
  -			else
  -			{
  -				fGotWhitespace = true;
  -
  -				consumeWhitespace(theCurrent);
  -			}
  -			break;
  -
  -		default:
  -			fError = true;
  -			break;
  -		}
  -	}
  -
  -	// If there was no error, check to see that we got
  -	// at least one digit.  Otherwise, return false if
  -	// there was an error.
  -	return fError == false ? fGotDigit : false;
  +    bool    fError = false;
  +    bool    fGotDigit = false;
  +    bool    fGotMinus = false;
  +    bool    fGotWhitespace = false;
  +
  +    const XalanDOMChar*     theCurrent = theString;
  +
  +    // trim any whitespace
  +    consumeWhitespace(theCurrent);
  +
  +    while(*theCurrent != 0 && fError == false)
  +    {
  +        switch(*theCurrent)
  +        {
  +        case XalanUnicode::charFullStop:
  +            if (fGotDecimalPoint == true || // can't have more than one...
  +                fGotWhitespace == true) // can't have one after whitespace...
  +            {
  +                fError = true;
  +            }
  +            else
  +            {
  +                fGotDecimalPoint = true;
  +
  +                ++theCurrent;
  +            }
  +            break;
  +
  +        case XalanUnicode::charHyphenMinus:
  +            if (fGotDecimalPoint == true ||
  +                fGotMinus == true ||
  +                fGotDigit == true ||
  +                fGotWhitespace == true)
  +            {
  +                // Error -- more than one, or in bad position.
  +                fError = true;
  +            }
  +            else
  +            {
  +                fGotMinus = true;
  +
  +                ++theCurrent;
  +            }
  +            break;
  +
  +        case XalanUnicode::charDigit_0:
  +        case XalanUnicode::charDigit_1:
  +        case XalanUnicode::charDigit_2:
  +        case XalanUnicode::charDigit_3:
  +        case XalanUnicode::charDigit_4:
  +        case XalanUnicode::charDigit_5:
  +        case XalanUnicode::charDigit_6:
  +        case XalanUnicode::charDigit_7:
  +        case XalanUnicode::charDigit_8:
  +        case XalanUnicode::charDigit_9:
  +            if (fGotWhitespace == true)
  +            {
  +                fError = true;
  +            }
  +            else
  +            {
  +                fGotDigit = true;
  +
  +                consumeNumbers(theCurrent);
  +            }
  +            break;
  +
  +        case XalanUnicode::charSpace:
  +        case XalanUnicode::charCR:
  +        case XalanUnicode::charHTab:
  +        case XalanUnicode::charLF:
  +            if (fGotWhitespace == true)
  +            {
  +                fError = true;
  +            }
  +            else
  +            {
  +                fGotWhitespace = true;
  +
  +                consumeWhitespace(theCurrent);
  +            }
  +            break;
  +
  +        default:
  +            fError = true;
  +            break;
  +        }
  +    }
  +
  +    // If there was no error, check to see that we got
  +    // at least one digit.  Otherwise, return false if
  +    // there was an error.
  +    return fError == false ? fGotDigit : false;
   }
   
   
   
   static bool
  -doValidate(const XalanDOMChar*	theString)
  +doValidate(const XalanDOMChar*  theString)
   {
  -	bool	fDummy = false;
  +    bool    fDummy = false;
   
  -	return doValidate(theString, fDummy);
  +    return doValidate(theString, fDummy);
   }
   
   
  @@ -487,70 +468,70 @@
   #if defined(XALAN_NON_ASCII_PLATFORM)
   void
   translateWideString(
  -			const XalanDOMChar*			theWideString,
  -			char*						theNarrowString,
  -			XalanDOMString::size_type	theStringLength,
  -			char						theDecimalPointCharacter)
  -{
  -	for(XalanDOMString::size_type i = 0; i < theStringLength; ++i)
  -	{
  -		switch(theWideString[i])
  -		{
  -		case XalanUnicode::charHyphenMinus:
  -			theNarrowString[i] = '-';
  -			break;
  -
  -		case XalanUnicode::charFullStop:
  -			theNarrowString[i] = theDecimalPointCharacter;
  -			break;
  -
  -		case XalanUnicode::charDigit_0:
  -			theNarrowString[i] = '0';
  -			break;
  -
  -		case XalanUnicode::charDigit_1:
  -			theNarrowString[i] = '1';
  -			break;
  -
  -		case XalanUnicode::charDigit_2:
  -			theNarrowString[i] = '2';
  -			break;
  -
  -		case XalanUnicode::charDigit_3:
  -			theNarrowString[i] = '3';
  -			break;
  -
  -		case XalanUnicode::charDigit_4:
  -			theNarrowString[i] = '4';
  -			break;
  -
  -		case XalanUnicode::charDigit_5:
  -			theNarrowString[i] = '5';
  -			break;
  -
  -		case XalanUnicode::charDigit_6:
  -			theNarrowString[i] = '6';
  -			break;
  -
  -		case XalanUnicode::charDigit_7:
  -			theNarrowString[i] = '7';
  -			break;
  -
  -		case XalanUnicode::charDigit_8:
  -			theNarrowString[i] = '8';
  -			break;
  -
  -		case XalanUnicode::charDigit_9:
  -			theNarrowString[i] = '9';
  -			break;
  -
  -		default:
  -			theNarrowString[i] = char(0);
  -			break;
  -		}
  -	}
  -	
  -	theNarrowString[theStringLength] = char(0);
  +            const XalanDOMChar*         theWideString,
  +            char*                       theNarrowString,
  +            XalanDOMString::size_type   theStringLength,
  +            char                        theDecimalPointCharacter)
  +{
  +    for(XalanDOMString::size_type i = 0; i < theStringLength; ++i)
  +    {
  +        switch(theWideString[i])
  +        {
  +        case XalanUnicode::charHyphenMinus:
  +            theNarrowString[i] = '-';
  +            break;
  +
  +        case XalanUnicode::charFullStop:
  +            theNarrowString[i] = theDecimalPointCharacter;
  +            break;
  +
  +        case XalanUnicode::charDigit_0:
  +            theNarrowString[i] = '0';
  +            break;
  +
  +        case XalanUnicode::charDigit_1:
  +            theNarrowString[i] = '1';
  +            break;
  +
  +        case XalanUnicode::charDigit_2:
  +            theNarrowString[i] = '2';
  +            break;
  +
  +        case XalanUnicode::charDigit_3:
  +            theNarrowString[i] = '3';
  +            break;
  +
  +        case XalanUnicode::charDigit_4:
  +            theNarrowString[i] = '4';
  +            break;
  +
  +        case XalanUnicode::charDigit_5:
  +            theNarrowString[i] = '5';
  +            break;
  +
  +        case XalanUnicode::charDigit_6:
  +            theNarrowString[i] = '6';
  +            break;
  +
  +        case XalanUnicode::charDigit_7:
  +            theNarrowString[i] = '7';
  +            break;
  +
  +        case XalanUnicode::charDigit_8:
  +            theNarrowString[i] = '8';
  +            break;
  +
  +        case XalanUnicode::charDigit_9:
  +            theNarrowString[i] = '9';
  +            break;
  +
  +        default:
  +            theNarrowString[i] = char(0);
  +            break;
  +        }
  +    }
  +    
  +    theNarrowString[theStringLength] = char(0);
   }
   #endif
   
  @@ -558,186 +539,186 @@
   
   inline double
   convertHelper(
  -			const XalanDOMChar*		theString,
  -			bool					fGotDecimalPoint)
  +            const XalanDOMChar*     theString,
  +            bool                    fGotDecimalPoint)
   {
  -	// This is a big hack.  If the length of the
  -	// string is less than n characters, we'll convert
  -	// it as a long and coerce that to a double.  This
  -	// is _much_ cheaper...
  -	const XalanDOMString::size_type		theLongHackThreshold = 10;
  -
  -	XalanDOMString::size_type	theLength = length(theString);
  -
  -	if (fGotDecimalPoint == false && theLength < theLongHackThreshold)
  -	{
  -		return double(WideStringToLong(theString));
  -	}
  -	else
  -	{
  +    // This is a big hack.  If the length of the
  +    // string is less than n characters, we'll convert
  +    // it as a long and coerce that to a double.  This
  +    // is _much_ cheaper...
  +    const XalanDOMString::size_type     theLongHackThreshold = 10;
  +
  +    XalanDOMString::size_type   theLength = length(theString);
  +
  +    if (fGotDecimalPoint == false && theLength < theLongHackThreshold)
  +    {
  +        return double(WideStringToLong(theString));
  +    }
  +    else
  +    {
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -		const char	theDecimalPointChar = std::localeconv()->decimal_point[0];
  +        const char  theDecimalPointChar = std::localeconv()->decimal_point[0];
   #else
  -		const char	theDecimalPointChar = localeconv()->decimal_point[0];
  +        const char  theDecimalPointChar = localeconv()->decimal_point[0];
   #endif
   
  -		// trim any whitespace
  -		consumeWhitespace(theString, theLength);
  +        // trim any whitespace
  +        consumeWhitespace(theString, theLength);
   
  -		// Use a stack-based buffer, when possible...
  -		const XalanDOMString::size_type		theBufferSize = 200u;
  +        // Use a stack-based buffer, when possible...
  +        const XalanDOMString::size_type     theBufferSize = 200u;
   
  -		if (theLength < theBufferSize)
  -		{
  -			char	theBuffer[theBufferSize];
  +        if (theLength < theBufferSize)
  +        {
  +            char    theBuffer[theBufferSize];
   
   #if defined(XALAN_NON_ASCII_PLATFORM)
  -			translateWideString(theString, theBuffer, theLength, theDecimalPointChar);
  +            translateWideString(theString, theBuffer, theLength, theDecimalPointChar);
   #else
  -			for(XalanDOMString::size_type i = 0; i < theLength; ++i)
  -			{
  -				if (theString[i] == XalanUnicode::charFullStop)
  -				{
  -					theBuffer[i] = theDecimalPointChar;
  -				}
  -				else
  -				{
  -					theBuffer[i] = char(theString[i]);
  -				}
  -			}
  +            for(XalanDOMString::size_type i = 0; i < theLength; ++i)
  +            {
  +                if (theString[i] == XalanUnicode::charFullStop)
  +                {
  +                    theBuffer[i] = theDecimalPointChar;
  +                }
  +                else
  +                {
  +                    theBuffer[i] = char(theString[i]);
  +                }
  +            }
   
  -			theBuffer[theLength] = '\0';
  +            theBuffer[theLength] = '\0';
   #endif
   
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -			return std::atof(theBuffer);
  +            return std::atof(theBuffer);
   #else
  -			return atof(theBuffer);
  +            return atof(theBuffer);
   #endif
  -		}
  -		else
  -		{
  -			CharVectorType	theVector;
  +        }
  +        else
  +        {
  +            CharVectorType  theVector;
   
   #if !defined(XALAN_NON_ASCII_PLATFORM)
  -			theVector.reserve(theLength + 1);
  +            theVector.reserve(theLength + 1);
   
  -			CopyWideStringToVector(theString, theVector);
  +            CopyWideStringToVector(theString, theVector);
   #else
  -			theVector.resize(theLength + 1, CharVectorType::value_type(0));
  +            theVector.resize(theLength + 1, CharVectorType::value_type(0));
   
  -			translateWideString(theString, &*theVector.begin(), theLength, theDecimalPointChar);
  +            translateWideString(theString, &*theVector.begin(), theLength, theDecimalPointChar);
   #endif
   
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -			return std::atof(&*theVector.begin());
  +            return std::atof(&*theVector.begin());
   #else
  -			return atof(&*theVector.begin());
  +            return atof(&*theVector.begin());
   #endif
  -		}
  -	}
  +        }
  +    }
   }
   
   
   
   double
  -doConvert(const XalanDOMChar*	theString)
  +doConvert(const XalanDOMChar*   theString)
   {
  -	assert(theString != 0);
  -	assert(*theString != 0);
  +    assert(theString != 0);
  +    assert(*theString != 0);
   
  -	bool	fGotDecimalPoint = false;
  +    bool    fGotDecimalPoint = false;
   
  -	if (doValidate(theString, fGotDecimalPoint) == false)
  -	{
  -		return DoubleSupport::getNaN();
  -	}
  -	else
  -	{
  -		return convertHelper(theString, fGotDecimalPoint);
  -	}
  +    if (doValidate(theString, fGotDecimalPoint) == false)
  +    {
  +        return DoubleSupport::getNaN();
  +    }
  +    else
  +    {
  +        return convertHelper(theString, fGotDecimalPoint);
  +    }
   }
   
   
   
   double
  -DoubleSupport::toDouble(const XalanDOMChar*		theString)
  +DoubleSupport::toDouble(const XalanDOMChar*     theString)
   {
  -	if (theString == 0 ||
  -		*theString == 0)
  -	{
  -		return getNaN();
  -	}
  -	else
  -	{
  -		return doConvert(theString);
  -	}
  +    if (theString == 0 ||
  +        *theString == 0)
  +    {
  +        return getNaN();
  +    }
  +    else
  +    {
  +        return doConvert(theString);
  +    }
   }
   
   
   
   bool
  -DoubleSupport::isValid(const XalanDOMString&	theString)
  +DoubleSupport::isValid(const XalanDOMString&    theString)
   {
  -	return isValid(c_wstr(theString));
  +    return isValid(c_wstr(theString));
   }
   
   
   
   bool
  -DoubleSupport::isValid(const XalanDOMChar*		theString)
  +DoubleSupport::isValid(const XalanDOMChar*      theString)
   {
  -	return doValidate(theString);
  +    return doValidate(theString);
   }
   
   
   
   double
  -DoubleSupport::round(double		theValue)
  +DoubleSupport::round(double     theValue)
   {
  -	if (isNaN(theValue))
  -	{
  -		return getNaN();
  -	}
  -	else if (isPositiveInfinity(theValue))
  -	{
  -		return getPositiveInfinity();
  -	}
  -	if (isNegativeInfinity(theValue))
  -	{
  -		return getNegativeInfinity();
  -	}
  -	else if (theValue == 0)
  -	{
  -		return 0.0;
  -	}
  -	else if (theValue > 0)
  -	{
  -		return long(theValue + 0.5);
  -	}
  -	else
  -	{
  -		// Negative numbers are a special case.  Any time we
  -		// have -0.5 as the fractional part, we have to
  -		// round up (toward 0), rather than down.
  -		double			intPart = 0;
  +    if (isNaN(theValue))
  +    {
  +        return getNaN();
  +    }
  +    else if (isPositiveInfinity(theValue))
  +    {
  +        return getPositiveInfinity();
  +    }
  +    if (isNegativeInfinity(theValue))
  +    {
  +        return getNegativeInfinity();
  +    }
  +    else if (theValue == 0)
  +    {
  +        return 0.0;
  +    }
  +    else if (theValue > 0)
  +    {
  +        return long(theValue + 0.5);
  +    }
  +    else
  +    {
  +        // Negative numbers are a special case.  Any time we
  +        // have -0.5 as the fractional part, we have to
  +        // round up (toward 0), rather than down.
  +        double          intPart = 0;
   
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -		const double	fracPart = std::modf(theValue, &intPart);
  +        const double    fracPart = std::modf(theValue, &intPart);
   #else
  -		const double	fracPart = modf(theValue, &intPart);
  +        const double    fracPart = modf(theValue, &intPart);
   #endif
   
  -		if (fracPart == -0.5)
  -		{
  -			// special case -- we have have to round toward 0...
  -			return long(theValue + 0.5);
  -		}
  -		else
  -		{
  -			return long(theValue - 0.5);
  -		}
  -	}
  +        if (fracPart == -0.5)
  +        {
  +            // special case -- we have have to round toward 0...
  +            return long(theValue + 0.5);
  +        }
  +        else
  +        {
  +            return long(theValue - 0.5);
  +        }
  +    }
   }
   
   
  
  
  
  1.5       +556 -543  xml-xalan/c/src/xalanc/PlatformSupport/DoubleSupport.hpp
  
  Index: DoubleSupport.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/xalanc/PlatformSupport/DoubleSupport.hpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- DoubleSupport.hpp	26 Feb 2004 22:34:18 -0000	1.4
  +++ DoubleSupport.hpp	29 Jul 2004 20:45:19 -0000	1.5
  @@ -41,559 +41,572 @@
   {
   public:
   
  -	// Use these functions to determine if a value represents one of these
  -	// values.  It seems that under some architectures, NaN will compare
  -	// as equal to any number, which is a big problem.  Hence these helper
  -	// functions.
  -
  -	/**
  -	 * Determine if target is not a number
  -	 * 
  -	 * @param theNumber target number
  -	 * @return true if target represents the "not a number" value
  -	 */
  -	static bool
  -	isNaN(double	theNumber)
  -	{
  -		const NumberUnion	temp = { theNumber };
  -
  -		return s_NaN.dwords.dw1 == temp.dwords.dw1 &&
  -			   s_NaN.dwords.dw2 == temp.dwords.dw2;
  -	}
  -
  -	/**
  -	 * Determine if target is positive infinity
  -	 * 
  -	 * @param theNumber target number
  -	 * @return true if target represents the value for positive infinity
  -	 */
  -	static bool
  -	isPositiveInfinity(double	theNumber)
  -	{
  -		return !isNaN(theNumber) && theNumber == s_positiveInfinity;
  -	}
  -
  -	/**
  -	 * Determine if target is negative infinity
  -	 * 
  -	 * @param theNumber target number
  -	 * @return true if target represents the value for negative infinity
  -	 */
  -	static bool
  -	isNegativeInfinity(double	theNumber)
  -	{
  -		return !isNaN(theNumber) && theNumber == s_negativeInfinity;
  -	}
  -
  -	/**
  -	 * Determine if target is positive 0.
  -	 * 
  -	 * @param theNumber target number
  -	 * @return true if target represents the value for positive 0.
  -	 */
  -	static bool
  -	isPositiveZero(double	theNumber)
  -	{
  -		const NumberUnion	temp = { theNumber };
  -
  -		return s_positiveZero.dwords.dw1 == temp.dwords.dw1 &&
  -			   s_positiveZero.dwords.dw2 == temp.dwords.dw2;
  -	}
  -
  -	/**
  -	 * Determine if target is negative 0
  -	 * 
  -	 * @param theNumber target number
  -	 * @return true if target represents the value for negative 0
  -	 */
  -	static bool
  -	isNegativeZero(double	theNumber)
  -	{
  -		const NumberUnion	temp = { theNumber };
  -
  -		return s_negativeZero.dwords.dw1 == temp.dwords.dw1 &&
  -			   s_negativeZero.dwords.dw2 == temp.dwords.dw2;
  -	}
  -
  -	// These can be used to initialize values, but should not
  -	// be used to do equality comparisons, as == may fail on
  -	// some platforms.
  -	//
  -
  -	/**
  -	 * Double value that represents "not a number"
  -	 * 
  -	 * @return "not a number" value
  -	 */
  -	static double
  -	getNaN()
  -	{
  -		return s_NaN.d;
  -	}
  -
  -	/**
  -	 * Double value that represents positive infinity
  -	 * 
  -	 * @return positive infinity value
  -	 */
  -	static double
  -	getPositiveInfinity()
  -	{
  -		return s_positiveInfinity;
  -	}
  -
  -	/**
  -	 * Double value that represents negative infinity
  -	 * 
  -	 * @return negative infinity value
  -	 */
  -	static double
  -	getNegativeInfinity()
  -	{
  -		return s_negativeInfinity;
  -	}
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	equal(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	notEqual(
  -			double	theLHS,
  -			double	theRHS)
  -	{
  -		return !equal(theLHS, theRHS);
  -	}
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	lessThan(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	lessThanOrEqual(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	greaterThan(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Compare two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to compare
  -	 * @param theRHS a number to compare
  -	 * @return the result of the compare
  -	 */
  -	static bool
  -	greaterThanOrEqual(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Add two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to add
  -	 * @param theRHS a number to add
  -	 * @return the result of the addition
  -	 */
  -	static double
  -	add(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Subtract two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to subtract
  -	 * @param theRHS a number to subtract
  -	 * @return the result of the subtraction
  -	 */
  -	static double
  -	subtract(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Multiply two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to multiply
  -	 * @param theRHS a number to multiply
  -	 * @return the result of the multiplication
  -	 */
  -	static double
  -	multiply(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Divide two double values, taking into account
  -	 * the fact that we must support IEEE 754
  -	 *
  -	 * @param theLHS a number to divide
  -	 * @param theRHS a number to divide
  -	 * @return the result of the division
  -	 */
  -	static double
  -	divide(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Determine the modulus two double values,
  -	 * taking into account the fact that we must
  -	 * support IEEE 754
  -	 *
  -	 * @param theLHS a number to divide
  -	 * @param theRHS a number to divide
  -	 * @return the result of the modulus
  -	 */
  -	static double
  -	modulus(
  -			double	theLHS,
  -			double	theRHS);
  -
  -	/**
  -	 * Determine the negative of a double value,
  -	 * taking into account the fact that we must
  -	 * support IEEE 754
  -	 *
  -	 * @param theDouble a number to negate
  -	 * @return the result of the negation
  -	 */
  -	static double
  -	negative(double	theDouble);
  -
  -	// Some functors to do the same thing.  This is for
  -	// STL integration...
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct equalFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct equalFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return equal(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct notEqualFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct notEqualFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return notEqual(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct lessThanFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct lessThanFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return lessThan(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct lessThanOrEqualFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct lessThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return lessThanOrEqual(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct greaterThanFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct greaterThanFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return greaterThan(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct greaterThanOrEqualFunction : public binary_function<const double&, const double&, bool>
  -	#else
  -	struct greaterThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return greaterThanOrEqual(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct addFunction : public binary_function<const double&, const double&, double>
  -	#else
  -	struct addFunction : public std::binary_function<const double&, const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return add(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct subtractFunction : public binary_function<const double&, const double&, double>
  -	#else
  -	struct subtractFunction : public std::binary_function<const double&, const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return subtract(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct multiplyFunction : public binary_function<const double&, const double&, double>
  -	#else
  -	struct multiplyFunction : public std::binary_function<const double&, const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return multiply(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct divideFunction : public binary_function<const double&, const double&, double>
  -	#else
  -	struct divideFunction : public std::binary_function<const double&, const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return divide(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct modulusFunction : public binary_function<const double&, const double&, double>
  -	#else
  -	struct modulusFunction : public std::binary_function<const double&, const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(
  -			first_argument_type		theLHS,
  -			second_argument_type	theRHS) const
  -		{
  -			return modulus(theLHS, theRHS);
  -		}
  -	};
  -
  -	#if defined(XALAN_NO_STD_NAMESPACE)
  -	struct negativeFunction : public unary_function<const double&, double>
  -	#else
  -	struct negativeFunction : public std::unary_function<const double&, double>
  -	#endif
  -	{
  -		result_type
  -		operator()(argument_type	theDouble) const
  -		{
  -			return negative(theDouble);
  -		}
  -	};
  -
  -	/**
  -	 * Determine whether or not a string contains
  -	 * a valid floating point number.
  -	 *
  -	 * @param theString The string to check.
  -	 * @return true if the string is valid, false if not.
  -	 */
  -	static bool
  -	isValid(const XalanDOMString&	theString);
  -
  -	/**
  -	 * Determine whether or not a string contains
  -	 * a valid floating point number.
  -	 *
  -	 * @param theString The string to check.
  -	 * @return true if the string is valid, false if not.
  -	 */
  -	static bool
  -	isValid(const XalanDOMChar*		theString);
  -
  -	/**
  -	 * Convert a string to a double value.  Returns
  -	 * NaN if the string is not a valid floating
  -	 * point number.
  -	 *
  -	 * @param theString The string to convert.
  -	 * @return The result of the conversion
  -	 */
  -	static double
  -	toDouble(const XalanDOMString&	theString);
  -
  -	/**
  -	 * Convert a string to a double value.  Returns
  -	 * NaN if the string is not a valid floating
  -	 * point number.
  -	 *
  -	 * @param theString The string to convert.
  -	 * @return The result of the conversion
  -	 */
  -	static double
  -	toDouble(const XalanDOMChar*	theString);
  -
  -	/**
  -	 * Round a number according to the XPath
  -	 * rules.
  -	 *
  -	 * @param theValue The value to round.
  -	 * @return The result of the rounding
  -	 */
  -	static double
  -	round(double	theValue);
  -
  -	/**
  -	 * Returns the ceiling of a number according to the XPath
  -	 * rules.
  -	 *
  -	 * @param theValue The value to round.
  -	 * @return The result of the rounding
  -	 */
  -	static double
  -	ceiling(double	theValue)
  -	{
  +    /**
  +     * Perform static initialization.  See class PlatformSupportInit.
  +     */
  +    static void
  +    initialize();
  + 
  +    /**
  +     * Perform static shut down.  See class PlatformSupportInit.
  +     */
  +    static void
  +    terminate();
  +
  +
  +    // Use these functions to determine if a value represents one of these
  +    // specia values.  On some platforms, regular C/C++ operators don't work
  +    // as we need them too, so we have these helper functions.
  +
  +    /**
  +     * Determine if target is not a number
  +     * 
  +     * @param theNumber target number
  +     * @return true if target represents the "not a number" value
  +     */
  +    static bool
  +    isNaN(double    theNumber)
  +    {
  +        return s_NaN == theNumber;
  +    }
  +
  +    /**
  +     * Determine if target is positive infinity
  +     * 
  +     * @param theNumber target number
  +     * @return true if target represents the value for positive infinity
  +     */
  +    static bool
  +    isPositiveInfinity(double   theNumber)
  +    {
  +        return s_positiveInfinity == theNumber;
  +    }
  +
  +    /**
  +     * Determine if target is negative infinity
  +     * 
  +     * @param theNumber target number
  +     * @return true if target represents the value for negative infinity
  +     */
  +    static bool
  +    isNegativeInfinity(double   theNumber)
  +    {
  +        return s_negativeInfinity == theNumber;
  +    }
  +
  +    /**
  +     * Determine if target is positive 0.
  +     * 
  +     * @param theNumber target number
  +     * @return true if target represents the value for positive 0.
  +     */
  +    static bool
  +    isPositiveZero(double   theNumber)
  +    {
  +        return s_positiveZero == theNumber;
  +    }
  +
  +    /**
  +     * Determine if target is negative 0
  +     * 
  +     * @param theNumber target number
  +     * @return true if target represents the value for negative 0
  +     */
  +    static bool
  +    isNegativeZero(double   theNumber)
  +    {
  +        return s_negativeZero == theNumber;
  +    }
  +
  +    // These can be used to initialize values, but should not
  +    // be used to do equality comparisons, as == may fail on
  +    // some platforms.
  +    //
  +
  +    /**
  +     * Double value that represents "not a number"
  +     * 
  +     * @return "not a number" value
  +     */
  +    static double
  +    getNaN()
  +    {
  +        return s_NaN.d;
  +    }
  +
  +    /**
  +     * Double value that represents positive infinity
  +     * 
  +     * @return positive infinity value
  +     */
  +    static double
  +    getPositiveInfinity()
  +    {
  +        return s_positiveInfinity.d;
  +    }
  +
  +    /**
  +     * Double value that represents negative infinity
  +     * 
  +     * @return negative infinity value
  +     */
  +    static double
  +    getNegativeInfinity()
  +    {
  +        return s_negativeInfinity.d;
  +    }
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    equal(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    notEqual(
  +            double  theLHS,
  +            double  theRHS)
  +    {
  +        return !equal(theLHS, theRHS);
  +    }
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    lessThan(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    lessThanOrEqual(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    greaterThan(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Compare two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to compare
  +     * @param theRHS a number to compare
  +     * @return the result of the compare
  +     */
  +    static bool
  +    greaterThanOrEqual(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Add two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to add
  +     * @param theRHS a number to add
  +     * @return the result of the addition
  +     */
  +    static double
  +    add(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Subtract two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to subtract
  +     * @param theRHS a number to subtract
  +     * @return the result of the subtraction
  +     */
  +    static double
  +    subtract(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Multiply two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to multiply
  +     * @param theRHS a number to multiply
  +     * @return the result of the multiplication
  +     */
  +    static double
  +    multiply(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Divide two double values, taking into account
  +     * the fact that we must support IEEE 754
  +     *
  +     * @param theLHS a number to divide
  +     * @param theRHS a number to divide
  +     * @return the result of the division
  +     */
  +    static double
  +    divide(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Determine the modulus two double values,
  +     * taking into account the fact that we must
  +     * support IEEE 754
  +     *
  +     * @param theLHS a number to divide
  +     * @param theRHS a number to divide
  +     * @return the result of the modulus
  +     */
  +    static double
  +    modulus(
  +            double  theLHS,
  +            double  theRHS);
  +
  +    /**
  +     * Determine the negative of a double value,
  +     * taking into account the fact that we must
  +     * support IEEE 754
  +     *
  +     * @param theDouble a number to negate
  +     * @return the result of the negation
  +     */
  +    static double
  +    negative(double theDouble);
  +
  +    // Some functors to do the same thing.  This is for
  +    // STL integration...
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct equalFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct equalFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return equal(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct notEqualFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct notEqualFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return notEqual(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct lessThanFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct lessThanFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return lessThan(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct lessThanOrEqualFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct lessThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return lessThanOrEqual(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct greaterThanFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct greaterThanFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return greaterThan(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct greaterThanOrEqualFunction : public binary_function<const double&, const double&, bool>
  +    #else
  +    struct greaterThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return greaterThanOrEqual(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct addFunction : public binary_function<const double&, const double&, double>
  +    #else
  +    struct addFunction : public std::binary_function<const double&, const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return add(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct subtractFunction : public binary_function<const double&, const double&, double>
  +    #else
  +    struct subtractFunction : public std::binary_function<const double&, const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return subtract(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct multiplyFunction : public binary_function<const double&, const double&, double>
  +    #else
  +    struct multiplyFunction : public std::binary_function<const double&, const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return multiply(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct divideFunction : public binary_function<const double&, const double&, double>
  +    #else
  +    struct divideFunction : public std::binary_function<const double&, const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return divide(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct modulusFunction : public binary_function<const double&, const double&, double>
  +    #else
  +    struct modulusFunction : public std::binary_function<const double&, const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(
  +            first_argument_type     theLHS,
  +            second_argument_type    theRHS) const
  +        {
  +            return modulus(theLHS, theRHS);
  +        }
  +    };
  +
  +    #if defined(XALAN_NO_STD_NAMESPACE)
  +    struct negativeFunction : public unary_function<const double&, double>
  +    #else
  +    struct negativeFunction : public std::unary_function<const double&, double>
  +    #endif
  +    {
  +        result_type
  +        operator()(argument_type    theDouble) const
  +        {
  +            return negative(theDouble);
  +        }
  +    };
  +
  +    /**
  +     * Determine whether or not a string contains
  +     * a valid floating point number.
  +     *
  +     * @param theString The string to check.
  +     * @return true if the string is valid, false if not.
  +     */
  +    static bool
  +    isValid(const XalanDOMString&   theString);
  +
  +    /**
  +     * Determine whether or not a string contains
  +     * a valid floating point number.
  +     *
  +     * @param theString The string to check.
  +     * @return true if the string is valid, false if not.
  +     */
  +    static bool
  +    isValid(const XalanDOMChar*     theString);
  +
  +    /**
  +     * Convert a string to a double value.  Returns
  +     * NaN if the string is not a valid floating
  +     * point number.
  +     *
  +     * @param theString The string to convert.
  +     * @return The result of the conversion
  +     */
  +    static double
  +    toDouble(const XalanDOMString&  theString);
  +
  +    /**
  +     * Convert a string to a double value.  Returns
  +     * NaN if the string is not a valid floating
  +     * point number.
  +     *
  +     * @param theString The string to convert.
  +     * @return The result of the conversion
  +     */
  +    static double
  +    toDouble(const XalanDOMChar*    theString);
  +
  +    /**
  +     * Round a number according to the XPath
  +     * rules.
  +     *
  +     * @param theValue The value to round.
  +     * @return The result of the rounding
  +     */
  +    static double
  +    round(double    theValue);
  +
  +    /**
  +     * Returns the ceiling of a number according to the XPath
  +     * rules.
  +     *
  +     * @param theValue The value to round.
  +     * @return The result of the rounding
  +     */
  +    static double
  +    ceiling(double  theValue)
  +    {
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -		return std::ceil(theValue);
  +        return std::ceil(theValue);
   #else
  -		return ceil(theValue);
  +        return ceil(theValue);
   #endif
  -	}
  +    }
   
  -	/**
  -	 * Returns the floor of a number according to the XPath
  -	 * rules.
  -	 *
  -	 * @param theValue The value to round.
  -	 * @return The result of the rounding
  -	 */
  -	static double
  -	floor(double	theValue)
  -	{
  +    /**
  +     * Returns the floor of a number according to the XPath
  +     * rules.
  +     *
  +     * @param theValue The value to round.
  +     * @return The result of the rounding
  +     */
  +    static double
  +    floor(double    theValue)
  +    {
   #if defined(XALAN_STRICT_ANSI_HEADERS)
  -		return std::floor(theValue);
  +        return std::floor(theValue);
   #else
  -		return ::floor(theValue);
  +        return ::floor(theValue);
   #endif
  -	}
  +    }
   
  -	typedef union
  -	{
  -		double	d;
  -		struct
  -		{
  -			unsigned int	dw1;
  -			unsigned int	dw2;
  -		} dwords;
  -	} NumberUnion;
  +    typedef union
  +    {
  +        double  d;
  +        struct
  +        {
  +            unsigned int    dw1;
  +            unsigned int    dw2;
  +        } dwords;
  +
  +        bool
  +        operator==(double   theNumber) const
  +        {
  +            const NumberUnion   temp = { theNumber };
  +
  +            return dwords.dw1 == temp.dwords.dw1 &&
  +                   dwords.dw2 == temp.dwords.dw2;
  +        }
  +
  +    } NumberUnion;
   
   private:
   
  -	static const NumberUnion	s_NaN;
  -	static const double			s_positiveInfinity;
  -	static const double			s_negativeInfinity;
  -	static const NumberUnion	s_positiveZero;
  -	static const NumberUnion	s_negativeZero;
  +    static NumberUnion          s_NaN;
  +    static const NumberUnion    s_positiveInfinity;
  +    static const NumberUnion    s_negativeInfinity;
  +    static const NumberUnion    s_positiveZero;
  +    static const NumberUnion    s_negativeZero;
   };
   
   
  @@ -602,4 +615,4 @@
   
   
   
  -#endif	// DOUBLESUPPORT_HEADER_GUARD_1357924680
  +#endif  // DOUBLESUPPORT_HEADER_GUARD_1357924680
  
  
  
  1.6       +5 -0      xml-xalan/c/src/xalanc/PlatformSupport/PlatformSupportInit.cpp
  
  Index: PlatformSupportInit.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/xalanc/PlatformSupport/PlatformSupportInit.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- PlatformSupportInit.cpp	26 Feb 2004 22:34:18 -0000	1.5
  +++ PlatformSupportInit.cpp	29 Jul 2004 20:45:19 -0000	1.6
  @@ -18,6 +18,7 @@
   
   
   
  +#include "DoubleSupport.hpp"
   #include "XalanMessageLoader.hpp"
   #include "XalanTranscodingServices.hpp"
   
  @@ -59,6 +60,8 @@
   void
   PlatformSupportInit::initialize()
   {
  +    DoubleSupport::initialize();
  +
   	XalanMessageLoader::createLoader();
   
   	XalanTranscodingServices::initialize();
  @@ -72,6 +75,8 @@
   	XalanTranscodingServices::terminate();
   
   	XalanMessageLoader::destroyLoader();
  +
  +    DoubleSupport::terminate();
   }
   
   
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: xalan-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xalan-cvs-help@xml.apache.org


Mime
View raw message