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 * @author <a href="mailto:david_n_bertoni@lotus.com">David N. Bertoni</a> 00058 */ 00059 #if !defined(STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680) 00060 #define STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 00061 00062 00063 00064 // Base include file. Must be first. 00065 #include <xalanc/XSLT/XSLTDefinitions.hpp> 00066 00067 00068 00069 #include <vector> 00070 00071 00072 00073 #include <xalanc/PlatformSupport/ArenaAllocator.hpp> 00074 #include <xalanc/PlatformSupport/XalanArrayAllocator.hpp> 00075 #include <xalanc/PlatformSupport/XalanDOMStringPool.hpp> 00076 00077 00078 00079 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) || (XALAN_ALLINONE_BUILD_DLL) 00080 #include <xalanc/XPath/XPathProcessor.hpp> 00081 #endif 00082 00083 00084 00085 #include <xalanc/Include/XalanAutoPtr.hpp> 00086 00087 00088 00089 #include <xalanc/PlatformSupport/XalanDOMStringCache.hpp> 00090 00091 00092 00093 #include <xalanc/XPath/XalanQNameByReference.hpp> 00094 #include <xalanc/XPath/XalanQNameByValue.hpp> 00095 #include <xalanc/XPath/XalanQNameByValueAllocator.hpp> 00096 00097 00098 00099 // Base class header file... 00100 #include <xalanc/XSLT/StylesheetConstructionContext.hpp> 00101 00102 00103 00104 #include <xalanc/XSLT/AVT.hpp> 00105 #include <xalanc/XSLT/XalanAVTAllocator.hpp> 00106 #include <xalanc/XSLT/AVTPartSimple.hpp> 00107 #include <xalanc/XSLT/XalanAVTPartSimpleAllocator.hpp> 00108 #include <xalanc/XSLT/AVTPartXPath.hpp> 00109 #include <xalanc/XSLT/XalanAVTPartXPathAllocator.hpp> 00110 #include <xalanc/XSLT/XalanElemApplyTemplatesAllocator.hpp> 00111 #include <xalanc/XSLT/XalanElemAttributeAllocator.hpp> 00112 #include <xalanc/XSLT/XalanElemAttributeSetAllocator.hpp> 00113 #include <xalanc/XSLT/XalanElemCallTemplateAllocator.hpp> 00114 #include <xalanc/XSLT/XalanElemElementAllocator.hpp> 00115 #include <xalanc/XSLT/XalanElemLiteralResultAllocator.hpp> 00116 #include <xalanc/XSLT/XalanElemTemplateAllocator.hpp> 00117 #include <xalanc/XSLT/XalanElemTextLiteralAllocator.hpp> 00118 #include <xalanc/XSLT/XalanElemValueOfAllocator.hpp> 00119 #include <xalanc/XSLT/XalanElemVariableAllocator.hpp> 00120 00121 00122 00123 XALAN_CPP_NAMESPACE_BEGIN 00124 00125 00126 00127 class XPathEnvSupport; 00128 class XPathFactory; 00129 class XPathProcessor; 00130 class XSLTEngineImpl; 00131 00132 00133 00140 class XALAN_XSLT_EXPORT StylesheetConstructionContextDefault : public StylesheetConstructionContext 00141 { 00142 public: 00143 00144 typedef XalanArrayAllocator<XalanDOMChar> XalanDOMCharVectorAllocatorType; 00145 typedef XalanArrayAllocator<const void*> PointerVectorAllocatorType; 00146 typedef XalanDOMCharVectorAllocatorType::size_type VectorAllocatorSizeType; 00147 00148 // Default size for vector allocation. 00149 enum { 00150 eDefaultXalanDOMCharVectorBlockSize = 1024, 00151 eDefaultAVTBlockSize = 128, 00152 eDefaultAVTPartSimpleBlockSize = 128, 00153 eDefaultAVTPartXPathBlockSize = 128, 00154 eDefaultXalanQNameByValueBlockSize = 32, 00155 eDefaultPointerVectorBlockSize = 512, 00156 eDefaultElemApplyTemplatesBlockSize = 10, 00157 eDefaultElemAttributeBlockSize = 10, 00158 eDefaultElemAttributeSetBlockSize = 10, 00159 eDefaultElemCallTemplateBlockSize = 10, 00160 eDefaultElemElementBlockSize = 10, 00161 eDefaultElemLiteralResultBlockSize = 20, 00162 eDefaultElemTemplateBlockSize = 10, 00163 eDefaultElemTextLiteralBlockSize = 20, 00164 eDefaultElemValueOfBlockSize = 10, 00165 eDefaultElemVariableBlockSize = 10 }; 00166 00167 /* 00168 * Construct an instance. If the stylesheet(s) constructed is/are meant to be reused (a.k.a. "compiled"), 00169 * the XObjectFactory and XPathFactory instance must exist for the lifetime of the construction context 00170 * and, therefore, for the lifetime of the stylesheet(s). Otherwise, XObject and XPath instance will be 00171 * destroyed when the corresponding factories are destryed, leaving pointers to destroyed objects in the. 00172 * stylesheet(s). 00173 * 00174 * @param processor a reference to an XSLTEngineImpl instance. Used for error reporting. 00175 * @param xpathFactory a reference to an XPathFactory instance. See comments above for important details. 00176 * @param theXalanDOMCharVectorAllocatorBlockSize The block size to use for allocating vectors of XalanDOMChars 00177 * @param theAVTAllocatorBlockSize The block size to use for allocating AVT instances. 00178 * @param theAVTPartSimpleAllocatorBlockSize The block size to use for allocating AVTPartSimple instances. 00179 * @param theAVTPartXPathAllocatorBlockSize The block size to use for allocating AVTPartXPath instances. 00180 * @param theXalanQNameByValueAllocatorBlockSize The block size to use for allocating XalanQNameByValue instances. 00181 * @param thePointerVectorAllocatorBlockSize The block size to use for allocating vectors of pointers. 00182 */ 00183 StylesheetConstructionContextDefault( 00184 XSLTEngineImpl& processor, 00185 XPathFactory& xpathFactory, 00186 VectorAllocatorSizeType theXalanDOMCharVectorAllocatorBlockSize = eDefaultXalanDOMCharVectorBlockSize, 00187 XalanAVTAllocator::size_type theAVTAllocatorBlockSize = eDefaultAVTBlockSize, 00188 XalanAVTPartSimpleAllocator::size_type theAVTPartSimpleAllocatorBlockSize = eDefaultAVTPartSimpleBlockSize, 00189 XalanAVTPartXPathAllocator::size_type theAVTPartXPathAllocatorBlockSize = eDefaultAVTPartXPathBlockSize, 00190 XalanQNameByValueAllocator::size_type theXalanQNameByValueAllocatorBlockSize = eDefaultXalanQNameByValueBlockSize, 00191 VectorAllocatorSizeType thePointerVectorAllocatorBlockSize = eDefaultPointerVectorBlockSize); 00192 00193 virtual 00194 ~StylesheetConstructionContextDefault(); 00195 00196 00197 virtual void 00198 error( 00199 const XalanDOMString& msg, 00200 const XalanNode* sourceNode = 0, 00201 const ElemTemplateElement* styleNode = 0) const; 00202 00203 virtual void 00204 error( 00205 const XalanDOMString& msg, 00206 const XalanNode* sourceNode, 00207 const LocatorType* locator) const; 00208 00209 virtual void 00210 error( 00211 const char* msg, 00212 const XalanNode* sourceNode = 0, 00213 const ElemTemplateElement* styleNode = 0) const; 00214 00215 virtual void 00216 error( 00217 const char* msg, 00218 const XalanNode* sourceNode, 00219 const LocatorType* locator) const; 00220 00221 virtual void 00222 warn( 00223 const XalanDOMString& msg, 00224 const XalanNode* sourceNode = 0, 00225 const ElemTemplateElement* styleNode = 0) const; 00226 00227 virtual void 00228 warn( 00229 const XalanDOMString& msg, 00230 const XalanNode* sourceNode, 00231 const LocatorType* locator) const; 00232 00233 virtual void 00234 warn( 00235 const char* msg, 00236 const XalanNode* sourceNode = 0, 00237 const ElemTemplateElement* styleNode = 0) const; 00238 00239 virtual void 00240 warn( 00241 const char* msg, 00242 const XalanNode* sourceNode, 00243 const LocatorType* locator) const; 00244 00245 virtual void 00246 message( 00247 const XalanDOMString& msg, 00248 const XalanNode* sourceNode = 0, 00249 const ElemTemplateElement* styleNode = 0) const; 00250 00251 virtual void 00252 message( 00253 const XalanDOMString& msg, 00254 const XalanNode* sourceNode, 00255 const LocatorType* locator) const; 00256 00257 virtual void 00258 message( 00259 const char* msg, 00260 const XalanNode* sourceNode = 0, 00261 const ElemTemplateElement* styleNode = 0) const; 00262 00263 virtual void 00264 message( 00265 const char* msg, 00266 const XalanNode* sourceNode, 00267 const LocatorType* locator) const; 00268 00269 // These interfaces are inherited from StylesheetConstructionContext... 00270 00271 virtual void 00272 reset(); 00273 00274 virtual StylesheetRoot* 00275 create(const XalanDOMString& theBaseIdentifier); 00276 00277 virtual StylesheetRoot* 00278 create(const XSLTInputSource& theInputSource); 00279 00280 virtual Stylesheet* 00281 create( 00282 StylesheetRoot& theStylesheetRoot, 00283 const XalanDOMString& theBaseIdentifier); 00284 00285 virtual void 00286 destroy(StylesheetRoot* theStylesheetRoot); 00287 00288 virtual URLAutoPtrType 00289 getURLFromString(const XalanDOMString& urlString); 00290 00291 virtual XalanDOMString 00292 getURLStringFromString(const XalanDOMString& urlString); 00293 00294 virtual URLAutoPtrType 00295 getURLFromString( 00296 const XalanDOMString& urlString, 00297 const XalanDOMString& base); 00298 00299 virtual XalanDOMString 00300 getURLStringFromString( 00301 const XalanDOMString& urlString, 00302 const XalanDOMString& base); 00303 00304 virtual const XalanDOMString& 00305 getXSLTNamespaceURI() const; 00306 00307 virtual XPath* 00308 createMatchPattern( 00309 const LocatorType* locator, 00310 const XalanDOMString& str, 00311 const PrefixResolver& resolver); 00312 00313 virtual XPath* 00314 createMatchPattern( 00315 const LocatorType* locator, 00316 const XalanDOMChar* str, 00317 const PrefixResolver& resolver); 00318 00319 virtual XPath* 00320 createXPath( 00321 const LocatorType* locator, 00322 const XalanDOMString& str, 00323 const PrefixResolver& resolver); 00324 00325 virtual XPath* 00326 createXPath( 00327 const LocatorType* locator, 00328 const XalanDOMChar* str, 00329 XalanDOMString::size_type len, 00330 const PrefixResolver& resolver); 00331 00332 virtual XPath* 00333 createXPath( 00334 const LocatorType* locator, 00335 const XalanDOMChar* str, 00336 const PrefixResolver& resolver); 00337 00338 virtual const LocatorType* 00339 getLocatorFromStack() const; 00340 00341 virtual void 00342 pushLocatorOnStack(const LocatorType* locator); 00343 00344 virtual void 00345 popLocatorStack(); 00346 00347 virtual const XalanDOMString& 00348 getXalanXSLNameSpaceURL() const; 00349 00350 virtual XalanDocument* 00351 parseXML( 00352 const XalanDOMString& urlString, 00353 DocumentHandlerType* docHandler, 00354 XalanDocument* docToRegister); 00355 00356 virtual bool 00357 isXMLSpaceAttribute( 00358 const XalanDOMChar* theAttributeName, 00359 const Stylesheet& theStylesheet, 00360 const LocatorType* theLocator = 0); 00361 00362 virtual bool 00363 isXSLUseAttributeSetsAttribute( 00364 const XalanDOMChar* theAttributeName, 00365 const Stylesheet& theStylesheet, 00366 const LocatorType* theLocator = 0); 00367 00368 virtual bool 00369 isValidQName( 00370 const XalanDOMChar* theName, 00371 const Stylesheet& theStylesheet, 00372 const LocatorType* theLocator = 0); 00373 00374 virtual eElementToken 00375 getElementToken(const XalanDOMString& name) const; 00376 00377 virtual double 00378 getXSLTVersionSupported() const; 00379 00380 virtual const XalanDOMString& 00381 getPooledString(const XalanDOMString& theString); 00382 00383 virtual const XalanDOMString& 00384 getPooledString( 00385 const XalanDOMChar* theString, 00386 XalanDOMString::size_type theLength = XalanDOMString::npos); 00387 00388 virtual XalanDOMString& 00389 getCachedString(); 00390 00391 virtual bool 00392 releaseCachedString(XalanDOMString& theString); 00393 00394 virtual XalanDOMChar* 00395 allocateXalanDOMCharVector(XalanDOMString::size_type theLength); 00396 00397 virtual XalanDOMChar* 00398 allocateXalanDOMCharVector( 00399 const XalanDOMChar* theString, 00400 XalanDOMString::size_type theLength = XalanDOMString::npos, 00401 bool fTerminate = true); 00402 00403 virtual const AVT* 00404 createAVT( 00405 const LocatorType* locator, 00406 const XalanDOMChar* name, 00407 const XalanDOMChar* stringedValue, 00408 const PrefixResolver& resolver); 00409 00410 virtual const AVTPart* 00411 createAVTPart( 00412 const XalanDOMChar* theString, 00413 XalanDOMString::size_type theLength = XalanDOMString::npos); 00414 00415 virtual const AVTPart* 00416 createAVTPart( 00417 const LocatorType* locator, 00418 const XalanDOMChar* str, 00419 XalanDOMString::size_type len, 00420 const PrefixResolver& resolver); 00421 00422 virtual const AVT** 00423 allocateAVTPointerVector(size_type theLength); 00424 00425 virtual const AVTPart** 00426 allocateAVTPartPointerVector(size_type theLength); 00427 00428 virtual const XalanQName* 00429 createXalanQName( 00430 const XalanDOMString& qname, 00431 const NamespacesStackType& namespaces, 00432 const LocatorType* locator = 0, 00433 bool fUseDefault = false); 00434 00435 virtual const XalanQName* 00436 createXalanQName( 00437 const XalanDOMChar* qname, 00438 const NamespacesStackType& namespaces, 00439 const LocatorType* locator = 0, 00440 bool fUseDefault = false); 00441 00442 virtual const XalanQName** 00443 tokenizeQNames( 00444 size_type& count, 00445 const XalanDOMChar* qnameTokens, 00446 const NamespacesStackType& namespaces, 00447 const LocatorType* locator = 0, 00448 bool fUseDefault = false); 00449 00450 virtual ElemTemplateElement* 00451 createElement( 00452 int token, 00453 Stylesheet& stylesheetTree, 00454 const AttributeListType& atts, 00455 const LocatorType* locator = 0); 00456 00457 virtual ElemTemplateElement* 00458 createElement( 00459 Stylesheet& stylesheetTree, 00460 const XalanDOMChar* name, 00461 const AttributeListType& atts, 00462 const LocatorType* locator = 0); 00463 00464 virtual ElemTemplateElement* 00465 createElement( 00466 Stylesheet& stylesheetTree, 00467 const XalanDOMChar* chars, 00468 XalanDOMString::size_type length, 00469 bool preserveSpace, 00470 bool disableOutputEscaping, 00471 const LocatorType* locator = 0); 00472 00473 virtual ElemTemplateElement* 00474 createElement( 00475 Stylesheet& stylesheetTree, 00476 const XalanDOMChar* name, 00477 const AttributeListType& atts, 00478 ExtensionNSHandler& handler, 00479 const LocatorType* locator = 0); 00480 00481 static eElementToken 00482 getElementNameToken(const XalanDOMString& name); 00483 00484 #if defined(XALAN_NO_STD_NAMESPACE) 00485 typedef vector<StylesheetRoot*> StylesheetVectorType; 00486 typedef vector<ElemTemplateElement*> ElemTemplateElementVectorType; 00487 #else 00488 typedef std::vector<StylesheetRoot*> StylesheetVectorType; 00489 typedef std::vector<ElemTemplateElement*> ElemTemplateElementVectorType; 00490 #endif 00491 00492 private: 00493 00494 const AVT** 00495 doAllocateAVTPointerVector(size_type theSize) 00496 { 00497 assert(sizeof(AVT**) == sizeof(PointerVectorAllocatorType::value_type)); 00498 00499 #if defined(XALAN_OLD_STYLE_CASTS) 00500 return (const AVT**)m_pointerVectorAllocator.allocate(theSize); 00501 #else 00502 return reinterpret_cast<const AVT**>(m_pointerVectorAllocator.allocate(theSize)); 00503 #endif 00504 } 00505 00506 const AVTPart** 00507 doAllocateAVTPartPointerVector(size_type theSize) 00508 { 00509 assert(sizeof(AVTPart**) == sizeof(PointerVectorAllocatorType::value_type)); 00510 00511 #if defined(XALAN_OLD_STYLE_CASTS) 00512 return (const AVTPart**)m_pointerVectorAllocator.allocate(theSize); 00513 #else 00514 return reinterpret_cast<const AVTPart**>(m_pointerVectorAllocator.allocate(theSize)); 00515 #endif 00516 } 00517 00518 const XalanQName** 00519 doAllocateXalanQNamePointerVector(size_type theSize) 00520 { 00521 assert(sizeof(XalanQName**) == sizeof(PointerVectorAllocatorType::value_type)); 00522 00523 #if defined(XALAN_OLD_STYLE_CASTS) 00524 return (const XalanQName**)m_pointerVectorAllocator.allocate(theSize); 00525 #else 00526 return reinterpret_cast<const XalanQName**>(m_pointerVectorAllocator.allocate(theSize)); 00527 #endif 00528 } 00529 00530 00531 XSLTEngineImpl& m_processor; 00532 00533 XPathFactory& m_xpathFactory; 00534 00535 typedef XalanAutoPtr<XPathProcessor> XPathProcessAutoPtr; 00536 00537 XPathProcessAutoPtr m_xpathProcessor; 00538 00539 StylesheetVectorType m_stylesheets; 00540 00541 XalanDOMStringPool m_stringPool; 00542 00543 XalanDOMCharVectorAllocatorType m_xalanDOMCharVectorAllocator; 00544 00545 mutable XalanDOMString m_tempBuffer; 00546 00547 XalanQNameByValue m_scratchQName; 00548 00549 XalanDOMStringCache m_stringCache; 00550 00551 XalanAVTAllocator m_avtAllocator; 00552 00553 XalanAVTPartSimpleAllocator m_avtPartSimpleAllocator; 00554 00555 XalanAVTPartXPathAllocator m_avtPartXPathAllocator; 00556 00557 XalanQNameByValueAllocator m_xalanQNameByValueAllocator; 00558 00559 const XalanQNameByReference m_useAttributeSetsQName; 00560 00561 PointerVectorAllocatorType m_pointerVectorAllocator; 00562 00563 ElemTemplateElementVectorType m_allocatedElements; 00564 00565 XalanElemApplyTemplatesAllocator m_elemApplyTemplatesAllocator; 00566 00567 XalanElemAttributeAllocator m_elemAttributeAllocator; 00568 00569 XalanElemAttributeSetAllocator m_elemAttributeSetAllocator; 00570 00571 XalanElemCallTemplateAllocator m_elemCallTemplateAllocator; 00572 00573 XalanElemElementAllocator m_elemElementAllocator; 00574 00575 XalanElemLiteralResultAllocator m_elemLiteralResultAllocator; 00576 00577 XalanElemTemplateAllocator m_elemTemplateAllocator; 00578 00579 XalanElemTextLiteralAllocator m_elemTextLiteralAllocator; 00580 00581 XalanElemValueOfAllocator m_elemValueOfAllocator; 00582 00583 XalanElemVariableAllocator m_elemVariableAllocator; 00584 00585 const XalanQNameByReference m_spaceAttrQName; 00586 00587 // Static strings for stylesheet compilation... 00588 00589 // The string "if" 00590 static const XalanDOMChar s_if[]; 00591 00592 // The string "key" 00593 static const XalanDOMChar s_key[]; 00594 00595 // The string "copy" 00596 static const XalanDOMChar s_copy[]; 00597 00598 // The string "sort" 00599 static const XalanDOMChar s_sort[]; 00600 00601 // The string "text" 00602 static const XalanDOMChar s_text[]; 00603 00604 // The string "when" 00605 static const XalanDOMChar s_when[]; 00606 00607 // The string "empty" 00608 static const XalanDOMChar s_empty[]; 00609 00610 // The string "param" 00611 static const XalanDOMChar s_param[]; 00612 00613 // The string "choose" 00614 static const XalanDOMChar s_choose[]; 00615 00616 // The string "import" 00617 static const XalanDOMChar s_import[]; 00618 00619 // The string "number" 00620 static const XalanDOMChar s_number[]; 00621 00622 // The string "output" 00623 static const XalanDOMChar s_output[]; 00624 00625 // The string "comment" 00626 static const XalanDOMChar s_comment[]; 00627 00628 // The string "copy-of" 00629 static const XalanDOMChar s_copyOf[]; 00630 00631 // The string "element" 00632 static const XalanDOMChar s_element[]; 00633 00634 // The string "include" 00635 static const XalanDOMChar s_include[]; 00636 00637 // The string "message" 00638 static const XalanDOMChar s_message[]; 00639 00640 // The string "fallback" 00641 static const XalanDOMChar s_fallback[]; 00642 00643 // The string "for-each" 00644 static const XalanDOMChar s_forEach[]; 00645 00646 // The string "template" 00647 static const XalanDOMChar s_template[]; 00648 00649 // The string "value-of" 00650 static const XalanDOMChar s_valueOf[]; 00651 00652 // The string "variable" 00653 static const XalanDOMChar s_variable[]; 00654 00655 // The string "attribute" 00656 static const XalanDOMChar s_attribute[]; 00657 00658 // The string "otherwise" 00659 static const XalanDOMChar s_otherwise[]; 00660 00661 // The string "transform" 00662 static const XalanDOMChar s_transform[]; 00663 00664 // The string "stylesheet" 00665 static const XalanDOMChar s_stylesheet[]; 00666 00667 // The string "with-param" 00668 static const XalanDOMChar s_withParam[]; 00669 00670 // The string "strip-space" 00671 static const XalanDOMChar s_stripSpace[]; 00672 00673 // The string "apply-imports" 00674 static const XalanDOMChar s_applyImports[]; 00675 00676 // The string "attribute-set" 00677 static const XalanDOMChar s_attributeSet[]; 00678 00679 // The string "call-template" 00680 static const XalanDOMChar s_callTemplate[]; 00681 00682 // The string "decimal-format" 00683 static const XalanDOMChar s_decimalFormat[]; 00684 00685 // The string "preserve-space" 00686 static const XalanDOMChar s_preserveSpace[]; 00687 00688 // The string "apply-templates" 00689 static const XalanDOMChar s_applyTemplates[]; 00690 00691 // The string "namespace-alias" 00692 static const XalanDOMChar s_namespaceAlias[]; 00693 00694 // The string "processing-instruction" 00695 static const XalanDOMChar s_processingInstruction[]; 00696 00697 // A struct for an array that maps stylesheet element names 00698 // to int tokens. 00699 struct ElementTokenTableEntry 00700 { 00701 const XalanDOMChar* m_name; 00702 00703 eElementToken m_token; 00704 }; 00705 00706 static const ElementTokenTableEntry s_elementTokenTable[]; 00707 00708 static const unsigned int s_elementTokenTableSize; 00709 00710 static const ElementTokenTableEntry& s_elementTokenTableLast; 00711 00712 static const ElementTokenTableEntry& s_elementTokenTableDummy; 00713 }; 00714 00715 00716 00717 XALAN_CPP_NAMESPACE_END 00718 00719 00720 00721 #endif // STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSLT Processor Version 1.6 |
|