Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

StylesheetHandler.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_STYLESHEETHANDLER_HEADER_GUARD)
#define XALAN_STYLESHEETHANDLER_HEADER_GUARD

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



#include <xalanc/Include/XalanVector.hpp>
#include <xalanc/Include/XalanSet.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#include <xalanc/PlatformSupport/FormatterListener.hpp>



#include <xalanc/XPath/XalanQNameByValue.hpp>



#include <xalanc/XSLT/NamespacesHandler.hpp>
#include <xalanc/XSLT/Stylesheet.hpp>
#include <xalanc/XSLT/XalanElemEmptyAllocator.hpp>
#include <xalanc/XSLT/XalanElemTextAllocator.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class ElemTemplate;
class ElemTemplateElement;
class ElemTextLiteral;
class ExtensionNSHandler;
class StylesheetConstructionContext;



class XALAN_XSLT_EXPORT StylesheetHandler : public FormatterListener
{

public:

    typedef XalanVector<ElemTemplateElement*>       ElemTemplateStackType;
    typedef XalanVector<ElemTemplateElement*>       ElemTextLiteralStackType;

    typedef XalanVector<bool>                       BoolStackType;
    typedef XalanSet<XalanQNameByReference>         QNameSetType;
    typedef XalanVector<QNameSetType, ConstructWithMemoryManagerTraits<QNameSetType> >
                                                    QNameSetVectorType;

    static void
    initialize(MemoryManagerType&  theManager);

    static void
    terminate();

    StylesheetHandler(
            Stylesheet&                     stylesheetTree,
            StylesheetConstructionContext&  constructionContext);

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

    virtual
    ~StylesheetHandler();

    virtual void characters (const XMLCh* const chars, const unsigned int length);

    virtual void charactersRaw(const XMLCh* const chars, const unsigned int length);

    virtual void cdata(const XMLCh* const ch, const unsigned int length);

    virtual void ignorableWhitespace (const XMLCh* const chars, const unsigned int length);

    virtual void processingInstruction (const XMLCh* const target, const XMLCh* const data);

    virtual void comment(const XMLCh* const data);

    virtual void entityReference(const XMLCh* const data);

    // These methods are inherited DocumentHandler ...
    
    // $$$ Theoretically, shouldn't need javadoc for these, since they are
    // inherited from DocumentHandler, but let's leave them in for now -- JMD

    virtual void setDocumentLocator(const LocatorType* const    locator);

    virtual void startDocument();

    virtual void endDocument();
    
    virtual void startElement(const XMLCh* const name, AttributeListType& attrs);
    
    virtual void endElement(const XMLCh* const name);
    
    virtual void resetDocument();

protected:

    bool
    isAttrOK(
            const XalanDOMChar*         attrName,
            const AttributeListType&    atts,
            int                         which);

    bool
    processSpaceAttr(
            const XalanDOMChar*         elementName,
            const XalanDOMChar*         aname,
            const AttributeListType&    atts,
            int                         which,
            const LocatorType*          locator,
            bool&                       fPreserve);

    bool
    processSpaceAttr(
            const XalanDOMChar*         elementName,
            const AttributeListType&    atts,
            const LocatorType*          locator,
            bool&                       fPreserve);

    void
    processImport(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const LocatorType*          locator);

    void
    processInclude(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const LocatorType*          locator);

    void
    doCleanup();

private:

    enum { eElemEmptyAllocatorBlockSize = 10, eElemTextBlockSize = 10 };

    // not implemented
    StylesheetHandler(const StylesheetHandler&);

    StylesheetHandler&
    operator=(const StylesheetHandler&);

    // Utility functions...
    void
    illegalAttributeError(
            const XalanDOMChar*     theElementName,
            const XalanDOMChar*     theAttributeName,
            const LocatorType*      theLocator) const;

    void
    error(
            const XalanDOMChar*     theMessage1,
            const XalanDOMChar*     theMessage2,
            const LocatorType*      theLocator) const;

    void
    error(
            const XalanDOMChar*     theMessage1,
            const XalanDOMString&   theMessage2,
            const LocatorType*      theLocator) const;

    void
    error(
            const XalanDOMString&   theMessage1,
            const XalanDOMChar*     theMessage2,
            const LocatorType*      theLocator) const;

    void
    error(
            const XalanDOMString&   theMessage1,
            const XalanDOMString&   theMessage2,
            const LocatorType*      theLocator) const;

    void
    warn(
            const XalanDOMChar*     theMessage1,
            const XalanDOMChar*     theMessage2,
            const LocatorType*      theLocator) const;

    void
    warn(
            const XalanDOMChar*     theMessage1,
            const XalanDOMString&   theMessage2,
            const LocatorType*      theLocator) const;
    void
    warn(
            const XalanDOMString&   theMessage,
            const LocatorType*      theLocator) const;

    void
    error(
            const XalanDOMString&   theMessage,
            const LocatorType*      theLocator) const;

    void
    processText(
            const XMLCh*                chars,
            XalanDOMString::size_type   length);

    void
    accumulateText(
            const XMLCh*                chars,
            XalanDOMString::size_type   length);

    void
    processAccumulatedText();

    void
    processTopLevelElement(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            int                         xslToken,
            const LocatorType*          locator,
            bool&                       fPreserveSpace,
            bool&                       fSpaceAttrProcessed);

