src/xalanc/XSLT/Stylesheet.hpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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_STYLESHEET_HEADER_GUARD)
#define XALAN_STYLESHEET_HEADER_GUARD



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



#include <xalanc/XalanDOM/XalanNode.hpp>
#include <xalanc/XalanDOM/XalanDOMString.hpp>



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



#include <xalanc/PlatformSupport/PrefixResolver.hpp>



#include <xalanc/XPath/NameSpace.hpp>
#include <xalanc/XPath/XalanQNameByReference.hpp>
#include <xalanc/XPath/XPath.hpp>



#include <xalanc/XSLT/NamespacesHandler.hpp>
#include <xalanc/XSLT/KeyDeclaration.hpp>
#include <xalanc/XSLT/StylesheetConstructionContext.hpp>
#include <xalanc/XSLT/StylesheetExecutionContext.hpp>
#include <xalanc/XSLT/XalanSpaceNodeTester.hpp>



namespace XALAN_CPP_NAMESPACE {



class ExtensionNSHandler;
class XalanDecimalFormatSymbols;
class ElemDecimalFormat;
class ElemTemplate;
class ElemTemplateElement;
class ElemVariable;
class KeyTable;
class NodeRefListBase;
class PrefixResolver;
class StylesheetConstructionContext;
class StylesheetRoot;
class XalanMatchPatternData;
class XalanQName;
class XObject;
class StylesheetExecutionContext;


typedef XalanVector<const XalanMatchPatternData*>   PatternTableVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(PatternTableVectorTypeDecl)


/**
 * This class represents the base stylesheet or an "import" stylesheet.
 * "include" stylesheets are combined with the including stylesheet.
 */
class XALAN_XSLT_EXPORT Stylesheet : public PrefixResolver
{

public:

    typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
    typedef XalanQName::NamespaceVectorType                 NamespaceVectorType;
    typedef XalanQName::NamespacesStackType                 NamespacesStackType;

    typedef XalanVector<ElemVariable*>                  ElemVariableVectorType;
    typedef XalanVector<KeyDeclaration>                 KeyDeclarationVectorType;
    typedef XalanVector<Stylesheet*>                    StylesheetVectorType;
    typedef XalanVector<XalanDOMString>                 URLStackType;
    typedef XalanVector<ElemDecimalFormat*>             ElemDecimalFormatVectorType;
    typedef XalanVector<XalanSpaceNodeTester>           WhitespaceElementsVectorType;
    typedef PatternTableVectorTypeDecl                  PatternTableVectorType;
    
    typedef  XalanMap<XalanDOMString, ExtensionNSHandler*>      ExtensionNamespacesMapType;

    typedef  XalanMap<XalanQNameByReference,
                         const ElemTemplate* >      ElemTemplateMapType;

    typedef XalanMap<const XalanNode*, KeyTable* >  KeyTablesTableType;

    typedef XalanMap<XalanDOMString, PatternTableVectorType> PatternTableMapType;

    typedef StylesheetConstructionContext::GetCachedString  GetCachedString;

    /**
     * Constructor for a Stylesheet needs a Document.
     * @exception XSLProcessorException thrown if the active ProblemListener and XMLParserLiaison decide 
     * the error condition is severe enough to halt processing.
     */
    Stylesheet(
            StylesheetRoot&                 root,
            const XalanDOMString&           baseIdentifier,
            StylesheetConstructionContext&  constructionContext);

    virtual
    ~Stylesheet();

    static Stylesheet*
    create(MemoryManager& theManager,
            StylesheetRoot&                 root,
            const XalanDOMString&           baseIdentifier,
            StylesheetConstructionContext&  constructionContext);

    MemoryManager&
    getMemoryManager()
    {
        return m_elementPatternTable.getMemoryManager();
    }

    /**
     * Retrieve XSLT version number
     * 
     * @return number representing XSLT version
     */
    double
    getXSLTVerDeclared() const
    {
        return m_XSLTVerDeclared;
    }

    /**
     * Set XSLT version number
     * 
     * @param ver number representing XSLT version
     */
    void
    setXSLTVerDeclared(double ver)
    {
        m_XSLTVerDeclared = ver;
    }

    /**
     * Retrieve the root stylesheet object
     * 
     * @return const reference to the stylesheet object
     */
    const StylesheetRoot&
    getStylesheetRoot() const
    {
        return m_stylesheetRoot;
    }

    /**
     * Retrieve the root stylesheet object
     * 
     * @return reference to the stylesheet object
     */
    StylesheetRoot&
    getStylesheetRoot()
    {
        return m_stylesheetRoot;
    }

