/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #if !defined(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680) #define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 // Base class include file. #include #include #include #include #include #include #include #include #include #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) #include #endif #include #include #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) #include #endif #include #include #include #include #include #include #include #include #include namespace XALAN_CPP_NAMESPACE { class XalanSourceTreeDocument; class XPathProcessor; class XSLTEngineImpl; typedef VariablesStack::ParamsVectorType ParamsVectorTypeDecl; XALAN_USES_MEMORY_MANAGER(ParamsVectorTypeDecl) // // An class which provides support for executing stylesheets. // class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext { public: typedef std::clock_t ClockType; typedef XalanVector FormatterListenerVectorType; typedef XalanVector PrintWriterVectorType; typedef XalanVector OutputStreamVectorType; typedef XalanVector ElementTemplateElementStackType; typedef std::pair XPathCacheEntry; typedef XalanMap XPathCacheMapType; typedef XalanVector CurrentTemplateStackType; typedef Stylesheet::KeyTablesTableType KeyTablesTableType; typedef ParamsVectorTypeDecl ParamsVectorType; /** * Construct a StylesheetExecutionContextDefault object * * @param theXPathEnvSupport XPath environment support class instance * @param theDOMSupport DOMSupport class instance * @param theXobjectFactory factory class instance for XObjects * @param theCurrentNode current node in the source tree * @param theContextNodeList node list for current context * @param thePrefixResolver pointer to prefix resolver to use */ StylesheetExecutionContextDefault( MemoryManager& theManager, XSLTEngineImpl& xsltProcessor, XPathEnvSupport& theXPathEnvSupport, DOMSupport& theDOMSupport, XObjectFactory& theXObjectFactory, XalanNode* theCurrentNode = 0, const NodeRefListBase* theContextNodeList = 0, const PrefixResolver* thePrefixResolver = 0); /** * Construct a StylesheetExecutionContextDefault object * * @param theXPathEnvSupport XPath environment support class instance * @param theDOMSupport DOMSupport class instance * @param theXobjectFactory factory class instance for XObjects * @param theCurrentNode current node in the source tree * @param theContextNodeList node list for current context * @param thePrefixResolver pointer to prefix resolver to use */ explicit StylesheetExecutionContextDefault( MemoryManager& theManager, XalanNode* theCurrentNode = 0, const NodeRefListBase* theContextNodeList = 0, const PrefixResolver* thePrefixResolver = 0); static StylesheetExecutionContextDefault* create( MemoryManager& theManager, XalanNode* theCurrentNode = 0, const NodeRefListBase* theContextNodeList = 0, const PrefixResolver* thePrefixResolver = 0); virtual ~StylesheetExecutionContextDefault(); /** * Set the XPathEnvSupport instance. * * @param theSupport a reference to the instance to use. */ void setXPathEnvSupport(XPathEnvSupport* theSupport) { m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport); } /** * Set the DOMSupport instance. * * @param theDOMSupport a reference to the instance to use. */ void setDOMSupport(DOMSupport* theDOMSupport) { m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport); } /** * Set the XObjectFactory instance. * * @param theFactory a reference to the instance to use. */ void setXObjectFactory(XObjectFactory* theXObjectFactory) { m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory); m_xobjectFactory = theXObjectFactory; } /** * Set the DOMSupport instance. * * @param theDOMSupport a reference to the instance to use. */ void setXSLTProcessor(XSLTEngineImpl* theProcessor) { m_xsltProcessor = theProcessor; } bool getUsePerInstanceDocumentFactory() const { return m_usePerInstanceDocumentFactory; } void setUsePerInstanceDocumentFactory(bool fValue) { m_usePerInstanceDocumentFactory = fValue; } // These interfaces are inherited from StylesheetExecutionContext... virtual bool getQuietConflictWarnings() const; virtual bool getCopyTextNodesOnly() const; virtual void pushCopyTextNodesOnly(bool copyTextNodesOnly); virtual bool popCopyTextNodesOnly(); #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual void pushProcessCurrentAttribute(bool processAttribute); virtual bool popProcessCurrentAttribute(); virtual void pushSkipElementAttributes(bool skipAttributes); virtual bool getSkipElementAttributes() const; virtual bool popSkipElementAttributes(); virtual void pushExecuteIf(bool executeIf); virtual bool popExecuteIf(); #endif virtual XalanNode* getRootDocument() const; virtual void setRootDocument(XalanNode* theDocument); virtual void setStylesheetRoot(const StylesheetRoot* theStylesheet); virtual const XalanQName* getCurrentMode() const; virtual void pushCurrentMode(const XalanQName* theMode); virtual void popCurrentMode(); virtual const ElemTemplate* getCurrentTemplate() const; virtual void pushCurrentTemplate(const ElemTemplate* theTemplate); virtual void popCurrentTemplate(); virtual bool isElementPending() const; virtual void replacePendingAttribute( const XalanDOMChar* theName, const XalanDOMChar* theNewType, const XalanDOMChar* theNewValue); virtual void pushOutputContext(FormatterListener* flistener = 0); virtual void popOutputContext(); virtual void addResultAttribute( const XalanDOMString& aname, const XalanDOMString& value); virtual void addResultAttribute( const XalanDOMString& aname, const XalanDOMChar* value); virtual void copyNamespaceAttributes(const XalanNode& src); virtual const XalanDOMString* getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; virtual const XalanDOMString* getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const; virtual bool isPendingResultPrefix(const XalanDOMString& thePrefix); virtual void getUniqueNamespaceValue(XalanDOMString& theValue) const; virtual FormatterListener* getFormatterListener() const; virtual void setFormatterListener(FormatterListener* flistener); virtual int getIndent() const; virtual void setIndent(int indentAmount); virtual const XPath* createMatchPattern( const XalanDOMString& str, const PrefixResolver& resolver); virtual void returnXPath(const XPath* xpath); virtual void pushTopLevelVariables(const ParamVectorType& topLevelParams); virtual const XObjectPtr createVariable( const XPath& xpath, XalanNode* contextNode, const PrefixResolver& resolver); #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual const XObjectPtr createVariable( const ElemTemplateElement& templateChild, XalanNode* sourceNode); #endif virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const XalanDOMString& str, XalanNode* contextNode, const PrefixResolver& resolver); virtual void pushVariable( const XalanQName& name, const XObjectPtr val, const ElemTemplateElement* element); virtual void pushVariable( const XalanQName& name, const ElemVariable* var, const ElemTemplateElement* element); virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const XPath& xpath, XalanNode* contextNode, const PrefixResolver& resolver); #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const ElemTemplateElement& templateChild, XalanNode* sourceNode); #endif virtual void pushContextMarker(); virtual void popContextMarker(); virtual void resolveTopLevelParams(); virtual void clearTopLevelParams(); #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual void beginParams(); virtual void endParams(); virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue); #else virtual void pushParams(const ElemTemplateElement& xslCallTemplateElement); #endif virtual const XObjectPtr getParamVariable(const XalanQName& theName); virtual void pushElementFrame(const ElemTemplateElement* elem); virtual void popElementFrame(); virtual int getGlobalStackFrameIndex() const; virtual int getCurrentStackFrameIndex() const; virtual void pushCurrentStackFrameIndex(int currentStackFrameIndex = -1); virtual void popCurrentStackFrameIndex(); virtual void startDocument(); virtual void endDocument(); virtual void startElement(const XalanDOMChar* name); virtual void endElement(const XalanDOMChar* name); virtual void characters( const XalanDOMChar* ch, fl_size_type start, fl_size_type length); virtual void charactersRaw( const XalanDOMChar* ch, fl_size_type start, fl_size_type length); virtual void comment(const XalanDOMChar* data); virtual void processingInstruction( const XalanDOMChar* target, const XalanDOMChar* data); virtual void flushPending(); virtual void cloneToResultTree( const XalanNode& node, const Locator* locator); virtual void cloneToResultTree( const XalanNode& node, XalanNode::NodeType nodeType, bool overrideStrip, bool shouldCloneAttributes, const Locator* locator); #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual void beginCreateXResultTreeFrag(XalanNode* sourceNode); virtual const XObjectPtr endCreateXResultTreeFrag(); virtual void beginFormatToText(XalanDOMString& theResult); virtual void endFormatToText(); #endif #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual const XObjectPtr createXResultTreeFrag( const ElemTemplateElement& templateChild, XalanNode* sourceNode); #endif virtual void outputToResultTree( const XObject& xobj, const Locator* locator); virtual void outputResultTreeFragment( const XObject& theTree, const Locator* locator); virtual const XalanDOMString& getXSLNameSpaceURL() const; virtual const XalanDOMString& getXalanXSLNameSpaceURL() const; virtual bool findOnElementRecursionStack(const ElemTemplateElement* theElement) const; virtual void pushOnElementRecursionStack(const ElemTemplateElement* theElement); virtual const ElemTemplateElement* popElementRecursionStack(); virtual bool returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag); virtual eEscapeURLs getEscapeURLs() const; virtual void setEscapeURLs(eEscapeURLs value); virtual eOmitMETATag getOmitMETATag() const; void setOmitMETATag(eOmitMETATag value); virtual FormatterListener* createFormatterToXML( Writer& writer, const XalanDOMString& version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool doIndent = false, int indent = eDefaultXMLIndentAmount, const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool xmlDecl = true, const XalanDOMString& standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr())); virtual FormatterListener* createFormatterToHTML( Writer& writer, const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool doIndent = true, int indent = eDefaultHTMLIndentAmount, bool escapeURLs = true, bool omitMetaTag = false); virtual FormatterListener* createFormatterToText( Writer& writer, const XalanDOMString& encoding); #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual NodeSorter* getNodeSorter(); #else virtual NodeSorter* borrowNodeSorter(); virtual bool returnNodeSorter(NodeSorter* theSorter); #endif virtual XalanNumberFormatAutoPtr createXalanNumberFormat(); // A basic class to create XalanNumberFormat instances... class XALAN_XSLT_EXPORT XalanNumberFormatFactory { public: explicit XalanNumberFormatFactory(); virtual ~XalanNumberFormatFactory(); virtual XalanNumberFormat* create(MemoryManager& theManager); }; static XalanNumberFormatFactory& getDefaultXalanNumberFormatFactory() { return s_defaultXalanNumberFormatFactory; } /** * Static function to install a new XalanNumberFormatFactory. * The caller owns the XalanNumberFormatFactory instance. * * @param a pointer to the new factory instance to use. * @return a pointer to the old factory instance. */ static XalanNumberFormatFactory* installXalanNumberFormatFactory(XalanNumberFormatFactory* theFactory); virtual tl_size_type getTraceListeners() const; virtual void fireGenerateEvent(const GenerateEvent& ge); virtual void fireTraceEvent(const TracerEvent& te); virtual void fireSelectEvent(const SelectionEvent& se); virtual bool getTraceSelects() const; virtual void traceSelect( const ElemTemplateElement& theStylesheetElement, const NodeRefListBase& nl, const XPath* xpath); virtual int collationCompare( const XalanDOMString& theLHS, const XalanDOMString& theRHS, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); virtual int collationCompare( const XalanDOMString& theLHS, const XalanDOMString& theRHS, const XalanDOMString& theLocale, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); virtual int collationCompare( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); virtual int collationCompare( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, const XalanDOMChar* theLocale, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); typedef XalanCollationServices::CollationCompareFunctor CollationCompareFunctor; class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor { public: DefaultCollationCompareFunctor(); virtual ~DefaultCollationCompareFunctor(); virtual int operator()( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; virtual int operator()( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, const XalanDOMChar* theLocale, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; }; const CollationCompareFunctor* installCollationCompareFunctor(CollationCompareFunctor* theFunctor); CollationCompareFunctor* uninstallCollationCompareFunctor(); class XALAN_XSLT_EXPORT FormatNumberFunctor { public: FormatNumberFunctor() {}; virtual ~FormatNumberFunctor() {}; virtual void operator() ( XPathExecutionContext& executionContext, double theNumber, const XalanDOMString& thePattern, const XalanDecimalFormatSymbols* theDFS, XalanDOMString& theResult, const XalanNode* context = 0, const Locator* locator = 0) const = 0; }; virtual void formatNumber( double number, const XalanDOMString& pattern, XalanDOMString& theResult, const XalanNode* context = 0, const Locator* locator = 0); virtual void formatNumber( double number, const XalanDOMString& pattern, const XalanDOMString& dfsName, XalanDOMString& theResult, const XalanNode* context = 0, const Locator* locator = 0); const FormatNumberFunctor* installFormatNumberFunctor(FormatNumberFunctor* formatNumberFunctor); FormatNumberFunctor* uninstallFormatNumberFunctor(); virtual PrintWriter* createPrintWriter(XalanOutputStream* theTextOutputStream); virtual PrintWriter* createPrintWriter( const XalanDOMString& theFileName, const XalanDOMString& theEncoding); virtual PrintWriter* createPrintWriter(StreamType& theStream); virtual PrintWriter* createPrintWriter(FILE* theStream); virtual CountersTable& getCountersTable(); virtual void characters(const XalanNode& node); virtual void characters(const XObjectPtr& xobject); virtual void charactersRaw(const XalanNode& node); virtual void charactersRaw(const XObjectPtr& xobject); // These interfaces are inherited from XPathExecutionContext... virtual void reset(); virtual XalanNode* getCurrentNode() const; virtual void pushCurrentNode(XalanNode* theCurrentNode); virtual void popCurrentNode(); virtual bool isNodeAfter( const XalanNode& node1, const XalanNode& node2) const; virtual void pushContextNodeList(const NodeRefListBase& theList); virtual void popContextNodeList(); virtual const NodeRefListBase& getContextNodeList() const; virtual size_type getContextNodeListLength() const; virtual size_type getContextNodeListPosition(const XalanNode& contextNode) const; virtual bool elementAvailable(const XalanQName& theQName) const; virtual bool elementAvailable( const XalanDOMString& theName, const Locator* locator) const; virtual bool functionAvailable(const XalanQName& theQName) const; virtual bool functionAvailable( const XalanDOMString& theName, const Locator* locator) const; virtual const XObjectPtr extFunction( const XalanDOMString& theNamespace, const XalanDOMString& functionName, XalanNode* context, const XObjectArgVectorType& argVec, const Locator* locator); virtual XalanDocument* parseXML( MemoryManager& theManager, const XalanDOMString& urlString, const XalanDOMString& base, ErrorHandler* theErrorHandler = 0) const; virtual MutableNodeRefList* borrowMutableNodeRefList(); virtual bool returnMutableNodeRefList(MutableNodeRefList* theList); virtual MutableNodeRefList* createMutableNodeRefList(MemoryManager& theManager) const; #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual void createUseAttributeSetIndexesOnStack(); virtual UseAttributeSetIndexes& getUseAttributeSetIndexes(); virtual void popUseAttributeSetIndexesFromStack(); virtual void pushInvoker(const ElemTemplateElement * invoker); virtual void popInvoker(); virtual const ElemTemplateElement* getInvoker() const; virtual MutableNodeRefList& createAndPushMutableNodeRefList(); virtual void releaseAndPopMutableNodeRefList(); virtual void pushXObjectPtr(const XObjectPtr& xobjectPtr); virtual void popXObjectPtr(); virtual void createAndPushNodesToTransformList(const NodeRefListBase* nodeList); virtual XalanNode* getNextNodeToTransform(); virtual void popNodesToTransformList(); virtual XalanDOMString& getAndPushCachedString(); virtual XalanDOMString& getLastCachedString(); virtual XalanDOMString& getAndPopCachedString(); #endif virtual XalanDOMString& getCachedString(); virtual bool releaseCachedString(XalanDOMString& theString); virtual void getNodeSetByKey( XalanNode* context, const XalanQName& qname, const XalanDOMString& ref, const Locator* locator, MutableNodeRefList& nodelist); virtual void getNodeSetByKey( XalanNode* context, const XalanDOMString& name, const XalanDOMString& ref, const Locator* locator, MutableNodeRefList& nodelist); virtual const XObjectPtr getVariable( const XalanQName& name, const Locator* locator = 0); virtual const PrefixResolver* getPrefixResolver() const; virtual void setPrefixResolver(const PrefixResolver* thePrefixResolver); virtual const XalanDOMString* getNamespaceForPrefix(const XalanDOMString& prefix) const; virtual const XalanDOMString& findURIFromDoc(const XalanDocument* owner) const; virtual const XalanDOMString& getUnparsedEntityURI( const XalanDOMString& theName, const XalanDocument& theDocument) const; virtual bool shouldStripSourceNode(const XalanText& node); virtual XalanDocument* getSourceDocument(const XalanDOMString& theURI) const; virtual void setSourceDocument( const XalanDOMString& theURI, XalanDocument* theDocument); // These interfaces are inherited from ExecutionContext... virtual void problem( eSource source, eClassification classification, const XalanDOMString& msg, const Locator* locator, const XalanNode* sourceNode); virtual void problem( eSource source, eClassification classification, const XalanDOMString& msg, const XalanNode* sourceNode); class XPathCacheReturnFunctor { public: XPathCacheReturnFunctor(XSLTEngineImpl& xsltProcessor) : m_xsltProcessor(xsltProcessor) { } void operator()(const XPathCacheMapType::value_type& theCacheEntry); private: XSLTEngineImpl& m_xsltProcessor; }; /** * Get a XalanSourceTreeDocument, primarily for creating result * tree fragments. */ XalanSourceTreeDocument* getSourceTreeFactory(MemoryManager& theManager) const; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) protected: virtual FormatterToText* borrowFormatterToText(); virtual bool returnFormatterToText(FormatterToText* theFormatter); #endif private: const XalanDecimalFormatSymbols* getDecimalFormatSymbols(const XalanQName& qname); #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Given a context, create the params for a template * call. * * @param xslCallTemplateElement "call-template" element * @param params The params */ void getParams( const ElemTemplateElement& xslCallTemplateElement, ParamsVectorType& params); #endif /** * Determine if the XPath is one that we have cached. * * @param theXPath the XPath instance to check * @return true if the instance has been cached, false if not. */ bool isCached(const XPath* theXPath); /** * Clear out the cache of XPath instances. */ void clearXPathCache(); /** * Add an XPath instance to the cache, clearing out an old entry * if the cache is full. * * @param pattern the key for looking up the XPath instance in the cache. * @param theXPath the XPath instance to cache */ void addToXPathCache( const XalanDOMString& pattern, const XPath* theXPath); /** * Clean up anything that was created for use only during the transformation. */ void cleanUpTransients(); XPathExecutionContextDefault m_xpathExecutionContextDefault; XSLTEngineImpl* m_xsltProcessor; XalanNode* m_rootDocument; enum { eXPathCacheMax = 50, eDefaultParamsVectorSize = 10, eXResultTreeFragAllocatorBlockSize = 10, eDocumentAllocatorBlockSize = 10, eDocumentFragmentAllocatorBlockSize = 10, eDefaultAttributeAllocatorBlockSize = 10, eDefaultAttributeNSAllocatorBlockSize = 10, eDefaultCommentAllocatorBlockSize = 10, eDefaultElementAllocatorBlockSize = 10, eDefaultElementNSAllocatorBlockSize = 10, eDefaultPIAllocatorBlockSize = 10, eDefaultTextAllocatorBlockSize = 20, eDefaultTextIWSAllocatorBlockSize = 20 }; ElementTemplateElementStackType m_elementRecursionStack; const StylesheetRoot* m_stylesheetRoot; FormatterListenerVectorType m_formatterListeners; PrintWriterVectorType m_printWriters; OutputStreamVectorType m_outputStreams; CollationCompareFunctor* m_collationCompareFunctor; FormatNumberFunctor * m_formatNumberFunctor; /** * Holds all information about variables during execution. */ VariablesStack m_variablesStack; ParamsVectorType m_paramsVector; XPathCacheMapType m_matchPatternCache; KeyTablesTableType m_keyTables; CountersTable m_countersTable; /** * The factory that will be used to create result tree fragments based on our * internal source tree. */ mutable XalanMemMgrAutoPtr m_sourceTreeResultTreeFactory; // Holds the current mode. const XalanQName* m_mode; CurrentTemplateStackType m_currentTemplateStack; int m_indentAmount; XResultTreeFragAllocator m_xresultTreeFragAllocator; XalanSourceTreeDocumentFragmentAllocator m_documentFragmentAllocator; XalanSourceTreeDocumentAllocator m_documentAllocator; typedef XalanVector BooleanStackType; typedef XalanVector ModeStackType; typedef XalanVector IntStackType; BooleanStackType m_copyTextNodesOnlyStack; ModeStackType m_modeStack; IntStackType m_currentIndexStack; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) typedef XalanMemoryManagerObjectCacheDefault FormatterToTextCacheType; typedef XalanMemoryManagerObjectCacheDefault FormatterToSourceTreeCacheType; typedef XalanMemoryManagerObjectCacheDefault NodeSorterCacheType; FormatterToTextCacheType m_formatterToTextCache; FormatterToSourceTreeCacheType m_formatterToSourceTreeCache; NodeSorterCacheType m_nodeSorterCache; #else class FormatterToTextDOMString : public FormatterToText { public: FormatterToTextDOMString(MemoryManager& theManager); virtual ~FormatterToTextDOMString(); void setDOMString(XalanDOMString& theString) { m_printWriter.setString(theString); } private: // These are not defined... FormatterToTextDOMString(const FormatterToTextDOMString&); FormatterToTextDOMString& operator=(const FormatterToTextDOMString&); bool operator==(const FormatterToTextDOMString&) const; // Data members... DOMStringPrintWriter m_printWriter; static XalanDOMString s_dummyString; }; typedef XalanVector XObjectPtrStackType; typedef XalanVector ParamsVectorStackType; typedef XalanVector UseAttributeSetIndexesStackType; typedef XalanObjectStackCache > MutableNodeRefListStackType; typedef XalanObjectStackCache > StringStackType; typedef XalanObjectStackCache > FormatterToTextStackType; typedef XalanObjectStackCache > FormatterToSourceTreeStackType; /* * class to maintain the list of nodes to be transformed by an element */ class NodesToTransform { public: NodesToTransform(const NodeRefListBase* nodeList) : m_nodeList(nodeList), m_index(0) { assert(m_nodeList != 0); } const NodeRefListBase* operator() () { return m_nodeList; } NodeRefListBase::size_type& index() { return m_index; } XalanNode* next() { if (m_index < m_nodeList->getLength()) { return m_nodeList->item(m_index++); } return 0; } private: const NodeRefListBase* m_nodeList; NodeRefListBase::size_type m_index; }; typedef XalanVector NodesToTransformStackType; XObjectPtrStackType m_xobjectPtrStack; MutableNodeRefListStackType m_mutableNodeRefListStack; NodesToTransformStackType m_nodesToTransformStack; BooleanStackType m_processCurrentAttributeStack; BooleanStackType m_executeIfStack; StringStackType m_stringStack; FormatterToTextStackType m_formatterToTextStack; BooleanStackType m_skipElementAttributesStack; FormatterToSourceTreeStackType m_formatterToSourceTreeStack; ParamsVectorStackType m_paramsVectorStack; ElementTemplateElementStackType m_elementInvokerStack; UseAttributeSetIndexesStackType m_useAttributeSetIndexesStack; NodeSorter m_nodeSorter; #endif // If true, we will use a separate document factory for // result tree fragments. bool m_usePerInstanceDocumentFactory; // Determines whether or not to override the property in the stylesheet. eEscapeURLs m_escapeURLs; // Determines whether or not to override the property in the stylesheet. eOmitMETATag m_omitMETATag; static XalanNumberFormatFactory s_defaultXalanNumberFormatFactory; static XalanNumberFormatFactory* s_xalanNumberFormatFactory; static const DefaultCollationCompareFunctor s_defaultCollationFunctor; }; } #endif // STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680