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 <list> 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 <DOMSupport/PrefixResolver.hpp> 00083 00084 00085 00086 #include <XPath/NameSpace.hpp> 00087 #include <XPath/QNameByReference.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 MatchPattern2; 00107 class NodeRefListBase; 00108 class PrefixResolver; 00109 class StylesheetConstructionContext; 00110 class StylesheetRoot; 00111 class XMLURL; 00112 class XObject; 00113 class XPath; 00114 class StylesheetExecutionContext; 00115 00116 00117 00122 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, private PrefixResolver 00123 { 00124 00125 public: 00126 00127 typedef StylesheetExecutionContext::ParamVectorType ParamVectorType; 00128 typedef NamespacesHandler::NamespaceVectorType NamespaceVectorType; 00129 typedef NamespacesHandler::NamespacesStackType NamespacesStackType; 00130 00131 #if defined(XALAN_NO_NAMESPACES) 00132 typedef map<XalanDOMString, 00133 XalanDOMString, 00134 less<XalanDOMString> > StringToStringMapType; 00135 typedef map<XalanDOMString, 00136 ExtensionNSHandler*, 00137 less<XalanDOMString> > ExtensionNamespacesMapType; 00138 typedef map<QNameByReference, 00139 ElemTemplate*, 00140 less<QName> > ElemTemplateMapType; 00141 typedef vector<ElemAttributeSet*> AttributeSetMapType; 00142 typedef vector<ElemVariable*> ElemVariableVectorType; 00143 typedef vector<KeyDeclaration> KeyDeclarationVectorType; 00144 typedef map<const XalanNode*, 00145 KeyTable*, 00146 less<const XalanNode*> > KeyTablesTableType; 00147 typedef vector<QNameByValue> QNameVectorType; 00148 typedef vector<Stylesheet*> StylesheetVectorType; 00149 typedef vector<XalanDOMString> URLStackType; 00150 typedef vector<const XPath*> XPathVectorType; 00151 typedef vector<ElemDecimalFormat*> ElemDecimalFormatVectorType; 00152 #else 00153 typedef std::map<XalanDOMString, XalanDOMString> StringToStringMapType; 00154 typedef std::map<XalanDOMString, ExtensionNSHandler*> ExtensionNamespacesMapType; 00155 typedef std::map<QNameByReference, ElemTemplate*> ElemTemplateMapType; 00156 typedef std::vector<ElemAttributeSet*> AttributeSetMapType; 00157 typedef std::vector<ElemVariable*> ElemVariableVectorType; 00158 typedef std::vector<KeyDeclaration> KeyDeclarationVectorType; 00159 typedef std::map<const XalanNode*, KeyTable*> KeyTablesTableType; 00160 typedef std::vector<QNameByValue> QNameVectorType; 00161 typedef std::vector<Stylesheet*> StylesheetVectorType; 00162 typedef std::vector<XalanDOMString> URLStackType; 00163 typedef std::vector<const XPath*> XPathVectorType; 00164 typedef std::vector<ElemDecimalFormat*> ElemDecimalFormatVectorType; 00165 #endif 00166 00172 Stylesheet( 00173 StylesheetRoot& root, 00174 const XalanDOMString& baseIdentifier, 00175 StylesheetConstructionContext& constructionContext); 00176 00177 virtual 00178 ~Stylesheet(); 00179 00185 double 00186 getXSLTVerDeclared() const 00187 { 00188 return m_XSLTVerDeclared; 00189 } 00190 00196 void 00197 setXSLTVerDeclared(double ver) 00198 { 00199 m_XSLTVerDeclared = ver; 00200 } 00201 00207 const StylesheetRoot& 00208 getStylesheetRoot() const 00209 { 00210 return m_stylesheetRoot; 00211 } 00212 00218 StylesheetRoot& 00219 getStylesheetRoot() 00220 { 00221 return m_stylesheetRoot; 00222 } 00223 00229 const NamespacesStackType& 00230 getNamespaces() const 00231 { 00232 return m_namespaces; 00233 } 00234 00240 NamespacesStackType& 00241 getNamespaces() 00242 { 00243 return m_namespaces; 00244 } 00245 00246 const NamespacesHandler& 00247 getNamespacesHandler() const 00248 { 00249 return m_namespacesHandler; 00250 } 00251 00252 NamespacesHandler& 00253 getNamespacesHandler() 00254 { 00255 return m_namespacesHandler; 00256 } 00257 00263 const NamespaceVectorType& 00264 getNamespaceDecls() const 00265 { 00266 return m_namespaceDecls; 00267 } 00268 00274 NamespaceVectorType& 00275 getNamespaceDecls() 00276 { 00277 return m_namespaceDecls; 00278 } 00279 00285 void 00286 setNamespaceDecls(const NamespaceVectorType& ns) 00287 { 00288 m_namespaceDecls = ns; 00289 } 00290 00291 /* 00292 * Get the top entry on the namespace stack, or 0, if 00293 * there is nothing on the stack. 00294 */ 00295 const NamespaceVectorType& 00296 getCurrentNamespace() const; 00297 00304 void 00305 pushNamespaces(const AttributeList& atts); 00306 00310 void 00311 popNamespaces(); 00312 00316 virtual void 00317 postConstruction(); 00318 00328 bool 00329 isAttrOK( 00330 const XalanDOMChar* attrName, 00331 const AttributeList& atts, 00332 int which, 00333 StylesheetConstructionContext& constructionContext) const; 00334 00341 const XalanDOMString& 00342 getNamespaceFromStack(const XalanDOMString& nodeName) const; 00343 00350 const XalanDOMString& 00351 getNamespaceFromStack(const XalanDOMChar* nodeName) const; 00352 00360 const XalanDOMString& 00361 getNamespaceForPrefixFromStack(const XalanDOMString& prefix) const; 00362 00370 const XalanDOMString& 00371 getNamespaceForPrefixFromStack(const XalanDOMChar* prefix) const; 00372 00379 XalanDOMString 00380 getAliasNamespaceURI(const XalanDOMChar* uri) const; 00381 00388 XalanDOMString 00389 getAliasNamespaceURI(const XalanDOMString& uri) const; 00390 00398 void 00399 processExcludeResultPrefixes( 00400 const XalanDOMChar* theValue, 00401 StylesheetConstructionContext& theConstructionContext); 00402 00412 const Stylesheet* 00413 getPreviousImport(const Stylesheet* stylesheet) const; 00414 00421 void 00422 addTemplate( 00423 ElemTemplate* tmpl, 00424 StylesheetConstructionContext& constructionContext); 00425 00434 virtual bool 00435 getYesOrNo( 00436 const XalanDOMChar* aname, 00437 const XalanDOMChar* val, 00438 StylesheetConstructionContext& constructionContext) const; 00439 00445 bool 00446 isRoot() const 00447 { 00448 return m_isRoot; 00449 } 00450 00456 const XalanDOMString& 00457 getBaseIdentifier() const 00458 { 00459 return m_baseIdent; 00460 } 00461 00467 void 00468 setBaseIdentifier(const XalanDOMString& str) 00469 { 00470 m_baseIdent = str; 00471 } 00472 00481 const XalanDOMString& 00482 getCurrentIncludeBaseIdentifier() const; 00483 00491 void 00492 processNSAliasElement( 00493 const XalanDOMChar* name, 00494 const AttributeList& atts, 00495 StylesheetConstructionContext& constructionContext); 00496 00504 void 00505 processDecimalFormatElement( 00506 ElemDecimalFormat* elemDecimalFormat, 00507 const AttributeList& atts, 00508 StylesheetConstructionContext& constructionContext); 00509 00517 const XalanDecimalFormatSymbols* 00518 getDecimalFormatSymbols(const XalanDOMString& name) const; 00519 00526 void 00527 addAttributeSet( 00528 const QName& qname, 00529 ElemAttributeSet* attrSet); 00530 00541 void 00542 applyAttrSets( 00543 const QNameVectorType& attributeSetsNames, 00544 StylesheetExecutionContext& executionContext, 00545 XalanNode* sourceTree, 00546 XalanNode* sourceNode, 00547 const QName& mode) const; 00548 00554 bool 00555 isDefaultSpaceProcessing() const 00556 { 00557 return m_defaultSpace; 00558 } 00559 00565 void 00566 setDefaultSpaceProcessing(bool bEnabled) 00567 { 00568 m_defaultSpace = bEnabled; 00569 } 00570 00577 void 00578 addImport( 00579 Stylesheet* theStylesheet, 00580 bool fFront) 00581 { 00582 m_imports.insert(fFront ? m_imports.begin() : m_imports.end(), theStylesheet); 00583 } 00584 00590 const ElemTemplate* 00591 getWrapperlessTemplate() 00592 { 00593 return m_wrapperlessTemplate; 00594 } 00595 00601 void 00602 setWrapperlessTemplate(ElemTemplate* templ) 00603 { 00604 m_wrapperlessTemplate = templ; 00605 } 00606 00612 bool 00613 isWrapperless() const 00614 { 00615 return m_isWrapperless; 00616 } 00617 00623 void 00624 setWrapperless(bool b) 00625 { 00626 m_isWrapperless = b; 00627 } 00628 00634 URLStackType& 00635 getIncludeStack() 00636 { 00637 return m_includeStack; 00638 } 00639 00647 /* 00648 * (Notes to myself) 00649 * What we need to do is: 00650 * 1) As this function is called, build a table of KeyDeclarations. 00651 * 2) During either XML processing, or upon request, walk the XML 00652 * document tree, and build a hash table: 00653 * a) keyed by name, 00654 * b) each with a value of a hashtable, keyed by the value returned by 00655 * the use attribute, 00656 * c) each with a value that is a nodelist. 00657 * Thus, for a given key or keyref, look up hashtable by name, 00658 * look up the nodelist by the given reference. 00659 */ 00660 void 00661 processKeyElement( 00662 ElemTemplateElement* nsContext, 00663 const AttributeList& atts, 00664 StylesheetConstructionContext& constructionContext); 00665 00673 const ElemTemplate* 00674 findNamedTemplate( 00675 const QName& qname, 00676 StylesheetExecutionContext& executionContext) const; 00677 00687 const ElemTemplate* 00688 findTemplate( 00689 StylesheetExecutionContext& executionContext, 00690 XalanNode* sourceTree, 00691 XalanNode* targetNode) const; 00692 00704 const ElemTemplate* 00705 findTemplate( 00706 StylesheetExecutionContext& executionContext, 00707 XalanNode* sourceTree, 00708 XalanNode* targetNode, 00709 const QName& mode, 00710 bool useImports, 00711 const Stylesheet*& foundStylesheet) const; 00712 00717 class MatchPattern2 00718 { 00719 public: 00720 00731 MatchPattern2( 00732 const XalanDOMString& pat, 00733 const XPath* exp, 00734 const ElemTemplate* theTemplate, 00735 int posInStylesheet, 00736 const XalanDOMString& targetString, 00737 const Stylesheet* stylesheet); 00738 00739 ~MatchPattern2(); 00740 00746 const Stylesheet* 00747 getStylesheet() const 00748 { 00749 return m_stylesheet; 00750 } 00751 00757 const XalanDOMString& 00758 getTargetString() const 00759 { 00760 return m_targetString; 00761 } 00762 00768 const XPath* 00769 getExpression() const 00770 { 00771 return m_expression; 00772 } 00773 00779 int 00780 getPositionInStylesheet() const 00781 { 00782 return m_posInStylesheet; 00783 } 00784 00790 const XalanDOMString& 00791 getPattern() const 00792 { 00793 return m_pattern; 00794 } 00795 00801 const ElemTemplate* 00802 getTemplate() const 00803 { 00804 return m_template; 00805 } 00806 00807 private: 00808 00809 const Stylesheet* const m_stylesheet; 00810 const XalanDOMString m_targetString; 00811 const XPath* const m_expression; 00812 const int m_posInStylesheet; 00813 const XalanDOMString m_pattern; 00814 const ElemTemplate* const m_template; // ref to the corresponding template 00815 00816 // Not implemented... 00817 MatchPattern2(); 00818 MatchPattern2& operator=(const MatchPattern2&); 00819 }; 00820 00821 #if defined(XALAN_NO_NAMESPACES) 00822 typedef list<MatchPattern2*> PatternTableListType; 00823 00824 typedef vector<const MatchPattern2*> PatternTableVectorType; 00825 00826 typedef map<XalanDOMString, 00827 PatternTableListType, 00828 less<XalanDOMString> > PatternTableMapType; 00829 #else 00830 typedef std::list<MatchPattern2*> PatternTableListType; 00831 00832 typedef std::vector<const MatchPattern2*> PatternTableVectorType; 00833 00834 typedef std::map<XalanDOMString, 00835 PatternTableListType> PatternTableMapType; 00836 #endif 00837 00844 static void 00845 addObjectIfNotFound( 00846 const MatchPattern2* thePattern, 00847 PatternTableVectorType& theVector); 00848 00858 static void 00859 addObjectIfNotFound( 00860 const MatchPattern2* thePattern, 00861 const MatchPattern2* theArray[], 00862 unsigned int& theArraySize); 00863 00870 const PatternTableListType* 00871 locateMatchPatternList2(XalanNode* sourceNode) const; 00872 00880 const PatternTableListType* 00881 locateMatchPatternList2( 00882 const XalanDOMString& sourceElementType, 00883 bool tryWildCard = false) const; 00884 00893 void 00894 addExtensionNamespace( 00895 const XalanDOMString& uri, 00896 ExtensionNSHandler* nsh); 00897 00904 ExtensionNSHandler* 00905 lookupExtensionNSHandler(const XalanDOMString& uri) const 00906 { 00907 const ExtensionNamespacesMapType::const_iterator it = 00908 m_extensionNamespaces.find(uri); 00909 00910 return it == m_extensionNamespaces.end() ? 0 : (*it).second; 00911 } 00912 00920 void 00921 setTopLevelVariable(ElemVariable* var) 00922 { 00923 m_topLevelVariables.push_back(var); 00924 } 00925 00933 void 00934 pushTopLevelVariables( 00935 StylesheetExecutionContext& executionContext, 00936 const ParamVectorType& topLevelParams) const; 00937 00938 const XPathVectorType& 00939 getWhitespacePreservingElements() const 00940 { 00941 return m_whitespacePreservingElements; 00942 } 00943 00944 void 00945 pushWhitespacePreservingElement(const XPath* theXPath) 00946 { 00947 m_whitespacePreservingElements.push_back(theXPath); 00948 } 00949 00950 const XPathVectorType& 00951 getWhitespaceStrippingElements() const 00952 { 00953 return m_whitespaceStrippingElements; 00954 } 00955 00956 void 00957 pushWhitespaceStrippingElement(const XPath* theXPath) 00958 { 00959 m_whitespaceStrippingElements.push_back(theXPath); 00960 } 00961 00962 // These interfaces are inherited from XalanDocument... 00963 00964 virtual const XalanDOMString& 00965 getNodeName() const; 00966 00967 virtual const XalanDOMString& 00968 getNodeValue() const; 00969 00970 virtual NodeType 00971 getNodeType() const; 00972 00973 virtual XalanNode* 00974 getParentNode() const; 00975 00976 virtual const XalanNodeList* 00977 getChildNodes() const; 00978 00979 virtual XalanNode* 00980 getFirstChild() const; 00981 00982 virtual XalanNode* 00983 getLastChild() const; 00984 00985 virtual XalanNode* 00986 getPreviousSibling() const; 00987 00988 virtual XalanNode* 00989 getNextSibling() const; 00990 00991 virtual const XalanNamedNodeMap* 00992 getAttributes() const; 00993 00994 virtual XalanDocument* 00995 getOwnerDocument() const; 00996 00997 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00998 virtual XalanNode* 00999 #else 01000 virtual Stylesheet* 01001 #endif 01002 cloneNode(bool deep) const; 01003 01004 virtual XalanNode* 01005 insertBefore( 01006 XalanNode* newChild, 01007 XalanNode* refChild); 01008 01009 virtual XalanNode* 01010 replaceChild( 01011 XalanNode* newChild, 01012 XalanNode* oldChild); 01013 01014 virtual XalanNode* 01015 removeChild(XalanNode* oldChild); 01016 01017 virtual XalanNode* 01018 appendChild(XalanNode* newChild); 01019 01020 virtual bool 01021 hasChildNodes() const; 01022 01023 virtual void 01024 setNodeValue(const XalanDOMString& nodeValue); 01025 01026 virtual void 01027 normalize(); 01028 01029 virtual bool 01030 supports( 01031 const XalanDOMString& feature, 01032 const XalanDOMString& version) const; 01033 01034 virtual const XalanDOMString& 01035 getNamespaceURI() const; 01036 01037 virtual const XalanDOMString& 01038 getPrefix() const; 01039 01040 virtual const XalanDOMString& 01041 getLocalName() const; 01042 01043 virtual void 01044 setPrefix(const XalanDOMString& prefix); 01045 01046 virtual unsigned long 01047 getIndex() const; 01048 01049 virtual XalanElement* 01050 createElement(const XalanDOMString& tagName); 01051 01052 virtual XalanDocumentFragment* 01053 createDocumentFragment(); 01054 01055 virtual XalanText* 01056 createTextNode(const XalanDOMString& data); 01057 01058 virtual XalanComment* 01059 createComment(const XalanDOMString& data); 01060 01061 virtual XalanCDATASection* 01062 createCDATASection(const XalanDOMString& data); 01063 01064 virtual XalanProcessingInstruction* 01065 createProcessingInstruction( 01066 const XalanDOMString& target, 01067 const XalanDOMString& data); 01068 01069 virtual XalanAttr* 01070 createAttribute(const XalanDOMString& name); 01071 01072 virtual XalanEntityReference* 01073 createEntityReference(const XalanDOMString &name); 01074 01075 virtual XalanDocumentType* 01076 getDoctype() const; 01077 01078 virtual XalanDOMImplementation* 01079 getImplementation() const; 01080 01081 virtual XalanElement* 01082 getDocumentElement() const; 01083 01084 virtual XalanNodeList* 01085 getElementsByTagName(const XalanDOMString& tagname) const; 01086 01087 virtual XalanNode* 01088 importNode( 01089 XalanNode* importedNode, 01090 bool deep); 01091 01092 virtual XalanElement* 01093 createElementNS( 01094 const XalanDOMString& namespaceURI, 01095 const XalanDOMString& qualifiedName); 01096 01097 virtual XalanAttr* 01098 createAttributeNS( 01099 const XalanDOMString& namespaceURI, 01100 const XalanDOMString& qualifiedName); 01101 01102 virtual XalanNodeList* 01103 getElementsByTagNameNS( 01104 const XalanDOMString& namespaceURI, 01105 const XalanDOMString& localName) const; 01106 01107 virtual XalanElement* 01108 getElementById(const XalanDOMString& elementId) const; 01109 01110 virtual bool 01111 isIndexed() const; 01112 01113 // These interfaces are inherited from PrefixResolver... 01114 01115 virtual const XalanDOMString& 01116 getNamespaceForPrefix(const XalanDOMString& prefix) const; 01117 01118 virtual const XalanDOMString& 01119 getURI() const; 01120 01121 const XalanDOMString& 01122 getXSLTNamespaceURI() const 01123 { 01124 return m_XSLTNamespaceURI; 01125 } 01126 01127 void 01128 setXSLTNamespaceURI(const XalanDOMString& theURI) 01129 { 01130 m_XSLTNamespaceURI = theURI; 01131 } 01132 01133 protected: 01134 01138 StylesheetRoot& m_stylesheetRoot; 01139 01143 bool m_needToBuildKeysTable; 01144 01148 XalanDOMString m_baseIdent; 01149 01154 KeyDeclarationVectorType m_keyDeclarations; 01155 01156 private: 01157 01158 // Not defined... 01159 Stylesheet(const Stylesheet&); 01160 01161 Stylesheet& 01162 operator=(const Stylesheet&); 01163 01164 bool 01165 operator==(const Stylesheet&) const; 01166 01171 XalanDOMString m_XSLTNamespaceURI; 01172 01176 XPathVectorType m_whitespacePreservingElements; 01177 01181 XPathVectorType m_whitespaceStrippingElements; 01182 01186 StylesheetVectorType m_imports; 01187 01191 NamespacesStackType m_namespaces; 01192 01197 NamespaceVectorType m_namespaceDecls; 01198 01203 static const NamespaceVectorType s_emptyNamespace; 01204 01208 bool m_tablesAreInvalid; 01209 01214 bool m_isWrapperless; 01215 01219 ElemTemplate* m_wrapperlessTemplate; 01220 01224 ExtensionNamespacesMapType m_extensionNamespaces; 01225 01226 01230 ElemTemplateElement* m_firstTemplate; 01231 01236 URLStackType m_includeStack; 01237 01243 bool m_defaultSpace; 01244 01250 ElemTemplateMapType m_namedTemplates; 01251 01255 ElemVariableVectorType m_topLevelVariables; 01256 01257 01261 double m_XSLTVerDeclared; 01262 01263 const bool m_isRoot; 01264 01270 PatternTableMapType m_patternTable; 01271 01276 PatternTableMapType::size_type m_patternCount; 01277 01281 AttributeSetMapType m_attributeSets; 01282 01283 XalanNodeListSurrogate m_surrogateChildren; 01284 01285 XalanEmptyNamedNodeMap m_fakeAttributes; 01286 01287 ElemDecimalFormatVectorType m_elemDecimalFormats; 01288 01289 StringToStringMapType m_prefixAliases; 01290 01291 NamespacesHandler m_namespacesHandler; 01292 01293 static const XalanDOMString s_emptyString; 01294 }; 01295 01296 01297 01298 #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 |
|