    /**
     * Retrieve the stack of namespace lists
     * 
     * @return vector of namespace vectors
     */
    const NamespacesStackType&
    getNamespaces() const
    { 
        return m_namespaces;
    }

    /**
     * Retrieve the stack of namespace lists
     * 
     * @return vector of namespace vectors
     */
    NamespacesStackType&
    getNamespaces()
    { 
        return m_namespaces;
    }

    const NamespacesHandler&
    getNamespacesHandler() const
    {
        return m_namespacesHandler;
    }

    NamespacesHandler&
    getNamespacesHandler()
    {
        return m_namespacesHandler;
    }

    /**
     * Retrieve the list of namespace declarations currently in effect
     * 
     * @return vector of namespace vectors
     */
    const NamespaceVectorType&
    getNamespaceDecls() const
    {
        return m_namespaceDecls;
    }

    /**
     * Retrieve the list of namespace declarations currently in effect
     * 
     * @return vector of namespace vectors
     */
    NamespaceVectorType&
    getNamespaceDecls()
    {
        return m_namespaceDecls;
    }

    /**
     * Set the list of namespace declarations currently in effect
     * 
     * @param ns vector of namespace vectors
     */
    void
    setNamespaceDecls(const NamespaceVectorType& ns)
    {
        m_namespaceDecls = ns;
    }

    /** 
     * Push the namespace declarations from the current attribute 
     * list onto the namespace stack.
     * 
     * @param atts attribute list constaining namespaces
     */
    void
    pushNamespaces(const AttributeListType&     atts);

    /**
     * Pop a namespace declaration from the namespace stack.
     */
    void
    popNamespaces()
    {
        assert(m_namespaces.empty() == false);

        m_namespaces.pop_back(); 
    }

    void
    addWhitespaceElement(const XalanSpaceNodeTester&    theTester);

    /**
     * Called after construction is completed.
     */
    virtual void
    postConstruction(StylesheetConstructionContext&     constructionContext);

    /** 
     * See if this is a xmlns attribute, and, if so, process it.
     * 
     * @param attrName qualified name of attribute
     * @param atts     attribute list where the element comes from (not used at 
     *                 this time)
     * @param which    index into the attribute list (not used at this time)
     * @return         true if this is a namespace name
     */
    bool
    isAttrOK(
            const XalanDOMChar*             attrName,
            const AttributeListType&        atts,
            XalanSize_t                     which,
            StylesheetConstructionContext&  constructionContext) const;

    /**
     * Get the namespace from a qualified name.
     * 
     * @param nodeName name of node
     * @return namespace string for node, or null if not found.
     */
    const XalanDOMString*
    getNamespaceFromStack(
                const XalanDOMString&   nodeName,
                XalanDOMString&         theBuffer) const
    {
        return getNamespaceFromStack(nodeName.c_str(), theBuffer);
    }

    /**
     * Get the namespace from a qualified name.
     * 
     * @param nodeName name of node
     * @return namespace string for node, or null if not found.
     */
    const XalanDOMString*
    getNamespaceFromStack(
                const XalanDOMChar*     nodeName,
                XalanDOMString&         theBuffer) const;

    /**
     * Get the namespace from a prefix by searching the stack of namespace
     * lists.
     * 
     * @param prefix prefix to search
     * @return namespace corresponding to prefix, or null if not found.
     */
    const XalanDOMString*
    getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const
    {
        return XalanQName::getNamespaceForPrefix(m_namespaces, prefix);
    }

    /**
     * Get the namespace from a prefix by searching the stack of namespace
     * lists.
     * 
     * @param prefix prefix to search
     * @return namespace corresponding to prefix, or null if not found.
     */
    const XalanDOMString*
    getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const
    {
        assert(prefix != 0);

        return XalanQName::getNamespaceForPrefix(m_namespaces, (const XalanDOMChar*)prefix);
    }

    /**
     * Get the namespace for a prefix, and report an error if it wasn't found.
     * 
     * @param prefix prefix to search
     * @param constructionContext The current construction context
     * @return namespace corresponding to prefix, or null if not found.
     */
    const XalanDOMString*
    getNamespaceForPrefix(
            const XalanDOMString&           prefix,
            StylesheetConstructionContext&  constructionContext) const;

    /**
     * Get the namespace for a prefix, and report an error if it wasn't found.
     * 
     * @param prefix prefix to search
     * @param constructionContext The current construction context
     * @return namespace corresponding to prefix, or null if not found.
     */
    const XalanDOMString*
    getNamespaceForPrefix(
            const XalanDOMChar*             prefix,
            StylesheetConstructionContext&  constructionContext) const;

