/*
 * 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.
 */
#include "StylesheetHandler.hpp"


#include <algorithm>


#include <xercesc/sax/Locator.hpp>
#include <xercesc/sax/SAXParseException.hpp>


#include <xalanc/Include/STLHelper.hpp>


#include <xalanc/XalanDOM/XalanDOMException.hpp>


#include <xalanc/PlatformSupport/AttributeListImpl.hpp>
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/DoubleSupport.hpp>
#include <xalanc/PlatformSupport/StringTokenizer.hpp>
#include <xalanc/PlatformSupport/XalanLocator.hpp>
#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>


#include <xalanc/DOMSupport/DOMServices.hpp>


#include "Constants.hpp"
#include "ElemTemplateElement.hpp"
#include "ElemTextLiteral.hpp"
#include "Stylesheet.hpp"
#include "StylesheetConstructionContext.hpp"
#include "StylesheetRoot.hpp"
#include "XalanSpaceNodeTester.hpp"


#include <xalanc/Include/XalanMemMgrAutoPtr.hpp>


namespace XALAN_CPP_NAMESPACE {


typedef StylesheetConstructionContext::GetCachedString  GetCachedString;


StylesheetHandler::StylesheetHandler(
            Stylesheet&                     stylesheetTree,
            StylesheetConstructionContext&  constructionContext) :
    FormatterListener(OUTPUT_METHOD_OTHER),
    m_stylesheet(stylesheetTree),
    m_constructionContext(constructionContext),
    m_elemEmptyAllocator(constructionContext.getMemoryManager(), eElemEmptyAllocatorBlockSize),
    m_elemTextAllocator(constructionContext.getMemoryManager(), eElemTextBlockSize),
    m_elemStack(constructionContext.getMemoryManager()),
    m_whiteSpaceElems(constructionContext.getMemoryManager()),
    m_pTemplate(0),
    m_lastPopped(*this),
    m_inTemplate(false),
    m_foundStylesheet(false),
    m_foundNotImport(false),
    m_elementLocalName(constructionContext.getMemoryManager()),
    m_accumulateText(constructionContext.getMemoryManager()),
    m_includeBase(stylesheetTree.getBaseIdentifier(), constructionContext.getMemoryManager()),
    m_inExtensionElementStack(constructionContext.getMemoryManager()),
    m_preserveSpaceStack(constructionContext.getMemoryManager()),
    m_locatorsPushed(0),
    m_globalVariableNames(constructionContext.getMemoryManager()),
    m_inScopeVariableNamesStack(constructionContext.getMemoryManager())
{
    m_inScopeVariableNamesStack.reserve(eVariablesStackDefault);
}


StylesheetHandler::~StylesheetHandler()
{
    doCleanup();
}


void StylesheetHandler::setDocumentLocator(const Locator* const     locator)
{
    m_constructionContext.pushLocatorOnStack(locator);

    ++m_locatorsPushed;
}


void
StylesheetHandler::startDocument()
{
}


void
StylesheetHandler::endDocument()
{
    m_constructionContext.popLocatorStack();

    if (m_locatorsPushed > 0)
    {
        --m_locatorsPushed;
    }

    m_inExtensionElementStack.clear();
}


bool
StylesheetHandler::isAttrOK(
            const XalanDOMChar*         attrName,
            const AttributeListType&    atts,
            XalanSize_t                 which)
{
    return m_stylesheet.isAttrOK(attrName, atts, which, m_constructionContext);
}


bool
StylesheetHandler::processSpaceAttr(
            const XalanDOMChar*         elementName,
            const XalanDOMChar*         aname,
            const AttributeListType&    atts,
            XalanSize_t                 which,
            const Locator*              locator,
            bool&                       fPreserve)
{
    if (m_constructionContext.isXMLSpaceAttribute(aname, m_stylesheet, locator) == false)
    {
        fPreserve = false;

        return false;
    }
    else
    {
        const XalanDOMChar* const   spaceVal = atts.getValue(which);

        if (equals(spaceVal, Constants::ATTRVAL_DEFAULT))
        {
            fPreserve = false;
        }
        else if (equals(spaceVal, Constants::ATTRVAL_PRESERVE))
        {
            fPreserve = true;
        }
        else
        {
            const GetCachedString   theGuard(m_constructionContext);

            error(
                XalanMessageLoader::getMessage(
                    theGuard.get(),
                    XalanMessages::ElementHasIllegalAttributeValue_3Param,
                    elementName,
                    Constants::ATTRNAME_XMLSPACE.c_str(),
                    spaceVal),
                locator);
        }

        return true;
    }
}


bool
StylesheetHandler::processSpaceAttr(
            const XalanDOMChar*         elementName,
            const AttributeListType&    atts,
            const Locator*              locator,
            bool&                       fPreserve)
{
    const XalanSize_t  len = atts.getLength();

    for (XalanSize_t i = 0; i < len; ++i)
    {
        if (processSpaceAttr(
                elementName,
                atts.getName(i),
                atts,
                i,
                locator,
                fPreserve) == true)
        {
            return true;
        }
    }

    return false;
}


void
StylesheetHandler::startElement(
            const XMLCh* const  name,
            AttributeListType&  atts)
{
    m_inExtensionElementStack.push_back(false);

    if (m_preserveSpaceStack.empty() == true)
    {
        m_preserveSpaceStack.push_back(false);
    }
    else
    {
        m_preserveSpaceStack.push_back(m_preserveSpaceStack.back());
    }

    try
    {
        // By default, space is not preserved...
        bool    fPreserveSpace = false;
        bool    fSpaceAttrProcessed = false;

        processAccumulatedText();

        m_whiteSpaceElems.clear();

        const Locator* const    locator = m_constructionContext.getLocatorFromStack();

        // First push namespaces
        m_stylesheet.pushNamespaces(atts);

        const XalanDOMString::size_type     nameLength = length(name);
        const XalanDOMString::size_type     index = indexOf(name, XalanUnicode::charColon);

        const GetCachedString   theGuard2(m_constructionContext);
        XalanDOMString&     buffer = theGuard2.get();

        const XalanDOMString*   ns = getNamespaceFromStack(name, buffer);

        if(ns == 0)
        {
            if (index < nameLength)
            {
                const GetCachedString   theGuard(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theGuard.get(),
                        XalanMessages::PrefixIsNotDeclared_1Param,
                        name),
                    locator);
            }
            else
            {
                ns = &s_emptyString;
            }
        }
        assert(ns != 0);

        if (index < nameLength)
        {
            m_elementLocalName.assign(name + index + 1, nameLength - index - 1);
        }
        else
        {
            m_elementLocalName.assign(name, nameLength);
        }

        ElemTemplateElement* elem = 0;

        const ElemTemplateStackType::size_type  origStackSize = m_elemStack.size();

        if (equals(*ns, m_constructionContext.getXSLTNamespaceURI()))
        {
            if (!m_stylesheet.getXSLTNamespaceURI().empty())
                m_stylesheet.setXSLTNamespaceURI(*ns);

            const StylesheetConstructionContext::eElementToken  xslToken =
                m_constructionContext.getElementToken(m_elementLocalName);

            if (!m_inTemplate)
            {
                processTopLevelElement(name, atts, xslToken, locator, fPreserveSpace, fSpaceAttrProcessed);
            }
            else
            {
                switch(xslToken)
                {            
                case StylesheetConstructionContext::ELEMNAME_APPLY_TEMPLATES:
                case StylesheetConstructionContext::ELEMNAME_ATTRIBUTE:
                case StylesheetConstructionContext::ELEMNAME_CALL_TEMPLATE:
                case StylesheetConstructionContext::ELEMNAME_CHOOSE:
                case StylesheetConstructionContext::ELEMNAME_COMMENT:
                case StylesheetConstructionContext::ELEMNAME_COPY:
                case StylesheetConstructionContext::ELEMNAME_COPY_OF:
                case StylesheetConstructionContext::ELEMNAME_ELEMENT:
                case StylesheetConstructionContext::ELEMNAME_FALLBACK:
                case StylesheetConstructionContext::ELEMNAME_FOR_EACH:
                case StylesheetConstructionContext::ELEMNAME_IF:
                case StylesheetConstructionContext::ELEMNAME_MESSAGE:
                case StylesheetConstructionContext::ELEMNAME_NUMBER:
                case StylesheetConstructionContext::ELEMNAME_VALUE_OF:
                case StylesheetConstructionContext::ELEMNAME_WITH_PARAM:
                case StylesheetConstructionContext::ELEMNAME_PI:
                    elem = m_constructionContext.createElement(
                                                xslToken,
                                                m_stylesheet,
                                                atts,
                                                locator);
                    assert(elem != 0);
                    break;
          
                case StylesheetConstructionContext::ELEMNAME_PARAM:
                    elem = m_constructionContext.createElement(
                                                xslToken,
                                                m_stylesheet,
                                                atts,
                                                locator);

                    checkForOrAddVariableName(elem->getNameAttribute(), locator);

                    assert(elem != 0);
                    break;

                case StylesheetConstructionContext::ELEMNAME_SORT:
                    {
                        if (m_elemStack.empty() == true)
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::IsNotAllowedInThisPosition_1Param,
                                    Constants::ELEMNAME_SORT_WITH_PREFIX_STRING),
                                locator);
                        }

                        ElemTemplateElement* const  theElement =
                                m_elemStack.back();
                        assert(theElement != 0);

                        theElement->processSortElement(
                            m_constructionContext,
                            m_stylesheet,
                            atts,
                            locator);

                        m_elemStack.push_back(
                            m_elemEmptyAllocator.create(
                                    m_constructionContext,
                                    m_stylesheet,
                                    &Constants::ELEMNAME_SORT_WITH_PREFIX_STRING));
                    }
                    break;

                case StylesheetConstructionContext::ELEMNAME_APPLY_IMPORTS:
                    {
                        if (m_elemStack.empty() == true)
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::IsNotAllowedInThisPosition_1Param,
                                    Constants::ELEMNAME_APPLY_IMPORTS_WITH_PREFIX_STRING),
                                locator);
                        }

                        ElemTemplateElement* const  theElement =
                                m_elemStack.back();
                        assert(theElement != 0);

                        const int   parentToken =
                            theElement->getXSLToken();

                        if (parentToken == StylesheetConstructionContext::ELEMNAME_FOR_EACH)
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::IsNotAllowedInThisPosition_1Param,
                                    Constants::ELEMNAME_APPLY_IMPORTS_WITH_PREFIX_STRING),
                                locator);
                        }

                        elem = m_constructionContext.createElement(
                                                    xslToken,
                                                    m_stylesheet,
                                                    atts,
                                                    locator);
                        assert(elem != 0);
                    }
                    break;
          
                case StylesheetConstructionContext::ELEMNAME_VARIABLE:
                    {
                        elem =
                            m_constructionContext.createElement(
                                                xslToken,
                                                m_stylesheet,
                                                atts,
                                                locator);
                        assert(elem != 0);

                        checkForOrAddVariableName(elem->getNameAttribute(), locator);
                    }
                    break;

                case StylesheetConstructionContext::ELEMNAME_WHEN:
                    {
                        ElemTemplateElement* const  parent = m_elemStack.back();

                        if(StylesheetConstructionContext::ELEMNAME_CHOOSE != parent->getXSLToken())
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::NotParentedBy_2Param,
                                    Constants::ELEMNAME_WHEN_WITH_PREFIX_STRING,
                                    Constants::ELEMNAME_CHOOSE_WITH_PREFIX_STRING),
                                locator);
                        }
                        else
                        {
                            ElemTemplateElement* const  lastChild = parent->getLastChildElem();

                            if(0 == lastChild ||
                                StylesheetConstructionContext::ELEMNAME_WHEN == lastChild->getXSLToken() ||
                                lastChild->isWhitespace() == true)
                            {
                                elem = m_constructionContext.createElement(
                                                            xslToken,
                                                            m_stylesheet,
                                                            atts,
                                                            locator);
                                assert(elem != 0);
                            }
                            else
                            {
                                const GetCachedString   theGuard(m_constructionContext);

                                error(
                                    XalanMessageLoader::getMessage(
                                        theGuard.get(),
                                        XalanMessages::IsNotAllowedInThisPosition_1Param,
                                        Constants::ELEMNAME_WHEN_WITH_PREFIX_STRING),
                                    locator);
                            }
                        }
                    }
                    break;
          
                case StylesheetConstructionContext::ELEMNAME_OTHERWISE:
                    {
                        ElemTemplateElement* parent = m_elemStack.back();

                        if(StylesheetConstructionContext::ELEMNAME_CHOOSE != parent->getXSLToken())
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::NotParentedBy_2Param,
                                    Constants::ELEMNAME_OTHERWISE_WITH_PREFIX_STRING,
                                    Constants::ELEMNAME_CHOOSE_WITH_PREFIX_STRING),
                                locator);
                        }
                        else
                        {
                            ElemTemplateElement* lastChild = parent->getLastChildElem();

                            if(0 == lastChild ||
                                StylesheetConstructionContext::ELEMNAME_WHEN == lastChild->getXSLToken() ||
                                lastChild->isWhitespace() == true)
                            {
                                elem = m_constructionContext.createElement(
                                                            xslToken,
                                                            m_stylesheet,
                                                            atts,
                                                            locator);
                                assert(elem != 0);
                            }
                            else
                            {
                                const GetCachedString   theGuard(m_constructionContext);

                                error(
                                    XalanMessageLoader::getMessage(
                                        theGuard.get(),
                                        XalanMessages::IsNotAllowedInThisPosition_1Param,
                                        Constants::ELEMNAME_OTHERWISE_WITH_PREFIX_STRING),
                                    locator);
                            }
                        }
                    }
                    break;

                case StylesheetConstructionContext::ELEMNAME_TEXT:
                    m_elemStack.push_back(
                        m_elemTextAllocator.create(
                            m_constructionContext,
                            m_stylesheet,
                            atts,
                            XalanLocator::getLineNumber(locator),
                            XalanLocator::getColumnNumber(locator)));

                    // This fixes Bugzilla 26354, but it's really a workaround
                    // for the bizarre way we handle literal text in the
                    // stylesheet.  We should examine this strategy, because
                    // an xml:space attribute on an xsl:text element results
                    // in building a stylesheet that tries to parent an
                    // ElemTextLiteral instance to an ElemText instance, which
                    // should not ever happen.
                    fSpaceAttrProcessed = true;
                    break;

                case StylesheetConstructionContext::ELEMNAME_TEMPLATE:
                case StylesheetConstructionContext::ELEMNAME_ATTRIBUTE_SET:
                case StylesheetConstructionContext::ELEMNAME_EXTENSION:
                case StylesheetConstructionContext::ELEMNAME_EXTENSION_HANDLER:
                case StylesheetConstructionContext::ELEMNAME_KEY:
                case StylesheetConstructionContext::ELEMNAME_IMPORT:
                case StylesheetConstructionContext::ELEMNAME_INCLUDE:
                case StylesheetConstructionContext::ELEMNAME_PRESERVE_SPACE:
                case StylesheetConstructionContext::ELEMNAME_STRIP_SPACE:
                case StylesheetConstructionContext::ELEMNAME_DECIMAL_FORMAT:
                    {
                        const GetCachedString   theGuard(m_constructionContext);

                        error(
                            XalanMessageLoader::getMessage(
                                theGuard.get(),
                                XalanMessages::IsNotAllowedInsideTemplate_1Param,
                                name),
                            locator);
                    }
                    break;

                default:
                    {
                        // If this stylesheet is declared to be of a higher version than the one
                        // supported, don't flag an error.
                        if(m_constructionContext.getXSLTVersionSupported() < m_stylesheet.getXSLTVerDeclared())
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            warn(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::UnknownXSLElement_1Param,
                                    name),
                                locator);

                            elem = m_constructionContext.createElement(
                                StylesheetConstructionContext::ELEMNAME_FORWARD_COMPATIBLE,
                                m_stylesheet,
                                name,
                                atts,
                                locator);
                        }
                        else
                        {
                            const GetCachedString   theGuard(m_constructionContext);

                            error(
                                XalanMessageLoader::getMessage(
                                    theGuard.get(),
                                    XalanMessages::UnknownXSLElement_1Param,
                                    name),
                                locator);
                        }
                    }
                }

                m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);
            }
        }
        else if (!m_inTemplate && startsWith(*ns, m_constructionContext.getXalanXSLNameSpaceURL()))
        {
            processExtensionElement(name, m_elementLocalName, atts, locator);
        }
        else
        {
            if(!m_inTemplate)
            {
                // If it's a top level 
                if (!m_foundStylesheet)
                {
                    elem = initWrapperless(name, atts, locator);
                }
                else if (ns->empty() == true && m_elemStack.size() == 1)
                {
                    const GetCachedString   theGuard(m_constructionContext);

                    error(
                        XalanMessageLoader::getMessage(
                            theGuard.get(),
                            XalanMessages::IsNotAllowedInThisPosition_1Param,
                            name),
                        locator);
                }
                else
                {
                    m_inExtensionElementStack.back() = true;
                }
            }
            else
            {
                m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);

                // BEGIN SANJIVA CODE
                // is this an extension element call?
                ExtensionNSHandler*     nsh = 0;

                if (!ns->empty() &&
                    ((nsh = m_stylesheet.lookupExtensionNSHandler(*ns)) != 0))
                {
                    elem = m_constructionContext.createElement(
                                                m_stylesheet,
                                                name,
                                                atts,
                                                *nsh,
                                                locator);
                    assert(m_inExtensionElementStack.empty() == false);

                    m_inExtensionElementStack.back() = true;
                }
                else 
                {
                    elem = m_constructionContext.createElement(
                                                StylesheetConstructionContext::ELEMNAME_LITERAL_RESULT,
                                                m_stylesheet,
                                                name,
                                                atts,
                                                locator);
                }

                assert(elem != 0);
            }
        }

        if(m_inTemplate && 0 != elem)
        {
            if(!m_elemStack.empty())
            {
                appendChildElementToParent(elem, locator);
            }

            m_elemStack.push_back(elem);
        }

        // If we haven't processed an xml:space attribute already, look for one...
        if (fSpaceAttrProcessed == false)
        {
            fSpaceAttrProcessed = processSpaceAttr(name, atts, locator, fPreserveSpace);
        }

        // Only update the stack if we actually processed an xml:space attribute...
        if (fSpaceAttrProcessed == true)
        {
            // Set the preserve value...
            m_preserveSpaceStack.back() = fPreserveSpace;
        }

        // If for some reason something didn't get pushed, push an empty 
        // object.
        if(origStackSize == m_elemStack.size())
        {
            m_elemStack.push_back(m_elemEmptyAllocator.create(m_constructionContext, m_stylesheet));
        }
    } // end try
    catch(...)
    {
        doCleanup();

        throw;
    }
}


