00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999-2002 The Apache Software Foundation. All rights 00006 * reserved. 00007 * 00008 * Redistribution and use in source and binary forms, with or without 00009 * modification, are permitted provided that the following conditions 00010 * are met: 00011 * 00012 * 1. Redistributions of source code must retain the above copyright 00013 * notice, this list of conditions and the following disclaimer. 00014 * 00015 * 2. Redistributions in binary form must reproduce the above copyright 00016 * notice, this list of conditions and the following disclaimer in 00017 * the documentation and/or other materials provided with the 00018 * distribution. 00019 * 00020 * 3. The end-user documentation included with the redistribution, 00021 * if any, must include the following acknowledgment: 00022 * "This product includes software developed by the 00023 * Apache Software Foundation (http://www.apache.org/)." 00024 * Alternately, this acknowledgment may appear in the software itself, 00025 * if and wherever such third-party acknowledgments normally appear. 00026 * 00027 * 4. The names "Xalan" and "Apache Software Foundation" must 00028 * not be used to endorse or promote products derived from this 00029 * software without prior written permission. For written 00030 * permission, please contact apache@apache.org. 00031 * 00032 * 5. Products derived from this software may not be called "Apache", 00033 * nor may "Apache" appear in their name, without prior written 00034 * permission of the Apache Software Foundation. 00035 * 00036 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 00037 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 00038 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00039 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR 00040 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00041 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00042 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 00043 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 00044 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00045 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 00046 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 00047 * SUCH DAMAGE. 00048 * ==================================================================== 00049 * 00050 * This software consists of voluntary contributions made by many 00051 * individuals on behalf of the Apache Software Foundation and was 00052 * originally based on software copyright (c) 1999, International 00053 * Business Machines, Inc., http://www.ibm.com. For more 00054 * information on the Apache Software Foundation, please see 00055 * <http://www.apache.org/>. 00056 */ 00057 #if !defined(XALAN_XSLTENGINEIMPL_HEADER_GUARD) 00058 #define XALAN_XSLTENGINEIMPL_HEADER_GUARD 00059 00060 00061 00062 // Base include file. Must be first. 00063 #include "XSLTDefinitions.hpp" 00064 00065 00066 00067 // Base class 00068 #include "XSLTProcessor.hpp" 00069 00070 00071 00072 00073 // Standard library headers 00074 #include <cassert> 00075 #include <ctime> 00076 #include <map> 00077 #include <set> 00078 00079 00080 00081 #include <XalanDOM/XalanDOMString.hpp> 00082 00083 00084 00085 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) 00086 #include <XPath/XPathProcessor.hpp> 00087 #endif 00088 00089 00090 00091 #include <Include/XalanAutoPtr.hpp> 00092 00093 00094 00095 #include <PlatformSupport/AttributeListImpl.hpp> 00096 #include <PlatformSupport/DOMStringHelper.hpp> 00097 #include <PlatformSupport/PrefixResolver.hpp> 00098 00099 00100 00101 #include <DOMSupport/XalanNamespacesStack.hpp> 00102 00103 00104 00105 #include <XPath/Function.hpp> 00106 00107 00108 00109 #include <XPath/XPathConstructionContextDefault.hpp> 00110 00111 00112 00113 #include "OutputContextStack.hpp" 00114 #include "ProblemListenerDefault.hpp" 00115 #include "ResultNamespacesStack.hpp" 00116 #include "StylesheetExecutionContext.hpp" 00117 #include "XSLTProcessorException.hpp" 00118 00119 00120 00121 XALAN_DECLARE_XERCES_CLASS(InputSource) 00122 XALAN_DECLARE_XERCES_CLASS(DocumentHandler) 00123 00124 00125 00126 XALAN_CPP_NAMESPACE_BEGIN 00127 00128 00129 00130 typedef XERCES_CPP_NAMESPACE_QUALIFIER InputSource InputSourceType; 00131 typedef XERCES_CPP_NAMESPACE_QUALIFIER DocumentHandler DocumentHandlerType; 00132 00133 00134 00135 // Forward declarations... 00136 class DOMSupport; 00137 class GenerateEvent; 00138 class PrintWriter; 00139 class ResultTreeFragBase; 00140 class StylesheetConstructionContext; 00141 class StylesheetExecutionContext; 00142 class StylesheetRoot; 00143 class XalanAttr; 00144 class XalanSourceTreeDocument; 00145 class XalanText; 00146 class XMLParserLiaison; 00147 class XObject; 00148 class XPathEnvSupport; 00149 class XPathFactory; 00150 class XPathProcessor; 00151 class XSLTResultTarget; 00152 00153 00154 00167 class XALAN_XSLT_EXPORT XSLTEngineImpl : public XSLTProcessor, public PrefixResolver 00168 { 00169 public: 00170 00171 #if defined(XALAN_STRICT_ANSI_HEADERS) 00172 typedef std::clock_t ClockType; 00173 #else 00174 typedef clock_t ClockType; 00175 #endif 00176 00177 struct LessXalanDOMStringPointers 00178 { 00179 bool 00180 operator()( 00181 const XalanDOMString* theLHS, 00182 const XalanDOMString* theRHS) const 00183 { 00184 if (theLHS == 0 && theRHS != 0) 00185 { 00186 return true; 00187 } 00188 else if (theRHS == 0) 00189 { 00190 return false; 00191 } 00192 else 00193 { 00194 return theLHS->compare(*theRHS) < 0 ? true : false; 00195 } 00196 } 00197 }; 00198 00199 #if defined(XALAN_NO_STD_NAMESPACE) 00200 typedef map<const void*, 00201 ClockType, 00202 less<const void*> > DurationsTableMapType; 00203 typedef vector<const LocatorType*> LocatorStack; 00204 typedef vector<TraceListener*> TraceListenerVectorType; 00205 #if defined(XALAN_USE_DEQUE_FOR_VECTOR_BOOL) 00206 typedef deque<bool> BoolVectorType; 00207 #else 00208 typedef vector<bool> BoolVectorType; 00209 #endif 00210 typedef vector<const XalanDOMString*> XalanDOMStringPointerVectorType; 00211 #else 00212 typedef std::map<const void*, ClockType> DurationsTableMapType; 00213 typedef std::vector<const LocatorType*> LocatorStack; 00214 typedef std::vector<TraceListener*> TraceListenerVectorType; 00215 #if defined(XALAN_USE_DEQUE_FOR_VECTOR_BOOL) 00216 typedef std::deque<bool> BoolVectorType; 00217 #else 00218 typedef std::vector<bool> BoolVectorType; 00219 #endif 00220 typedef std::vector<const XalanDOMString*> XalanDOMStringPointerVectorType; 00221 #endif 00222 00223 struct FindStringPointerFunctor 00224 { 00225 FindStringPointerFunctor(const XalanDOMString& theString) : 00226 m_string(theString) 00227 { 00228 } 00229 00230 bool 00231 operator()(const XalanDOMString* theString) const 00232 { 00233 assert(theString != 0); 00234 00235 return *theString == m_string; 00236 } 00237 00238 private: 00239 00240 const XalanDOMString& m_string; 00241 }; 00242 00243 typedef XalanAutoPtr<XPathProcessor> XPathProcessorPtrType; 00244 typedef Function::XObjectArgVectorType XObjectArgVectorType; 00245 typedef StylesheetExecutionContext::ParamVectorType ParamVectorType; 00246 00247 // Public members 00248 //--------------------------------------------------------------------- 00249 00262 XSLTEngineImpl( 00263 XMLParserLiaison& parserLiaison, 00264 XPathEnvSupport& xpathEnvSupport, 00265 DOMSupport& domSupport, 00266 XObjectFactory& xobjectFactory, 00267 XPathFactory& xpathFactory); 00268 00269 virtual 00270 ~XSLTEngineImpl(); 00271 00276 static void 00277 initialize(); 00278 00282 static void 00283 terminate(); 00284 00285 // These methods are inherited from XSLTProcessor ... 00286 00287 virtual void 00288 process( 00289 const XSLTInputSource& inputSource, 00290 const XSLTInputSource& stylesheetSource, 00291 XSLTResultTarget& outputTarget, 00292 StylesheetConstructionContext& constructionContext, 00293 StylesheetExecutionContext& executionContext); 00294 00295 virtual void 00296 process( 00297 const XSLTInputSource& inputSource, 00298 XSLTResultTarget& outputTarget, 00299 StylesheetExecutionContext& executionContext); 00300 00301 virtual StylesheetRoot* 00302 processStylesheet( 00303 const XSLTInputSource& stylesheetSource, 00304 StylesheetConstructionContext& constructionContext); 00305 00306 virtual StylesheetRoot* 00307 processStylesheet( 00308 const XalanDOMString& xsldocURLString, 00309 StylesheetConstructionContext& constructionContext); 00310 00311 virtual XalanNode* 00312 getSourceTreeFromInput(const XSLTInputSource& inputSource); 00313 00314 virtual void 00315 resolveTopLevelParams(StylesheetExecutionContext& executionContext); 00316 00317 virtual XMLParserLiaison& 00318 getXMLParserLiaison() const; 00319 00320 virtual const XalanDOMString 00321 getUniqueNamespaceValue(); 00322 00323 virtual void 00324 getUniqueNamespaceValue(XalanDOMString& theValue); 00325 00326 virtual void 00327 setStylesheetParam( 00328 const XalanDOMString& key, 00329 const XalanDOMString& expression); 00330 00331 virtual void 00332 setStylesheetParam( 00333 const XalanDOMString& key, 00334 XObjectPtr value); 00335 00336 virtual bool 00337 shouldStripSourceNode( 00338 StylesheetExecutionContext& executionContext, 00339 const XalanNode& node) const; 00340 00341 virtual FormatterListener* 00342 getFormatterListener() const; 00343 00344 virtual void 00345 setFormatterListener(FormatterListener* flistener); 00346 00347 // Trace-related functions... 00348 00349 virtual size_type 00350 getTraceListeners() const; 00351 00352 virtual void 00353 addTraceListener(TraceListener* tl); 00354 00355 virtual void 00356 removeTraceListener(TraceListener* tl); 00357 00358 virtual void 00359 fireGenerateEvent(const GenerateEvent& ge); 00360 00361 virtual void 00362 fireTraceEvent(const TracerEvent& te); 00363 00364 virtual void 00365 fireSelectEvent(const SelectionEvent& se); 00366 00367 virtual bool 00368 getTraceSelects() const; 00369 00370 virtual void 00371 setTraceSelects(bool b); 00372 00373 void 00374 traceSelect( 00375 StylesheetExecutionContext& executionContext, 00376 const ElemTemplateElement& theTemplate, 00377 const NodeRefListBase& nl, 00378 const XPath* xpath) const; 00379 00380 virtual void 00381 setQuietConflictWarnings(bool b); 00382 00383 virtual void 00384 setDiagnosticsOutput(PrintWriter* pw); 00385 00386 00387 // Inherited from PrefixResolver... 00388 00397 virtual const XalanDOMString* 00398 getNamespaceForPrefix(const XalanDOMString& prefix) const; 00399 00405 virtual const XalanDOMString& 00406 getURI() const; 00407 00419 XalanDocument* 00420 parseXML( 00421 const XalanDOMString& urlString, 00422 DocumentHandlerType* docHandler, 00423 XalanDocument* docToRegister); 00424 00436 XalanDocument* 00437 parseXML( 00438 const InputSourceType& inputSource, 00439 DocumentHandlerType* docHandler, 00440 XalanDocument* docToRegister); 00441 00454 Stylesheet* 00455 getStylesheetFromPIURL( 00456 const XalanDOMString& xslURLString, 00457 XalanNode& fragBase, 00458 const XalanDOMString& xmlBaseIdent, 00459 bool isRoot, 00460 StylesheetConstructionContext& constructionContext); 00461 00465 void 00466 flushPending(); 00467 00474 void 00475 addResultNamespaceDecl( 00476 const XalanDOMString& prefix, 00477 const XalanDOMString& namespaceVal) 00478 { 00479 addResultNamespaceDecl( 00480 prefix, 00481 namespaceVal.c_str(), 00482 namespaceVal.length()); 00483 } 00484 00492 void 00493 addResultNamespaceDecl( 00494 const XalanDOMString& prefix, 00495 const XalanDOMChar* namespaceVal, 00496 XalanDOMString::size_type len) 00497 { 00498 m_resultNamespacesStack.addDeclaration( 00499 prefix, 00500 namespaceVal, 00501 len); 00502 } 00503 00512 void 00513 addResultAttribute( 00514 AttributeListImpl& attList, 00515 const XalanDOMString& aname, 00516 const XalanDOMString& value) 00517 { 00518 addResultAttribute( 00519 attList, 00520 aname, 00521 value.c_str()); 00522 } 00523 00532 void 00533 addResultAttribute( 00534 AttributeListImpl& attList, 00535 const XalanDOMString& aname, 00536 const XalanDOMChar* value); 00537 00545 void 00546 addResultAttribute( 00547 const XalanDOMString& aname, 00548 const XalanDOMChar* value) 00549 { 00550 assert(m_outputContextStack.empty() == false); 00551 00552 addResultAttribute( 00553 getPendingAttributesImpl(), 00554 aname, 00555 value); 00556 } 00557 00565 void 00566 addResultAttribute( 00567 const XalanDOMString& aname, 00568 const XalanDOMString& value) 00569 { 00570 assert(m_outputContextStack.empty() == false); 00571 00572 addResultAttribute( 00573 getPendingAttributesImpl(), 00574 aname, 00575 value); 00576 } 00577 00578 void 00579 setDocumentLocator(const LocatorType* locator); 00580 00581 void 00582 startDocument(); 00583 00584 void 00585 endDocument(); 00586 00587 void 00588 startElement( 00589 const XalanDOMChar* name, 00590 AttributeListType& atts); 00591 00592 void 00593 endElement(const XalanDOMChar* name); 00594 00595 void 00596 characters ( 00597 const XalanDOMChar* ch, 00598 XalanDOMString::size_type length); 00599 00600 void 00601 ignorableWhitespace( 00602 const XalanDOMChar* ch, 00603 XalanDOMString::size_type length); 00604 00605 void 00606 processingInstruction( 00607 const XalanDOMChar* target, 00608 const XalanDOMChar* data); 00609 00610 void 00611 resetDocument(); 00612 00620 void 00621 characters( 00622 const XalanDOMChar* ch, 00623 XalanDOMString::size_type start, 00624 XalanDOMString::size_type length); 00625 00631 void 00632 characters(const XalanNode& node); 00633 00639 void 00640 characters(const XObjectPtr& xobject); 00641 00648 void 00649 startElement(const XalanDOMChar* name); 00650 00660 void 00661 charactersRaw( 00662 const XalanDOMChar* ch, 00663 XalanDOMString::size_type start, 00664 XalanDOMString::size_type length); 00665 00671 void 00672 charactersRaw(const XalanNode& node); 00673 00679 void 00680 charactersRaw(const XObjectPtr& xobject); 00681 00687 void 00688 comment(const XalanDOMChar* data); 00689 00696 void 00697 entityReference(const XalanDOMChar* data); 00698 00706 void 00707 cdata( 00708 const XalanDOMChar* ch, 00709 XalanDOMString::size_type start, 00710 XalanDOMString::size_type length); 00711 00719 void 00720 cloneToResultTree( 00721 const XalanNode& node, 00722 bool cloneTextNodesOnly, 00723 const ElemTemplateElement* styleNode); 00724 00736 void 00737 cloneToResultTree( 00738 const XalanNode& node, 00739 XalanNode::NodeType nodeType, 00740 bool isLiteral, 00741 bool overrideStrip, 00742 bool shouldCloneAttributes, 00743 bool cloneTextNodesOnly, 00744 const ElemTemplateElement* styleNode); 00745 00752 void 00753 outputToResultTree( 00754 const XObject& value, 00755 bool outputTextNodesOnly, 00756 const ElemTemplateElement* styleNode); 00757 00766 void 00767 outputResultTreeFragment( 00768 const XObject& theTree, 00769 bool outputTextNodesOnly, 00770 const ElemTemplateElement* styleNode); 00771 00777 virtual const StylesheetRoot* 00778 getStylesheetRoot() const; 00779 00785 virtual void 00786 setStylesheetRoot(const StylesheetRoot* theStylesheet); 00787 00793 virtual void 00794 setExecutionContext(StylesheetExecutionContext* theExecutionContext); 00795 00802 static const XalanDOMString& 00803 getXSLNameSpaceURL() 00804 { 00805 return s_XSLNameSpaceURL; 00806 } 00807 00813 static const XalanDOMString& 00814 getXalanXSLNameSpaceURL() 00815 { 00816 return s_XalanNamespaceURL; 00817 } 00818 00824 bool 00825 getQuietConflictWarnings() const 00826 { 00827 return m_quietConflictWarnings; 00828 } 00829 00830 virtual void 00831 message( 00832 const XalanDOMString& msg, 00833 const XalanNode* sourceNode = 0, 00834 const ElemTemplateElement* styleNode = 0) const; 00835 00836 virtual void 00837 message( 00838 const XalanDOMString& msg, 00839 const LocatorType& locator, 00840 const XalanNode* sourceNode = 0) const; 00841 00842 virtual void 00843 warn( 00844 const XalanDOMString& msg, 00845 const XalanNode* sourceNode = 0, 00846 const ElemTemplateElement* styleNode = 0) const; 00847 00855 virtual void 00856 warn( 00857 const char* msg, 00858 const XalanNode* sourceNode = 0, 00859 const ElemTemplateElement* styleNode = 0) const; 00860 00861 virtual void 00862 warn( 00863 const XalanDOMString& msg, 00864 const LocatorType& locator, 00865 const XalanNode* sourceNode = 0) const; 00866 00867 virtual void 00868 error( 00869 const XalanDOMString& msg, 00870 const XalanNode* sourceNode = 0, 00871 const ElemTemplateElement* styleNode = 0) const; 00872 00873 virtual void 00874 error( 00875 const XalanDOMString& msg, 00876 const LocatorType& locator, 00877 const XalanNode* sourceNode = 0) const; 00878 00879 public: 00880 00887 void 00888 pushTime(const void* key); 00889 00896 ClockType 00897 popDuration(const void* key); 00898 00906 void 00907 displayDuration( 00908 const XalanDOMString& info, 00909 const void* key); 00910 00911 00917 bool doDiagnosticsOutput() 00918 { 00919 return 0 != m_diagnosticsPrintWriter ? true : false; 00920 } 00921 00927 void 00928 diag(const XalanDOMString& s) const; 00929 00935 void 00936 diag(const char* s) const; 00937 00944 const XalanDOMString* 00945 getResultNamespaceForPrefix(const XalanDOMString& prefix) const; 00946 00953 const XalanDOMString* 00954 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; 00955 00964 bool 00965 isPendingResultPrefix(const XalanDOMString& thePrefix) const; 00966 00975 double 00976 evalMatchPatternStr( 00977 const XalanDOMString& str, 00978 XalanNode* context, 00979 XPathExecutionContext& executionContext); 00980 00988 const XPath* 00989 createMatchPattern( 00990 const XalanDOMString& str, 00991 const PrefixResolver& resolver); 00992 00999 void 01000 returnXPath(const XPath* xpath); 01001 01007 void 01008 copyNamespaceAttributes(const XalanNode& src); 01009 01017 const XObjectPtr 01018 evalXPathStr( 01019 const XalanDOMString& str, 01020 XPathExecutionContext& executionContext); 01021 01031 const XObjectPtr 01032 evalXPathStr( 01033 const XalanDOMString& str, 01034 XalanNode* contextNode, 01035 const PrefixResolver& prefixResolver, 01036 XPathExecutionContext& executionContext); 01037 01047 const XObjectPtr 01048 evalXPathStr( 01049 const XalanDOMString& str, 01050 XalanNode* contextNode, 01051 const XalanElement& prefixResolver, 01052 XPathExecutionContext& executionContext); 01053 01061 void 01062 copyAttributeToTarget( 01063 const XalanDOMString& attrName, 01064 const XalanDOMString& attrValue, 01065 AttributeListImpl& attrList); 01066 01072 XPathFactory& 01073 getXPathFactory() 01074 { 01075 return m_xpathFactory; 01076 } 01077 01083 XPathProcessor& 01084 getXPathProcessor() 01085 { 01086 return *m_xpathProcessor.get(); 01087 } 01088 01093 virtual void 01094 reset(); 01095 01101 XPathEnvSupport& 01102 getXPathEnvSupport() 01103 { 01104 return m_xpathEnvSupport; 01105 } 01106 01115 void 01116 setProblemListener(ProblemListener* l) 01117 { 01118 m_problemListener = l; 01119 } 01120 01129 ProblemListener* 01130 getProblemListener() const 01131 { 01132 return m_problemListener; 01133 } 01134 01135 /* 01136 * Push a new output context using the provided FormatterListener. 01137 * 01138 * @param A pointer to the FormatterListener instance for the new context. 01139 */ 01140 void 01141 pushOutputContext(FormatterListener* theListener) 01142 { 01143 m_outputContextStack.pushContext(theListener); 01144 } 01145 01146 /* 01147 * Pop the current output context. 01148 */ 01149 void 01150 popOutputContext() 01151 { 01152 m_outputContextStack.popContext(); 01153 } 01154 01155 /* 01156 * See if there is a pending start document event waiting. 01157 * @return true if there is a start document event waiting. 01158 */ 01159 bool 01160 getHasPendingStartDocument() const 01161 { 01162 return getHasPendingStartDocumentImpl(); 01163 } 01164 01165 /* 01166 * Set the pending start document event state. 01167 * @param the new value 01168 */ 01169 void 01170 setHasPendingStartDocument(bool b) 01171 { 01172 setHasPendingStartDocumentImpl(b); 01173 } 01174 01175 /* 01176 * See if a pending start document event must be flushed. 01177 * @return true if the event must be flushed. 01178 */ 01179 bool 01180 getMustFlushPendingStartDocument() const 01181 { 01182 return getMustFlushPendingStartDocumentImpl(); 01183 } 01184 01185 /* 01186 * Set the pending start document event flush state. 01187 * @param the new value 01188 */ 01189 void 01190 setMustFlushPendingStartDocument(bool b) 01191 { 01192 setMustFlushPendingStartDocumentImpl(b); 01193 } 01194 01200 const AttributeListType& 01201 getPendingAttributes() const 01202 { 01203 return getPendingAttributesImpl(); 01204 } 01205 01211 void 01212 setPendingAttributes(const AttributeListType& pendingAttributes) 01213 { 01214 getPendingAttributesImpl() = pendingAttributes; 01215 } 01216 01224 void 01225 replacePendingAttribute( 01226 const XalanDOMChar* theName, 01227 const XalanDOMChar* theNewType, 01228 const XalanDOMChar* theNewValue) 01229 { 01230 // Remove the old attribute, then add the new one. AttributeListImpl::addAttribute() 01231 // does this for us. 01232 getPendingAttributesImpl().addAttribute(theName, theNewType, theNewValue); 01233 } 01234 01235 bool 01236 isElementPending() const 01237 { 01238 return length(getPendingElementNameImpl()) != 0 ? true : false; 01239 } 01240 01246 const XalanDOMString& 01247 getPendingElementName() const 01248 { 01249 return getPendingElementNameImpl(); 01250 } 01251 01257 void 01258 setPendingElementName(const XalanDOMString& elementName) 01259 { 01260 setPendingElementNameImpl(elementName); 01261 } 01262 01263 void 01264 setPendingElementName(const XalanDOMChar* elementName) 01265 { 01266 setPendingElementNameImpl(elementName); 01267 } 01268 01274 const LocatorType* 01275 getLocatorFromStack() const 01276 { 01277 return m_stylesheetLocatorStack.empty() == true ? 0 : m_stylesheetLocatorStack.back(); 01278 } 01279 01285 void 01286 pushLocatorOnStack(const LocatorType* locator) 01287 { 01288 m_stylesheetLocatorStack.push_back(locator); 01289 } 01290 01294 void 01295 popLocatorStack() 01296 { 01297 if (m_stylesheetLocatorStack.empty() == false) 01298 { 01299 m_stylesheetLocatorStack.pop_back(); 01300 } 01301 } 01302 01303 protected: 01304 01310 const AttributeListImpl& 01311 getPendingAttributesImpl() const 01312 { 01313 return m_outputContextStack.getPendingAttributes(); 01314 } 01315 01321 AttributeListImpl& 01322 getPendingAttributesImpl() 01323 { 01324 return m_outputContextStack.getPendingAttributes(); 01325 } 01326 01332 void 01333 setPendingAttributesImpl(const AttributeListType& pendingAttributes) 01334 { 01335 getPendingAttributesImpl() = pendingAttributes; 01336 } 01337 01343 const XalanDOMString& 01344 getPendingElementNameImpl() const 01345 { 01346 return m_outputContextStack.getPendingElementName(); 01347 } 01348 01354 XalanDOMString& 01355 getPendingElementNameImpl() 01356 { 01357 return m_outputContextStack.getPendingElementName(); 01358 } 01359 01365 void 01366 setPendingElementNameImpl(const XalanDOMString& elementName) 01367 { 01368 m_outputContextStack.getPendingElementName() = elementName; 01369 } 01370 01376 void 01377 setPendingElementNameImpl(const XalanDOMChar* elementName) 01378 { 01379 assert(elementName != 0); 01380 01381 m_outputContextStack.getPendingElementName() = elementName; 01382 } 01383 01384 /* 01385 * See if there is a pending start document event waiting. 01386 * @return true if there is a start document event waiting. 01387 */ 01388 bool 01389 getHasPendingStartDocumentImpl() const 01390 { 01391 return m_outputContextStack.getHasPendingStartDocument(); 01392 } 01393 01394 /* 01395 * Set the pending start document event state. 01396 * @param the new value 01397 */ 01398 void 01399 setHasPendingStartDocumentImpl(bool b) 01400 { 01401 m_outputContextStack.getHasPendingStartDocument() = b; 01402 } 01403 01404 /* 01405 * See if a pending start document event must be flushed. 01406 * @return true if the event must be flushed. 01407 */ 01408 bool 01409 getMustFlushPendingStartDocumentImpl() const 01410 { 01411 return m_outputContextStack.getMustFlushPendingStartDocument(); 01412 } 01413 01414 /* 01415 * Set the pending start document event flush state. 01416 * @param the new value 01417 */ 01418 void 01419 setMustFlushPendingStartDocumentImpl(bool b) 01420 { 01421 m_outputContextStack.getMustFlushPendingStartDocument() = b; 01422 } 01423 01424 FormatterListener* 01425 getFormatterListenerImpl() const 01426 { 01427 return m_outputContextStack.getFormatterListener(); 01428 } 01429 01430 void 01431 setFormatterListenerImpl(FormatterListener* flistener) 01432 { 01433 m_outputContextStack.getFormatterListener() = flistener; 01434 } 01435 01442 XalanDOMString m_resultNameSpacePrefix; 01443 01447 XalanDOMString m_resultNameSpaceURL; 01448 01449 01454 void 01455 copyAttributesToAttList( 01456 const XalanNode& node, 01457 AttributeListImpl& attList); 01458 01459 // Factory for creating xpaths. 01460 XPathFactory& m_xpathFactory; 01461 01462 // Factory for creating xobjects 01463 XObjectFactory& m_xobjectFactory; 01464 01465 // The query/pattern-matcher object. 01466 const XPathProcessorPtrType m_xpathProcessor; 01467 01472 BoolVectorType m_cdataStack; 01473 01474 private: 01475 01482 void 01483 warnCopyTextNodesOnly( 01484 const XalanNode* sourceNode, 01485 const ElemTemplateElement* styleNode) const; 01486 01494 void 01495 cloneToResultTree( 01496 const XalanText& node, 01497 bool isLiteral, 01498 bool overrideStrip); 01499 01504 bool 01505 pendingAttributesHasDefaultNS() const; 01506 01507 void 01508 addResultNamespace( 01509 const XalanDOMString& thePrefix, 01510 const XalanDOMString& theName, 01511 const XalanNode& theNode, 01512 AttributeListImpl& thePendingAttributes, 01513 bool fOnlyIfPrefixNotPresent); 01514 01515 void 01516 addResultNamespace( 01517 const XalanNode& theNode, 01518 AttributeListImpl& thePendingAttributes, 01519 bool fOnlyIfPrefixNotPresent = false); 01520 01525 LocatorStack m_stylesheetLocatorStack; 01526 01533 ProblemListenerDefault m_defaultProblemListener; 01534 01535 ProblemListener* m_problemListener; 01536 01540 const StylesheetRoot* m_stylesheetRoot; 01541 01545 static const XalanDOMString& s_XSLNameSpaceURL; //"http://www.w3.org/1999/XSL/Transform" 01546 01550 static const XalanDOMString& s_XalanNamespaceURL; // "http://xml.apache.org/xalan" 01551 01555 static const XalanDOMString& s_uniqueNamespacePrefix; 01556 01560 bool m_traceSelects; 01561 01566 bool m_quietConflictWarnings; 01567 01568 /* 01569 * A stream to print diagnostics to. 01570 */ 01571 PrintWriter* m_diagnosticsPrintWriter; 01572 01573 /* For diagnostics */ 01574 DurationsTableMapType m_durationsTable; 01575 01580 TraceListenerVectorType m_traceListeners; 01581 01582 void 01583 problem( 01584 const XalanDOMString& msg, 01585 ProblemListener::eClassification classification, 01586 const XalanNode* sourceNode, 01587 const ElemTemplateElement* styleNode) const; 01588 01589 void 01590 problem( 01591 const XalanDOMString& msg, 01592 ProblemListener::eClassification classification, 01593 const LocatorType& locator, 01594 const XalanNode* sourceNode) const; 01595 01596 //========================================================== 01597 // SECTION: Function to do with attribute handling 01598 //========================================================== 01599 01603 unsigned long m_uniqueNSValue; 01604 01605 ParamVectorType m_topLevelParams; 01606 01607 public: 01608 01612 void 01613 clearTopLevelParams() 01614 { 01615 m_topLevelParams.clear(); 01616 } 01617 01618 private: 01619 01620 bool 01621 generateCDATASection() const 01622 { 01623 if (m_hasCDATASectionElements == false) 01624 { 01625 return false; 01626 } 01627 else 01628 { 01629 assert(m_cdataStack.empty() == false); 01630 01631 return m_cdataStack.back(); 01632 } 01633 } 01634 01635 void 01636 doFlushPending() 01637 { 01638 setMustFlushPendingStartDocument(true); 01639 01640 flushPending(); 01641 } 01642 01650 bool 01651 isCDataResultElem(const XalanDOMString& elementName) const; 01652 01653 void 01654 fireCharacterGenerateEvent( 01655 const XalanNode& theNode, 01656 bool isCDATA); 01657 01658 void 01659 fireCharacterGenerateEvent( 01660 const XObjectPtr& theXObject, 01661 bool isCDATA); 01662 01663 void 01664 fireCharacterGenerateEvent( 01665 const XalanDOMString& theString, 01666 bool isCDATA); 01667 01668 void 01669 fireCharacterGenerateEvent( 01670 const XalanDOMChar* ch, 01671 XalanDOMString::size_type start, 01672 XalanDOMString::size_type length, 01673 bool isCDATA); 01674 01675 void 01676 checkDefaultNamespace( 01677 const XalanDOMString& theElementName, 01678 const XalanDOMString& theElementNamespaceURI); 01679 01680 XMLParserLiaison& m_parserLiaison; 01681 01682 XPathEnvSupport& m_xpathEnvSupport; 01683 01684 DOMSupport& m_domSupport; 01685 01689 StylesheetExecutionContext* m_executionContext; 01690 01691 /* 01692 * Stack of current output contexts... 01693 */ 01694 OutputContextStack m_outputContextStack; 01695 01696 /* 01697 * Stack of current result namespaces... 01698 */ 01699 XalanNamespacesStack m_resultNamespacesStack; 01700 01701 /* 01702 * Dummy AttributeListImpl 01703 */ 01704 AttributeListImpl m_dummyAttributesList; 01705 01706 XalanDOMString m_scratchString; 01707 01708 XalanDOMStringPointerVectorType m_attributeNamesVisited; 01709 01710 bool m_hasStripOrPreserveSpace; 01711 01712 bool m_hasCDATASectionElements; 01713 01714 XPathConstructionContextDefault m_xpathConstructionContext; 01715 01716 static void 01717 installFunctions(); 01718 01719 static void 01720 uninstallFunctions(); 01721 01722 01723 static const XalanDOMString s_emptyString; 01724 01725 static const XalanDOMString& s_stylesheetNodeName; 01726 static const XalanDOMString& s_typeString; 01727 static const XalanDOMString& s_hrefString; 01728 static const XalanDOMString& s_piTokenizerString; 01729 static const XalanDOMString& s_typeValueString1; 01730 static const XalanDOMString& s_typeValueString2; 01731 static const XalanDOMString& s_typeValueString3; 01732 static const XalanDOMString& s_typeValueString4; 01733 01734 // Not implemented... 01735 XSLTEngineImpl(const XSLTEngineImpl&); 01736 01737 XSLTEngineImpl& 01738 operator=(const XSLTEngineImpl&); 01739 01740 bool 01741 operator==(const XSLTEngineImpl&) const; 01742 }; 01743 01744 01745 01746 XALAN_CPP_NAMESPACE_END 01747 01748 01749 01750 #endif // XALAN_XSLTENGINEIMPL_HEADER_GUARD
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSLT Processor Version 1.5 |
|