Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XSLTEngineImpl.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if !defined(XALAN_XSLTENGINEIMPL_HEADER_GUARD)
#define XALAN_XSLTENGINEIMPL_HEADER_GUARD



// Base include file.  Must be first.
#include "XSLTDefinitions.hpp"



// Base class
#include "XSLTProcessor.hpp"




// Standard library headers
#include <cassert>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
#include <xalanc/XPath/XPathProcessor.hpp>
#endif



#include <xalanc/Include/XalanMemMgrAutoPtr.hpp>
#include <xalanc/Include/XalanMap.hpp>



#include <xalanc/PlatformSupport/AttributeListImpl.hpp>
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/PrefixResolver.hpp>



#include <xalanc/DOMSupport/XalanNamespacesStack.hpp>



#include <xalanc/XPath/Function.hpp>



#include <xalanc/XPath/XPathConstructionContextDefault.hpp>



#include "OutputContextStack.hpp"
#include "ProblemListenerDefault.hpp"
#include "ResultNamespacesStack.hpp"
#include "StylesheetExecutionContext.hpp"
#include "XSLTProcessorException.hpp"



XALAN_DECLARE_XERCES_CLASS(InputSource)
XALAN_DECLARE_XERCES_CLASS(DocumentHandler)



XALAN_CPP_NAMESPACE_BEGIN



typedef XERCES_CPP_NAMESPACE_QUALIFIER InputSource      InputSourceType;
typedef XERCES_CPP_NAMESPACE_QUALIFIER DocumentHandler  DocumentHandlerType;



// Forward declarations...
class DOMSupport;
class GenerateEvent;
class PrintWriter;
class StylesheetConstructionContext;
class StylesheetRoot;
class XalanAttr;
class XalanSourceTreeDocument;
class XalanText;
class XMLParserLiaison;
class XObject;
class XPathEnvSupport;
class XPathFactory;
class XPathProcessor;
class XSLTResultTarget;




class XALAN_XSLT_EXPORT XSLTEngineImpl : public XSLTProcessor, public PrefixResolver
{
public:

    struct LessXalanDOMStringPointers
    {
        bool
        operator()(
                const XalanDOMString*   theLHS,
                const XalanDOMString*   theRHS) const
        {
            if (theLHS == 0 && theRHS != 0)
            {
                return true;
            }
            else if (theRHS == 0)
            {
                return false;
            }
            else
            {
                return theLHS->compare(*theRHS) < 0 ? true : false;
            }
        }
    };

    typedef XalanVector<const LocatorType*>     LocatorStack;
    typedef XalanVector<TraceListener*>         TraceListenerVectorType;
    typedef XalanVector<const XalanDOMString*>  XalanDOMStringPointerVectorType;

    typedef XalanVector<bool>                           BoolVectorType;

    struct FindStringPointerFunctor
    {
        FindStringPointerFunctor(const XalanDOMString&  theString) :
            m_string(theString)
        {
        }

        bool
        operator()(const XalanDOMString*    theString) const
        {
            assert(theString != 0);

            return *theString == m_string;
        }

    private:

        const XalanDOMString&   m_string;
    };

    typedef XalanMemMgrAutoPtr<XPathProcessor, true>                XPathProcessorPtrType;
    typedef Function::XObjectArgVectorType              XObjectArgVectorType;
    typedef StylesheetExecutionContext::ParamVectorType ParamVectorType;
    typedef XPathConstructionContext::GetAndReleaseCachedString     CCGetAndReleaseCachedString;
    typedef XPathExecutionContext::GetAndReleaseCachedString        ECGetAndReleaseCachedString;

    // Public members
    //---------------------------------------------------------------------

    XSLTEngineImpl(
            MemoryManagerType&  theManager,
            XMLParserLiaison&   parserLiaison,
            XPathEnvSupport&    xpathEnvSupport,
            DOMSupport&         domSupport,
            XObjectFactory&     xobjectFactory,
            XPathFactory&       xpathFactory);

    virtual
    ~XSLTEngineImpl();

    MemoryManagerType&
    getMemoryManager()
    {
        return m_xpathConstructionContext.getMemoryManager();
    }

    static void
    initialize(MemoryManagerType&      theManager);

    static void
    terminate();

    // These methods are inherited from XSLTProcessor ...
    