ElemTemplateElement*
StylesheetHandler::initWrapperless(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator)
{
    assert(m_pTemplate == 0);

    m_pTemplate = m_stylesheet.initWrapperless(m_constructionContext, locator);
    assert(m_pTemplate != 0);

    ElemTemplateElement* const  pElem =
        m_constructionContext.createElement(
            StylesheetConstructionContext::ELEMNAME_LITERAL_RESULT,
            m_stylesheet,
            name,
            atts,
            locator);

    m_pTemplate->appendChildElem(pElem);
    m_inTemplate = true;

    m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);

    m_foundStylesheet = true;

    // This attempts to optimize for a literal result element with
    // the name HTML, so we don't have to switch on-the-fly.
    if(equalsIgnoreCaseASCII(name, Constants::ELEMNAME_HTML_STRING) == true)
    {
        // If there's a default namespace, then we must output XML.
        // Otherwise, we'll set the output method to HTML.
        if (atts.getValue(DOMServices::s_XMLNamespace.c_str()) == 0)
        {
            m_stylesheet.getStylesheetRoot().setIndentResult(true);
            m_stylesheet.getStylesheetRoot().setOutputMethod(OUTPUT_METHOD_HTML);
        }
    }

    return pElem;
}


const XalanDOMString*
StylesheetHandler::getNamespaceFromStack(const XalanDOMChar*    theName,
                                         XalanDOMString&        theBuffer) const
{
    return m_stylesheet.getNamespaceFromStack(theName, theBuffer);
}


