00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999 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 * $ Id: $ 00058 * 00059 */ 00060 00061 #if !defined(XALAN_STYLESHEET_HEADER_GUARD) 00062 #define XALAN_STYLESHEET_HEADER_GUARD 00063 00064 00065 00066 // Base include file. Must be first. 00067 #include "XSLTDefinitions.hpp" 00068 00069 00070 00071 #include <deque> 00072 #include <map> 00073 #include <vector> 00074 00075 00076 00077 #include <XalanDOM/XalanDocument.hpp> 00078 #include <XalanDOM/XalanEmptyNamedNodeMap.hpp> 00079 #include <XalanDOM/XalanNodeListSurrogate.hpp> 00080 00081 00082 #include <PlatformSupport/PrefixResolver.hpp> 00083 00084 00085 00086 #include <XPath/NameSpace.hpp> 00087 #include <XPath/XalanQNameByReference.hpp> 00088 00089 00090 00091 #include "NamespacesHandler.hpp" 00092 #include "KeyDeclaration.hpp" 00093 #include "StylesheetExecutionContext.hpp" 00094 00095 00096 00097 class AttributeList; 00098 class ExtensionNSHandler; 00099 class XalanDecimalFormatSymbols; 00100 class ElemAttributeSet; 00101 class ElemDecimalFormat; 00102 class ElemTemplate; 00103 class ElemTemplateElement; 00104 class ElemVariable; 00105 class KeyTable; 00106 class NodeRefListBase; 00107 class PrefixResolver; 00108 class StylesheetConstructionContext; 00109 class StylesheetRoot; 00110 class XMLURL; 00111 class XObject; 00112 class XPath; 00113 class StylesheetExecutionContext; 00114 00115 00116 00121 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, protected PrefixResolver 00122 { 00123 00124 public: 00125 00126 typedef StylesheetExecutionContext::ParamVectorType ParamVectorType; 00127 typedef NamespacesHandler::NamespaceVectorType NamespaceVectorType; 00128 typedef NamespacesHandler::NamespacesStackType NamespacesStackType; 00129 00130 #if defined(XALAN_NO_NAMESPACES) 00131 typedef map<XalanDOMString, 00132 XalanDOMString, 00133 less<XalanDOMString> > StringToStringMapType; 00134 typedef map<XalanDOMString, 00135 ExtensionNSHandler*, 00136 less<XalanDOMString> > ExtensionNamespacesMapType; 00137 typedef map<XalanQNameByReference, 00138 ElemTemplate*, 00139 less<XalanQName> > ElemTemplateMapType; 00140 typedef vector<ElemAttributeSet*> AttributeSetVectorType; 00141 typedef vector<ElemVariable*> ElemVariableVectorType; 00142 typedef vector<KeyDeclaration> KeyDeclarationVectorType; 00143 typedef map<const XalanNode*, 00144 KeyTable*, 00145 less<const XalanNode*> > KeyTablesTableType; 00146 typedef vector<XalanQNameByValue> QNameVectorType; 00147 typedef vector<Stylesheet*> StylesheetVectorType; 00148 typedef vector<XalanDOMString> URLStackType; 00149 typedef vector<const XPath*> XPathVectorType; 00150 typedef vector<ElemDecimalFormat*> ElemDecimalFormatVectorType; 00151 #else 00152 typedef std::map<XalanDOMString, XalanDOMString> StringToStringMapType; 00153 typedef std::map<XalanDOMString, ExtensionNSHandler*> ExtensionNamespacesMapType; 00154 typedef std::map<XalanQNameByReference, ElemTemplate*> ElemTemplateMapType; 00155 typedef std::vector<ElemAttributeSet*> AttributeSetVectorType; 00156 typedef std::vector<ElemVariable*> ElemVariableVectorType; 00157 typedef std::vector<KeyDeclaration> KeyDeclarationVectorType; 00158 typedef std::map<const XalanNode*, KeyTable*> KeyTablesTableType; 00159 typedef std::vector<XalanQNameByValue> QNameVectorType; 00160 typedef std::vector<Stylesheet*> StylesheetVectorType; 00161 typedef std::vector<XalanDOMString> URLStackType; 00162 typedef std::vector<const XPath*> XPathVectorType; 00163 typedef std::vector<ElemDecimalFormat*> ElemDecimalFormatVectorType; 00164 #endif 00165 00171 Stylesheet( 00172 StylesheetRoot& root, 00173 const XalanDOMString& baseIdentifier, 00174 StylesheetConstructionContext& constructionContext); 00175 00176 virtual 00177 ~Stylesheet(); 00178 00184 double 00185 getXSLTVerDeclared() const 00186 { 00187 return m_XSLTVerDeclared; 00188 } 00189 00195 void 00196 setXSLTVerDeclared(double ver) 00197 { 00198 m_XSLTVerDeclared = ver; 00199 } 00200 00206 const StylesheetRoot& 00207 getStylesheetRoot() const 00208 { 00209 return m_stylesheetRoot; 00210 } 00211 00217 StylesheetRoot& 00218 getStylesheetRoot() 00219 { 00220 return m_stylesheetRoot; 00221 } 00222 00228 const NamespacesStackType& 00229 getNamespaces() const 00230 { 00231 return m_namespaces; 00232 } 00233 00239 NamespacesStackType& 00240 getNamespaces() 00241 { 00242 return m_namespaces; 00243 } 00244 00245 const NamespacesHandler& 00246 getNamespacesHandler() const 00247 { 00248 return m_namespacesHandler; 00249 } 00250 00251 NamespacesHandler& 00252 getNamespacesHandler() 00253 { 00254 return m_namespacesHandler; 00255 } 00256 00262 const NamespaceVectorType& 00263 getNamespaceDecls() const 00264 { 00265 return m_namespaceDecls; 00266 } 00267 00273 NamespaceVectorType& 00274 getNamespaceDecls() 00275 { 00276 return m_namespaceDecls; 00277 } 00278 00284 void 00285 setNamespaceDecls(const NamespaceVectorType& ns) 00286 { 00287 m_namespaceDecls = ns; 00288 } 00289 00290 /* 00291 * Get the top entry on the namespace stack, or 0, if 00292 * there is nothing on the stack. 00293 */ 00294 const NamespaceVectorType& 00295 getCurrentNamespace() const 00296 { 00297 return m_namespaces.size() > 0 ? m_namespaces.back() : s_emptyNamespace; 00298 } 00299 00306 void 00307 pushNamespaces(const AttributeList& atts); 00308 00312 void 00313 popNamespaces() 00314 { 00315 assert(m_namespaces.empty() == false); 00316 00317 m_namespaces.pop_back(); 00318 } 00319 00323 virtual void 00324 postConstruction(StylesheetConstructionContext& constructionContext); 00325 00335 bool 00336 isAttrOK( 00337 const XalanDOMChar* attrName, 00338 const AttributeList& atts, 00339 int which, 00340 StylesheetConstructionContext& constructionContext) const; 00341 00348 const XalanDOMString* 00349 getNamespaceFromStack(const XalanDOMString& nodeName) const 00350 { 00351 return getNamespaceFromStack(c_wstr(nodeName)); 00352 } 00353 00360 const XalanDOMString* 00361 getNamespaceFromStack(const XalanDOMChar* nodeName) const; 00362 00370 const XalanDOMString* 00371 getNamespaceForPrefixFromStack(const XalanDOMString& prefix) const 00372 { 00373 return XalanQName::getNamespaceForPrefix(m_namespaces, prefix); 00374 } 00375 00383 const XalanDOMString* 00384 getNamespaceForPrefixFromStack(const XalanDOMChar* prefix) const 00385 { 00386 assert(prefix != 0); 00387 00388 return XalanQName::getNamespaceForPrefix(m_namespaces, XalanDOMString(prefix)); 00389 } 00390 00397 XalanDOMString 00398 getAliasNamespaceURI(const XalanDOMChar* uri) const; 00399 00406 XalanDOMString 00407 getAliasNamespaceURI(const XalanDOMString& uri) const; 00408 00416 void 00417 processExcludeResultPrefixes( 00418 const XalanDOMChar* theValue, 00419 StylesheetConstructionContext& theConstructionContext) 00420 { 00421 m_namespacesHandler.processExcludeResultPrefixes( 00422 theValue, 00423 m_namespaces, 00424 theConstructionContext); 00425 } 00426 00433 void 00434 addTemplate( 00435 ElemTemplate* theTemplate, 00436 StylesheetConstructionContext& constructionContext); 00437 00446 bool 00447 getYesOrNo( 00448 const XalanDOMChar* aname, 00449 const XalanDOMChar* val, 00450 StylesheetConstructionContext& constructionContext) const; 00451 00457 bool 00458 isRoot() const 00459 { 00460 return m_isRoot; 00461 } 00462 00468 const XalanDOMString& 00469 getBaseIdentifier() const 00470 { 00471 return m_baseIdent; 00472 } 00473 00479 void 00480 setBaseIdentifier(const XalanDOMString& str) 00481 { 00482 m_baseIdent = str; 00483 } 00484 00493 const XalanDOMString& 00494 getCurrentIncludeBaseIdentifier() const 00495 { 00496 return m_includeStack.size() == 0 ? getBaseIdentifier() : m_includeStack.back(); 00497 } 00498 00506 void 00507 processNSAliasElement( 00508 const XalanDOMChar* name, 00509 const AttributeList& atts, 00510 StylesheetConstructionContext& constructionContext); 00511 00517 void 00518 processDecimalFormatElement(ElemDecimalFormat* elemDecimalFormat) 00519 { 00520 assert(elemDecimalFormat != 0); 00521 00522 m_elemDecimalFormats.push_back(elemDecimalFormat); 00523 } 00524 00532 const XalanDecimalFormatSymbols* 00533 getDecimalFormatSymbols(const XalanDOMString& name) const; 00534 00540 void 00541 addAttributeSet(ElemAttributeSet* attrSet) 00542 { 00543 assert(attrSet != 0); 00544 00545 m_attributeSets.push_back(attrSet); 00546 } 00547 00556 void 00557 applyAttrSets( 00558 const QNameVectorType& attributeSetsNames, 00559 StylesheetExecutionContext& executionContext, 00560 XalanNode* sourceNode) const; 00561 00568 void 00569 addImport( 00570 Stylesheet* theStylesheet, 00571 bool fFront) 00572 { 00573 m_imports.insert(fFront ? m_imports.begin() : m_imports.end(), theStylesheet); 00574 } 00575 00581 const ElemTemplate* 00582 getWrapperlessTemplate() 00583 { 00584 return m_wrapperlessTemplate; 00585 } 00586 00592 void 00593 setWrapperlessTemplate(ElemTemplate* templ) 00594 { 00595 m_wrapperlessTemplate = templ; 00596 } 00597 00603 bool 00604 isWrapperless() const 00605 { 00606 return m_isWrapperless; 00607 } 00608 00614 void 00615 setWrapperless(bool b) 00616 { 00617 m_isWrapperless = b; 00618 } 00619 00625 URLStackType& 00626 getIncludeStack() 00627 { 00628 return m_includeStack; 00629 } 00630 00638 /* 00639 * (Notes to myself) 00640 * What we need to do is: 00641 * 1) As this function is called, build a table of KeyDeclarations. 00642 * 2) During either XML processing, or upon request, walk the XML 00643 * document tree, and build a hash table: 00644 * a) keyed by name, 00645 * b) each with a value of a hashtable, keyed by the value returned by 00646 * the use attribute, 00647 * c) each with a value that is a nodelist. 00648 * Thus, for a given key or keyref, look up hashtable by name, 00649 * look up the nodelist by the given reference. 00650 */ 00651 void 00652 processKeyElement( 00653 ElemTemplateElement* nsContext, 00654 const AttributeList& atts, 00655 StylesheetConstructionContext& constructionContext); 00656 00663 const ElemTemplate* 00664 findNamedTemplate(const XalanQName& qname) const; 00665 00674 const ElemTemplate* 00675 findTemplate( 00676 StylesheetExecutionContext& executionContext, 00677 XalanNode* targetNode) const 00678 { 00679 return findTemplate(executionContext, targetNode, s_emptyQName, false); 00680 } 00681 00692 const ElemTemplate* 00693 findTemplate( 00694 StylesheetExecutionContext& executionContext, 00695 XalanNode* targetNode, 00696 const XalanQName& mode, 00697 bool onlyUseImports) const; 00698 00703 class MatchPattern2 00704 { 00705 public: 00706 00716 MatchPattern2( 00717 const ElemTemplate& theTemplate, 00718 int posInStylesheet, 00719 const XalanDOMString& targetString, 00720 const XPath& matchPattern, 00721 const XalanDOMString& pattern) : 00722 m_template(&theTemplate), 00723 m_posInStylesheet(posInStylesheet), 00724 m_targetString(targetString), 00725 m_matchPattern(&matchPattern), 00726 m_pattern(&pattern) 00727 { 00728 } 00729 00730 MatchPattern2() : 00731 m_template(0), 00732 m_posInStylesheet(0), 00733 m_targetString(), 00734 m_matchPattern(0), 00735 m_pattern(0) 00736 { 00737 } 00738 00739 ~MatchPattern2() 00740 { 00741 } 00742 00748 const XalanDOMString& 00749 getTargetString() const 00750 { 00751 return m_targetString; 00752 } 00753 00759 const XPath* 00760 getExpression() const 00761 { 00762 return m_matchPattern; 00763 } 00764 00770 int 00771 getPositionInStylesheet() const 00772 { 00773 return m_posInStylesheet; 00774 } 00775 00781 const XalanDOMString* 00782 getPattern() const 00783 { 00784 return m_pattern; 00785 } 00786 00792 const ElemTemplate* 00793 getTemplate() const 00794 { 00795 return m_template; 00796 } 00797 00798 private: 00799 00800 const ElemTemplate* m_template; 00801 int m_posInStylesheet; 00802 XalanDOMString m_targetString; 00803 const XPath* m_matchPattern; 00804 const XalanDOMString* m_pattern; 00805 }; 00806 00807 #if defined(XALAN_NO_NAMESPACES) 00808 typedef vector<const MatchPattern2*> PatternTableListType; 00809 00810 typedef vector<const MatchPattern2*> PatternTableVectorType; 00811 00812 typedef map<XalanDOMString, 00813 PatternTableListType, 00814 less<XalanDOMString> > PatternTableMapType; 00815 00816 typedef deque<MatchPattern2> MatchPattern2Container; 00817 #else 00818 typedef std::vector<const MatchPattern2*> PatternTableListType; 00819 00820 typedef std::vector<const MatchPattern2*> PatternTableVectorType; 00821 00822 typedef std::map<XalanDOMString, 00823 PatternTableListType> PatternTableMapType; 00824 00825 typedef std::deque<MatchPattern2> MatchPattern2Container; 00826 #endif 00827 00834 static void 00835 addObjectIfNotFound( 00836 const MatchPattern2* thePattern, 00837 PatternTableVectorType& theVector); 00838 00848 static void 00849 addObjectIfNotFound( 00850 const MatchPattern2* thePattern, 00851 const MatchPattern2* theArray[], 00852 unsigned int& theArraySize); 00853 00861 const PatternTableListType* 00862 locateMatchPatternList2(const XalanDOMString& theName) const; 00863 00870 const PatternTableListType* 00871 locateMatchPatternList2(const XalanNode& theNode) const; 00872 00881 void 00882 addExtensionNamespace( 00883 const XalanDOMString& uri, 00884 ExtensionNSHandler* nsh); 00885 00892 ExtensionNSHandler* 00893 lookupExtensionNSHandler(const XalanDOMString& uri) const 00894 { 00895 const ExtensionNamespacesMapType::const_iterator it = 00896 m_extensionNamespaces.find(uri); 00897 00898 return it == m_extensionNamespaces.end() ? 0 : (*it).second; 00899 } 00900 00908 void 00909 setTopLevelVariable(ElemVariable* var) 00910 { 00911 m_topLevelVariables.push_back(var); 00912 } 00913 00921 void 00922 pushTopLevelVariables( 00923 StylesheetExecutionContext& executionContext, 00924 const ParamVectorType& topLevelParams) const; 00925 00926 const XPathVectorType& 00927 getWhitespacePreservingElements() const 00928 { 00929 return m_whitespacePreservingElements; 00930 } 00931 00932 void 00933 pushWhitespacePreservingElement(const XPath* theXPath) 00934 { 00935 m_whitespacePreservingElements.push_back(theXPath); 00936 } 00937 00938 const XPathVectorType& 00939 getWhitespaceStrippingElements() const 00940 { 00941 return m_whitespaceStrippingElements; 00942 } 00943 00944 void 00945 pushWhitespaceStrippingElement(const XPath* theXPath) 00946 { 00947 m_whitespaceStrippingElements.push_back(theXPath); 00948 } 00949 00950 // These interfaces are inherited from XalanDocument... 00951 00952 virtual const XalanDOMString& 00953 getNodeName() const; 00954 00955 virtual const XalanDOMString& 00956 getNodeValue() const; 00957 00958 virtual NodeType 00959 getNodeType() const; 00960 00961 virtual XalanNode* 00962 getParentNode() const; 00963 00964 virtual const XalanNodeList* 00965 getChildNodes() const; 00966 00967 virtual XalanNode* 00968 getFirstChild() const; 00969 00970 virtual XalanNode* 00971 getLastChild() const; 00972 00973 virtual XalanNode* 00974 getPreviousSibling() const; 00975 00976 virtual XalanNode* 00977 getNextSibling() const; 00978 00979 virtual const XalanNamedNodeMap* 00980 getAttributes() const; 00981 00982 virtual XalanDocument* 00983 getOwnerDocument() const; 00984 00985 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00986 virtual XalanNode* 00987 #else 00988 virtual Stylesheet* 00989 #endif 00990 cloneNode(bool deep) const; 00991 00992 virtual XalanNode* 00993 insertBefore( 00994 XalanNode* newChild, 00995 XalanNode* refChild); 00996 00997 virtual XalanNode* 00998 replaceChild( 00999 XalanNode* newChild, 01000 XalanNode* oldChild); 01001 01002 virtual XalanNode* 01003 removeChild(XalanNode* oldChild); 01004 01005 virtual XalanNode* 01006 appendChild(XalanNode* newChild); 01007 01008 virtual bool 01009 hasChildNodes() const; 01010 01011 virtual void 01012 setNodeValue(const XalanDOMString& nodeValue); 01013 01014 virtual void 01015 normalize(); 01016 01017 virtual bool 01018 supports( 01019 const XalanDOMString& feature, 01020 const XalanDOMString& version) const; 01021 01022 virtual const XalanDOMString& 01023 getNamespaceURI() const; 01024 01025 virtual const XalanDOMString& 01026 getPrefix() const; 01027 01028 virtual const XalanDOMString& 01029 getLocalName() const; 01030 01031 virtual void 01032 setPrefix(const XalanDOMString& prefix); 01033 01034 virtual unsigned long 01035 getIndex() const; 01036 01037 virtual XalanElement* 01038 createElement(const XalanDOMString& tagName); 01039 01040 virtual XalanDocumentFragment* 01041 createDocumentFragment(); 01042 01043 virtual XalanText* 01044 createTextNode(const XalanDOMString& data); 01045 01046 virtual XalanComment* 01047 createComment(const XalanDOMString& data); 01048 01049 virtual XalanCDATASection* 01050 createCDATASection(const XalanDOMString& data); 01051 01052 virtual XalanProcessingInstruction* 01053 createProcessingInstruction( 01054 const XalanDOMString& target, 01055 const XalanDOMString& data); 01056 01057 virtual XalanAttr* 01058 createAttribute(const XalanDOMString& name); 01059 01060 virtual XalanEntityReference* 01061 createEntityReference(const XalanDOMString &name); 01062 01063 virtual XalanDocumentType* 01064 getDoctype() const; 01065 01066 virtual XalanDOMImplementation* 01067 getImplementation() const; 01068 01069 virtual XalanElement* 01070 getDocumentElement() const; 01071 01072 virtual XalanNodeList* 01073 getElementsByTagName(const XalanDOMString& tagname) const; 01074 01075 virtual XalanNode* 01076 importNode( 01077 XalanNode* importedNode, 01078 bool deep); 01079 01080 virtual XalanElement* 01081 createElementNS( 01082 const XalanDOMString& namespaceURI, 01083 const XalanDOMString& qualifiedName); 01084 01085 virtual XalanAttr* 01086 createAttributeNS( 01087 const XalanDOMString& namespaceURI, 01088 const XalanDOMString& qualifiedName); 01089 01090 virtual XalanNodeList* 01091 getElementsByTagNameNS( 01092 const XalanDOMString& namespaceURI, 01093 const XalanDOMString& localName) const; 01094 01095 virtual XalanElement* 01096 getElementById(const XalanDOMString& elementId) const; 01097 01098 virtual unsigned long 01099 getNumber() const; 01100 01101 virtual bool 01102 isIndexed() const; 01103 01104 // These interfaces are inherited from PrefixResolver... 01105 01106 virtual const XalanDOMString* 01107 getNamespaceForPrefix(const XalanDOMString& prefix) const; 01108 01109 virtual const XalanDOMString& 01110 getURI() const; 01111 01112 const XalanDOMString& 01113 getXSLTNamespaceURI() const 01114 { 01115 return m_XSLTNamespaceURI; 01116 } 01117 01118 void 01119 setXSLTNamespaceURI(const XalanDOMString& theURI) 01120 { 01121 m_XSLTNamespaceURI = theURI; 01122 } 01123 01124 protected: 01125 01129 StylesheetRoot& m_stylesheetRoot; 01130 01134 XalanDOMString m_baseIdent; 01135 01140 KeyDeclarationVectorType m_keyDeclarations; 01141 01142 static const XalanQNameByReference s_emptyQName; 01143 01144 private: 01145 01146 // Not defined... 01147 Stylesheet(const Stylesheet&); 01148 01149 Stylesheet& 01150 operator=(const Stylesheet&); 01151 01152 bool 01153 operator==(const Stylesheet&) const; 01154 01159 XalanDOMString m_XSLTNamespaceURI; 01160 01164 XPathVectorType m_whitespacePreservingElements; 01165 01169 XPathVectorType m_whitespaceStrippingElements; 01170 01174 StylesheetVectorType m_imports; 01175 01176 StylesheetVectorType::size_type m_importsSize; 01177 01181 NamespacesStackType m_namespaces; 01182 01187 NamespaceVectorType m_namespaceDecls; 01188 01193 static const NamespaceVectorType s_emptyNamespace; 01194 01199 bool m_isWrapperless; 01200 01204 ElemTemplate* m_wrapperlessTemplate; 01205 01209 ExtensionNamespacesMapType m_extensionNamespaces; 01210 01211 01215 ElemTemplateElement* m_firstTemplate; 01216 01221 URLStackType m_includeStack; 01222 01228 ElemTemplateMapType m_namedTemplates; 01229 01233 ElemVariableVectorType m_topLevelVariables; 01234 01238 double m_XSLTVerDeclared; 01239 01240 const bool m_isRoot; 01241 01247 PatternTableMapType m_patternTable; 01248 01249 const PatternTableMapType::const_iterator m_patternTableEnd; 01250 01254 PatternTableListType m_textPatternList; 01255 01256 PatternTableListType m_commentPatternList; 01257 01258 PatternTableListType m_rootPatternList; 01259 01260 PatternTableListType m_piPatternList; 01261 01268 PatternTableListType m_nodePatternList; 01269 01273 PatternTableListType m_anyPatternList; 01274 01279 MatchPattern2Container m_matchPattern2Container; 01280 01284 MatchPattern2Container::size_type m_patternCount; 01285 01286 AttributeSetVectorType m_attributeSets; 01287 01288 AttributeSetVectorType::size_type m_attributeSetsSize; 01289 01290 XalanNodeListSurrogate m_surrogateChildren; 01291 01292 ElemDecimalFormatVectorType m_elemDecimalFormats; 01293 01294 StringToStringMapType m_prefixAliases; 01295 01296 NamespacesHandler m_namespacesHandler; 01297 01298 static const XalanDOMString s_emptyString; 01299 01300 static const XalanEmptyNamedNodeMap s_fakeAttributes; 01301 }; 01302 01303 01304 01305 #endif // XALAN_STYLESHEET_HEADER_GUARD
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSL Transformer Version 1.1 |
|