    void
    processStylesheet(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const LocatorType*          locator,
            bool&                       fPreserveSpace,
            bool&                       fSpaceAttrProcessed);

    void
    processPreserveStripSpace(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const LocatorType*          locator,
            int                         xslToken);

    void
    appendChildElementToParent(
            ElemTemplateElement*    elem,
            const LocatorType*      locator);

    void
    appendChildElementToParent(
            ElemTemplateElement*    parent,
            ElemTemplateElement*    elem);

    void
    appendChildElementToParent(
            ElemTemplateElement*    parent,
            ElemTemplateElement*    elem,
            const LocatorType*      locator);

    bool
    inExtensionElement() const;

    void
    processExtensionElement(
            const XalanDOMChar*         name,
            const XalanDOMString&       localName,
            const AttributeListType&    atts,
            const LocatorType*          locator);

    void
    checkForOrAddVariableName(
            const XalanQName&   theVariableName,
            const LocatorType*  theLocator);

    // Data members...

    Stylesheet&     m_stylesheet;

    StylesheetConstructionContext&  m_constructionContext;

    XalanElemEmptyAllocator     m_elemEmptyAllocator;

    XalanElemTextAllocator      m_elemTextAllocator;

    ElemTemplateStackType   m_elemStack;

    ElemTextLiteralStackType    m_whiteSpaceElems;

    ElemTemplateElement*    m_pTemplate;

    class LastPoppedHolder
    {
    public:

        LastPoppedHolder(StylesheetHandler&     theStylesheetHandler) :
            m_stylesheetHandler(theStylesheetHandler),
            m_lastPopped(0)
        {
        }

        ~LastPoppedHolder()
        {
            cleanup();
        }

        ElemTemplateElement*
        operator->() const
        {
            return m_lastPopped;
        }

        bool
        operator==(ElemTemplateElement*     theRHS)
        {
            return m_lastPopped == theRHS;
        }

        bool
        operator!=(ElemTemplateElement*     theRHS)
        {
            return m_lastPopped != theRHS;
        }

        void
        operator=(ElemTemplateElement*  theRHS)
        {
            if (theRHS != m_lastPopped)
            {
                cleanup();

                m_lastPopped = theRHS;
            }
        }

        void
        swap(LastPoppedHolder&  theOther)
        {
            ElemTemplateElement* const  theTemp = m_lastPopped;

            m_lastPopped = theOther.m_lastPopped;

            theOther.m_lastPopped = theTemp;
        }

        ElemTemplateElement*
        get() const
        {
            return m_lastPopped;
        }

    private:

        void
        set(ElemTemplateElement*    theNewElement)
        {
            if (theNewElement != m_lastPopped)
            {
                cleanup();

                m_lastPopped = theNewElement;
            }
        }

        // Not implemented...
        LastPoppedHolder&
        operator=(const LastPoppedHolder&);

        LastPoppedHolder(const LastPoppedHolder&);

        // Helper functions...
        void
        cleanup();

        // Data members...
        StylesheetHandler&      m_stylesheetHandler;

        ElemTemplateElement*    m_lastPopped;
    };

    friend class LastPoppedHolder;

    LastPoppedHolder    m_lastPopped;
    
    bool m_inTemplate;
    
    bool m_foundStylesheet;
    
    bool m_foundNotImport;

    XalanDOMString      m_elementLocalName;

    XalanDOMString  m_accumulateText;

    XalanDOMString  m_includeBase;

    BoolStackType   m_inExtensionElementStack;

    BoolStackType   m_preserveSpaceStack;

    // Note that these variables must not be saved by
    // PushPopIncludeState...
    unsigned long   m_locatorsPushed;

    QNameSetType    m_globalVariableNames;

    enum { eVariablesStackDefault = 20 };

    QNameSetVectorType  m_inScopeVariableNamesStack;

    ElemTemplateElement*
    initWrapperless(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const LocatorType*          locator);

    const XalanDOMString*
    getNamespaceFromStack(const XalanDOMChar*   theName,
                            XalanDOMString&     theBuffer) const;

    const XalanDOMString*
    getNamespaceForPrefixFromStack(const XalanDOMString&    thePrefix) const;

    class PushPopIncludeState;

    friend class StylesheetHandler::PushPopIncludeState;

    class PushPopIncludeState
    {
    public:

        PushPopIncludeState(StylesheetHandler&      theHandler);

        ~PushPopIncludeState();

    private:

        StylesheetHandler&                  m_handler;

        ElemTemplateStackType               m_elemStack;

        ElemTemplateElement* const          m_pTemplate;

        LastPoppedHolder                    m_lastPopped;       

        const bool                          m_inTemplate;       

        const bool                          m_foundStylesheet;

        const XalanDOMString                m_XSLNameSpaceURL;

        const bool                          m_foundNotImport;

        Stylesheet::NamespaceVectorType     m_namespaceDecls;

        Stylesheet::NamespacesStackType     m_namespaces;

        NamespacesHandler                   m_namespacesHandler;

        BoolStackType                       m_inExtensionElementStack;

        BoolStackType                       m_preserveSpaceStack;
    };

    static const XalanDOMString             s_emptyString;
};



XALAN_CPP_NAMESPACE_END



#endif  // XALAN_STYLESHEETHANDLER_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.