const XalanDOMString*
StylesheetHandler::getNamespaceForPrefixFromStack(const XalanDOMString&     thePrefix) const
{
    return m_stylesheet.getNamespaceForPrefixFromStack(thePrefix);
}


void
StylesheetHandler::processTopLevelElement(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            int                         xslToken,
            const Locator*              locator,
            bool&                       fPreserveSpace,
            bool&                       fSpaceAttrProcessed)
{
    if(m_foundStylesheet && StylesheetConstructionContext::ELEMNAME_IMPORT != xslToken)
    {
        m_foundNotImport = true;
    }

    switch(xslToken)
    {
    case StylesheetConstructionContext::ELEMNAME_TEMPLATE:
        assert(m_pTemplate == 0);

        m_pTemplate =
            m_constructionContext.createElement(
                                    StylesheetConstructionContext::ELEMNAME_TEMPLATE,
                                      m_stylesheet,
                                      atts,
                                      locator);
    
        m_elemStack.push_back(m_pTemplate);
        m_inTemplate = true;
        m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);
        break;

    case StylesheetConstructionContext::ELEMNAME_VARIABLE:
    case StylesheetConstructionContext::ELEMNAME_PARAM:
        {
            ElemTemplateElement* const  elem = m_constructionContext.createElement(
                                                xslToken,
                                                m_stylesheet,
                                                atts,
                                                locator);
            assert(elem != 0);

            checkForOrAddVariableName(elem->getNameAttribute(), locator);

            m_elemStack.push_back(elem);
            m_inTemplate = true; // fake it out
            m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);
            elem->addToStylesheet(m_constructionContext, m_stylesheet);
        }
    break;

    case StylesheetConstructionContext::ELEMNAME_PRESERVE_SPACE:
    case StylesheetConstructionContext::ELEMNAME_STRIP_SPACE:
        processPreserveStripSpace(name, atts, locator, xslToken);
        break;

    case StylesheetConstructionContext::ELEMNAME_KEY:
        {
            m_stylesheet.processKeyElement(
                XalanQName::PrefixResolverProxy(m_stylesheet.getNamespaces(), m_stylesheet.getURI()),
                atts,
                locator,
                m_constructionContext);
        }
        break;

    case StylesheetConstructionContext::ELEMNAME_ATTRIBUTE_SET:
        {
            m_inTemplate = true; // fake it out
            m_inScopeVariableNamesStack.resize(m_inScopeVariableNamesStack.size() + 1);

            ElemTemplateElement* const  theAttributeSet =
                m_constructionContext.createElement(
                    xslToken,
                    m_stylesheet,
                    atts,
                    locator);

            theAttributeSet->addToStylesheet(m_constructionContext, m_stylesheet);

            m_elemStack.push_back(theAttributeSet);
        }
        break;

    case StylesheetConstructionContext::ELEMNAME_INCLUDE:
        processInclude(name, atts, locator);
        break;

    case StylesheetConstructionContext::ELEMNAME_IMPORT:
        processImport(name, atts, locator);
        break;

    case StylesheetConstructionContext::ELEMNAME_OUTPUT:
        m_stylesheet.getStylesheetRoot().processOutputSpec(name, atts, m_constructionContext);
        break;

    case StylesheetConstructionContext::ELEMNAME_DECIMAL_FORMAT:
        m_stylesheet.processDecimalFormatElement(
                            m_constructionContext,
                            atts,
                            locator);
        break;

    case StylesheetConstructionContext::ELEMNAME_NAMESPACE_ALIAS:
        m_stylesheet.processNSAliasElement(name, atts, m_constructionContext);
        break;

    case StylesheetConstructionContext::ELEMNAME_WITH_PARAM:
    case StylesheetConstructionContext::ELEMNAME_ATTRIBUTE:
    case StylesheetConstructionContext::ELEMNAME_APPLY_TEMPLATES:
    case StylesheetConstructionContext::ELEMNAME_CHOOSE:
    case StylesheetConstructionContext::ELEMNAME_COMMENT:
    case StylesheetConstructionContext::ELEMNAME_COPY:
    case StylesheetConstructionContext::ELEMNAME_COPY_OF:
    case StylesheetConstructionContext::ELEMNAME_FOR_EACH:
    case StylesheetConstructionContext::ELEMNAME_IF:
    case StylesheetConstructionContext::ELEMNAME_CALL_TEMPLATE:
    case StylesheetConstructionContext::ELEMNAME_MESSAGE:
    case StylesheetConstructionContext::ELEMNAME_NUMBER:
    case StylesheetConstructionContext::ELEMNAME_OTHERWISE:
    case StylesheetConstructionContext::ELEMNAME_PI:
    case StylesheetConstructionContext::ELEMNAME_SORT:
    case StylesheetConstructionContext::ELEMNAME_TEXT:
    case StylesheetConstructionContext::ELEMNAME_VALUE_OF:
    case StylesheetConstructionContext::ELEMNAME_WHEN:
    case StylesheetConstructionContext::ELEMNAME_ELEMENT:
    case StylesheetConstructionContext::ELEMNAME_APPLY_IMPORTS:
        if (inExtensionElement() == false)
        {
            const GetCachedString   theGuard(m_constructionContext);

            error(
                XalanMessageLoader::getMessage(
                    theGuard.get(),
                    XalanMessages::IsNotAllowedInThisPosition_1Param,
                    name),
                locator);
        }
        break;

    case StylesheetConstructionContext::ELEMNAME_STYLESHEET:
        processStylesheet(name, atts, locator, fPreserveSpace, fSpaceAttrProcessed);
        break;

    default:
        if (inExtensionElement() == false)
        {
            if (m_constructionContext.getXSLTVersionSupported() < m_stylesheet.getXSLTVerDeclared())
            {
                // Forward-compatible mode...
                m_inExtensionElementStack.back() = true;
            }
            else
            {
                const GetCachedString   theGuard(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theGuard.get(),
                        XalanMessages::UnknownXSLElement_1Param,
                        name),
                    locator);
            }
        }
        break;
    }
}


