TranscodeFromLocalCodePage(
const CharVectorType& theSourceString,
XalanDOMString& result)
{
if (theSourceString.empty() == true)
{
result.erase();
return result;
}
else
{
typedef XalanDOMString::size_type size_type;
const CharVectorType::size_type theSize = theSourceString.size();
if (theSourceString[theSize - 1] == CharVectorType::value_type(0))
{
return TranscodeFromLocalCodePage(&*theSourceString.begin(), result , size_type(theSize) - 1);
}
else
{
return TranscodeFromLocalCodePage(&*theSourceString.begin(), result , size_type(theSize));
}
}
}
inline void
doTranscode(
const char* theString,
XalanDOMString::size_type theCount,
bool theSourceStringIsNullTerminated,
XalanDOMCharVectorType& theVector,
bool fTerminate)
{
assert(theString != 0);
if (theCount == XalanDOMString::size_type(XalanDOMString::npos))
{
if (TranscodeFromLocalCodePage(
theString,
theVector,
fTerminate) == false)
{
throw XalanDOMString::TranscodingError();
}
}
else
{
if (TranscodeFromLocalCodePage(
theString,
theCount,
theSourceStringIsNullTerminated,
theVector,
fTerminate) == false)
{
throw XalanDOMString::TranscodingError();
}
}
}
void
TestStringResults(
XPathFactory& theXPathFactory,
XPathProcessor& theXPathProcessor,
XPathEnvSupport& theXPathEnvSupport,
DOMSupport& theDOMSupport,
PrintWriter& thePrintWriter,
XPathExecutionContext& theExecutionContext)
{
assert(sizeof(theStringTestInput) == sizeof(theStringTestExpectedOutput));
MemoryManagerType& theMemoryManager =
theExecutionContext.getMemoryManager();
for(int i = 0; theStringTestInput[i] != 0; i++)
{
try
{
XPath* const theXPath = theXPathFactory.create();
XPathConstructionContextDefault theXPathConstructionContext(theMemoryManager);
const XPathGuard theGuard(
theXPathFactory,
theXPath);
XalanDOMString theInputString(theMemoryManager);
XalanDOMString theResult(theMemoryManager);
const ElementPrefixResolverProxy thePrefixResolver(
0,
theXPathEnvSupport,
theDOMSupport);
const NodeRefList theDummyNodeList(theMemoryManager);
TestStringResult(
theXPathProcessor,
*theXPath,
theXPathConstructionContext,
TranscodeFromLocalCodePage(theStringTestInput[i], theInputString),
thePrintWriter,
TranscodeFromLocalCodePage(theStringTestExpectedOutput[i], theResult),
0,
thePrefixResolver,
theDummyNodeList,
theExecutionContext);
}
catch(...)
{
thePrintWriter.print("Exception caught evaluating XPath \"");
thePrintWriter.print(theStringTestInput[i]);
thePrintWriter.println();
}
}
}
const XMLCh*
NamedNodeMapAttributeList::getValue(const char* const name) const
{
XalanDOMString theBuffer(m_memoryManager);
return getValue(c_wstr(TranscodeFromLocalCodePage(name, theBuffer)));
}
ElemMessage::ElemMessageTerminateException::ElemMessageTerminateException(
const LocatorType& theLocator,
const XalanDOMString& theMessage) :
XSLTProcessorException(
theLocator,
theMessage,
TranscodeFromLocalCodePage("ElemMessageTerminateException"))
{
}
XalanTranscodingServices::UnrepresentableCharacterException::UnrepresentableCharacterException(
UnicodeCharType theCharacter,
const XalanDOMString& theEncoding) :
XSLException(
XalanMessageLoader::getMessage(
XalanMessages::UnrepresentableCharacter_2Param,
UnsignedLongToHexDOMString(theCharacter),
theEncoding),
TranscodeFromLocalCodePage("UnrepresentableCharacterException")),
m_badCharacter(theCharacter),
m_encoding(theEncoding)
{
}
void
DOMStringPrintWriter::write(
const char* s,
size_t theOffset,
size_t theLength)
{
assert(XalanDOMString::size_type(theOffset) == theOffset);
assert(XalanDOMString::size_type(theLength) == theLength);
write(
TranscodeFromLocalCodePage(s),
XalanDOMString::size_type(theOffset),
XalanDOMString::size_type(theLength));
}
void
DOMStringPrintWriter::write(
const char* s,
size_t theOffset,
size_t theLength)
{
assert(XalanDOMString::size_type(theOffset) == theOffset);
assert(XalanDOMString::size_type(theLength) == theLength);
assert ( m_outputString != 0 );
XalanDOMString tmpString( m_outputString->getMemoryManager() );
tmpString = TranscodeFromLocalCodePage(s, tmpString);
write(
tmpString,
XalanDOMString::size_type(theOffset),
XalanDOMString::size_type(theLength));
}
const XMLCh*
NamedNodeMapAttributeList::getValue(const char* const name) const
{
return getValue(c_wstr(TranscodeFromLocalCodePage(name)));
}
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;
}