    /**
     * See if a namespace should be excluded.
     * 
     * @param theConstructionContext the current construction context.
     * @param theValue the prefix of the namespace.
     * @return
     */
    void
    processExcludeResultPrefixes(
        StylesheetConstructionContext&  theConstructionContext,
        const XalanDOMChar*             theValue)
    {
        m_namespacesHandler.processExcludeResultPrefixes(
                theConstructionContext,
                theValue,
                m_namespaces);
    }

    /**
     * Add a template to the list of names templates
     * 
     * @param theTemplate template to add
     * @param constructionContext context for construction
     */
    void
    addTemplate(
            ElemTemplate*                   theTemplate,
            StylesheetConstructionContext&  constructionContext);

    /**
     * Process an attribute that has the value of 'yes' or 'no'.
     * 
     * @param aname name of attribute
     * @param val value
     * @param constructionContext context for construction
     * @return true if value equals string constant for "yes," false otherwise
     */
    bool
    getYesOrNo(
            const XalanDOMChar*             aname,
            const XalanDOMChar*             val,
            StylesheetConstructionContext&  constructionContext) const;

    /**
     * Retrieve the base identifier with which this stylesheet is associated.
     * 
     * @return string for base identifier
     */
    const XalanDOMString&
    getBaseIdentifier() const
    {
        return m_baseIdent;
    }

    /**
     * Retrieve the base identifier for the most recently
     * included stylesheet.  This will return the same value
     * as getBaseIdentifier(), if no include is being
     * processed.
     * 
     * @return string for base identifier
     */
    const XalanDOMString&
    getCurrentIncludeBaseIdentifier() const
    {
        return m_includeStack.empty() == true ? getBaseIdentifier() : m_includeStack.back();
    }

    /**
     * Process an xsl:namespace-alias element.
     *
     * @param name   the element name.
     * @param attrs  the current attribute list
     * @param constructionContext  the active construction context
     */
    void
    processNSAliasElement(
            const XalanDOMChar*             name,
            const AttributeListType&        atts,
            StylesheetConstructionContext&  constructionContext);

    /**
     * Process an xsl:decimal-format element.
     *
     * @param elemDecimalFormat   the element
     */
    void
    processDecimalFormatElement(
            StylesheetConstructionContext&  constructionContext,
            const AttributeListType&        atts,
            const Locator*                  locator = 0);

    /**
     * Retrieve the XalanDecimalFormatSymbols instance associated with
     * the QName.
     *
     * @param theQName the QName for the lookup
     * @return a pointer to the matching instance, or 0 if none was found
     */
    const XalanDecimalFormatSymbols*
    getDecimalFormatSymbols(const XalanQName&   theQName) const;

    /**
     * Add an imported stylesheet.
     *
     * @param theStylesheet The stylesheet to add.
     */
    void
    addImport(Stylesheet*   theStylesheet)
    {
        m_imports.insert(m_imports.begin(), theStylesheet);
    }

    /**
     * whether there is a wrapper template
     * 
     * @return true is there is a wrapper
     */
    bool
    isWrapperless() const
    {
        return m_isWrapperless;
    }

    ElemTemplateElement*
    initWrapperless(
            StylesheetConstructionContext&  constructionContext,
            const Locator*                  locator);

    /**
     * Retrieve the stack of who's including who
     * 
     * @return stack of includes
     */
    URLStackType&
    getIncludeStack()
    {
        return m_includeStack;
    }

    /**
     * Process the xsl:key element.
     * 
     * @param nsContext The PrefixResolver instance for namespace prefixes.
     * @param atts The attribute list for element.
     * #param locator The Locator instance for error reporting, if any.  May be 0.    
     * @param constructionContext The current construction context.
     */
    void
    processKeyElement(
            const PrefixResolver&           nsContext,
            const AttributeListType&        atts,
            const Locator*                  locator,
            StylesheetConstructionContext&  constructionContext);

    /**
     * Locate a template via the "name" attribute.
     * 
     * @param name               qualified name of template
     * @return pointer to template found or 0 if none found
     */
    const ElemTemplate*
    findNamedTemplate(const XalanQName&     qname) const;

