Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.6

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

StylesheetConstructionContextDefault.hpp

Go to the documentation of this file.
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

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.6
Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.