## Xalan-C++ API Documentation

### The Xalan C++ XSLT Processor Version 1.7

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-2004 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             int                         token,
    00460             Stylesheet&                 stylesheetTree,
    00461             const XalanDOMChar*         name,
    00462             const AttributeListType&    atts,
    00463             const LocatorType*          locator = 0);
    00464
    00465     virtual ElemTemplateElement*
    00466     createElement(
    00467             Stylesheet&                 stylesheetTree,
    00468             const XalanDOMChar*         chars,
    00469             XalanDOMString::size_type   length,
    00470             bool                        preserveSpace,
    00471             bool                        disableOutputEscaping,
    00472             const LocatorType*          locator = 0);
    00473
    00474     virtual ElemTemplateElement*
    00475     createElement(
    00476             Stylesheet&                 stylesheetTree,
    00477             const XalanDOMChar*         name,
    00478             const AttributeListType&    atts,
    00479             ExtensionNSHandler&         handler,
    00480             const LocatorType*          locator = 0);
    00481
    00482     static eElementToken
    00483     getElementNameToken(const XalanDOMString&   name);
    00484
    00485 #if defined(XALAN_NO_STD_NAMESPACE)
    00486     typedef vector<StylesheetRoot*>         StylesheetVectorType;
    00487     typedef vector<ElemTemplateElement*>    ElemTemplateElementVectorType;
    00488 #else
    00489     typedef std::vector<StylesheetRoot*>        StylesheetVectorType;
    00490     typedef std::vector<ElemTemplateElement*>   ElemTemplateElementVectorType;
    00491 #endif
    00492
    00493 private:
    00494
    00495     const AVT**
    00496     doAllocateAVTPointerVector(size_type    theSize)
    00497     {
    00498         assert(sizeof(AVT**) == sizeof(PointerVectorAllocatorType::value_type));
    00499
    00500 #if defined(XALAN_OLD_STYLE_CASTS)
    00501         return (const AVT**)m_pointerVectorAllocator.allocate(theSize);
    00502 #else
    00503         return reinterpret_cast<const AVT**>(m_pointerVectorAllocator.allocate(theSize));
    00504 #endif
    00505     }
    00506
    00507     const AVTPart**
    00508     doAllocateAVTPartPointerVector(size_type    theSize)
    00509     {
    00510         assert(sizeof(AVTPart**) == sizeof(PointerVectorAllocatorType::value_type));
    00511
    00512 #if defined(XALAN_OLD_STYLE_CASTS)
    00513         return (const AVTPart**)m_pointerVectorAllocator.allocate(theSize);
    00514 #else
    00515         return reinterpret_cast<const AVTPart**>(m_pointerVectorAllocator.allocate(theSize));
    00516 #endif
    00517     }
    00518
    00519     const XalanQName**
    00520     doAllocateXalanQNamePointerVector(size_type theSize)
    00521     {
    00522         assert(sizeof(XalanQName**) == sizeof(PointerVectorAllocatorType::value_type));
    00523
    00524 #if defined(XALAN_OLD_STYLE_CASTS)
    00525         return (const XalanQName**)m_pointerVectorAllocator.allocate(theSize);
    00526 #else
    00527         return reinterpret_cast<const XalanQName**>(m_pointerVectorAllocator.allocate(theSize));
    00528 #endif
    00529     }
    00530
    00531
    00532     XSLTEngineImpl&                         m_processor;
    00533
    00534     XPathFactory&                           m_xpathFactory;
    00535
    00536     typedef XalanAutoPtr<XPathProcessor>    XPathProcessAutoPtr;
    00537
    00538     XPathProcessAutoPtr                     m_xpathProcessor;
    00539
    00540     StylesheetVectorType                    m_stylesheets;
    00541
    00542     XalanDOMStringPool                      m_stringPool;
    00543
    00544     XalanDOMCharVectorAllocatorType         m_xalanDOMCharVectorAllocator;
    00545
    00546     mutable XalanDOMString                  m_tempBuffer;
    00547
    00548     XalanQNameByValue                       m_scratchQName;
    00549
    00550     XalanDOMStringCache                     m_stringCache;
    00551
    00552     XalanAVTAllocator                       m_avtAllocator;
    00553
    00554     XalanAVTPartSimpleAllocator             m_avtPartSimpleAllocator;
    00555
    00556     XalanAVTPartXPathAllocator              m_avtPartXPathAllocator;
    00557
    00558     XalanQNameByValueAllocator              m_xalanQNameByValueAllocator;
    00559
    00560     const XalanQNameByReference             m_useAttributeSetsQName;
    00561
    00562     PointerVectorAllocatorType              m_pointerVectorAllocator;
    00563
    00564     ElemTemplateElementVectorType           m_allocatedElements;
    00565
    00566     XalanElemApplyTemplatesAllocator        m_elemApplyTemplatesAllocator;
    00567
    00568     XalanElemAttributeAllocator             m_elemAttributeAllocator;
    00569
    00570     XalanElemAttributeSetAllocator          m_elemAttributeSetAllocator;
    00571
    00572     XalanElemCallTemplateAllocator          m_elemCallTemplateAllocator;
    00573
    00574     XalanElemElementAllocator               m_elemElementAllocator;
    00575
    00576     XalanElemLiteralResultAllocator         m_elemLiteralResultAllocator;
    00577
    00578     XalanElemTemplateAllocator              m_elemTemplateAllocator;
    00579
    00580     XalanElemTextLiteralAllocator           m_elemTextLiteralAllocator;
    00581
    00582     XalanElemValueOfAllocator               m_elemValueOfAllocator;
    00583
    00584     XalanElemVariableAllocator              m_elemVariableAllocator;
    00585
    00586     const XalanQNameByReference             m_spaceAttrQName;
    00587
    00588     // Static strings for stylesheet compilation...
    00589
    00590     // The string "if"
    00591     static const XalanDOMChar   s_if[];
    00592
    00593     // The string "key"
    00594     static const XalanDOMChar   s_key[];
    00595
    00596     // The string "copy"
    00597     static const XalanDOMChar   s_copy[];
    00598
    00599     // The string "sort"
    00600     static const XalanDOMChar   s_sort[];
    00601
    00602     // The string "text"
    00603     static const XalanDOMChar   s_text[];
    00604
    00605     // The string "when"
    00606     static const XalanDOMChar   s_when[];
    00607
    00608     // The string "empty"
    00609     static const XalanDOMChar   s_empty[];
    00610
    00611     // The string "param"
    00612     static const XalanDOMChar   s_param[];
    00613
    00614     // The string "choose"
    00615     static const XalanDOMChar   s_choose[];
    00616
    00617     // The string "import"
    00618     static const XalanDOMChar   s_import[];
    00619
    00620     // The string "number"
    00621     static const XalanDOMChar   s_number[];
    00622
    00623     // The string "output"
    00624     static const XalanDOMChar   s_output[];
    00625
    00626     // The string "comment"
    00627     static const XalanDOMChar   s_comment[];
    00628
    00629     // The string "copy-of"
    00630     static const XalanDOMChar   s_copyOf[];
    00631
    00632     // The string "element"
    00633     static const XalanDOMChar   s_element[];
    00634
    00635     // The string "include"
    00636     static const XalanDOMChar   s_include[];
    00637
    00638     // The string "message"
    00639     static const XalanDOMChar   s_message[];
    00640
    00641     // The string "fallback"
    00642     static const XalanDOMChar   s_fallback[];
    00643
    00644     // The string "for-each"
    00645     static const XalanDOMChar   s_forEach[];
    00646
    00647     // The string "template"
    00648     static const XalanDOMChar   s_template[];
    00649
    00650     // The string "value-of"
    00651     static const XalanDOMChar   s_valueOf[];
    00652
    00653     // The string "variable"
    00654     static const XalanDOMChar   s_variable[];
    00655
    00656     // The string "attribute"
    00657     static const XalanDOMChar   s_attribute[];
    00658
    00659     // The string "otherwise"
    00660     static const XalanDOMChar   s_otherwise[];
    00661
    00662     // The string "transform"
    00663     static const XalanDOMChar   s_transform[];
    00664
    00665     // The string "stylesheet"
    00666     static const XalanDOMChar   s_stylesheet[];
    00667
    00668     // The string "with-param"
    00669     static const XalanDOMChar   s_withParam[];
    00670
    00671     // The string "strip-space"
    00672     static const XalanDOMChar   s_stripSpace[];
    00673
    00674     // The string "apply-imports"
    00675     static const XalanDOMChar   s_applyImports[];
    00676
    00677     // The string "attribute-set"
    00678     static const XalanDOMChar   s_attributeSet[];
    00679
    00680     // The string "call-template"
    00681     static const XalanDOMChar   s_callTemplate[];
    00682
    00683     // The string "decimal-format"
    00684     static const XalanDOMChar   s_decimalFormat[];
    00685
    00686     // The string "preserve-space"
    00687     static const XalanDOMChar   s_preserveSpace[];
    00688
    00689     // The string "apply-templates"
    00690     static const XalanDOMChar   s_applyTemplates[];
    00691
    00692     // The string "namespace-alias"
    00693     static const XalanDOMChar   s_namespaceAlias[];
    00694
    00695     // The string "processing-instruction"
    00696     static const XalanDOMChar   s_processingInstruction[];
    00697
    00698     // A struct for an array that maps stylesheet element names
    00699     // to int tokens.
    00700     struct ElementTokenTableEntry
    00701     {
    00702         const XalanDOMChar*     m_name;
    00703
    00704         eElementToken           m_token;
    00705     };
    00706
    00707     static const ElementTokenTableEntry     s_elementTokenTable[];
    00708
    00709     static const unsigned int               s_elementTokenTableSize;
    00710
    00711     static const ElementTokenTableEntry&    s_elementTokenTableLast;
    00712
    00713     static const ElementTokenTableEntry&    s_elementTokenTableDummy;
    00714 };
    00715
    00716
    00717
    00718 XALAN_CPP_NAMESPACE_END
    00719
    00720
    00721
    00722 #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.7 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.