    virtual void
    process(
            const XSLTInputSource&          inputSource, 
            const XSLTInputSource&          stylesheetSource,
            XSLTResultTarget&               outputTarget,
            StylesheetConstructionContext&  constructionContext,
            StylesheetExecutionContext&     executionContext);

    virtual void
    process(
            const XSLTInputSource&          inputSource,
            XSLTResultTarget&               outputTarget,
            StylesheetExecutionContext&     executionContext);

    virtual StylesheetRoot*
    processStylesheet(
            const XSLTInputSource&          stylesheetSource,
            StylesheetConstructionContext&  constructionContext);

    virtual StylesheetRoot*
    processStylesheet(
            const XalanDOMString&           xsldocURLString,
            StylesheetConstructionContext&  constructionContext);

    virtual XalanNode*
    getSourceTreeFromInput(const XSLTInputSource&   inputSource);

    virtual void
    resolveTopLevelParams(StylesheetExecutionContext&   executionContext);

    virtual XMLParserLiaison&
    getXMLParserLiaison() const;

    virtual void
    getUniqueNamespaceValue(XalanDOMString&     theValue);

    virtual void
    setStylesheetParam( 
                    const XalanDOMString&   key,
                    const XalanDOMString&   expression);

    virtual void
    setStylesheetParam(
            const XalanDOMString&   key,
            XObjectPtr              value);

    virtual FormatterListener*
    getFormatterListener() const;

    virtual void
    setFormatterListener(FormatterListener* flistener);

    // Trace-related functions...

    virtual size_type
    getTraceListeners() const;

    virtual void
    addTraceListener(TraceListener*     tl);

    virtual void
    removeTraceListener(TraceListener*  tl);

    virtual void
    fireGenerateEvent(const GenerateEvent&  ge);
      
    virtual void
    fireTraceEvent(const TracerEvent&   te);

    virtual void
    fireSelectEvent(const SelectionEvent&   se);

    virtual bool
    getTraceSelects() const;

    virtual void
    setTraceSelects(bool    b);

    void
    traceSelect(
            StylesheetExecutionContext&     executionContext,
            const ElemTemplateElement&      theTemplate,
            const NodeRefListBase&          nl,
            const XPath*                    xpath) const;

    virtual void
    setQuietConflictWarnings(bool   b);

    virtual void
    setDiagnosticsOutput(PrintWriter*   pw);


    // Inherited from PrefixResolver...

    virtual const XalanDOMString*
    getNamespaceForPrefix(const XalanDOMString&     prefix) const;

    virtual const XalanDOMString&
    getURI() const;

    XalanDocument*
    parseXML(
            const XalanDOMString&   urlString,
            DocumentHandlerType*    docHandler,
            XalanDocument*          docToRegister);

    XalanDocument*
    parseXML(
            const InputSourceType&  inputSource,
            DocumentHandlerType*    docHandler,
            XalanDocument*          docToRegister);

    Stylesheet*
    getStylesheetFromPIURL(
            const XalanDOMString&           xslURLString,
            XalanNode&                      fragBase,
            const XalanDOMString&           xmlBaseIdent,
            bool                            isRoot,
            StylesheetConstructionContext&  constructionContext);

    void
    flushPending();

    void
    addResultNamespaceDecl(
            const XalanDOMString&   prefix, 
            const XalanDOMString&   namespaceVal)
    {
        addResultNamespaceDecl(
            prefix,
            namespaceVal.c_str(),
            namespaceVal.length());
    }

    void
    addResultNamespaceDecl(
            const XalanDOMString&       prefix, 
            const XalanDOMChar*         namespaceVal,
            XalanDOMString::size_type   len)
    {
        m_resultNamespacesStack.addDeclaration(
            prefix,
            namespaceVal,
            len);
    }

    void
    addResultAttribute(
            AttributeListImpl&      attList,
            const XalanDOMString&   aname,
            const XalanDOMString&   value,
            bool                    fromCopy = false,
            const LocatorType*      locator = 0)
    {
        addResultAttribute(
            attList,
            aname,
            value.c_str(),
            fromCopy,
            locator);
    }

    void
    addResultAttribute(
            AttributeListImpl&      attList,
            const XalanDOMString&   aname,
            const XalanDOMChar*     value,
            bool                    fromCopy = false,
            const LocatorType*      locator = 0)
    {
        addResultAttribute(
            attList,
            aname,
            value,
            length(value),
            fromCopy,
            locator);
    }

