dbertoni 02/04/29 21:41:33
Modified: c/src/XalanEXSLT XalanEXSLTMath.cpp XalanEXSLTMathImpl.hpp
XalanEXSLTString.cpp
Log:
Clean up and new implementation of math:constant().
Revision Changes Path
1.2 +323 -53 xml-xalan/c/src/XalanEXSLT/XalanEXSLTMath.cpp
Index: XalanEXSLTMath.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XalanEXSLT/XalanEXSLTMath.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanEXSLTMath.cpp 26 Apr 2002 06:51:13 -0000 1.1
+++ XalanEXSLTMath.cpp 30 Apr 2002 04:41:33 -0000 1.2
@@ -527,47 +527,306 @@
XalanUnicode::charLetter_S,
XalanUnicode::charLetter_Q,
XalanUnicode::charLetter_R,
- XalanUnicode::charLetter_T,
XalanUnicode::charLetter_R,
+ XalanUnicode::charLetter_T,
XalanUnicode::charDigit_2,
0
};
-const char XalanEXSLTFunctionConstant::s_eValueString[] =
- "2.71828182845904523536028747135266249775724709369996";
+const double XalanEXSLTFunctionConstant::s_eValues[] =
+{
+ 0.0L,
+ 2.7L,
+ 2.71L,
+ 2.718L,
+ 2.7182L,
+ 2.71828L,
+ 2.718281L,
+ 2.7182818L,
+ 2.71828182L,
+ 2.718281828L,
+ 2.7182818284L,
+ 2.71828182845L,
+ 2.718281828459L,
+ 2.7182818284590L,
+ 2.71828182845904L,
+ 2.718281828459045L,
+ 2.7182818284590452L,
+ 2.71828182845904523L,
+ 2.718281828459045235L,
+ 2.7182818284590452353L,
+ 2.71828182845904523536L,
+ 2.718281828459045235360L,
+ 2.7182818284590452353602L,
+ 2.71828182845904523536028L,
+ 2.718281828459045235360287L,
+ 2.7182818284590452353602874L,
+ 2.71828182845904523536028747L,
+ 2.718281828459045235360287471L,
+ 2.7182818284590452353602874713L,
+ 2.71828182845904523536028747135L,
+ 2.718281828459045235360287471352L,
+ 2.7182818284590452353602874713526L,
+ 2.71828182845904523536028747135266L,
+ 2.718281828459045235360287471352662L,
+ 2.7182818284590452353602874713526624L,
+ 2.71828182845904523536028747135266249L,
+ 2.718281828459045235360287471352662497L,
+ 2.7182818284590452353602874713526624977L,
+ 2.71828182845904523536028747135266249775L,
+ 2.718281828459045235360287471352662497757L,
+ 2.7182818284590452353602874713526624977572L,
+ 2.71828182845904523536028747135266249775724L,
+ 2.718281828459045235360287471352662497757247L,
+ 2.7182818284590452353602874713526624977572470L,
+ 2.71828182845904523536028747135266249775724709L,
+ 2.718281828459045235360287471352662497757247093L,
+ 2.7182818284590452353602874713526624977572470936L,
+ 2.71828182845904523536028747135266249775724709369L,
+ 2.718281828459045235360287471352662497757247093699L,
+ 2.7182818284590452353602874713526624977572470936999L,
+ 2.71828182845904523536028747135266249775724709369996L,
+};
-const char XalanEXSLTFunctionConstant::s_ln10ValueString[] =
- "2.302585092994046";
+const double XalanEXSLTFunctionConstant::s_ln10Values[] =
+{
+ 0.0L,
+ 2.3L,
+ 2.30L,
+ 2.302L,
+ 2.3025L,
+ 2.30258L,
+ 2.302585L,
+ 2.3025850L,
+ 2.30258509L,
+ 2.302585092L,
+ 2.3025850929L,
+ 2.30258509299L,
+ 2.302585092994L,
+ 2.3025850929940L,
+ 2.30258509299404L,
+ 2.302585092994046L
+};
-const char XalanEXSLTFunctionConstant::s_ln2ValueString[] =
- "0.69314718055994530941723212145817656807550013436025";
+const double XalanEXSLTFunctionConstant::s_ln2Values[] =
+{
+ 0.0L,
+ 0.6L,
+ 0.69L,
+ 0.693L,
+ 0.6931L,
+ 0.69314L,
+ 0.693147L,
+ 0.6931471L,
+ 0.69314718L,
+ 0.693147180L,
+ 0.6931471805L,
+ 0.69314718055L,
+ 0.693147180559L,
+ 0.6931471805599L,
+ 0.69314718055994L,
+ 0.693147180559945L,
+ 0.6931471805599453L,
+ 0.69314718055994530L,
+ 0.693147180559945309L,
+ 0.6931471805599453094L,
+ 0.69314718055994530941L,
+ 0.693147180559945309417L,
+ 0.6931471805599453094172L,
+ 0.69314718055994530941723L,
+ 0.693147180559945309417232L,
+ 0.6931471805599453094172321L,
+ 0.69314718055994530941723212L,
+ 0.693147180559945309417232121L,
+ 0.6931471805599453094172321214L,
+ 0.69314718055994530941723212145L,
+ 0.693147180559945309417232121458L,
+ 0.6931471805599453094172321214581L,
+ 0.69314718055994530941723212145817L,
+ 0.693147180559945309417232121458176L,
+ 0.6931471805599453094172321214581765L,
+ 0.69314718055994530941723212145817656L,
+ 0.693147180559945309417232121458176568L,
+ 0.6931471805599453094172321214581765680L,
+ 0.69314718055994530941723212145817656807L,
+ 0.693147180559945309417232121458176568075L,
+ 0.6931471805599453094172321214581765680755L,
+ 0.69314718055994530941723212145817656807550L,
+ 0.693147180559945309417232121458176568075500L,
+ 0.6931471805599453094172321214581765680755001L,
+ 0.69314718055994530941723212145817656807550013L,
+ 0.693147180559945309417232121458176568075500134L,
+ 0.6931471805599453094172321214581765680755001343L,
+ 0.69314718055994530941723212145817656807550013436L,
+ 0.693147180559945309417232121458176568075500134360L,
+ 0.6931471805599453094172321214581765680755001343602L,
+ 0.69314718055994530941723212145817656807550013436025L
+};
-const char XalanEXSLTFunctionConstant::s_log2EValueString[] =
- "1.4426950408889633";
+const double XalanEXSLTFunctionConstant::s_log2EValues[] =
+{
+ 0.0L,
+ 1.4L,
+ 1.44L,
+ 1.442L,
+ 1.4426L,
+ 1.44269L,
+ 1.442695L,
+ 1.4426950L,
+ 1.44269504L,
+ 1.442695040L,
+ 1.4426950408L,
+ 1.44269504088L,
+ 1.442695040888L,
+ 1.4426950408889L,
+ 1.44269504088896L,
+ 1.442695040888963L,
+ 1.4426950408889633L
+};
-const char XalanEXSLTFunctionConstant::s_piValueString[] =
- "3.1415926535897932384626433832795028841971693993751";
+const double XalanEXSLTFunctionConstant::s_piValues[] =
+{
+ 0.0L,
+ 3.1L,
+ 3.14L,
+ 3.141L,
+ 3.1415L,
+ 3.14159L,
+ 3.141592L,
+ 3.1415926L,
+ 3.14159265L,
+ 3.141592653L,
+ 3.1415926535L,
+ 3.14159265358L,
+ 3.141592653589L,
+ 3.1415926535897L, //
+ 3.14159265358979L,
+ 3.141592653589793L,
+ 3.1415926535897932L,
+ 3.14159265358979323L,
+ 3.141592653589793238L,
+ 3.1415926535897932384L,
+ 3.14159265358979323846L,
+ 3.141592653589793238462L,
+ 3.1415926535897932384626L,
+ 3.14159265358979323846264L,
+ 3.141592653589793238462643L,
+ 3.1415926535897932384626433L,
+ 3.14159265358979323846264338L,
+ 3.141592653589793238462643383L,
+ 3.1415926535897932384626433832L,
+ 3.14159265358979323846264338327L,
+ 3.141592653589793238462643383279L,
+ 3.1415926535897932384626433832795L,
+ 3.14159265358979323846264338327950L,
+ 3.141592653589793238462643383279502L,
+ 3.1415926535897932384626433832795028L,
+ 3.14159265358979323846264338327950288L,
+ 3.141592653589793238462643383279502884L,
+ 3.1415926535897932384626433832795028841L,
+ 3.14159265358979323846264338327950288419L,
+ 3.141592653589793238462643383279502884197L,
+ 3.1415926535897932384626433832795028841971L,
+ 3.14159265358979323846264338327950288419716L,
+ 3.141592653589793238462643383279502884197169L,
+ 3.1415926535897932384626433832795028841971693L,
+ 3.14159265358979323846264338327950288419716939L,
+ 3.141592653589793238462643383279502884197169399L,
+ 3.1415926535897932384626433832795028841971693993L,
+ 3.14159265358979323846264338327950288419716939937L,
+ 3.141592653589793238462643383279502884197169399375L,
+ 3.1415926535897932384626433832795028841971693993751L
+};
-const char XalanEXSLTFunctionConstant::s_sqrt1_2ValueString[] =
- "0.7071067811865476";
+const double XalanEXSLTFunctionConstant::s_sqrt1_2Values[] =
+{
+ 0.0L,
+ 0.7L,
+ 0.70L,
+ 0.707L,
+ 0.7071L,
+ 0.70710L,
+ 0.707106L,
+ 0.7071067L,
+ 0.70710678L,
+ 0.707106781L,
+ 0.7071067811L,
+ 0.70710678118L,
+ 0.707106781186L,
+ 0.7071067811865L,
+ 0.70710678118654L,
+ 0.707106781186547L,
+ 0.7071067811865476L
+};
-const char XalanEXSLTFunctionConstant::s_sqrt2ValueString[] =
- "1.41421356237309504880168872420969807856967187537694";
+const double XalanEXSLTFunctionConstant::s_sqrt2Values[] =
+{
+ 0.0L,
+ 1.4L,
+ 1.41L,
+ 1.414L,
+ 1.4142L,
+ 1.41421L,
+ 1.414213L,
+ 1.4142135L,
+ 1.41421356L,
+ 1.414213562L,
+ 1.4142135623L,
+ 1.41421356237L,
+ 1.414213562373L,
+ 1.4142135623730L,
+ 1.41421356237309L,
+ 1.414213562373095L,
+ 1.4142135623730950L,
+ 1.41421356237309504L,
+ 1.414213562373095048L,
+ 1.4142135623730950488L,
+ 1.41421356237309504880L,
+ 1.414213562373095048801L,
+ 1.4142135623730950488016L,
+ 1.41421356237309504880168L,
+ 1.414213562373095048801688L,
+ 1.4142135623730950488016887L,
+ 1.41421356237309504880168872L,
+ 1.414213562373095048801688724L,
+ 1.4142135623730950488016887242L,
+ 1.41421356237309504880168872420L,
+ 1.414213562373095048801688724209L,
+ 1.4142135623730950488016887242096L,
+ 1.41421356237309504880168872420969L,
+ 1.414213562373095048801688724209698L,
+ 1.4142135623730950488016887242096980L,
+ 1.41421356237309504880168872420969807L,
+ 1.414213562373095048801688724209698078L,
+ 1.4142135623730950488016887242096980785L,
+ 1.41421356237309504880168872420969807856L,
+ 1.414213562373095048801688724209698078569L,
+ 1.4142135623730950488016887242096980785696L,
+ 1.41421356237309504880168872420969807856967L,
+ 1.414213562373095048801688724209698078569671L,
+ 1.4142135623730950488016887242096980785696718L,
+ 1.41421356237309504880168872420969807856967187L,
+ 1.414213562373095048801688724209698078569671875L,
+ 1.4142135623730950488016887242096980785696718753L,
+ 1.41421356237309504880168872420969807856967187537L,
+ 1.414213562373095048801688724209698078569671875376L,
+ 1.4142135623730950488016887242096980785696718753769L,
+ 1.41421356237309504880168872420969807856967187537694L
+};
XObjectPtr
doConvert(
XPathExecutionContext& executionContext,
- const char* theValue,
+ const double theValues[],
size_t theSize,
double thePrecision)
{
return executionContext.getXObjectFactory().createNumber(
- DoubleSupport::toDouble(
- XalanDOMString(theValue,
XalanDOMString::size_type(thePrecision <= theSize ? thePrecision : theSize))));
+ theValues[XalanDOMString::size_type(thePrecision <= theSize ?
thePrecision : theSize)]);
}
@@ -589,54 +848,65 @@
const XalanDOMString& theConstant = args[0]->str();
const double thePrecision =
DoubleSupport::round(args[1]->num());
- if (equals(
- s_eString,
- theConstant.c_str(),
- sizeof(s_eString) / sizeof(s_eString[0]) - 1) == true)
+ if (thePrecision <= 0.0L)
+ {
+ return
executionContext.getXObjectFactory().createNumber(DoubleSupport::getNaN());
+ }
+ else if (equals(s_eString, theConstant) == true)
{
- return doConvert(executionContext, s_eValueString,
sizeof(s_eValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_eValues,
+ sizeof(s_eValues) / sizeof(s_eValues[0]),
+ thePrecision);
}
- else if (equals(
- s_ln10String,
- theConstant.c_str(),
- sizeof(s_ln10String) / sizeof(s_ln10String[0]) - 1) ==
true)
+ else if (equals(s_ln10String, theConstant) == true)
{
- return doConvert(executionContext, s_ln10ValueString,
sizeof(s_ln10ValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_ln10Values,
+ sizeof(s_ln10Values) / sizeof(s_ln10Values[0]),
+ thePrecision);
}
- else if (equals(
- s_ln2String,
- theConstant.c_str(),
- sizeof(s_ln2String) / sizeof(s_ln2String[0]) - 1) ==
true)
+ else if (equals(s_ln2String, theConstant) == true)
{
- return doConvert(executionContext, s_ln2ValueString,
sizeof(s_ln2ValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_ln2Values,
+ sizeof(s_ln2Values) / sizeof(s_ln2Values[0]),
+ thePrecision);
}
- else if (equals(
- s_log2EString,
- theConstant.c_str(),
- sizeof(s_log2EString) / sizeof(s_log2EString[0]) - 1)
== true)
+ else if (equals(s_log2EString, theConstant) == true)
{
- return doConvert(executionContext, s_log2EValueString,
sizeof(s_log2EValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_log2EValues,
+ sizeof(s_log2EValues) / sizeof(s_log2EValues[0]),
+ thePrecision);
}
- else if (equals(
- s_piString,
- theConstant.c_str(),
- sizeof(s_piString) / sizeof(s_piString[0]) - 1) ==
true)
+ else if (equals(s_piString, theConstant) == true)
{
- return doConvert(executionContext, s_piValueString,
sizeof(s_piValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_piValues,
+ sizeof(s_piValues) / sizeof(s_piValues[0]),
+ thePrecision);
}
- else if (equals(
- s_sqrt1_2String,
- theConstant.c_str(),
- sizeof(s_sqrt1_2String) / sizeof(s_sqrt1_2String[0]) -
1) == true)
+ else if (equals(s_sqrt1_2String, theConstant) == true)
{
- return doConvert(executionContext, s_sqrt1_2ValueString,
sizeof(s_sqrt1_2ValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_sqrt1_2Values,
+ sizeof(s_sqrt1_2Values) / sizeof(s_sqrt1_2Values[0]),
+ thePrecision);
}
- else if (equals(
- s_sqrt2String,
- theConstant.c_str(),
- sizeof(s_sqrt2String) / sizeof(s_sqrt2String[0]) - 1)
== true)
+ else if (equals(s_sqrt2String, theConstant) == true)
{
- return doConvert(executionContext, s_sqrt2ValueString,
sizeof(s_sqrt2ValueString) - 1, thePrecision);
+ return doConvert(
+ executionContext,
+ s_sqrt2Values,
+ sizeof(s_sqrt2Values) / sizeof(s_sqrt2Values[0]),
+ thePrecision);
}
else
{
1.2 +7 -7 xml-xalan/c/src/XalanEXSLT/XalanEXSLTMathImpl.hpp
Index: XalanEXSLTMathImpl.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XalanEXSLT/XalanEXSLTMathImpl.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanEXSLTMathImpl.hpp 26 Apr 2002 06:51:13 -0000 1.1
+++ XalanEXSLTMathImpl.hpp 30 Apr 2002 04:41:33 -0000 1.2
@@ -362,13 +362,13 @@
static const XalanDOMChar s_sqrt1_2String[];
static const XalanDOMChar s_sqrt2String[];
- static const char s_eValueString[];
- static const char s_ln10ValueString[];
- static const char s_ln2ValueString[];
- static const char s_log2EValueString[];
- static const char s_piValueString[];
- static const char s_sqrt1_2ValueString[];
- static const char s_sqrt2ValueString[];
+ static const double s_eValues[];
+ static const double s_ln10Values[];
+ static const double s_ln2Values[];
+ static const double s_log2EValues[];
+ static const double s_piValues[];
+ static const double s_sqrt1_2Values[];
+ static const double s_sqrt2Values[];
// Not implemented...
1.2 +1 -773 xml-xalan/c/src/XalanEXSLT/XalanEXSLTString.cpp
Index: XalanEXSLTString.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XalanEXSLT/XalanEXSLTString.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanEXSLTString.cpp 26 Apr 2002 06:51:13 -0000 1.1
+++ XalanEXSLTString.cpp 30 Apr 2002 04:41:33 -0000 1.2
@@ -279,7 +279,7 @@
if (thePaddingStringLength == 1)
{
- theResult.assign(theLength, thePaddingString[0]);
+ theResult.assign(XalanDOMString::size_type(theLength),
thePaddingString[0]);
}
else
{
@@ -307,780 +307,8 @@
return executionContext.getXObjectFactory().createString(theResult);
}
-#if 0
- const XalanDOMString::size_type theTargetStringLength =
theTargetString.length();
-
- if (theTargetStringLength == thePaddingStringLength)
- {
- return XObjectPtr(args[0]);
- }
- else
- {
- if (theTargetStringLength > thePaddingStringLength)
- {
- theResult.assign(theTargetString, 0, thePaddingStringLength);
- }
- else
- {
- theResult.reserve(thePaddingStringLength);
-
- enum eAlignment { eCenter, eLeft, eRight };
-
- eAlignment theAlignment = eLeft;
-
- if (theSize == 3)
- {
- const XalanDOMString& theAlignmentString =
args[2]->str();
-
- if (equals(
- s_centerString,
- theAlignmentString.c_str(),
- sizeof(s_centerString) /
sizeof(s_centerString[0]) - 1) == true)
- {
- theAlignment = eCenter;
- }
- else if (equals(
- s_rightString,
- theAlignmentString.c_str(),
- sizeof(s_rightString) /
sizeof(s_rightString[0]) - 1) == true)
- {
- theAlignment = eRight;
- }
- }
-
- if (theAlignment == eLeft)
- {
- theResult = theTargetString;
-
- theResult.append(thePaddingString,
theTargetStringLength, thePaddingStringLength - theTargetStringLength);
- }
- else if (theAlignment == eRight)
- {
- theResult.assign(thePaddingString, 0,
thePaddingStringLength - theTargetStringLength);
- theResult.append(theTargetString);
- }
- else if (theAlignment == eCenter)
- {
- const XalanDOMString::size_type theStartIndex =
- (thePaddingStringLength -
theTargetStringLength) / 2;
-
- theResult.assign(thePaddingString, 0, theStartIndex);
-
- theResult.append(theTargetString);
-
- theResult.append(
- thePaddingString,
- theTargetStringLength + theStartIndex,
- thePaddingStringLength - theTargetStringLength
- theStartIndex);
- }
- }
- }
-#endif
-}
-
-
-
-#if 0
-const XalanDOMString
-XalanEXSLTFunctionHighest::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT highest()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionLowest::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
- return findNodes(executionContext, args[0]->nodeset(),
DoubleSupport::lessThan);
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionLowest::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT lowest()
function accepts one argument"));
-}
-
-
-
-template<class FunctionType>
-XObjectPtr
-findValue(
- XPathExecutionContext& executionContext,
- const NodeRefListBase& theNodeSet,
- FunctionType theCompareFunction)
-{
- const NodeRefListBase::size_type theLength = theNodeSet.getLength();
-
- if (theLength == 0)
- {
- return
executionContext.getXObjectFactory().createNumber(DoubleSupport::getNaN());
- }
- else
- {
- const XPathExecutionContext::GetAndReleaseCachedString
theGuard(executionContext);
-
- XalanDOMString& theStringValue = theGuard.get();
-
- assert(theNodeSet.item(0) != 0);
-
- DOMServices::getNodeData(*theNodeSet.item(0), theStringValue);
-
- double theResult = DOMStringToDouble(theStringValue);
-
- for (NodeRefListBase::size_type i = 1; i < theLength; ++i)
- {
- assert(theNodeSet.item(i) != 0);
-
- DOMServices::getNodeData(*theNodeSet.item(i), theStringValue);
-
- const double theCurrent = DOMStringToDouble(theStringValue);
-
- if (DoubleSupport::isNaN(theCurrent) == true)
- {
- theResult = theCurrent;
-
- break;
- }
- else if (theCompareFunction(theCurrent, theResult) == true)
- {
- theResult = theCurrent;
- }
-
- theStringValue.clear();
- }
-
- return executionContext.getXObjectFactory().createNumber(theResult);
- }
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionMin::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
- return findValue(executionContext, args[0]->nodeset(),
DoubleSupport::lessThan);
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionMin::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT min()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionMax::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
- return findValue(executionContext, args[0]->nodeset(),
DoubleSupport::greaterThan);
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionMax::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT max()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionAbs::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::fabs;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(fabs(args[0]->num()));
}
-
-
-const XalanDOMString
-XalanEXSLTFunctionAbs::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT abs()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionAcos::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::acos;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(acos(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionAcos::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT acos()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionAsin::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::asin;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(asin(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionAsin::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT asin()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionAtan::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::atan;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(atan(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionAtan::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT atan()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionAtan2::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 2)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false && args[1].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::atan2;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(atan2(args[0]->num(),
args[1]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionAtan2::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT atan2()
function accepts two arguments"));
-}
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_eString[] =
-{
- XalanUnicode::charLetter_E,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_ln10String[] =
-{
- XalanUnicode::charLetter_L,
- XalanUnicode::charLetter_N,
- XalanUnicode::charDigit_1,
- XalanUnicode::charDigit_0,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_ln2String[] =
-{
- XalanUnicode::charLetter_L,
- XalanUnicode::charLetter_N,
- XalanUnicode::charDigit_2,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_log2EString[] =
-{
- XalanUnicode::charLetter_L,
- XalanUnicode::charLetter_O,
- XalanUnicode::charLetter_G,
- XalanUnicode::charDigit_2,
- XalanUnicode::charLetter_E,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_piString[] =
-{
- XalanUnicode::charLetter_P,
- XalanUnicode::charLetter_I,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_sqrt1_2String[] =
-{
- XalanUnicode::charLetter_S,
- XalanUnicode::charLetter_Q,
- XalanUnicode::charLetter_R,
- XalanUnicode::charLetter_T,
- XalanUnicode::charDigit_1,
- XalanUnicode::charLowLine,
- XalanUnicode::charDigit_2,
- 0
-};
-
-
-
-const XalanDOMChar XalanEXSLTFunctionConstant::s_sqrt2String[] =
-{
- XalanUnicode::charLetter_S,
- XalanUnicode::charLetter_Q,
- XalanUnicode::charLetter_R,
- XalanUnicode::charLetter_T,
- XalanUnicode::charLetter_R,
- XalanUnicode::charDigit_2,
- 0
-};
-
-
-
-const char XalanEXSLTFunctionConstant::s_eValueString[] =
- "2.71828182845904523536028747135266249775724709369996";
-
-const char XalanEXSLTFunctionConstant::s_ln10ValueString[] =
- "2.302585092994046";
-
-const char XalanEXSLTFunctionConstant::s_ln2ValueString[] =
- "0.69314718055994530941723212145817656807550013436025";
-
-const char XalanEXSLTFunctionConstant::s_log2EValueString[] =
- "1.4426950408889633";
-
-const char XalanEXSLTFunctionConstant::s_piValueString[] =
- "3.1415926535897932384626433832795028841971693993751";
-
-const char XalanEXSLTFunctionConstant::s_sqrt1_2ValueString[] =
- "0.7071067811865476";
-
-const char XalanEXSLTFunctionConstant::s_sqrt2ValueString[] =
- "1.41421356237309504880168872420969807856967187537694";
-
-
-
-XObjectPtr
-doConvert(
- XPathExecutionContext& executionContext,
- const char* theValue,
- size_t theSize,
- double thePrecision)
-{
- return executionContext.getXObjectFactory().createNumber(
- DoubleSupport::toDouble(
- XalanDOMString(theValue,
XalanDOMString::size_type(thePrecision <= theSize ? thePrecision : theSize))));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionConstant::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 2)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false && args[1].null() == false);
-
- const XalanDOMString& theConstant = args[0]->str();
- const double thePrecision =
DoubleSupport::round(args[1]->num());
-
- if (equals(
- s_eString,
- theConstant.c_str(),
- sizeof(s_eString) / sizeof(s_eString[0]) - 1) == true)
- {
- return doConvert(executionContext, s_eValueString,
sizeof(s_eValueString) - 1, thePrecision);
- }
- else if (equals(
- s_ln10String,
- theConstant.c_str(),
- sizeof(s_ln10String) / sizeof(s_ln10String[0]) - 1) ==
true)
- {
- return doConvert(executionContext, s_ln10ValueString,
sizeof(s_ln10ValueString) - 1, thePrecision);
- }
- else if (equals(
- s_ln2String,
- theConstant.c_str(),
- sizeof(s_ln2String) / sizeof(s_ln2String[0]) - 1) ==
true)
- {
- return doConvert(executionContext, s_ln2ValueString,
sizeof(s_ln2ValueString) - 1, thePrecision);
- }
- else if (equals(
- s_log2EString,
- theConstant.c_str(),
- sizeof(s_log2EString) / sizeof(s_log2EString[0]) - 1)
== true)
- {
- return doConvert(executionContext, s_log2EValueString,
sizeof(s_log2EValueString) - 1, thePrecision);
- }
- else if (equals(
- s_piString,
- theConstant.c_str(),
- sizeof(s_piString) / sizeof(s_piString[0]) - 1) ==
true)
- {
- return doConvert(executionContext, s_piValueString,
sizeof(s_piValueString) - 1, thePrecision);
- }
- else if (equals(
- s_sqrt1_2String,
- theConstant.c_str(),
- sizeof(s_sqrt1_2String) / sizeof(s_sqrt1_2String[0]) -
1) == true)
- {
- return doConvert(executionContext, s_sqrt1_2ValueString,
sizeof(s_sqrt1_2ValueString) - 1, thePrecision);
- }
- else if (equals(
- s_sqrt2String,
- theConstant.c_str(),
- sizeof(s_sqrt2String) / sizeof(s_sqrt2String[0]) - 1)
== true)
- {
- return doConvert(executionContext, s_sqrt2ValueString,
sizeof(s_sqrt2ValueString) - 1, thePrecision);
- }
- else
- {
- return
executionContext.getXObjectFactory().createNumber(DoubleSupport::getNaN());
- }
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionCos::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::cos;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(cos(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionCos::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT cos()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionExp::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::exp;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(exp(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionExp::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT exp()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionLog::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::log;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(log(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionLog::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT log()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionPower::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 2)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false && args[1].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::pow;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(pow(args[0]->num(),
args[1]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionPower::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT power()
function accepts two arguments"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionSin::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::sin;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(sin(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionSin::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT sin()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionSqrt::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::sqrt;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(sqrt(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionSqrt::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT sqrt()
function accepts one argument"));
-}
-
-
-
-XObjectPtr
-XalanEXSLTFunctionTan::execute(
- XPathExecutionContext& executionContext,
- XalanNode*
context,
- const XObjectArgVectorType& args,
- const Locator* locator) const
-{
- if (args.size() != 1)
- {
- executionContext.error(getError(), context, locator);
- }
-
- assert(args[0].null() == false);
-
-#if defined(XALAN_STRICT_ANSI_HEADERS)
- using std::tan;
-#endif
-
- return executionContext.getXObjectFactory().createNumber(tan(args[0]->num()));
-}
-
-
-
-const XalanDOMString
-XalanEXSLTFunctionTan::getError() const
-{
- return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXSLT tan()
function accepts one argument"));
-}
-#endif
static const XalanDOMChar s_stringNamespace[] =
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