void
StylesheetHandler::processStylesheet(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator,
            bool&                       fPreserveSpace,
            bool&                       fSpaceAttrProcessed)
{
    m_foundStylesheet = true;

    const XalanSize_t   nAttrs = atts.getLength();

    bool                fVersionFound = false;

    for (XalanSize_t i = 0; i < nAttrs; ++i)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_EXCLUDE_RESULT_PREFIXES))
        {
            m_stylesheet.processExcludeResultPrefixes(m_constructionContext, atts.getValue(i));
        }
        else if (equals(aname, Constants::ATTRNAME_EXTENSIONELEMENTPREFIXES))
        {
            const GetCachedString   theGuard(m_constructionContext);

            XalanDOMString&     prefix = theGuard.get();

            StringTokenizer tokenizer(atts.getValue(i),
                                      Constants::DEFAULT_WHITESPACE_SEPARATOR_STRING);

            while (tokenizer.hasMoreTokens() == true)
            {
                tokenizer.nextToken(prefix);

                const XalanDOMString* const     extns = getNamespaceForPrefixFromStack(prefix);

                if (extns == 0)
                {
                    const GetCachedString   theGuard(m_constructionContext);

                    error(
                        XalanMessageLoader::getMessage(
                            theGuard.get(),
                            XalanMessages::PrefixIsNotDeclared_1Param,
                            prefix),
                        locator);
                }

                m_stylesheet.processExtensionNamespace(m_constructionContext, *extns);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_ID))
        {
            //
        }
        else if (equals(aname, Constants::ATTRNAME_VERSION))
        {
            const XalanDOMChar* const   versionStr = atts.getValue(i);
            assert(versionStr != 0);

            m_stylesheet.setXSLTVerDeclared(DoubleSupport::toDouble(versionStr, getMemoryManager()));

            fVersionFound = true;
        }
        else if (processSpaceAttr(name, aname, atts, i, locator, fPreserveSpace) == true)
        {
            fSpaceAttrProcessed = true;
        }
        else if (isAttrOK(aname, atts, i) == false)
        {
            if (false == m_stylesheet.isWrapperless())
            {
                illegalAttributeError(name, aname, locator);
            }
        }

        if (!m_stylesheet.getNamespaces().empty())
        {
            m_stylesheet.setNamespaceDecls(m_stylesheet.getNamespaces().back());
        }
    }

    if (fVersionFound == false)
    {
        const GetCachedString   theGuard(m_constructionContext);

        error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                XalanMessages::StylesheetAttribDidNotSpecifyVersionAttrib),
            locator);
    }
}