    void
    addResultAttribute(
            AttributeListImpl&          attList,
            const XalanDOMString&       aname,
            const XalanDOMChar*         value,
            XalanDOMString::size_type   theLength,
            bool                        fromCopy = false,
            const LocatorType*          locator = 0);

    void
    addResultAttribute(
            const XalanDOMString&       aname,
            const XalanDOMChar*         value,
            bool                        fromCopy = false,
            const LocatorType*          locator = 0)
    {
        assert(m_outputContextStack.empty() == false);

        addResultAttribute(
                getPendingAttributesImpl(),
                aname,
                value,
                fromCopy,
                locator);
    }

    void
    addResultAttribute(
            const XalanDOMString&   aname,
            const XalanDOMString&   value,
            bool                    fromCopy = false,
            const LocatorType*      locator = 0)
    {
        assert(m_outputContextStack.empty() == false);

        addResultAttribute(
                getPendingAttributesImpl(),
                aname,
                value,
                fromCopy,
                locator);
    }

    void
    reportDuplicateNamespaceNodeError(
            const XalanDOMString&   theName,
            const LocatorType*      locator);

    void
    setDocumentLocator(const LocatorType*   locator);

    void
    startDocument();

    void
    endDocument();
    
    void
    startElement(
            const XalanDOMChar*     name,
            AttributeListType&      atts);

    void
    endElement(const XalanDOMChar*  name);

    void
    characters (
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   length);

    void
    ignorableWhitespace(
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   length);

    void
    processingInstruction(
            const XalanDOMChar*     target,
            const XalanDOMChar*     data);

    void
    resetDocument();

