XObjectPtr
FunctionFormatNumber::execute(
XPathExecutionContext& executionContext,
XalanNode* context,
const XObjectPtr arg1,
const XObjectPtr arg2,
const XObjectPtr arg3,
const LocatorType* locator) const
{
assert(arg1.null() == false && arg2.null() == false && arg3.null() == false);
const double theNumber = arg1->num();
const XalanDOMString& thePattern = arg2->str();
const XalanDOMString& theDFSName = arg3->str();
assert(length(theDFSName) != 0);
typedef XPathExecutionContext::GetAndReleaseCachedString GetAndReleaseCachedString;
GetAndReleaseCachedString theString(executionContext);
executionContext.formatNumber(
theNumber,
thePattern,
theDFSName,
theString.get(),
context,
locator);
return executionContext.getXObjectFactory().createString(theString);
}
XObjectPtr
FunctionSubstringBefore::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const XObjectPtr arg2,
const LocatorType* /* locator */) const
{
assert(arg1.null() == false && arg2.null() == false);
const XalanDOMString& theFirstString = arg1->str();
const XalanDOMString::size_type theFirstStringLength = length(theFirstString);
if (theFirstStringLength == 0)
{
return createEmptyString(executionContext);
}
else
{
const XalanDOMString& theSecondString = arg2->str();
const XalanDOMString::size_type theSecondStringLength = length(theSecondString);
if (theSecondStringLength == 0)
{
return createEmptyString(executionContext);
}
else
{
const XalanDOMString::size_type theIndex = indexOf(theFirstString,
theSecondString);
if (theIndex == theFirstStringLength)
{
return createEmptyString(executionContext);
}
else
{
XPathExecutionContext::GetAndReleaseCachedString theResult(executionContext);
XalanDOMString& theString = theResult.get();
theString.assign(
toCharArray(theFirstString),
theIndex);
// Create a string of the appropriate length...
return executionContext.getXObjectFactory().createString(theResult);
}
}
}
}
bool
TestStringResult(
XPathProcessor& theXPathProcessor,
XPath& theXPath,
XPathConstructionContext& theXPathConstructionContext,
const XalanDOMString& theXPathString,
PrintWriter& thePrintWriter,
const XalanDOMString& theExpectedResult,
XalanNode* theContextNode,
const PrefixResolver& thePrefixResolver,
const NodeRefListBase& theContextNodeList,
XPathExecutionContext& theExecutionContext)
{
bool fError = false;
const XObjectPtr theResult =
ExecuteXPath(
theXPathProcessor,
theXPathConstructionContext,
theXPath,
theXPathString,
theContextNode,
thePrefixResolver,
theContextNodeList,
theExecutionContext);
thePrintWriter.print("Execution of XPath ");
thePrintWriter.print(theXPathString);
if (equals(theResult->str(), theExpectedResult) == true)
{
thePrintWriter.println(" succeeded.");
thePrintWriter.print("The result was \"");
thePrintWriter.print(theResult->str());
thePrintWriter.println("\".");
}
else
{
fError = true;
thePrintWriter.println(" failed!");
thePrintWriter.print("The expected result was \"");
thePrintWriter.print(theExpectedResult);
thePrintWriter.println("\".");
thePrintWriter.print("The actual result was \"");
thePrintWriter.print(theResult->str());
thePrintWriter.println("\".");
}
return fError;
}
XObjectPtr CExternalFunction::execute( XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const Locator* /* locator */) const
{
assert(arg1.null() == false);
const XalanDOMString& arg = arg1->str();
//convert XalanDOMString (implemented as unsigned short*) into StringBuffer
StringBuffer sbInput;
sbInput.ensureCapacity(arg.length()+1);
size32_t len = arg.length();
for (size32_t i=0; i < len; i++)
sbInput.append( (char) arg[i]);
StringBuffer sbOutput;
try
{
(*m_userFunction)(sbOutput, sbInput.str(), m_pTransform);
}
catch (IException* e)
{
StringBuffer msg;
e->errorMessage(msg);
e->Release();
}
catch (...)
{
}
XalanDOMString xdsOutput( sbOutput.str() );
return executionContext.getXObjectFactory().createString( xdsOutput );
}
XObjectPtr
FunctionStartsWith::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const XObjectPtr arg2,
const Locator* const /* locator */) const
{
assert(arg1.null() == false && arg2.null() == false);
const bool fStartsWith =
startsWith(
arg1->str(executionContext),
arg2->str(executionContext));
return executionContext.getXObjectFactory().createBoolean(fStartsWith);
}
XObjectPtr
FunctionLang::execute(
XPathExecutionContext& executionContext,
XalanNode* context,
const XObjectPtr arg1,
const LocatorType* /* locator */) const
{
assert(arg1.null() == false);
const XalanNode* parent = context;
bool fMatch = false;
const XalanDOMString& lang = arg1->str();
while(0 != parent)
{
if(XalanNode::ELEMENT_NODE == parent->getNodeType())
{
const XalanElement* const theElementNode =
#if defined(XALAN_OLD_STYLE_CASTS)
(const XalanElement*)parent;
#else
static_cast<const XalanElement*>(parent);
#endif
const XalanDOMString& langVal =
theElementNode->getAttributeNS(
DOMServices::s_XMLNamespaceURI,
s_attributeName);
if(0 != length(langVal))
{
XPathExecutionContext::GetAndReleaseCachedString theGuard1(executionContext);
XPathExecutionContext::GetAndReleaseCachedString theGuard2(executionContext);
if(startsWith(toLowerCaseASCII(langVal, theGuard1.get()), toLowerCaseASCII(lang, theGuard2.get())))
{
const XalanDOMString::size_type valLen = length(lang);
if(length(langVal) == valLen ||
charAt(langVal, valLen) == XalanUnicode::charHyphenMinus)
{
fMatch = true;
break;
}
}
}
}
parent = DOMServices::getParentOfNode(*parent);
}
return executionContext.getXObjectFactory().createBoolean(fMatch);
}
XObjectPtr
FunctionElementAvailable::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const LocatorType* locator) const
{
assert(arg1.null() == false);
return executionContext.getXObjectFactory().createBoolean(
executionContext.elementAvailable(arg1->str(), locator));
}
XObjectPtr
FunctionSample::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const XObjectPtr arg2,
const Locator* /* locator */) const
{
assert(arg1.null() == false);
assert(arg2.null() == false);
XalanDOMString path;
arg1->str(path);
const bool bLinux = arg2->boolean();
XalanDOMChar dchOld;
XalanDOMChar dchNew;
if (bLinux)
{
dchOld = '\\';
dchNew = '/';
}
else
{
dchOld = '/';
dchOld = '\\';
}
int len = path.length();
for (int i=0; i<len; i++)
if (path[i] == dchOld)
path[i] = dchNew;
return executionContext.getXObjectFactory().createString(path);
}
XObjectPtr
FunctionSubstring::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const XObjectPtr arg2,
const XObjectPtr arg3,
const LocatorType* /* locator */) const
{
assert(arg1.null() == false && arg2.null() == false);
const XalanDOMString& theSourceString = arg1->str();
const XalanDOMString::size_type theSourceStringLength = length(theSourceString);
if (theSourceStringLength == 0)
{
return createEmptyString(executionContext);
}
else
{
// Get the value of the second argument...
const double theSecondArgValue =
DoubleSupport::round(arg2->num());
// XPath indexes from 1, so this is the first XPath index....
const XalanDOMString::size_type theStartIndex = getStartIndex(theSecondArgValue, theSourceStringLength);
if (theStartIndex >= theSourceStringLength)
{
return createEmptyString(executionContext);
}
else
{
const double theTotal =
getTotal(theSourceStringLength, theSecondArgValue, arg3);
if (DoubleSupport::isNaN(theSecondArgValue) == true ||
DoubleSupport::isNaN(theTotal) == true ||
DoubleSupport::isNegativeInfinity(theTotal) == true ||
theTotal == 0.0 ||
theTotal < double(theStartIndex))
{
return createEmptyString(executionContext);
}
else
{
const XalanDOMString::size_type theSubstringLength =
getSubstringLength(
theSourceStringLength,
theStartIndex,
theTotal);
XPathExecutionContext::GetAndReleaseCachedString theResult(executionContext);
XalanDOMString& theString = theResult.get();
assign(
theString,
toCharArray(theSourceString) + theStartIndex,
theSubstringLength);
return executionContext.getXObjectFactory().createString(theResult);
}
}
}
}
XObjectPtr
FunctionSubstringAfter::execute(
XPathExecutionContext& executionContext,
XalanNode* /* context */,
const XObjectPtr arg1,
const XObjectPtr arg2,
const LocatorType* /* locator */) const
{
assert(arg1.null() == false && arg2.null() == false);
const XalanDOMString& theFirstString = arg1->str();
const XalanDOMString::size_type theFirstStringLength = length(theFirstString);
if (theFirstStringLength == 0)
{
return createEmptyString(executionContext);
}
else
{
const XalanDOMString& theSecondString = arg2->str();
const XalanDOMString::size_type theSecondStringLength = length(theSecondString);
if (theSecondStringLength == 0)
{
return arg1;
}
else
{
const XalanDOMString::size_type theIndex = indexOf(theFirstString,
theSecondString);
if (theIndex == theFirstStringLength)
{
return createEmptyString(executionContext);
}
else
{
const XalanDOMString::size_type theSecondStringLength = length(theSecondString);
// Find the first character, which will be the offset of the index of the
// beginning of the second string, plus the length of the second string.
const XalanDOMChar* const theFirstCharacter =
toCharArray(theFirstString) + theIndex + theSecondStringLength;
// The remaining length is just the opposite -- the length of the string,
// minus the index, minus the length of the second string.
const XalanDOMString::size_type theSubstringLength =
theFirstStringLength - theIndex - theSecondStringLength;
XPathExecutionContext::GetAndReleaseCachedString theResult(executionContext);
XalanDOMString& theString = theResult.get();
assign(
theString,
theFirstCharacter,
theSubstringLength);
return executionContext.getXObjectFactory().createString(theResult);
}
}
}
}
bool
TestPredicateResult(
XPathProcessor& theXPathProcessor,
XPathEnvSupport& theXPathEnvSupport,
DOMSupport& theDOMSupport,
XMLParserLiaison& theLiaison,
XPathFactory& theXPathFactory,
const XalanDOMString& theXMLFileURL,
const XalanDOMString& theXSLFileURL,
PrintWriter& thePrintWriter,
XPathExecutionContext& theExecutionContext)
{
bool fError = false;
XalanDocument* const theXMLDocument =
ParseXML(theLiaison,
theXMLFileURL);
MemoryManagerType& theMemoryManager =
theExecutionContext.getMemoryManager();
if (theXMLDocument != 0)
{
XalanDOMString theContextNodeMatchPattern(theMemoryManager);
XalanDOMString theXPathString(theMemoryManager);
if (GetXSLInput(theLiaison,
theXSLFileURL,
theContextNodeMatchPattern,
theXPathString,
theMemoryManager) == true)
{
XalanNode* const theContextNode =
FindContextNode(theXPathProcessor,
theXPathEnvSupport,
theDOMSupport,
theXPathFactory,
theXMLDocument,
theContextNodeMatchPattern,
thePrintWriter,
theExecutionContext);
if (theContextNode != 0)
{
XalanElement* const theNamespaceContext = 0;
ElementPrefixResolverProxy thePrefixResolver(theNamespaceContext, theXPathEnvSupport, theDOMSupport);
NodeRefList theContextNodeList(theMemoryManager);
XPath* const theXPath1 = theXPathFactory.create();
XPathConstructionContextDefault theXPathConstructionContext(theMemoryManager);
XPathGuard theGuard1(theXPathFactory,
theXPath1);
XalanDOMString theResult(theMemoryManager);
theXPathProcessor.initXPath(*theXPath1,
theXPathConstructionContext,
TranscodeFromLocalCodePage("following-sibling::*", theResult),
thePrefixResolver);
XPath* const theXPath2 = theXPathFactory.create();
XPathGuard theGuard2(theXPathFactory,
theXPath2);
theXPathProcessor.initXPath(*theXPath2,
theXPathConstructionContext,
TranscodeFromLocalCodePage("descendant::*", theResult),
thePrefixResolver);
bool fDump = false;
if (fDump == true)
{
thePrintWriter.println();
thePrintWriter.println();
theXPath1->getExpression().dumpOpCodeMap(thePrintWriter);
thePrintWriter.println();
theXPath1->getExpression().dumpTokenQueue(thePrintWriter);
thePrintWriter.println();
thePrintWriter.println();
theXPath2->getExpression().dumpOpCodeMap(thePrintWriter);
thePrintWriter.println();
theXPath2->getExpression().dumpTokenQueue(thePrintWriter);
thePrintWriter.println();
thePrintWriter.println();
}
XalanNode* theContextNode = theXMLDocument->getFirstChild()->getFirstChild();
for( ; theContextNode != 0; theContextNode = theContextNode->getNextSibling())
{
if (theContextNode->getNodeType() != XalanNode::ELEMENT_NODE)
{
continue;
}
const XObjectPtr theResult1 =
theXPath1->execute(theExecutionContext);
try
{
assert(theResult1.null() == false);
const NodeRefListBase& theResultList =
theResult1->nodeset();
const unsigned int theLength = theResultList.getLength();
thePrintWriter.print("theResult1->str() == \"");
thePrintWriter.print(theResult1->str());
thePrintWriter.print("\"");
thePrintWriter.println();
if (theLength > 0)
{
for (unsigned int i = 0; i < theLength; i++)
{
thePrintWriter.print(theResultList.item(i)->getNodeName());
thePrintWriter.println();
}
}
}
catch(...)
{
thePrintWriter.print("Execution of XPath ");
thePrintWriter.print(theXPathString);
thePrintWriter.println(" failed!");
}
const XObjectPtr theResult2 =
theXPath2->execute(theExecutionContext);
try
{
assert(theResult2.null() == false);
const NodeRefListBase& theResultList =
theResult2->nodeset();
const int theLength = theResultList.getLength();
thePrintWriter.print("theResult2->str() == \"");
thePrintWriter.print(theResult2->str());
thePrintWriter.print("\"");
thePrintWriter.println();
if (theLength > 0)
{
for (int i = 0; i < theLength; i++)
{
thePrintWriter.print(theResultList.item(i)->getNodeName());
thePrintWriter.println();
}
}
}
catch(...)
{
thePrintWriter.print("Execution of XPath ");
thePrintWriter.print(theXPathString);
thePrintWriter.println(" failed!");
}
if (theResult1->equals(*theResult2, theExecutionContext) == true)
{
thePrintWriter.print("theResult1 is equal to theResult2");
thePrintWriter.println();
thePrintWriter.print("theContextNode->getNodeName() == \"");
thePrintWriter.print(theContextNode->getNodeName());
thePrintWriter.print("\" theContextNode->getNodeValue() == \"");
thePrintWriter.print(theContextNode->getNodeValue());
thePrintWriter.println("\"");
}
}
}
}
}
return fError;
}