void
StylesheetHandler::processExtensionElement(
            const XalanDOMChar*         /* name */,
            const XalanDOMString&       /* localName */,
            const AttributeListType&    /* atts */,
            const Locator*              /* locator */)
{
}


void
StylesheetHandler::checkForOrAddVariableName(
            const XalanQName&   theVariableName,
            const Locator*      theLocator)
{
    if (inExtensionElement() == true)
    {
        // We can't really do anything yet here, because we
        // don't handle extension elements.  It would be
        // better if we tried to track what was going on
        // inside extension elements.
    }
    else if (m_inTemplate == false)
    {
        assert(m_inScopeVariableNamesStack.empty() == true);

        if (m_globalVariableNames.count(theVariableName) != 0)
        {
            const GetCachedString   theGuard(m_constructionContext);

            error(
                XalanMessageLoader::getMessage(
                    theGuard.get(),
                    XalanMessages::VariableHasBeenDeclared),
                theLocator);
        }
        else
        {
            m_globalVariableNames.insert(theVariableName);
        }
    }
    else
    {
        assert(m_inScopeVariableNamesStack.empty() == false);

        QNameSetVectorType::iterator        theCurrent = m_inScopeVariableNamesStack.begin();
        const QNameSetVectorType::iterator  theEnd = m_inScopeVariableNamesStack.end();

        while(theCurrent != theEnd)
        {
            QNameSetVectorType::value_type& theLocalScope = *theCurrent;

            if (theLocalScope.count(theVariableName) != 0)
            {
                const GetCachedString   theGuard(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theGuard.get(),
                        XalanMessages::VariableHasBeenDeclaredInThisTemplate),
                    theLocator);
            }

            ++theCurrent;
        }

        assert(theCurrent == theEnd);

        m_inScopeVariableNamesStack.back().insert(theVariableName);
    }
}


void
StylesheetHandler::processPreserveStripSpace(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator,
            int                         xslToken)
{
    const XalanSize_t   nAttrs = atts.getLength();

    bool foundIt = false;

    const bool  isPreserveSpace =
        StylesheetConstructionContext::ELEMNAME_PRESERVE_SPACE == xslToken ? true : false;

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_ELEMENTS))
        {
            foundIt = true;

            StringTokenizer     tokenizer(atts.getValue(i),
                                          Constants::DEFAULT_WHITESPACE_SEPARATOR_STRING);

            const GetCachedString   theGuard(m_constructionContext);

            XalanDOMString&     theNameTest = theGuard.get();

            const XalanQName::PrefixResolverProxy   theProxy(m_stylesheet.getNamespaces(), m_stylesheet.getURI());

            while (tokenizer.hasMoreTokens())
            {
                tokenizer.nextToken(theNameTest);

                m_stylesheet.addWhitespaceElement(
                    XalanSpaceNodeTester(
                            isPreserveSpace == true ?
                                XalanSpaceNodeTester::ePreserve :
                                XalanSpaceNodeTester::eStrip,
                            m_constructionContext,
                            theNameTest,
                            theProxy,
                            locator));
            }
        }
        else if (!isAttrOK(aname, atts, i))
        {
            illegalAttributeError(name, aname, locator);
        }
    }

    if (!foundIt && inExtensionElement() == false)
    {
        const GetCachedString   theGuard(m_constructionContext);

        error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                XalanMessages::ElementRequiresAttribute_2Param,
                isPreserveSpace == true ? 
                    Constants::ELEMNAME_PRESERVESPACE_WITH_PREFIX_STRING :
                    Constants::ELEMNAME_STRIPSPACE_WITH_PREFIX_STRING,
                Constants::ATTRNAME_ELEMENTS),
            locator);
    }
}