    /**
     * Given a target element, find the template that best matches in the given
     * XSL document, according to the rules specified in the xsl draft. 
     *
     * @param executionContext current execution context
     * @param targetNode       element that needs a rule
     * @return                 pointer to rule that best matches targetNode
     */
    const ElemTemplate*
    findTemplate(
            StylesheetExecutionContext&     executionContext,
            XalanNode*                      targetNode) const
    {
        assert(targetNode != 0);

        return findTemplate(
                executionContext,
                targetNode,
                targetNode->getNodeType(),
                s_emptyQName,
                false);
    }

    /**
     * Given a target element, find the template that best matches in the given
     * XSL document, according to the rules specified in the xsl draft. 
     *
     * @param executionContext current execution context
     * @param targetNode        node that needs a rule
     * @param targetNodeType    the type of targetNode
     * @param mode              string indicating the mode
     * @param onlyUseImports    only use imports, do not use any templates from the stylesheet itself
     * @return pointer to rule that best matches targetElem
     */
    const ElemTemplate*
    findTemplate(
            StylesheetExecutionContext&     executionContext,
            XalanNode*                      targetNode,
            XalanNode::NodeType             targetNodeType,
            const XalanQName&               mode,
            bool                            onlyUseImports) const;

    /**
     * Add object to vector of match patterns if not already there.
     *
     * @param thePattern pattern to add
     * @param theVector  vector of patterns to add to
     */
    static void
    addObjectIfNotFound(
            const XalanMatchPatternData*    thePattern,
            PatternTableVectorType&         theVector);

    /**
     * Add object to array of match patterns if not already there.
     * theArraySize size will be incremented if the pattern was
     * added.
     *
     * @param thePattern pattern to add
     * @param theArray  vector of patterns to add to
     * @param theArraySize The size of the array
     */
    static void
    addObjectIfNotFound(
            const XalanMatchPatternData*    thePattern,
            const XalanMatchPatternData*    theArray[],
            XalanSize_t&                    theArraySize);

    /**
     * Given a name, locate the start of a list of 
     * possible templates that match that name.  If
     * none match, then use the default list.
     *
     * @param theName The name to match
     */
    const PatternTableVectorType*
    locateElementMatchPatternDataList(const XalanDOMString&     theName) const;

    /**
     * Given a name, locate the start of a list of 
     * possible templates that match that name.  If
     * none match, then use the default list.
     *
     * @param theName The name to match
     */
    const PatternTableVectorType*
    locateAttributeMatchPatternDataList(const XalanDOMString&   theName) const;

    /**
     * Given a XalanNode, locate the start of a list of 
     * possible templates that match it.
     *
     * @param XalanNode The node to match
     */
    const PatternTableVectorType*
    locateMatchPatternDataList(
            const XalanNode&        theNode,
            XalanNode::NodeType     targetNodeType) const;

    /**
     * Add an extension namespace handler. This provides methods for calling
     * an element extension as well as for function calls (which is passed
     * on to XPath).
     *
     * @param constructionContext The current construction context.
     * @param uri The namespace URI of the extension.
     */
    void
    processExtensionNamespace(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMString&           uri);

    /**
     * Return the handler for a given extension namespace.
     *
     * @param uri the URI of the extension namespace.
     * @return pointer to extension handler
     */
    ExtensionNSHandler*
    lookupExtensionNSHandler(const XalanDOMString&  uri) const
    {
        const ExtensionNamespacesMapType::const_iterator    it = 
          m_extensionNamespaces.find(uri);

        return it == m_extensionNamespaces.end() ? 0 : (*it).second;
    }

    /**
     * Set a top level variable.
     *
     * @param var top-level variable declared with "xsl:variable" or
     *            xsl:param-variable.
     */
    void
    setTopLevelVariable(ElemVariable*   var)
    {
        m_topLevelVariables.push_back(var);
    }

    /**
     * Set a list of top level variables in the specified execution context
     * stylesheet.
     *
     * @param executionContext current execution context
     * @param topLevelParams   list of top level parameters
     */
    void
    pushTopLevelVariables(
            StylesheetExecutionContext&     executionContext,
            const ParamVectorType&          topLevelParams) const;


    // These interfaces are inherited from PrefixResolver...

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

    virtual const XalanDOMString&
    getURI() const;

    const XalanDOMString&
    getXSLTNamespaceURI() const
    {
        return m_XSLTNamespaceURI;
    }

    void
    setXSLTNamespaceURI(const XalanDOMString&   theURI)
    {
        m_XSLTNamespaceURI = theURI;
    }

    const ElemTemplate* 
    getFirstTemplate() const    
    {
        return m_firstTemplate;
    }
    
protected:

    /**
     * The root of the stylesheet tree.
     */
    StylesheetRoot&                     m_stylesheetRoot;

