Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

Main Page | Directories | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

StylesheetConstructionContextDefault.hpp

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

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.8
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.