void
StylesheetHandler::appendChildElementToParent(
            ElemTemplateElement*    parent,
            ElemTemplateElement*    elem)
{
    assert(elem != 0);

    appendChildElementToParent(parent, elem, elem->getLocator());
}


void
StylesheetHandler::appendChildElementToParent(
            ElemTemplateElement*    elem,
            const Locator*          locator)
{
    appendChildElementToParent(m_elemStack.back(), elem, locator);
}


void
StylesheetHandler::appendChildElementToParent(
            ElemTemplateElement*    parent,
            ElemTemplateElement*    elem,
            const Locator*          locator)
{
    assert(parent != 0 && elem != 0);

    try
    {
        parent->appendChildElem(elem);
    }
    catch(const XalanDOMException&  e)
    {
        if (e.getExceptionCode() == XalanDOMException::HIERARCHY_REQUEST_ERR)
        {
            const GetCachedString   theGuard(m_constructionContext);

            const XalanMessages::Codes  theCode =
                elem->getXSLToken() == StylesheetConstructionContext::ELEMNAME_TEXT_LITERAL_RESULT ?
                    XalanMessages::ElemOrLTIsNotAllowed_1Param :
                    XalanMessages::ElemIsNotAllowed_1Param;

            error(
                XalanMessageLoader::getMessage(
                    theGuard.get(),
                    theCode,
                    elem->getElementName()),
                locator);
        }
    }
}


void
StylesheetHandler::doCleanup()
{
    if (m_locatorsPushed > 0)
    {
        m_constructionContext.popLocatorStack();

        --m_locatorsPushed;
    }

    m_lastPopped = 0;
}


static bool
stackContains(
            const Stylesheet::URLStackType&     stack, 
            const XalanDOMString&               urlString)
{
    const Stylesheet::URLStackType::size_type   n = stack.size();

    bool                contains = false;

    for(Stylesheet::URLStackType::size_type i = 0; i < n && contains == false; ++i)
    {
        if(equals(stack[i], urlString))
        {
            contains = true;
        }
    }

    return contains;    
}


void
StylesheetHandler::processImport(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator)
{
    const XalanSize_t   nAttrs = atts.getLength();

    bool                foundIt = false;

    const GetCachedString   theGuard4(m_constructionContext);
    XalanDOMString&     hrefUrl = theGuard4.get();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_HREF))
        {
            foundIt = true;
            
            if (m_foundNotImport)
            {
                const GetCachedString   theError(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theError.get(),
                        XalanMessages::ImportCanOnlyOccur),
                    locator);
            }

            const GetCachedString   theGuard1(m_constructionContext);

            XalanDOMString&     saved_XSLNameSpaceURL = theGuard1.get();

            saved_XSLNameSpaceURL = m_stylesheet.getXSLTNamespaceURI();

            const GetCachedString   theGuard2(m_constructionContext);

            XalanDOMString&     href = theGuard2.get();

            href = atts.getValue(i);

            const Stylesheet::URLStackType&     includeStack =
                m_stylesheet.getIncludeStack();
            assert(includeStack.empty() == false);

            hrefUrl = m_constructionContext.getURLStringFromString(
                            href,
                            includeStack.back(),
                            hrefUrl);

            assert(hrefUrl.empty() == false);

            Stylesheet::URLStackType&   importStack = m_stylesheet.getStylesheetRoot().getImportStack();

            if (stackContains(importStack, hrefUrl))
            {
                const GetCachedString   theError(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theError.get(),
                        XalanMessages::ImportingItself_1Param,
                        hrefUrl),
                    locator);
            }

            importStack.push_back(hrefUrl);
            
            // This will take care of cleaning up the stylesheet if an exception
            // is thrown.
            typedef XalanMemMgrAutoPtr<Stylesheet>  AutpPtr;

            AutpPtr importedStylesheet( 
                m_constructionContext.getMemoryManager(),
                m_constructionContext.create(
                m_stylesheet.getStylesheetRoot(), 
                hrefUrl));

            StylesheetHandler tp(*importedStylesheet.get(), m_constructionContext);

            m_constructionContext.parseXML(hrefUrl, &tp, 0);

            // Add it to the imports, releasing the XalanAutoPtr...
            m_stylesheet.addImport(importedStylesheet.get());

            importedStylesheet.release();

            assert(equals(importStack.back(), hrefUrl));
            importStack.pop_back();     

            m_stylesheet.setXSLTNamespaceURI(saved_XSLNameSpaceURL);
        }
        else if (!isAttrOK(aname, atts, i))
        {
            illegalAttributeError(name, aname, locator);
        }
    }

    if (!foundIt)
    {            
        const GetCachedString   theError(m_constructionContext);

        error(
            XalanMessageLoader::getMessage(
                theError.get(),
                XalanMessages::ElementRequiresAttribute_2Param,
                Constants::ELEMNAME_IMPORT_WITH_PREFIX_STRING,
                Constants::ATTRNAME_HREF),
            locator);
    }
}


void
StylesheetHandler::processInclude(
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator)
{
    const XalanSize_t   nAttrs = atts.getLength();

    bool                foundIt = false;

    const GetCachedString   theGuard1(m_constructionContext);
    XalanDOMString& href = theGuard1.get();

    const GetCachedString   theGuard2(m_constructionContext);
    XalanDOMString& hrefUrl = theGuard2.get();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_HREF))
        {
            foundIt = true;

            PushPopIncludeState     theStateHandler(*this);

            href.assign(atts.getValue(i));
        
            assert(m_stylesheet.getIncludeStack().back().c_str() != 0);
     
            m_constructionContext.getURLStringFromString(href, m_stylesheet.getIncludeStack().back(), hrefUrl);

            if (stackContains(m_stylesheet.getIncludeStack(), hrefUrl))
            {
                const GetCachedString   theError(m_constructionContext);

                error(
                    XalanMessageLoader::getMessage(
                        theError.get(),
                        XalanMessages::IncludingItself_1Param,
                        hrefUrl),
                    locator);
            }

            m_stylesheet.getIncludeStack().push_back(hrefUrl);

            m_constructionContext.parseXML(hrefUrl, this, 0);

            assert(equals(m_stylesheet.getIncludeStack().back(), hrefUrl));
            m_stylesheet.getIncludeStack().pop_back();
        }
        else if (!isAttrOK(aname, atts, i))
        {
            illegalAttributeError(name, aname, locator);
        }
    }

    if (!foundIt)
    {
        const GetCachedString   theError(m_constructionContext);

        error(
            XalanMessageLoader::getMessage(
                theError.get(),
                XalanMessages::ElementRequiresAttribute_2Param,
                Constants::ELEMNAME_INCLUDE_WITH_PREFIX_STRING,
                Constants::ATTRNAME_HREF),
            locator);
    }
}


