==== //depot/main/contrib/xml-xalan/c/src/PlatformSupport/XalanOutputStream.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/PlatformSupport/XalanOutputStream.hpp#4 (text) ==== content @@ -270,6 +270,15 @@ ~TranscodingException(); }; + // Need access to these methods to allow unbuffered I/O for debugging + + virtual void + doFlush() = 0; + + virtual void + writeData(const char* theBuffer, + unsigned long theBufferLength) = 0; + protected: /** @@ -296,13 +305,6 @@ unsigned long theBufferLength, TranscodeVectorType& theDestination); - virtual void - writeData(const char* theBuffer, - unsigned long theBufferLength) = 0; - - virtual void - doFlush() = 0; - private: // These are not implemented... ==== //depot/main/contrib/xml-xalan/c/src/XMLSupport/FormatterToXML.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XMLSupport/FormatterToXML.hpp#4 (text) ==== content @@ -309,6 +309,15 @@ typedef std::vector ByteBufferType; #endif + + // These need to be accessable to allow unbuffered I/O for debugging + + void + flush(); + + void + flushWriter(); + protected: /** @@ -464,12 +473,6 @@ flushBytes(); void - flush(); - - void - flushWriter(); - - void openElementForChildren(); bool ==== //depot/main/contrib/xml-xalan/c/src/XSLT/ElemTemplate.cpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/ElemTemplate.cpp#4 (text) ==== content @@ -140,6 +140,8 @@ { constructionContext.error(Constants::ELEMNAME_TEMPLATE_WITH_PREFIX_STRING + " requires either a name or a match attribute."); } + + m_attributes = atts; } @@ -169,3 +171,14 @@ executeChildren(executionContext, sourceTree, sourceNode, mode); } + +// For debugging... + +XalanDOMString +ElemTemplate::getAttributeValue(const XalanDOMString & name) const +{ + if ( m_attributes.getValue( name.c_str( ) ) ) + return XalanDOMString( m_attributes.getValue( name.c_str( ) ) ); + else + return XalanDOMString( ); +} ==== //depot/main/contrib/xml-xalan/c/src/XSLT/ElemTemplate.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/ElemTemplate.hpp#4 (text) ==== content @@ -73,13 +73,15 @@ #include - +#include class XPath; +// Access to this class is required for debugging so added XALAN_XSLT_EXPORT to class +// definition -class ElemTemplate : public ElemTemplateElement +class XALAN_XSLT_EXPORT ElemTemplate : public ElemTemplateElement { public: @@ -157,6 +159,11 @@ XalanNode* sourceNode, const QName& mode) const; + // Debugging extension... + + XalanDOMString + getAttributeValue(const XalanDOMString & name) const; + private: // not implemented @@ -172,6 +179,9 @@ QNameByValue m_mode; double m_priority; + + // Debugging extension... + AttributeListImpl m_attributes; }; ==== //depot/main/contrib/xml-xalan/c/src/XSLT/StylesheetExecutionContextDefault.cpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/StylesheetExecutionContextDefault.cpp#4 (text) ==== content @@ -1194,8 +1194,6 @@ } } - - int StylesheetExecutionContextDefault::collationCompare( const XalanDOMChar* theLHS, ==== //depot/main/contrib/xml-xalan/c/src/XSLT/StylesheetExecutionContextDefault.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/StylesheetExecutionContextDefault.hpp#4 (text) ==== content @@ -848,6 +848,10 @@ XSLTEngineImpl& m_xsltProcessor; }; + // For debugging... + const VariablesStack & + getVariablesStack( void ) const { return m_variablesStack; }; + private: /** ==== //depot/main/contrib/xml-xalan/c/src/XSLT/StylesheetHandler.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/StylesheetHandler.hpp#3 (text) ==== content @@ -90,7 +90,21 @@ class ExtensionNSHandler; class StylesheetConstructionContext; +// Something like this will be needed for "loose" line numbers + +class XALAN_XSLT_EXPORT ExtendedNodeInfo +{ +public: + ExtendedNodeInfo( void ); + ExtendedNodeInfo( const Locator * locator ); +public: + unsigned long m_lineNumber; + unsigned long m_columnNumber; + // This is not really necessary until XSLT can process multiple source documents. + // Still, we have to remember the URI somewhere and this isn't a bad spot. + XalanDOMString m_uri; +}; /** * This class processes a stylesheet via SAX events, and inits ==== //depot/main/contrib/xml-xalan/c/src/XSLT/VariablesStack.cpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/VariablesStack.cpp#5 (text) ==== content @@ -763,3 +763,285 @@ VariablesStack::InvalidStackContextException::~InvalidStackContextException() { } + + +/** + * The following methods add debugging information + */ + +#include +#include "ElemTemplateElement.hpp" + +// We added the variables to the vector starting from the highest stack index so +// now need to filter from the lowest index to maintain the correct variables + +VariableNameValueVector filterVariables( VariableNameValueVector & variables ) +{ + for ( unsigned int i = 0; i < variables.size( ); ++i ) + for ( unsigned int j = i + 1; j < variables.size( ); ++j ) + if ( *variables[i].first == *variables[j].first ) + { + variables.erase( variables.begin() + j ); + --j; + } + + return variables; +} + +XObjectPtr +VariablesStack::getStackEntryXObjectPtr( const StackEntry& theEntry, StylesheetExecutionContext& executionContext ) +{ + const ElemVariable* const var = theEntry.getVariable(); + const XObjectPtr& theValue = theEntry.getValue(); + + if (theValue.null() == false) + { + return theValue; + } + else + { + XObjectPtr theNewValue; + + if (var != 0) + { + XalanNode* const doc = executionContext.getRootDocument(); + assert(doc != 0); + + SetAndRestoreForceGlobalSearch theGuard(*this); + + theNewValue = var->getValue(executionContext, doc, doc); + assert(theNewValue.null() == false); + + // Leave the variable unchanged. Change this if it has serious performance problems. + } + + return theNewValue; + } + +} +/* +XObjectPtr +VariablesStack::getVariableXObjectPtr( const ElemVariable* const var, StylesheetExecutionContext& executionContext ) +{ + XObjectPtr theNewValue; + + if (var != 0) + { + XalanNode* const doc = executionContext.getRootDocument(); + assert(doc != 0); + + SetAndRestoreForceGlobalSearch theGuard(*this); + + theNewValue = var->getValue(executionContext, doc, doc); + assert(theNewValue.null() == false); + + // Leave the variable unchanged. Change this if it has serious performance problems. + } + + return theNewValue; +} +*/ +VariableNameValueVector +VariablesStack::getGlobalVariables( StylesheetExecutionContext& executionContext ) +{ + VariableNameValueVector variables; + + int searchPoint; + + // If m_globalStackFrameIndex is -1 then the context marker for the global stack frame has not been added + // so we can start searching at the top of the stack + if ( m_globalStackFrameIndex == -1 ) + searchPoint = getCurrentStackFrameIndex( ); + else + searchPoint = m_globalStackFrameIndex; + + for(unsigned int i = searchPoint - 1; i > 0; i--) + { + const StackEntry& theEntry = m_stack[i]; + + if( theEntry.getType() == StackEntry::eVariable || + theEntry.getType() == StackEntry::eParam || + theEntry.getType() == StackEntry::eActiveParam) + { + variables.push_back( VariableNameValue( theEntry.getName( ), + getStackEntryXObjectPtr( theEntry, executionContext ) ) ); + } + else if(theEntry.getType() == StackEntry::eContextMarker) + { + break; + } + } + + return filterVariables( variables ); +} + +VariableNameValueVector +VariablesStack::getLocalVariables( int context, + StylesheetExecutionContext& executionContext) +{ + VariableNameValueVector variables; + unsigned int stackFrameIndex; + + stackFrameIndex = getStackFrameIndex(context); + + for ( unsigned int i = stackFrameIndex - 1; i > 0; --i ) + { + const StackEntry& theEntry = + m_stack[i]; + + + if( theEntry.getType() == StackEntry::eVariable || + theEntry.getType() == StackEntry::eParam || + theEntry.getType() == StackEntry::eActiveParam) + { + variables.push_back( VariableNameValue( theEntry.getName( ), + getStackEntryXObjectPtr( theEntry, executionContext ) ) ); + } + else if(theEntry.getType() == StackEntry::eContextMarker) + { + break; + } + + } + + return filterVariables( variables ); +} + +// Just like getCurrentStackFrameIndex, returns the next context marker +unsigned int +VariablesStack::getStackFrameIndex(int context) const +{ + unsigned int stackFrameIndex; + + if (context == -1) + return getCurrentStackFrameIndex( ); + else + { + int currentDepth = getContextIndex( ); + + for ( stackFrameIndex = getCurrentStackFrameIndex( ) - 1; ( stackFrameIndex > 0 ) && ( context < currentDepth ); --stackFrameIndex ) + { + const StackEntry& theEntry = + m_stack[stackFrameIndex]; + + if(theEntry.getType() == StackEntry::eContextMarker) + --currentDepth; + } + + assert( currentDepth == context ); + + return stackFrameIndex + 1; + } +} + +const ElemTemplateElement* +VariablesStack::getBottomTemplateElement(int context) const +{ + unsigned int stackFrameIndex; + + stackFrameIndex = getStackFrameIndex(context - 1); + + for ( unsigned int i = stackFrameIndex + 1; i < m_stack.size( ); ++i ) + { + const StackEntry& theEntry = + m_stack[i]; + + if(theEntry.getType() == StackEntry::eElementFrameMarker) + { + return theEntry.getElement( ); + } + else if(theEntry.getType() == StackEntry::eContextMarker) + { + return NULL; + } + } + + return NULL; +} + +const ElemTemplateElement* +VariablesStack::getTopTemplateElement(int context) const +{ + unsigned int stackFrameIndex; + + stackFrameIndex = getStackFrameIndex(context); + + for ( unsigned int i = stackFrameIndex - 1; i > 0; --i ) + { + const StackEntry& theEntry = + m_stack[i]; + + if(theEntry.getType() == StackEntry::eElementFrameMarker) + { + return theEntry.getElement( ); + } + else if(theEntry.getType() == StackEntry::eContextMarker) + { + return NULL; + } + } + + return NULL; +} + +const ElemTemplateElement* +VariablesStack::getCurrentTemplateElement(int context) const +{ + unsigned int stackFrameIndex; + + stackFrameIndex = getStackFrameIndex(context); + + if ( stackFrameIndex != m_stack.size() ) + return getBottomTemplateElement( context + 1 ); + else + return getTopTemplateElement( context ); +} + +unsigned int +VariablesStack::getContextIndex(int stackFrameIndex) const +{ + unsigned int depth = 0; + + if ( stackFrameIndex == -1 ) + stackFrameIndex = getCurrentStackFrameIndex( ); + + for ( unsigned int i = stackFrameIndex - 1; i > 0; --i ) + { + const StackEntry& theEntry = + m_stack[i]; + + if(theEntry.getType() == StackEntry::eContextMarker) + { + ++depth; + } + + } + + return depth; +} + +/* +bool +VariablesStack::setVariable( + const QName& name, + XObject * xObject, + int context ) +{ + // XXX This will leak the XObject, probably want to add the the object to the + // StyleSheetExecutionContextDefault liveVariablesStack + + int oldIndex = getCurrentStackFrameIndex( ); + setCurrentStackFrameIndex( getStackFrameIndex(context) ); + VariablesStack::StackEntry *variableEntry; + + variableEntry = findVariable( name, false ); + if ( variableEntry ) + { + variableEntry->setVariable( xObject ); + } + + setCurrentStackFrameIndex( oldIndex ); + + return variableEntry != NULL; +} +*/==== //depot/main/contrib/xml-xalan/c/src/XSLT/VariablesStack.hpp#2 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XSLT/VariablesStack.hpp#5 (text) ==== content @@ -84,11 +84,13 @@ class StylesheetExecutionContext; class XalanNode; - - /** * Defines a class to keep track of a stack for macro arguments. */ + +typedef std::pair VariableNameValue; +typedef std::vector VariableNameValueVector; + class XALAN_XSLT_EXPORT VariablesStack { public: @@ -335,6 +337,43 @@ VariablesStack& m_variablesStack; }; + /** + * The following methods add debugging information + */ + + VariableNameValueVector + getGlobalVariables( StylesheetExecutionContext& executionContext ); + + VariableNameValueVector + getLocalVariables( int context, + StylesheetExecutionContext& executionContext); + + +// XObjectPtr +// getVariableDebug(); + + // This method is not yet implemented. + bool + setVariable( + const QName& name, + XObject * xObject, + int context ); + + unsigned int + getStackFrameIndex(int context = -1) const; + + const ElemTemplateElement* + getBottomTemplateElement(int context) const; + + const ElemTemplateElement* + getTopTemplateElement(int context) const; + + const ElemTemplateElement* + getCurrentTemplateElement(int context) const; + + unsigned int + getContextIndex(int stackFrameIndex = -1) const; + private: class StackEntry; @@ -550,6 +589,14 @@ bool fSearchGlobalSpace); + /** + * The following method add debugging information + */ + + XObjectPtr + getStackEntryXObjectPtr( const StackEntry& theEntry, + StylesheetExecutionContext& executionContext); + VariableStackStackType m_stack; int m_globalStackFrameIndex; ==== //depot/main/contrib/xml-xalan/c/src/XalanSourceTree/FormatterToSourceTree.cpp#1 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XalanSourceTree/FormatterToSourceTree.cpp#2 (text) ==== content @@ -145,8 +145,6 @@ assert(isEmpty(m_textBuffer) == true); } - - void FormatterToSourceTree::startElement( const XMLCh* const name, ==== //depot/main/contrib/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeContentHandler.cpp#1 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeContentHandler.cpp#2 (text) ==== content @@ -66,12 +66,12 @@ -#include "XalanSourceTreeDocument.hpp" -#include "XalanSourceTreeElement.hpp" -#include "XalanSourceTreeHelper.hpp" +#include +#include +#include +#include - XalanSourceTreeContentHandler::XalanSourceTreeContentHandler( XalanSourceTreeDocument* theDocument, bool fAccumulateText) : @@ -166,21 +166,26 @@ // Pop the last child stack m_lastChildStack.pop_back(); + + // Weirdness... +// m_extendedNodeInfoVector.clear( ); } - - -// A helper function to manage appending the new child. template inline void doAppendChildNode( - ParentNodeType* theParent, - XalanNode*& theLastChild, - ChildNodeType theNewChild) + ParentNodeType* theParent, + XalanNode*& theLastChild, + ChildNodeType theNewChild, + ExtendedNodeInfoVector &infoVector, + ExtendedNodeInfo nodeInfo) { assert(theParent != 0); assert(theNewChild != 0); + infoVector.push_back( + std::pair( theNewChild, nodeInfo ) ); + if (theLastChild == 0) { theParent->appendChildNode(theNewChild); @@ -193,8 +198,6 @@ theLastChild = theNewChild; } - - // A helper function to manage appending the new child. template inline void @@ -202,18 +205,20 @@ XalanSourceTreeDocument* theDocument, XalanSourceTreeElement* theCurrentElement, XalanNode*& theLastChild, - ChildNodeType theNewChild) + ChildNodeType theNewChild, + ExtendedNodeInfoVector & infoVector, + ExtendedNodeInfo nodeInfo) { assert(theDocument != 0); assert(theNewChild != 0); if (theCurrentElement == 0) { - doAppendChildNode(theDocument, theLastChild, theNewChild); + doAppendChildNode(theDocument, theLastChild, theNewChild, infoVector, nodeInfo); } else { - doAppendChildNode(theCurrentElement, theLastChild, theNewChild); + doAppendChildNode(theCurrentElement, theLastChild, theNewChild, infoVector, nodeInfo); } } @@ -234,7 +239,7 @@ XalanSourceTreeText* theNewTextNode = m_document->createTextIWSNode(chars, length, m_currentElement); - doAppendChildNode(m_currentElement, m_lastChild, theNewTextNode); + doAppendChildNode(m_currentElement, m_lastChild, theNewTextNode, m_extendedNodeInfoVector, m_locator); } } @@ -254,14 +259,17 @@ m_document, m_currentElement, m_lastChild, - theNewPI); + theNewPI, + m_extendedNodeInfoVector, + m_locator); } void -XalanSourceTreeContentHandler::setDocumentLocator(const Locator* const /* locator */) +XalanSourceTreeContentHandler::setDocumentLocator(const Locator* const locator ) { + m_locator = locator; } @@ -323,7 +331,9 @@ m_document, m_currentElement, m_lastChild, - theNewElement); + theNewElement, + m_extendedNodeInfoVector, + m_locator); m_elementStack.push_back(theNewElement); @@ -406,7 +416,9 @@ m_document, m_currentElement, m_lastChild, - theNewComment); + theNewComment, + m_extendedNodeInfoVector, + m_locator); } @@ -530,5 +542,21 @@ XalanSourceTreeText* theNewTextNode = m_document->createTextNode(chars, length, m_currentElement); - doAppendChildNode(m_currentElement, m_lastChild, theNewTextNode); + doAppendChildNode(m_currentElement, m_lastChild, theNewTextNode, m_extendedNodeInfoVector, m_locator); +} + +ExtendedNodeInfoVector +XalanSourceTreeContentHandler::getExtendedNodeInfoVector( void ) +{ + return m_extendedNodeInfoVector; } + +ExtendedNodeInfo::ExtendedNodeInfo( void ) +{ +}; + +ExtendedNodeInfo::ExtendedNodeInfo( const Locator * locator ) +{ + m_lineNumber = locator->getLineNumber( ); + m_columnNumber = locator->getColumnNumber( ); +}; ==== //depot/main/contrib/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeContentHandler.hpp#1 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeContentHandler.hpp#3 (text) ==== content @@ -54,14 +54,15 @@ * . */ -#if !defined(XALANSOURCETREECONTENTHANDLER_HEADER_GUARD_1357924680) -#define XALANSOURCETREECONTENTHANDLER_HEADER_GUARD_1357924680 +#if !defined(XalanSourceTreeContentHandler_HEADER_GUARD_1357924680) +#define XalanSourceTreeContentHandler_HEADER_GUARD_1357924680 #include +#include #include @@ -76,13 +77,28 @@ #include +#include +#include +//#include - class XalanNode; class XalanSourceTreeDocument; class XalanSourceTreeElement; +class XALAN_XALANSOURCETREE_EXPORT ExtendedNodeInfo +{ +public: + ExtendedNodeInfo( void ); + ExtendedNodeInfo( const Locator * locator ); + +public: + unsigned long m_lineNumber; + unsigned long m_columnNumber; + XalanDOMString m_uri; +}; +typedef std::map ExtendedNodeInfoMap; +typedef std::vector > ExtendedNodeInfoVector; class XALAN_XALANSOURCETREE_EXPORT XalanSourceTreeContentHandler : public ContentHandler, public DTDHandler, public LexicalHandler { @@ -223,6 +239,8 @@ XalanSourceTreeDocument* detachDocument(); + ExtendedNodeInfoVector + getExtendedNodeInfoVector( void ); private: // Not implemented... @@ -251,7 +269,6 @@ const XMLCh* chars, unsigned int length); - // Data members... // The current document we're building... @@ -284,8 +301,13 @@ // A buffer to hold accumulated text. XalanDOMString m_textBuffer; + + // Added for debugging + + const Locator * m_locator; + ExtendedNodeInfoVector m_extendedNodeInfoVector; }; -#endif // #if !defined(XALANSOURCETREECONTENTHANDLER_HEADER_GUARD_1357924680) +#endif // #if !defined(XalanSourceTreeContentHandler_HEADER_GUARD_1357924680) ==== //depot/main/contrib/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeParserLiaison.hpp#1 (text) - //depot/main/Apps/SharedXSLT/xml-xalan/c/src/XalanSourceTree/XalanSourceTreeParserLiaison.hpp#2 (text) ==== content @@ -364,7 +364,7 @@ XalanSourceTreeDocument*> DocumentMapType; #endif -private: +protected: // Data members... XercesDOMSupport m_xercesDOMSupport; // Must be before m_xercesParserLiaison!!!