    /**
     * The base URL of the XSL document.
     */
    XalanDOMString                      m_baseIdent;

    /**
     * Table of KeyDeclaration objects, which are set by the 
     * xsl:key element.
     */
    KeyDeclarationVectorType            m_keyDeclarations;

    WhitespaceElementsVectorType        m_whitespaceElements;

    static const XalanQNameByReference  s_emptyQName;

private:    

    // Not defined...
    Stylesheet(const Stylesheet&);

    Stylesheet&
    operator=(const Stylesheet&);

    bool
    operator==(const Stylesheet&) const;

    void
    error(
            StylesheetConstructionContext&  theContext,
            XalanMessages::Codes            theErrorCode,
            const Locator*                  theLocator,
            const XalanDOMChar*             theParam1 = 0,
            const XalanDOMChar*             theParam2 = 0,
            const XalanDOMChar*             theParam3 = 0) const;

    /**
     * Given a target element, find the template that best matches in the given
     * stylesheet, using only imports
     *
     * @param executionContext current execution context
     * @param targetNode        node that needs a rule
     * @param targetNodeType    the type of targetNode
     * @param mode              string indicating the mode
     * @return pointer to rule that best matches targetElem
     */
    const ElemTemplate*
    findTemplateInImports(
            StylesheetExecutionContext&     executionContext,
            XalanNode*                      targetNode,
            XalanNode::NodeType             targetNodeType,
            const XalanQName&               mode) const;

    /**
     * The full XSLT Namespace URI.  To be replaced by the one actually
     * found.
     */
    XalanDOMString                          m_XSLTNamespaceURI;

    /**
     * A vector of the -imported- XSL Stylesheets.
     */
    StylesheetVectorType                    m_imports;

    StylesheetVectorType::size_type         m_importsSize;

    /**
     * A stack to keep track of the result tree namespaces.
     */
    NamespacesStackType                     m_namespaces;

    /** 
     * A list of namespace declarations,
     * for mapping from prefix to namespace URI.
     */
    NamespaceVectorType                     m_namespaceDecls;

    /**
     * Tells if the stylesheet is without an xsl:stylesheet and xsl:template
     * wrapper.
     */
    bool                                    m_isWrapperless;

    /**
     * The table of extension namespaces.
     */
    ExtensionNamespacesMapType              m_extensionNamespaces;

    /**
     * The first template of the template children.
     */
    ElemTemplate*                           m_firstTemplate;

    /**
     * A stack of who's including who is needed in order to support "It is an
     * error if a stylesheet directly or indirectly includes itself."
     */
    URLStackType                            m_includeStack;

    /**
     * Keyed on string macro names, and holding values that are macro elements
     * in the XSL DOM tree. Initialized in initMacroLookupTable, and used in
     * findNamedTemplate.
     */
    ElemTemplateMapType                     m_namedTemplates;

    /**
     * Table for defined constants, keyed on the names.
     */
    ElemVariableVectorType                  m_topLevelVariables;

    /**
     * The version of XSL that was declared.
     */
    double                                  m_XSLTVerDeclared;

    /**
     * This table is keyed on the target elements of patterns, and contains linked
     * lists of the actual patterns that match the target element to some degree
     * of specifity.
     */
    PatternTableMapType                         m_elementPatternTable;

    const PatternTableMapType::const_iterator   m_elementPatternTableEnd;

    PatternTableVectorType                      m_elementAnyPatternList;

    /**
     * This table is keyed on the target attributes of patterns, and contains linked
     * lists of the actual patterns that match the target attribute to some degree
     * of specifity.
     */
    PatternTableMapType                         m_attributePatternTable;

    const PatternTableMapType::const_iterator   m_attributePatternTableEnd;

    PatternTableVectorType                      m_attributeAnyPatternList;

    /**
     * These tables are for text, comment, root, and PI node templates.
     */
    PatternTableVectorType                  m_textPatternList;

    PatternTableVectorType                  m_commentPatternList;

    PatternTableVectorType                  m_rootPatternList;

    PatternTableVectorType                  m_piPatternList;

    /**
     * This table is for patterns that match "node()".
     */
    PatternTableVectorType                  m_nodePatternList;

    size_type                               m_patternCount;

    ElemDecimalFormatVectorType             m_elemDecimalFormats;

    NamespacesHandler                       m_namespacesHandler;

    static const XalanDOMString             s_emptyString;

    static const PatternTableVectorType     s_emptyTemplateList;
};



}



#endif  // XALAN_STYLESHEET_HEADER_GUARD