void
StylesheetHandler::endElement(const XMLCh* const    /* name */)
{
    processAccumulatedText();

    m_whiteSpaceElems.clear();

    m_stylesheet.popNamespaces();

    assert(m_elemStack.empty() == false);

    m_lastPopped = m_elemStack.back();

    assert(m_lastPopped != 0);

    m_elemStack.pop_back();
    m_lastPopped->setFinishedConstruction(true);

    const int tok = m_lastPopped->getXSLToken();

    if (m_inTemplate == true)
    {
        assert(m_inScopeVariableNamesStack.empty() == false);

        m_inScopeVariableNamesStack.pop_back();
    }

    if (StylesheetConstructionContext::ELEMNAME_TEMPLATE == tok)
    {
        m_inTemplate = false;
        m_pTemplate->addToStylesheet(m_constructionContext, m_stylesheet);
        m_pTemplate = 0;
    }
    else if (StylesheetConstructionContext::ELEMNAME_PARAM == tok ||
             StylesheetConstructionContext::ELEMNAME_VARIABLE == tok)
    {
        if(m_lastPopped->getParentNodeElem() == 0)
        {
            // Top-level param or variable
            m_inTemplate = false;
        }
    }
    else if (StylesheetConstructionContext::ELEMNAME_ATTRIBUTE_SET == tok)
    {
        m_inTemplate = false;
    }

    assert(m_inExtensionElementStack.empty() == false);

    m_inExtensionElementStack.pop_back();

    assert(m_preserveSpaceStack.empty() == false);

    m_preserveSpaceStack.pop_back();
}


void
StylesheetHandler::characters(
            const XMLCh* const  chars,
            const size_type     length)
{
    if (m_inTemplate == false &&
        inExtensionElement() == false &&
        isXMLWhitespace(chars, 0, length) == false)
    {
        const GetCachedString   theGuard(m_constructionContext);

        error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                XalanMessages::CharIsNotAllowedInStylesheet),
            m_constructionContext.getLocatorFromStack());
              
    }
    else
    {
        accumulateText(chars, length);
    }
}


void
StylesheetHandler::cdata(
            const XMLCh* const  chars,
            const size_type     length)
{
    accumulateText(chars, length);

    processText(chars, length);

    m_lastPopped = 0;
}


void
StylesheetHandler::ignorableWhitespace(
            const XMLCh* const  /*chars*/,
            const size_type     /*length*/)
{
    // Ignore!
    m_lastPopped = 0;
}


void
StylesheetHandler::processingInstruction(
            const XMLCh* const  /*target*/,
            const XMLCh* const  /*data*/)
{
    if (isXMLWhitespace(m_accumulateText) == false)
    {
        processAccumulatedText();
    }
    else
    {
        m_accumulateText.clear();
    }
}


void
StylesheetHandler::comment(const XMLCh* const /*data*/)
{
    processAccumulatedText();
}


void
StylesheetHandler::entityReference(const XMLCh* const /*name*/)
{
    processAccumulatedText();
}


void
StylesheetHandler::resetDocument()
{
    m_accumulateText.clear();
}


void
StylesheetHandler::charactersRaw(
            const XMLCh* const  /* chars */,
            const size_type     /* length */)
{
}


void
StylesheetHandler::processText(
            const XMLCh*    chars,
            size_type       length)
{
    if (m_inTemplate)
    {
        ElemTemplateElement*    parent = m_elemStack.back();
        assert(parent != 0);

        assert(m_preserveSpaceStack.empty() == false);

        bool    preserveSpace = m_preserveSpaceStack.back();
        bool    disableOutputEscaping = false;

        if (preserveSpace == false &&
            parent->getXSLToken() == StylesheetConstructionContext::ELEMNAME_TEXT)
        {
            disableOutputEscaping = static_cast<ElemText*>(parent)->getDisableOutputEscaping();

            preserveSpace = true;

            parent = m_elemStack[m_elemStack.size() - 2];
        }

        const Locator* const    locator = m_constructionContext.getLocatorFromStack();

        ElemTemplateElement* const  elem =
            m_constructionContext.createElement(
                m_stylesheet,
                chars,
                length,
                preserveSpace, 
                disableOutputEscaping,
                locator);
        assert(elem != 0);

        const bool  isWhite = elem->isWhitespace();

        if (preserveSpace || (!preserveSpace && !isWhite))
        {
            while (!m_whiteSpaceElems.empty())
            {
                assert(m_whiteSpaceElems.back() != 0);

                appendChildElementToParent(
                    parent,
                    m_whiteSpaceElems.back());

                m_whiteSpaceElems.pop_back();
            }

            appendChildElementToParent(
                parent,
                elem);
        }
        else if (isWhite)
        {
            bool    shouldPush = true;

            ElemTemplateElement* const  last = parent->getLastChildElem();

            if (0 != last)
            {
                // If it was surrounded by xsl:text, it will count as an element.
                const bool  isPrevCharData =
                    StylesheetConstructionContext::ELEMNAME_TEXT_LITERAL_RESULT == last->getXSLToken();

                const bool  isLastPoppedXSLText = (m_lastPopped != 0) &&
                        (StylesheetConstructionContext::ELEMNAME_TEXT == m_lastPopped->getXSLToken());

                if (isPrevCharData == true && isLastPoppedXSLText == false)
                {
                    appendChildElementToParent(
                        parent,
                        elem);

                    shouldPush = false;
                }
            }

            if (shouldPush)
            {
                m_whiteSpaceElems.push_back(elem);
            }
        }
    }
    // TODO: Flag error if text inside of stylesheet
}


void
StylesheetHandler::accumulateText(
            const XMLCh*    chars,
            size_type       length)
{   
    if (m_inTemplate)
    {
        m_accumulateText.append(chars, length);
    }
}


void
StylesheetHandler::processAccumulatedText()
{
    if (m_accumulateText.empty() == false)
    {
        processText(m_accumulateText.c_str(), m_accumulateText.length());

        m_accumulateText.clear();
    }   
}


bool
StylesheetHandler::inExtensionElement() const
{
    using std::find;

    if (!(find(
            m_inExtensionElementStack.begin(),
            m_inExtensionElementStack.end(),
            true) == m_inExtensionElementStack.end()))
    {
        return true;
    }
    else
    {
        return false;
    }
}


void
StylesheetHandler::error(
            const XalanDOMString&   theMessage,
            const Locator*          theLocator) const
{
    m_constructionContext.problem(
                StylesheetConstructionContext::eXSLTProcessor,
                StylesheetConstructionContext::eError,
                theMessage,
                theLocator,
                0);
}