    void
    characters(
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    characters(const XalanNode&     node);

    void
    characters(const XObjectPtr&    xobject);

    void
    startElement(const XalanDOMChar*    name);

    void
    charactersRaw(
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    charactersRaw(const XalanNode&  node);

    void
    charactersRaw(const XObjectPtr&     xobject);

    void
    comment(const XalanDOMChar*     data);

    void
    entityReference(const XalanDOMChar*     data);

    void
    cdata(
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    cloneToResultTree(
            const XalanNode&    node,
            bool                cloneTextNodesOnly,
            const LocatorType*  locator);

    void
    cloneToResultTree(
            const XalanNode&        node,
            XalanNode::NodeType     nodeType,
            bool                    overrideStrip,
            bool                    shouldCloneAttributes,
            bool                    cloneTextNodesOnly,
            const LocatorType*      locator);

    void
    outputToResultTree(
            const XObject&      value,
            bool                outputTextNodesOnly,
            const LocatorType*  locator);

    void
    outputResultTreeFragment(
            const XObject&      theTree,
            bool                outputTextNodesOnly,
            const LocatorType*  locator)
    {
        outputResultTreeFragment(theTree.rtree(), outputTextNodesOnly, locator);
    }

    void
    outputResultTreeFragment(
            const XalanDocumentFragment&    theTree,
            bool                            outputTextNodesOnly,
            const LocatorType*              locator);

    virtual const StylesheetRoot*
    getStylesheetRoot() const;

    virtual void
    setStylesheetRoot(const StylesheetRoot*     theStylesheet);

    virtual void
    setExecutionContext(StylesheetExecutionContext*     theExecutionContext);

    static const XalanDOMString&
    getXSLNameSpaceURL()
    {
        return s_XSLNameSpaceURL;
    }

    static const XalanDOMString&
    getXalanXSLNameSpaceURL()
    {
        return s_XalanNamespaceURL;
    }

    bool
    getQuietConflictWarnings() const
    {
        return m_quietConflictWarnings;
    }

    virtual void
    message(
            const XalanDOMString&       msg,
            const XalanNode*            sourceNode = 0,
            const ElemTemplateElement*  styleNode = 0) const;

    virtual void
    message(
            const XalanDOMString&   msg,
            const LocatorType&      locator,
            const XalanNode*        sourceNode = 0) const;

    virtual void
    warn(
            const XalanDOMString&       msg,
            const XalanNode*            sourceNode = 0,
            const ElemTemplateElement*  styleNode = 0) const;


    virtual void
    warn(
            const XalanDOMString&   msg,
            const LocatorType&      locator,
            const XalanNode*        sourceNode = 0) const;

    virtual void
    error(
            const XalanDOMString&       msg,
            const XalanNode*            sourceNode = 0,
            const ElemTemplateElement*  styleNode = 0) const;

    virtual void
    error(
            const XalanDOMString&   msg,
            const LocatorType&      locator,
            const XalanNode*        sourceNode = 0) const;

public:

    const XalanDOMString*
    getResultNamespaceForPrefix(const XalanDOMString&   prefix) const;

    const XalanDOMString*
    getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const;

    bool
    isPendingResultPrefix(const XalanDOMString&     thePrefix) const;

    double
    evalMatchPatternStr(
            const XalanDOMString&   str,
            XalanNode*              context,
            XPathExecutionContext&  executionContext);

    const XPath*
    createMatchPattern(
            const XalanDOMString&   str,
            const PrefixResolver&   resolver);

    void
    returnXPath(const XPath*    xpath);

    void
    copyNamespaceAttributes(const XalanNode&    src);

    const XObjectPtr
    evalXPathStr(
            const XalanDOMString&   str,
            XPathExecutionContext&  executionContext);

    const XObjectPtr
    evalXPathStr(
            const XalanDOMString&   str,
            XalanNode*              contextNode,
            const PrefixResolver&   prefixResolver,
            XPathExecutionContext&  executionContext);

    const XObjectPtr
    evalXPathStr(
            const XalanDOMString&   str,
            XalanNode*              contextNode,
            const XalanElement&     prefixResolver,
            XPathExecutionContext&  executionContext);

    void
    copyAttributeToTarget(
            const XalanDOMString&   attrName,
            const XalanDOMString&   attrValue,
            AttributeListImpl&      attrList);

    XPathFactory&
    getXPathFactory()
    {
        return m_xpathFactory;
    }

    XPathProcessor&
    getXPathProcessor()
    {
        return *m_xpathProcessor.get();
    }

    virtual void
    reset();

    XPathEnvSupport&
    getXPathEnvSupport()
    {
        return m_xpathEnvSupport;
    }

    void
    setProblemListener(ProblemListener*     l)
    {
        m_problemListener = l;
    }

    ProblemListener*
    getProblemListener() const
    {
        return m_problemListener;
    }

    /*
     * Push a new output context using the provided FormatterListener.
     *
     * @param A pointer to the FormatterListener instance for the new context.
     */
    void
    pushOutputContext(FormatterListener*    theListener)
    {
        m_outputContextStack.pushContext(theListener);
    }

    /*
     * Pop the current output context.
     */
    void
    popOutputContext()
    {
        m_outputContextStack.popContext();
    }

    /*
     * See if there is a pending start document event waiting.
     * @return true if there is a start document event waiting.
     */
    bool
    getHasPendingStartDocument() const
    {
        return getHasPendingStartDocumentImpl();
    }

    /*
     * Set the pending start document event state.
     * @param the new value
     */
    void
    setHasPendingStartDocument(bool b)
    {
        setHasPendingStartDocumentImpl(b);
    }

    /*
     * See if a pending start document event must be flushed.
     * @return true if the event must be flushed.
     */
    bool
    getMustFlushPendingStartDocument() const
    {
        return getMustFlushPendingStartDocumentImpl();
    }

    /*
     * Set the pending start document event flush state.
     * @param the new value
     */
    void
    setMustFlushPendingStartDocument(bool   b)
    {
        setMustFlushPendingStartDocumentImpl(b);
    }

    const AttributeListType&
    getPendingAttributes() const
    {
        return getPendingAttributesImpl();
    }

    void
    setPendingAttributes(const AttributeListType&   pendingAttributes)
    {
        getPendingAttributesImpl() = pendingAttributes;
    }

    void
    replacePendingAttribute(
            const XalanDOMChar*     theName,
            const XalanDOMChar*     theNewType,
            const XalanDOMChar*     theNewValue)
    {
        // Remove the old attribute, then add the new one.  AttributeListImpl::addAttribute()
        // does this for us.
        getPendingAttributesImpl().addAttribute(theName, theNewType, theNewValue);
    }

    bool
    isElementPending() const
    {
        return length(getPendingElementNameImpl()) != 0 ? true : false;
    }

    const XalanDOMString&
    getPendingElementName() const
    {
        return getPendingElementNameImpl();
    }

    void
    setPendingElementName(const XalanDOMString&     elementName)
    {
        setPendingElementNameImpl(elementName);
    }

    void
    setPendingElementName(const XalanDOMChar*   elementName)
    {
        setPendingElementNameImpl(elementName);
    }

    const LocatorType*
    getLocatorFromStack() const
    {
        return m_stylesheetLocatorStack.empty() == true ? 0 : m_stylesheetLocatorStack.back();
    }

    void
    pushLocatorOnStack(const LocatorType*   locator)
    {
        m_stylesheetLocatorStack.push_back(locator);
    }

    void
    popLocatorStack()
    {
        if (m_stylesheetLocatorStack.empty() == false)
        {
            m_stylesheetLocatorStack.pop_back();
        }
    }

protected:

    const AttributeListImpl&
    getPendingAttributesImpl() const
    {
        return m_outputContextStack.getPendingAttributes();
    }

    AttributeListImpl&
    getPendingAttributesImpl()
    {
        return m_outputContextStack.getPendingAttributes();
    }

    void
    setPendingAttributesImpl(const AttributeListType&   pendingAttributes)
    {
        getPendingAttributesImpl() = pendingAttributes;
    }

    const XalanDOMString&
    getPendingElementNameImpl() const
    {
        return m_outputContextStack.getPendingElementName();
    }

    XalanDOMString&
    getPendingElementNameImpl()
    {
        return m_outputContextStack.getPendingElementName();
    }

    void
    setPendingElementNameImpl(const XalanDOMString&     elementName)
    {
        m_outputContextStack.getPendingElementName() = elementName;
    }

    void
    setPendingElementNameImpl(const XalanDOMChar*   elementName)
    {
        assert(elementName != 0);

        m_outputContextStack.getPendingElementName() = elementName;
    }

    /*
     * See if there is a pending start document event waiting.
     * @return true if there is a start document event waiting.
     */
    bool
    getHasPendingStartDocumentImpl() const
    {
        return m_outputContextStack.getHasPendingStartDocument();
    }

    /*
     * Set the pending start document event state.
     * @param the new value
     */
    void
    setHasPendingStartDocumentImpl(bool     b)
    {
        m_outputContextStack.getHasPendingStartDocument() = b;
    }

    /*
     * See if a pending start document event must be flushed.
     * @return true if the event must be flushed.
     */
    bool
    getMustFlushPendingStartDocumentImpl() const
    {
        return m_outputContextStack.getMustFlushPendingStartDocument();
    }

    /*
     * Set the pending start document event flush state.
     * @param the new value
     */
    void
    setMustFlushPendingStartDocumentImpl(bool   b)
    {
        m_outputContextStack.getMustFlushPendingStartDocument() = b;
    }

    FormatterListener*
    getFormatterListenerImpl() const
    {
        return m_outputContextStack.getFormatterListener();
    }

    void
    setFormatterListenerImpl(FormatterListener*     flistener)
    {
        m_outputContextStack.getFormatterListener() = flistener;
    }

    XalanDOMString  m_resultNameSpacePrefix;

    XalanDOMString  m_resultNameSpaceURL;


    void
    copyAttributesToAttList(
            const XalanNode&    node,
            AttributeListImpl&  attList);

    // Factory for creating xpaths.
    XPathFactory&           m_xpathFactory;

    // Factory for creating xobjects
    XObjectFactory&         m_xobjectFactory;

    // The query/pattern-matcher object.
    const XPathProcessorPtrType     m_xpathProcessor;

    BoolVectorType  m_cdataStack;

private:

    void
    warnCopyTextNodesOnly(
            const XalanNode*    sourceNode,
            const LocatorType*  locator);

    void
    cloneToResultTree(
            const XalanText&    node,
            bool                overrideStrip);

    bool
    pendingAttributesHasDefaultNS() const; 

    void
    addResultNamespace(
            const XalanDOMString&   thePrefix,
            const XalanDOMString&   theName,
            const XalanNode&        theNode,
            AttributeListImpl&      thePendingAttributes,
            bool                    fOnlyIfPrefixNotPresent);

    void
    addResultNamespace(
            const XalanNode&    theNode,
            AttributeListImpl&  thePendingAttributes,
            bool                fOnlyIfPrefixNotPresent = false);

    LocatorStack  m_stylesheetLocatorStack;

    ProblemListenerDefault  m_defaultProblemListener;

    ProblemListener*    m_problemListener;

    const StylesheetRoot*               m_stylesheetRoot;

    static const XalanDOMString&        s_XSLNameSpaceURL;  //"http://www.w3.org/1999/XSL/Transform"

    static const XalanDOMString&        s_XalanNamespaceURL; // "http://xml.apache.org/xalan"

    static const XalanDOMString&        s_uniqueNamespacePrefix;

    bool    m_traceSelects;

    bool    m_quietConflictWarnings;

    /*
     * A stream to print diagnostics to.
     */
    PrintWriter*    m_diagnosticsPrintWriter;

    TraceListenerVectorType     m_traceListeners;
    
    void
    problem(
            const XalanDOMString&               msg, 
            ProblemListener::eClassification    classification,
            const XalanNode*                    sourceNode,
            const ElemTemplateElement*          styleNode) const;

    void
    problem(
            const XalanDOMString&               msg, 
            ProblemListener::eClassification    classification,
            const LocatorType&                  locator,
            const XalanNode*                    sourceNode) const;

  //==========================================================
  // SECTION: Function to do with attribute handling
  //==========================================================

    unsigned long       m_uniqueNSValue;

    ParamVectorType     m_topLevelParams;

public:

    void
    clearTopLevelParams()
    {
        m_topLevelParams.clear();
    }

private:

    bool
    generateCDATASection() const
    {
        if (m_hasCDATASectionElements == false)
        {
            return false;
        }
        else
        {
            assert(m_cdataStack.empty() == false);

            return m_cdataStack.back();
        }
    }

    void
    doFlushPending()
    {
        setMustFlushPendingStartDocument(true);

        flushPending();
    }

    bool
    isCDataResultElem(const XalanDOMString&     elementName) const;

    void
    fireCharacterGenerateEvent(
            const XalanNode&    theNode,
            bool                isCDATA);

    void
    fireCharacterGenerateEvent(
            const XObjectPtr&   theXObject,
            bool                isCDATA);

    void
    fireCharacterGenerateEvent(
            const XalanDOMString&   theString,
            bool                    isCDATA);

    void
    fireCharacterGenerateEvent(
            const XalanDOMChar*         ch,
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length,
            bool                        isCDATA);

    void
    checkDefaultNamespace(
            const XalanDOMString&   theElementName,
            const XalanDOMString&   theElementNamespaceURI);



    // Data members...
    XMLParserLiaison&   m_parserLiaison;

    XPathEnvSupport&    m_xpathEnvSupport;

    DOMSupport&         m_domSupport;

    StylesheetExecutionContext*     m_executionContext;

    /*
     * Stack of current output contexts...
     */
    OutputContextStack              m_outputContextStack;

    /*
     * Stack of current result namespaces...
     */
    XalanNamespacesStack            m_resultNamespacesStack;

    /*
     * Dummy AttributeListImpl
     */
    AttributeListImpl                   m_dummyAttributesList;

    XalanDOMString                      m_scratchString;

    XalanDOMStringPointerVectorType     m_attributeNamesVisited;

    bool                                m_hasCDATASectionElements;

    XPathConstructionContextDefault     m_xpathConstructionContext;

    static void
    installFunctions(MemoryManagerType& theManager);

    static void
    uninstallFunctions();


    static const XalanDOMString     s_emptyString;

    static const XalanDOMString&    s_stylesheetNodeName;
    static const XalanDOMString&    s_typeString;
    static const XalanDOMString&    s_hrefString;
    static const XalanDOMString&    s_piTokenizerString;
    static const XalanDOMString&    s_typeValueString1;
    static const XalanDOMString&    s_typeValueString2;
    static const XalanDOMString&    s_typeValueString3;
    static const XalanDOMString&    s_typeValueString4;

    // Not implemented...
    XSLTEngineImpl(const XSLTEngineImpl&);

    XSLTEngineImpl&
    operator=(const XSLTEngineImpl&);

    bool
    operator==(const XSLTEngineImpl&) const;
};



XALAN_CPP_NAMESPACE_END



#endif  // XALAN_XSLTENGINEIMPL_HEADER_GUARD

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.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.