void
StylesheetHandler::error(
            const XalanDOMChar*     theMessage1,
            const XalanDOMChar*     theMessage2,
            const Locator*          theLocator) const
{
    const GetCachedString   theGuard(m_constructionContext);

    XalanDOMString&     msg = theGuard.get();

    msg = theMessage1;
    msg += theMessage2;

    error(msg, theLocator);
}


void
StylesheetHandler::error(
            const XalanDOMChar*     theMessage1,
            const XalanDOMString&   theMessage2,
            const Locator*          theLocator) const
{
    error(theMessage1, theMessage2.c_str(), theLocator);
}


void
StylesheetHandler::error(
            const XalanDOMString&   theMessage1,
            const XalanDOMChar*     theMessage2,
            const Locator*          theLocator) const
{
    error(theMessage1.c_str(), theMessage2, theLocator);
}


void
StylesheetHandler::error(
            const XalanDOMString&   theMessage1,
            const XalanDOMString&   theMessage2,
            const Locator*          theLocator) const
{
    error(theMessage1.c_str(), theMessage2.c_str(), theLocator);
}


void
StylesheetHandler::warn(
            const XalanDOMChar*     theMessage1,
            const XalanDOMString&   theMessage2,
            const Locator*          theLocator) const
{
    warn(theMessage1, theMessage2.c_str(), theLocator);
}

void
StylesheetHandler::warn(
            const XalanDOMString&   theMessage,
            const Locator*          theLocator) const
{
    m_constructionContext.problem(
        StylesheetConstructionContext::eXSLTProcessor,
        StylesheetConstructionContext::eWarning,
        theMessage,
        theLocator,
        0);
}


void
StylesheetHandler::warn(
            const XalanDOMChar*     theMessage1,
            const XalanDOMChar*     theMessage2,
            const Locator*          theLocator) const
{
    const GetCachedString   theGuard(m_constructionContext);

    XalanDOMString&     msg = theGuard.get();

    msg = theMessage1;
    msg += theMessage2;

    m_constructionContext.problem(
        StylesheetConstructionContext::eXSLTProcessor,
        StylesheetConstructionContext::eWarning,
        msg,
        theLocator,
        0);
}


void
StylesheetHandler::illegalAttributeError(
            const XalanDOMChar*     theElementName,
            const XalanDOMChar*     theAttributeName,
            const Locator*          theLocator) const

{
    const GetCachedString   theGuard(m_constructionContext);

    error(
        XalanMessageLoader::getMessage(
            theGuard.get(),
            XalanMessages::HasIllegalAttribute_2Param,
            theElementName,
            theAttributeName),
        theLocator);
}


StylesheetHandler::PushPopIncludeState::PushPopIncludeState(StylesheetHandler&  theHandler) :
    m_handler(theHandler),
    m_elemStack(theHandler.m_elemStack, theHandler.getMemoryManager()),
    m_pTemplate(theHandler.m_pTemplate),
    m_lastPopped(theHandler),
    m_inTemplate(theHandler.m_inTemplate),
    m_foundStylesheet(theHandler.m_foundStylesheet),
    m_XSLNameSpaceURL(theHandler.m_stylesheet.getXSLTNamespaceURI(), theHandler.getMemoryManager()),
    m_foundNotImport(theHandler.m_foundNotImport),
    m_namespaceDecls(theHandler.getMemoryManager()),
    m_namespaces(theHandler.getMemoryManager()),
    m_namespacesHandler(theHandler.getMemoryManager()),
    m_inExtensionElementStack(theHandler.getMemoryManager()),
    m_preserveSpaceStack(theHandler.getMemoryManager())
{
    m_handler.m_accumulateText.clear();

    m_handler.m_elemStack.clear();
    m_handler.m_pTemplate = 0;

    m_lastPopped.swap(theHandler.m_lastPopped);

    m_handler.m_inTemplate = false;
    m_handler.m_foundStylesheet = false;
    m_handler.m_foundNotImport = false;

    // This is much more efficient, since we're just swapping
    // underlying data.  This clears out the stack as well...
    m_namespaceDecls.swap(theHandler.m_stylesheet.getNamespaceDecls());
    m_namespaces.swap(theHandler.m_stylesheet.getNamespaces());
    m_namespacesHandler.swap(theHandler.m_stylesheet.getNamespacesHandler());
    m_inExtensionElementStack.swap(theHandler.m_inExtensionElementStack);
    m_preserveSpaceStack.swap(theHandler.m_preserveSpaceStack);
}


StylesheetHandler::PushPopIncludeState::~PushPopIncludeState()
{
    m_handler.m_accumulateText.clear();
    m_handler.m_elemStack = m_elemStack;
    m_handler.m_pTemplate = m_pTemplate;

    m_lastPopped.swap(m_handler.m_lastPopped);

    m_handler.m_inTemplate = m_inTemplate;
    m_handler.m_foundStylesheet = m_foundStylesheet;
    m_handler.m_stylesheet.setXSLTNamespaceURI(m_XSLNameSpaceURL);
    m_handler.m_foundNotImport = m_foundNotImport;

    // This is much more efficient, since we're just swapping
    // underlying data.
    m_handler.m_stylesheet.getNamespaceDecls().swap(m_namespaceDecls);
    m_handler.m_stylesheet.getNamespaces().swap(m_namespaces);
    m_handler.m_stylesheet.getNamespacesHandler().swap(m_namespacesHandler);
    m_handler.m_inExtensionElementStack.swap(m_inExtensionElementStack);
    m_handler.m_preserveSpaceStack.swap(m_preserveSpaceStack);
}


void
StylesheetHandler::LastPoppedHolder::cleanup()
{
    if (m_lastPopped != 0)
    {
        const int tok = m_lastPopped->getXSLToken();

        if (tok == StylesheetConstructionContext::ELEMNAME_UNDEFINED)
        {
            m_stylesheetHandler.m_elemEmptyAllocator.destroy(static_cast<ElemEmpty*>(m_lastPopped));
        }
        else if (tok == StylesheetConstructionContext::ELEMNAME_TEXT)
        {
            m_stylesheetHandler.m_elemTextAllocator.destroy(static_cast<ElemText*>(m_lastPopped));
        }
    }
}


const XalanDOMString    StylesheetHandler::s_emptyString(XalanMemMgrs::getDummyMemMgr());


void
StylesheetHandler::initialize(MemoryManager& /* theManager*/)
{
}


void
StylesheetHandler::terminate()
{
}


}