/*
 * 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.
 */

// Class header file...
#include "XPathProcessorImpl.hpp"


#include <xercesc/sax/Locator.hpp>


#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/DOMStringPrintWriter.hpp>
#include <xalanc/PlatformSupport/DoubleSupport.hpp>
#include <xalanc/PlatformSupport/PrefixResolver.hpp>
#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
#include <xalanc/PlatformSupport/XalanUnicode.hpp>
#include <xalanc/PlatformSupport/XalanXMLChar.hpp>


#include <xalanc/DOMSupport/DOMServices.hpp>


#include "XalanQName.hpp"
#include "XPathEnvSupport.hpp"
#include "XPathFunctionTable.hpp"
#include "XPathConstructionContext.hpp"
#include "XPathExecutionContext.hpp"
#include "XPathParserException.hpp"


namespace XALAN_CPP_NAMESPACE {


XPathProcessorImpl::XPathProcessorImpl(MemoryManager&   theManager) :
    m_token(theManager),
    m_tokenChar(0),
    m_xpath(0),
    m_constructionContext(0),
    m_expression(0),
    m_prefixResolver(0),
    m_requireLiterals(false),
    m_isMatchPattern(false),
    m_positionPredicateStack(theManager),
    m_namespaces(theManager),
    m_allowVariableReferences(true),
    m_allowKeyFunction(true)
{
}


XPathProcessorImpl*
XPathProcessorImpl::create(MemoryManager&   theManager)
{
    typedef XPathProcessorImpl ThisType;

    XalanAllocationGuard    theGuard(theManager, theManager.allocate(sizeof(ThisType)));

    ThisType* const     theResult =
        new (theGuard.get()) ThisType(theManager);

    theGuard.release();

    return theResult;
}


XPathProcessorImpl::~XPathProcessorImpl()
{
}


void
XPathProcessorImpl::initXPath(
            XPath&                      pathObj,
            XPathConstructionContext&   constructionContext,
            const XalanDOMString&       expression,
            const PrefixResolver&       resolver,
            const Locator*              locator,
            bool                        allowVariableReferences,
            bool                        allowKeyFunction)
{
    m_isMatchPattern = false;

    m_requireLiterals = false;

    m_allowVariableReferences = allowVariableReferences;

    m_allowKeyFunction = allowKeyFunction;

    m_xpath = &pathObj;

    m_constructionContext = &constructionContext;

    m_expression = &m_xpath->getExpression();

    m_prefixResolver = &resolver;

    m_locator = locator;

    m_expression->reset();

    tokenize(expression);

    m_expression->appendOpCode(XPathExpression::eOP_XPATH);

    nextToken();

    Expr();

    if (m_token.empty() == false)
    {
        error(XalanMessages::ExtraIllegalTokens);
    }

    m_xpath = 0;
    m_constructionContext = 0;
    m_expression = 0;
    m_prefixResolver = 0;
    m_locator = 0;
    m_positionPredicateStack.clear();
    m_namespaces.clear();
}


void
XPathProcessorImpl::initMatchPattern(
            XPath&                      pathObj,
            XPathConstructionContext&   constructionContext,
            const XalanDOMString&       expression,
            const PrefixResolver&       resolver,
            const Locator*              locator,
            bool                        allowVariableReferences,
            bool                        allowKeyFunction)
{
    m_isMatchPattern = true;

    m_allowVariableReferences = allowVariableReferences;

    m_allowKeyFunction = allowKeyFunction;

    m_xpath = &pathObj;

    m_constructionContext = &constructionContext;

    m_expression = &m_xpath->getExpression();

    m_prefixResolver = &resolver;

    m_locator = locator;

    m_expression->reset();

    tokenize(expression);

    m_expression->appendOpCode(XPathExpression::eOP_MATCHPATTERN);

    nextToken();

    Pattern();

    if (m_token.empty() == false)
    {
        error(XalanMessages::ExtraIllegalTokens);
    }

    // Terminate for safety.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    m_expression->shrink();

    m_xpath = 0;
    m_constructionContext = 0;
    m_expression = 0;
    m_prefixResolver = 0;
    m_locator = 0;
    m_positionPredicateStack.clear();
    m_namespaces.clear();
}


void
XPathProcessorImpl::tokenize(const XalanDOMString&  pat)
{
    assert(m_xpath != 0);
    assert(m_expression != 0);
    assert(m_constructionContext != 0);

    m_expression->setCurrentPattern(m_constructionContext->getPooledString(pat));

    const t_size_type   nChars = pat.length();

    t_size_type     startSubstring = XalanDOMString::npos;
    t_size_type     posOfNSSep = XalanDOMString::npos;

    const XPathConstructionContext::GetCachedString     theGuard(*m_constructionContext);

    XalanDOMString&     theToken = theGuard.get();

    for(t_size_type i = 0; i < nChars; i++)
    {
        XalanDOMChar    c = pat[i];

        switch(c)
        {
        case XalanUnicode::charQuoteMark: 
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {      
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }
                    else
                    {
                        substring(pat, theToken, startSubstring, i);

                        addToTokenQueue(theToken);
                    }
                }

                startSubstring = i;

                for(++i; i < nChars && (c = pat[i]) != XalanUnicode::charQuoteMark; ++i);

                if(c == XalanUnicode::charQuoteMark && i < nChars)
                {
                    substring(pat, theToken, startSubstring, i + 1);

                    addToTokenQueue(theToken);

                    startSubstring = XalanDOMString::npos;
                }
                else
                {
                    error(XalanMessages::UnterminatedStringLiteral);
                }
            }
            break;

        case XalanUnicode::charApostrophe:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }
                    else
                    {
                        substring(pat, theToken, startSubstring, i);

                        addToTokenQueue(theToken);
                    }
                }

                startSubstring = i;

                for(++i; i < nChars && (c = pat[i]) != XalanUnicode::charApostrophe; ++i);

                if(c == XalanUnicode::charApostrophe && i < nChars)
                {
                    substring(pat, theToken, startSubstring, i + 1);

                    addToTokenQueue(theToken);

                    startSubstring = XalanDOMString::npos;
                }
                else
                {
                    error(XalanMessages::UnterminatedStringLiteral);
                }
            }
            break;
        
        case XalanUnicode::charLF:
        case XalanUnicode::charCR:
        case XalanUnicode::charSpace:
        case XalanUnicode::charHTab:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }
                    else
                    {
                        substring(pat, theToken, startSubstring, i);

                        addToTokenQueue(theToken);
                    }

                    startSubstring = XalanDOMString::npos;
                }
            }
            break;
        
        case XalanUnicode::charHyphenMinus:
            {
                if(!(startSubstring == XalanDOMString::npos))
                {
                    break;
                }
            }
            // fall-through on purpose

        case XalanUnicode::charCommercialAt:
        case XalanUnicode::charLeftParenthesis:
        case XalanUnicode::charLeftSquareBracket:
        case XalanUnicode::charRightParenthesis:
        case XalanUnicode::charRightSquareBracket:
        case XalanUnicode::charVerticalLine:
        case XalanUnicode::charSolidus:
        case XalanUnicode::charAsterisk:
        case XalanUnicode::charPlusSign:
        case XalanUnicode::charEqualsSign:
        case XalanUnicode::charComma:
        case XalanUnicode::charReverseSolidus: // Unused at the moment
        case XalanUnicode::charCircumflexAccent: // Unused at the moment
        case XalanUnicode::charExclamationMark: // Unused at the moment
        case XalanUnicode::charDollarSign:
        case XalanUnicode::charLessThanSign:
        case XalanUnicode::charGreaterThanSign:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }
                    else
                    {
                        substring(pat, theToken, startSubstring, i);

                        addToTokenQueue(theToken);
                    }

                    startSubstring = XalanDOMString::npos;
                }

                substring(pat, theToken, i, i + 1);

                addToTokenQueue(theToken);
            }       
            break;

        case XalanUnicode::charColon:
            {
                if(posOfNSSep == i - 1 && i > 0)
                { 
                    if(startSubstring != XalanDOMString::npos)
                    {
                        if (startSubstring < i - 1)
                        {
                            substring(pat, theToken, startSubstring, i - 1);

                            addToTokenQueue(theToken);
                        }
                    }

                    startSubstring = XalanDOMString::npos;
                    posOfNSSep = XalanDOMString::npos;

                    substring(pat, theToken, i - 1, i + 1);

                    addToTokenQueue(theToken);
                    break;
                }
                else
                {
                    posOfNSSep = i;
                }
            }
            // fall through on purpose

        
        default:
            {
                if(XalanDOMString::npos == startSubstring)
                {
                    startSubstring = i;

                    if (XalanXMLChar::isDigit(c) == true)
                    {
                        bool    gotFullStop = false;

                        while(i < nChars - 1)
                        {
                            ++i;

                            const XalanDOMChar  currentChar = pat[i];

                            if (currentChar == XalanUnicode::charFullStop)
                            {
                                if (gotFullStop == false)
                                {
                                    gotFullStop = true;
                                }
                                else
                                {
                                    --i;

                                    break;
                                }
                            }
                            else if (XalanXMLChar::isDigit(currentChar) == false)
                            {
                                --i;

                                break;
                            }
                        }

                        substring(pat, theToken, startSubstring, i + 1);

                        addToTokenQueue(theToken);

                        startSubstring = XalanDOMString::npos;
                    }
                }
            }
        }
    }

    if(startSubstring != XalanDOMString::npos)
    {
        if(XalanDOMString::npos != posOfNSSep)
        {    
            posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, nChars);
        }
        else
        {
            substring(pat, theToken, startSubstring, nChars);

            addToTokenQueue(theToken);
        }
    }

    if (0 == m_expression->tokenQueueSize())
    {
        error(XalanMessages::EmptyExpression);

    }

    m_expression->resetTokenPosition();
}


void
XPathProcessorImpl::addToTokenQueue(const XalanDOMString&   s) const
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    m_expression->pushToken(m_constructionContext->getPooledString(s));
}


void
XPathProcessorImpl::replaceTokenWithNamespaceToken() const
{
    assert(m_xpath != 0);
    assert(m_expression != 0);
    assert(m_token.empty() == false);

    StringToStringMapType::const_iterator   i = m_namespaces.find(m_token);
    assert(i != m_namespaces.end());

    const XalanDOMString* const     theNamespaceURI = (*i).second;
    assert(theNamespaceURI != 0 && theNamespaceURI->empty() == false);

    m_expression->replaceRelativeToken(
            1,
            XPathExpression::eRelativeBackward,
            m_constructionContext->getPooledString(*theNamespaceURI));
}


XPathProcessorImpl::t_size_type
XPathProcessorImpl::mapNSTokens(
            const XalanDOMString&   pat,
            t_size_type             startSubstring,
            t_size_type             posOfNSSep,
            t_size_type             posOfScan)
{
    assert(m_prefixResolver != 0);

    const XPathConstructionContext::GetCachedString     theGuard(*m_constructionContext);

    XalanDOMString&     scratchString = theGuard.get();

    // Get the prefix of the QName...
    scratchString.assign(pat, startSubstring, posOfNSSep - startSubstring);

    if (XalanQName::isValidNCName(scratchString) == false)
    {
        error(
            XalanMessages::IsNotValidNCName_1Param,
            scratchString);

    }

    const XalanDOMString* const     uName =
                m_prefixResolver->getNamespaceForPrefix(scratchString);

    if(uName == 0)
    {
        error(
            XalanMessages::PrefixIsNotDeclared_1Param,
            scratchString);
    }
    else if (uName->empty() == true)
    {
        error(
            XalanMessages::PrefixIsBoundToZeroLengthURI_1Param,
            scratchString);
    }
    else
    {
        m_namespaces[scratchString] = uName;

        addToTokenQueue(scratchString);

        addToTokenQueue(DOMServices::s_XMLNamespaceSeparatorString);

        // If there's no local part, then don't bother.  We need to check
        // this because '*' tokenizes separately, which means "ns:*" tokenizes
        // differently from "ns:foo".  In the first case, '*' will be tokenized
        // _after_ this code, in the second 'ns:foo' will be split into tokens
        // here...
        if(posOfNSSep + 1 < posOfScan)
        {
            scratchString.assign(pat, posOfNSSep + 1, posOfScan - (posOfNSSep + 1));

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

            if (XalanQName::isValidNCName(scratchString) == false)
            {
                error(
                    XalanMessages::NotValidNCName_1Param,
                    scratchString);
            }
            else
            {
                addToTokenQueue(scratchString);
            }
        }
    }

    return XalanDOMString::npos;
}


bool
XPathProcessorImpl::tokenIs(const XalanDOMString&   s) const
{
    return equals(m_token, s);
}


bool
XPathProcessorImpl::tokenIs(const XalanDOMChar*     s) const
{
    return equals(m_token, s);
}


bool
XPathProcessorImpl::tokenIs(XalanDOMChar    c) const
{
    return m_tokenChar == c ? true : false;
}


bool
XPathProcessorImpl::lookahead(
            XalanDOMChar    c,
            int             n) const
{
    const XalanDOMString&   tok =
        getTokenRelative(n - 1);

    if (tok.length() == 1 &&
        tok[0] == c)
    {
        return true;
    }
    else
    {
        return false;
    }
}


bool
XPathProcessorImpl::lookahead(
            const XalanDOMChar*     s,
            int                     n) const
{
    assert(s != 0);

    const XalanDOMString&   tok =
        getTokenRelative(n - 1);

    return equals(tok, s);
}


bool
XPathProcessorImpl::lookahead(
            const XalanDOMString&   s,
            int                     n) const
{
    const XalanDOMString&   tok =
        getTokenRelative(n - 1);

    return equals(tok, s);
}


bool
XPathProcessorImpl::lookbehind(
            char    c,
            int     n) const
{
    const XalanDOMString&   tok =
        getTokenRelative(-(n + 1));

    if (tok.length() == 1 &&
        tok[0] == c)
    {
        return true;
    }
    else
    {
        return false;
    }
}


bool
XPathProcessorImpl::lookbehindHasToken(int  n) const
{
    const XalanDOMString&   tok =
        getTokenRelative(-(n + 1));

    const XalanDOMChar      c0 = tok.length() == 0 ?
        XalanUnicode::charVerticalLine : tok[0];

    return c0 == XalanUnicode::charVerticalLine ? false : true;
}


bool
XPathProcessorImpl::nextToken()
{
    assert(m_expression != 0);

    const XToken* const     theNextToken =
            m_expression->getNextToken();

    if (theNextToken == 0)
    {
        m_token.clear();
    }
    else
    {
        m_token = theNextToken->str();
    }

    if(m_token.empty() == false)
    {
        m_tokenChar = m_token[0];

        return true;
    }
    else
    {
        m_tokenChar = 0;

        return false;
    }
}


void
XPathProcessorImpl::prevToken()
{
    assert(m_expression != 0);

    const XToken* const     thePreviousToken =
            m_expression->getPreviousToken();

    m_token = thePreviousToken == 0 ? s_emptyString : thePreviousToken->str();

    if(m_token.empty() == false)
    {
        m_tokenChar = m_token[0];
    }
    else
    {
        m_tokenChar = 0;
    }
}


const XalanDOMString&
XPathProcessorImpl::getTokenRelative(int    theOffset) const
{
    assert(m_expression != 0);

    const XToken*   theToken = 0;

    if (theOffset < 0)
    {
        theToken = 
            m_expression->getRelativeToken(
                    XPathExpression::TokenQueueSizeType(-theOffset),
                    XPathExpression::eRelativeBackward);
    }
    else
    {
        theToken =
            m_expression->getRelativeToken(
                    XPathExpression::TokenQueueSizeType(theOffset),
                    XPathExpression::eRelativeForward);
    }

    return theToken == 0 ? s_emptyString : theToken->str();
}


void
XPathProcessorImpl::consumeExpected(XalanDOMChar    expected)
{
    if(tokenIs(expected) == true)
    {
        nextToken();
    }
    else
    {
        error(
            XalanMessages::NotFoundWhatExpected_2Param,
            expected,
            m_token);
    }
}


typedef XPathConstructionContext::GetCachedString   GetCachedString;


void
XPathProcessorImpl::error(const XalanDOMString&     msg) const
{
    assert(m_constructionContext != 0);

    const GetCachedString   theGuard(*m_constructionContext);

    XalanDOMString&     emsg = theGuard.get();

    if (m_expression == 0)
    {
        emsg = msg;
    }
    else
    {
        const XalanDOMString&   theCurrentPattern =
                m_expression->getCurrentPattern();

        DOMStringPrintWriter    thePrintWriter(emsg);

        thePrintWriter.print(msg);

        thePrintWriter.println();

        if (theCurrentPattern.empty() == false)
        {
            const GetCachedString   theGuard(*m_constructionContext);

            XalanDOMString&     theResult = theGuard.get();

            const XalanMessages::Codes  theCode =
                            m_isMatchPattern == true ?
                                XalanMessages::PatternIs_1Param :
                                XalanMessages::ExpressionIs_1Param;

            thePrintWriter.print(
                XalanMessageLoader::getMessage(
                    theResult,
                    theCode,
                    theCurrentPattern));
        }

        // Back up one token, since we've consumed one...
        m_expression->getPreviousToken();

        // Ask the expression to dump the remaining tokens...
        m_expression->dumpRemainingTokenQueue(thePrintWriter);
    }

    m_constructionContext->problem(
        XPathConstructionContext::eXPath,
        XPathConstructionContext::eError,
        emsg,
        m_locator,
        0);

    throw XPathParserException(
                emsg, 
                m_constructionContext->getMemoryManager(),
                m_locator);
}


void
XPathProcessorImpl::error(XalanMessages::Codes  theCode) const
{
    assert(m_constructionContext != 0);

    const GetCachedString   theGuard(*m_constructionContext);

    error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                theCode));
}


void
XPathProcessorImpl::error(
            XalanMessages::Codes    theCode,
            const XalanDOMString&   theToken) const
{
    assert(m_constructionContext != 0);

    const GetCachedString   theGuard(*m_constructionContext);

    error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                theCode,
                theToken));
}


void
XPathProcessorImpl::error(
            XalanMessages::Codes    theCode,
            const XalanDOMChar*     theToken) const
{
    assert(m_constructionContext != 0);

    const GetCachedString   theGuard(*m_constructionContext);

    error(
            XalanMessageLoader::getMessage(
                theGuard.get(),
                theCode,
                theToken));
}


void
XPathProcessorImpl::error(
            XalanMessages::Codes    theCode,
            XalanDOMChar            theToken1,
            const XalanDOMString&   theToken2) const
{
    assert(m_constructionContext != 0);

    const GetCachedString   theGuard(*m_constructionContext);

    XalanDOMString&     theResult = theGuard.get();

    error(
            XalanMessageLoader::getMessage(
                theResult,
                theCode,
                XalanDOMString(1, theToken1, theResult.getMemoryManager()),
                theToken2));
}


void
XPathProcessorImpl::Expr()
{
    OrExpr();
}


void
XPathProcessorImpl::OrExpr()
{
    const int   opPos = m_expression->opCodeMapLength();

    AndExpr();

    if(tokenIs(s_orString) == true)
    {
        if (nextToken() == false)
        {
            error(XalanMessages::ExpectedToken);
        }
        else
        {
            m_expression->insertOpCode(
                XPathExpression::eOP_OR,
                opPos);

            OrExpr();

            m_expression->updateOpCodeLength(
                XPathExpression::eOP_OR,
                opPos);
        }
    }
}


void
XPathProcessorImpl::AndExpr() 
{
    const int   opPos = m_expression->opCodeMapLength();

    EqualityExpr();

    if(tokenIs(s_andString) == true)
    {
        if (nextToken() == false)
        {
            error(XalanMessages::ExpectedToken);
        }
        else
        {
            m_expression->insertOpCode(
                XPathExpression::eOP_AND,
                opPos);

            AndExpr();

            m_expression->updateOpCodeLength(
                XPathExpression::eOP_AND,
                opPos);
        }
    }
}


int
XPathProcessorImpl::EqualityExpr(int    opCodePos)
{
    int         theOpDisplacement = 0;

    const int   opPos = opCodePos != -1 ? opCodePos : m_expression->opCodeMapLength();

    RelationalExpr();

    XPathExpression::eOpCodes   theOpCode =
            XPathExpression::eENDOP;

    bool    foundToken = false;

    if(tokenIs(XalanUnicode::charExclamationMark) &&
       lookahead(XalanUnicode::charEqualsSign, 1))
    {
        nextToken();

        foundToken = nextToken();

        theOpCode = XPathExpression::eOP_NOTEQUALS;
    }
    else if(tokenIs(XalanUnicode::charEqualsSign))
    {
        foundToken = nextToken();

        theOpCode = XPathExpression::eOP_EQUALS;
    }

    if (theOpCode != XPathExpression::eENDOP)
    {
        if (foundToken == false)
        {
            error(XalanMessages::ExpectedToken);
        }
        else
        {
            // Save the number of bytes we inserted
            // into the map.
            const int   theLocalDisplacement =
                    m_expression->insertOpCode(theOpCode,
                                               opPos);

            // Update the length
            m_expression->updateOpCodeLength(theOpCode,
                                             opPos);

            // Do the right term of the expression.
            theOpDisplacement += EqualityExpr(opPos);

            // If there's any displacement from the right
            // term, update the length for a shift. Otherwise,
            // just update the length.
            if (theOpDisplacement > 0)
            {
                m_expression->updateShiftedOpCodeLength(
                    theOpCode,
                    opPos,
                    opPos + theOpDisplacement);
            }
            else
            {
                m_expression->updateOpCodeLength(
                    theOpCode,
                    opPos);
            }

            // Accumulate the displacement.
            theOpDisplacement += theLocalDisplacement;
        }
    }

    return theOpDisplacement;
}


int
XPathProcessorImpl::RelationalExpr(int  opCodePos)
{
    int         theOpDisplacement = 0;

    const int   opPos = opCodePos != -1 ? opCodePos : m_expression->opCodeMapLength();

    AdditiveExpr();

    if(m_token.empty() == false)
    {
        bool    foundToken = false;

        XPathExpression::eOpCodes   theOpCode =
            XPathExpression::eENDOP;

        if(tokenIs(XalanUnicode::charLessThanSign) == true)
        {
            foundToken = nextToken();

            if(tokenIs(XalanUnicode::charEqualsSign) == true)
            {
                foundToken = nextToken();

                theOpCode = XPathExpression::eOP_LTE;
            }
            else
            {
                theOpCode = XPathExpression::eOP_LT;
            }
        }
        else if(tokenIs(XalanUnicode::charGreaterThanSign) == true)
        {
            foundToken = nextToken();

            if(tokenIs(XalanUnicode::charEqualsSign) == true)
            {
                foundToken = nextToken();

                theOpCode = XPathExpression::eOP_GTE;
            }
            else
            {
                theOpCode = XPathExpression::eOP_GT;
            }
        }

        if (theOpCode != XPathExpression::eENDOP)
        {
            if (foundToken == false)
            {
                error(XalanMessages::ExpectedToken);
            }
            else
            {
                // Save the number of bytes we inserted
                // into the map.
                const int   theLocalDisplacement =
                    m_expression->insertOpCode(theOpCode,
                                               opPos);

                // Update the length
                m_expression->updateOpCodeLength(theOpCode,
                                                 opPos);

                // Do the right term of the expression.
                theOpDisplacement += RelationalExpr(opPos);

                // If there's any displacement from the right
                // term, update the length for a shift. Otherwise,
                // just update the length.
                if (theOpDisplacement > 0)
                {
                    m_expression->updateShiftedOpCodeLength(
                        theOpCode,
                        opPos,
                        opPos + theOpDisplacement);
                }
                else
                {
                    m_expression->updateOpCodeLength(
                        theOpCode,
                        opPos);
                }

                // Accumulate the displacement.
                theOpDisplacement += theLocalDisplacement;
            }
        }
    }

    return theOpDisplacement;
}


int
XPathProcessorImpl::AdditiveExpr(int    opCodePos)
{
    int         theOpDisplacement = 0;

    const int   opPos = opCodePos != -1 ? opCodePos : m_expression->opCodeMapLength();

    MultiplicativeExpr();

    if(m_token.empty() == false)
    {
        XPathExpression::eOpCodes   theOpCode =
            XPathExpression::eENDOP;

        if(tokenIs(XalanUnicode::charPlusSign) == true)
        {
            theOpCode = XPathExpression::eOP_PLUS;
        }
        else if(tokenIs(XalanUnicode::charHyphenMinus) == true)
        {
            theOpCode = XPathExpression::eOP_MINUS;
        }

        if (theOpCode != XPathExpression::eENDOP)
        {
            if (nextToken() == false)
            {
                error(XalanMessages::ExpectedToken);
            }
            else
            {
                // Save the number of bytes we inserted
                // into the map.
                const int   theLocalDisplacement =
                    m_expression->insertOpCode(theOpCode,
                                               opPos);

            // Update the length
            m_expression->updateOpCodeLength(theOpCode,
                                             opPos);

            // Do the right term of the expression.
            theOpDisplacement += AdditiveExpr(opPos);

                // If there's any displacement from the right
                // term, update the length for a shift. Otherwise,
                // just update the length.
                if (theOpDisplacement > 0)
                {
                    m_expression->updateShiftedOpCodeLength(
                        theOpCode,
                        opPos,
                        opPos + theOpDisplacement);
                }
                else
                {
                    m_expression->updateOpCodeLength(
                        theOpCode,
                        opPos);
                }

            // Accumulate the displacement.
            theOpDisplacement += theLocalDisplacement;
        }
    }
    }

    return theOpDisplacement;
}


int
XPathProcessorImpl::MultiplicativeExpr(int  opCodePos)
{
    int         theOpDisplacement = 0;

    const int   opPos = opCodePos != -1 ? opCodePos : m_expression->opCodeMapLength();

    UnaryExpr();

    if(m_token.empty() == false)
    {
        XPathExpression::eOpCodes   theOpCode =
            XPathExpression::eENDOP;

        if(tokenIs(XalanUnicode::charAsterisk) == true)
        {
            theOpCode = XPathExpression::eOP_MULT;
        }
        else if(tokenIs(s_divString) == true)
        {
            theOpCode = XPathExpression::eOP_DIV;
        }
        else if(tokenIs(s_modString) == true)
        {
            theOpCode = XPathExpression::eOP_MOD;
        }

        if (theOpCode != XPathExpression::eENDOP)
        {
            if (nextToken() == false)
            {
                error(XalanMessages::ExpectedToken);
            }
            else
            {
                // Save the number of bytes we inserted
                // into the map.
                const int   theLocalDisplacement =
                    m_expression->insertOpCode(theOpCode,
                                               opPos);

                // Update the length
                m_expression->updateOpCodeLength(theOpCode,
                                                 opPos);

            // Do the right term of the expression.
            theOpDisplacement += MultiplicativeExpr(opPos);

                // If there's any displacement from the right
                // term, update the length for a shift. Otherwise,
                // just update the length.
                if (theOpDisplacement > 0)
                {
                    m_expression->updateShiftedOpCodeLength(
                        theOpCode,
                        opPos,
                        opPos + theOpDisplacement);
                }
                else
                {
                    m_expression->updateOpCodeLength(
                        theOpCode,
                        opPos);
                }

            // Accumulate the displacement.
            theOpDisplacement += theLocalDisplacement;
        }
    }
    }

    return theOpDisplacement;
}


void
XPathProcessorImpl::UnaryExpr()
{
    const int   opPos = m_expression->opCodeMapLength();

    bool        isNeg = false;

    if(tokenIs(XalanUnicode::charHyphenMinus) == true)
    {
        nextToken();

        m_expression->insertOpCode(XPathExpression::eOP_NEG,
                                   opPos);

        isNeg = true;
    }

    UnionExpr();

    if(isNeg == true)
    {
        m_expression->updateOpCodeLength(XPathExpression::eOP_NEG,
                                         opPos);
    }
}
  

void
XPathProcessorImpl::UnionExpr()
{
    const int   opPos = m_expression->opCodeMapLength();

    bool        continueOrLoop = true;
    bool        foundUnion = false;

    do 
    {
        PathExpr();

        if(tokenIs(XalanUnicode::charVerticalLine) == true)
        {
            if(false == foundUnion)
            {
                foundUnion = true;

                m_expression->insertOpCode(XPathExpression::eOP_UNION,
                                           opPos);
            }

            nextToken();
        }
        else
        {
            if (foundUnion == true)
            {
                // Terminate for safety.
                m_expression->appendOpCode(XPathExpression::eENDOP);
            }

            break;
        }
    }
    while(continueOrLoop == true);

    m_expression->updateOpCodeLength(opPos);
}

 
void
XPathProcessorImpl::PathExpr()
{
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    FilterExpr();

    if(tokenIs(XalanUnicode::charSolidus) == true)
    {
        nextToken();

        m_expression->insertOpCode(
            XPathExpression::eOP_LOCATIONPATH,
            opPos);

        RelativeLocationPath();

        m_expression->appendOpCode(XPathExpression::eENDOP);

        m_expression->updateOpCodeLength(
            XPathExpression::eOP_LOCATIONPATH,
            opPos);
    }
}


void
XPathProcessorImpl::FilterExpr()
{
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    //  const bool  isFunc = lookahead(XalanUnicode::charLeftParenthesis, 1);

    PrimaryExpr();

    if(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
    {
        m_expression->insertOpCode(XPathExpression::eOP_LOCATIONPATH,
                                   opPos);
      
        while(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
        {
            Predicate();
        }

        if(tokenIs(XalanUnicode::charSolidus) == true)
        {
            nextToken();

            RelativeLocationPath();
        }

        // Terminate for safety.
        m_expression->appendOpCode(XPathExpression::eENDOP);

        m_expression->updateOpCodeLength(XPathExpression::eOP_LOCATIONPATH,
                                         opPos);
    }
}
  

void
XPathProcessorImpl::PrimaryExpr()
{
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    if(tokenIs(XalanUnicode::charApostrophe) == true ||
       tokenIs(XalanUnicode::charQuoteMark) == true)
    {
        m_expression->appendOpCode(XPathExpression::eOP_LITERAL);

        Literal();

        m_expression->updateOpCodeLength(
            XPathExpression::eOP_LITERAL,
            opPos);
    }
    else if(tokenIs(XalanUnicode::charDollarSign) == true)
    {
        nextToken(); // consume '$'

        if (m_allowVariableReferences == false)
        {
            error(XalanMessages::VariableReferenceNotAllowed);
        }
        else
        {
            m_expression->appendOpCode(XPathExpression::eOP_VARIABLE);

            QName();

            m_expression->updateOpCodeLength(
                XPathExpression::eOP_VARIABLE,
                opPos);
        }
    }
    else if(tokenIs(XalanUnicode::charLeftParenthesis) == true)
    {
        nextToken();

        m_expression->appendOpCode(XPathExpression::eOP_GROUP);

        Expr();

        consumeExpected(XalanUnicode::charRightParenthesis);

        m_expression->updateOpCodeLength(
            XPathExpression::eOP_GROUP,
            opPos);
    }
    else if((tokenIs(XalanUnicode::charFullStop) == true &&
                m_token.length() > 1 &&
                XalanXMLChar::isDigit(m_token[1]) == true) ||
                XalanXMLChar::isDigit(m_tokenChar) == true)
    {
        m_expression->appendOpCode(XPathExpression::eOP_NUMBERLIT);

        Number();

        m_expression->updateOpCodeLength(
            XPathExpression::eOP_NUMBERLIT,
            opPos);
    }
    else if(lookahead(XalanUnicode::charLeftParenthesis, 1) == true ||
            (lookahead(XalanUnicode::charColon, 1) == true && lookahead(XalanUnicode::charLeftParenthesis, 3) == true))
    {
        FunctionCall();
    }
    else
    {
        LocationPath();
    }
}


void
XPathProcessorImpl::Argument()
{
    assert(m_expression != 0);

    if (m_requireLiterals == false ||
        isCurrentLiteral() == true)
    {
        Expr();
    }
    else
    {
        error(XalanMessages::LiteralArgumentIsRequired);
    }
}


int
XPathProcessorImpl::FunctionCallArguments()
{
    int     argCount = 0;

    consumeExpected(XalanUnicode::charLeftParenthesis);

    while(tokenIs(XalanUnicode::charRightParenthesis) == false &&
          m_token.empty() == false)
    {
        if(tokenIs(XalanUnicode::charComma) == true)
        {
            error(XalanMessages::NoPrecedingArgument);
        }

        Argument();

        ++argCount;

        if(tokenIs(XalanUnicode::charRightParenthesis) == false)
        {
            consumeExpected(XalanUnicode::charComma);

            if(tokenIs(XalanUnicode::charRightParenthesis) == true)
            {
                error(XalanMessages::NoFollowingArgument);
            }
        }
    }

    consumeExpected(XalanUnicode::charRightParenthesis);

    return argCount;
}


void
XPathProcessorImpl::FunctionCall()
{
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    if(lookahead(XalanUnicode::charColon, 1) == true)
    {
        m_expression->appendOpCode(XPathExpression::eOP_EXTFUNCTION);

        XPathExpression::OpCodeMapValueVectorType   theArgs(2, 0, m_constructionContext->getMemoryManager());

        // Replace the token in the queue with the actual namespace URI...
        replaceTokenWithNamespaceToken();

        theArgs[0] = m_expression->getTokenPosition() - 1;

        nextToken();

        consumeExpected(XalanUnicode::charColon);

        theArgs[1] = m_expression->getTokenPosition() - 1;

        m_expression->setOpCodeArgs(XPathExpression::eOP_EXTFUNCTION,
                                    opPos,
                                    theArgs);

        nextToken();

        FunctionCallArguments();
    }
    else
    {
        if (isValidFunction(m_token) == false)
        {
            error(
                XalanMessages::CouldNotFindFunction_1Param,
                m_token);

        }

        const XPathExpression::eOpCodes     funcTok = getFunctionToken(m_token);

        switch(funcTok)
        {
        case XPathExpression::eNODETYPE_PI:
        case XPathExpression::eNODETYPE_COMMENT:
        case XPathExpression::eNODETYPE_TEXT:
        case XPathExpression::eNODETYPE_NODE:
            LocationPath();
            // ************** Nasty return here!!! *********************** //
            return;
            break;

        case XPathExpression::eOP_FUNCTION_POSITION:
            FunctionPosition();
            break;

        case XPathExpression::eOP_FUNCTION_LAST:
            FunctionLast();
            break;

        case XPathExpression::eOP_FUNCTION_COUNT:
            FunctionCount();
            break;

        case XPathExpression::eOP_FUNCTION_NOT:
            FunctionNot();
            break;

        case XPathExpression::eOP_FUNCTION_TRUE:
            FunctionTrue();
            break;

        case XPathExpression::eOP_FUNCTION_FALSE:
            FunctionFalse();
            break;

        case XPathExpression::eOP_FUNCTION_BOOLEAN:
            FunctionBoolean();
            break;

        case XPathExpression::eOP_FUNCTION_NAME_0:
            FunctionName(opPos);
            break;

        case XPathExpression::eOP_FUNCTION_LOCALNAME_0:
            FunctionLocalName(opPos);
            break;

        case XPathExpression::eOP_FUNCTION_NUMBER_0:
            FunctionNumber(opPos);
            break;

        case XPathExpression::eOP_FUNCTION_FLOOR:
            FunctionFloor();
            break;

        case XPathExpression::eOP_FUNCTION_CEILING:
            FunctionCeiling();
            break;

        case XPathExpression::eOP_FUNCTION_ROUND:
            FunctionRound();
            break;

        case XPathExpression::eOP_FUNCTION_STRINGLENGTH_0:
            FunctionStringLength(opPos);
            break;

        case XPathExpression::eOP_FUNCTION_SUM:
            FunctionSum();
            break;

        default:
            {
                // The position must be at least 1, since
                // we've looked at a token.
                assert(m_expression->getTokenPosition() > 0);

                if (m_allowKeyFunction == false &&
                    m_token == XPathFunctionTable::s_key)
                {
                    error(XalanMessages::KeyFunctionNotAllowed);
                }

                int     theFunctionID =
                    XPath::getFunctionTable().nameToID(m_token);

                if ((equals(m_token, s_positionString) == true ||
                     equals(m_token, s_lastString) == true) &&
                    m_positionPredicateStack.empty() == false)
                {
                    m_positionPredicateStack.back() = true;
                }

                XPathExpression::OpCodeMapValueVectorType   theArgs(2, 0, m_constructionContext->getMemoryManager());
        
                theArgs[0] = theFunctionID;
                theArgs[1] = 0;

                m_expression->appendOpCode(
                        XPathExpression::eOP_FUNCTION,
                        theArgs);

                nextToken();

                // Get the arguments, and the argument count...
                const int   argCount = FunctionCallArguments();

                assert(m_expression->getOpCodeMapValue(opPos + 3) == 0);

                // update the arg count in the op map...
                m_expression->setOpCodeMapValue(opPos + 3, argCount);
            }
        }
    }

    // Terminate for safety.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    m_expression->updateOpCodeLength(opPos);
}


void
XPathProcessorImpl::FunctionPosition()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_POSITION);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        XalanDOMString  theResult(m_constructionContext->getMemoryManager());

        error(
            XalanMessages::FunctionDoesNotAcceptAnyArguments_1Param,
            XPathFunctionTable::s_position);
    }
    else
    {
        if (m_positionPredicateStack.empty() == false)
        {
            m_positionPredicateStack.back() = true;
        }
    }
}


void
XPathProcessorImpl::FunctionLast()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_LAST);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        error(
            XalanMessages::FunctionDoesNotAcceptAnyArguments_1Param,
            XPathFunctionTable::s_last);
    }
    else
    {
        if (m_positionPredicateStack.empty() == false)
        {
            m_positionPredicateStack.back() = true;
        }
    }
}


void
XPathProcessorImpl::FunctionCount()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_COUNT);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_count);
    }
}


void
XPathProcessorImpl::FunctionNot()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_NOT);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_not);
    }
}


void
XPathProcessorImpl::FunctionTrue()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_TRUE);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        error(
            XalanMessages::FunctionDoesNotAcceptAnyArguments_1Param,
            XPathFunctionTable::s_true);
    }
}


void
XPathProcessorImpl::FunctionFalse()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_FALSE);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        error(
            XalanMessages::FunctionDoesNotAcceptAnyArguments_1Param,
            XPathFunctionTable::s_false);
    }
}


void
XPathProcessorImpl::FunctionBoolean()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_BOOLEAN);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_boolean);
    }
}


void
XPathProcessorImpl::FunctionName(int    opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_NAME_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_NAME_0,
                XPathExpression::eOP_FUNCTION_NAME_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_name);
        }
    }
}


void
XPathProcessorImpl::FunctionLocalName(int   opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_LOCALNAME_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_LOCALNAME_0,
                XPathExpression::eOP_FUNCTION_LOCALNAME_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_localName);
        }
    }
}


void
XPathProcessorImpl::FunctionNumber(int  opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_NUMBER_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_NUMBER_0,
                XPathExpression::eOP_FUNCTION_NUMBER_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_number);
        }
    }
}


void
XPathProcessorImpl::FunctionFloor()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_FLOOR);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_floor);
    }
}


void
XPathProcessorImpl::FunctionCeiling()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_CEILING);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_ceiling);
    }
}


void
XPathProcessorImpl::FunctionRound()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_ROUND);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_round);
    }
}


void
XPathProcessorImpl::FunctionString(int  opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_STRING_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_STRING_0,
                XPathExpression::eOP_FUNCTION_STRING_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_string);
        }
    }
}


void
XPathProcessorImpl::FunctionSum()
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_SUM);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 1)
    {
        error(
            XalanMessages::FunctionAcceptsOneArgument_1Param,
            XPathFunctionTable::s_sum);
    }
}


void
XPathProcessorImpl::FunctionStringLength(int    opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_STRINGLENGTH_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_STRINGLENGTH_0,
                XPathExpression::eOP_FUNCTION_STRINGLENGTH_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_stringLength);
        }
    }
}


void
XPathProcessorImpl::FunctionNamespaceURI(int    opPos)
{
    m_expression->appendOpCode(XPathExpression::eOP_FUNCTION_NAMESPACEURI_0);

    // Consume the name...
    nextToken();

    // Get the arguments, and the argument count...
    const int   argCount = FunctionCallArguments();

    if (argCount != 0)
    {
        if (argCount == 1)
        {
            m_expression->replaceOpCode(
                opPos,
                XPathExpression::eOP_FUNCTION_NAMESPACEURI_0,
                XPathExpression::eOP_FUNCTION_NAMESPACEURI_1);
        }
        else
        {
            error(
                XalanMessages::FunctionTakesZeroOrOneArg_1Param,
                XPathFunctionTable::s_namespaceUri);
        }
    }
}


void
XPathProcessorImpl::LocationPath()
{
    const int   opPos = m_expression->opCodeMapLength();

    m_expression->appendOpCode(XPathExpression::eOP_LOCATIONPATH);

    if(tokenIs(XalanUnicode::charSolidus) == true)
    {
        nextToken();

        const int   newOpPos = m_expression->opCodeMapLength();

        // Tell how long the step is without the predicate
        const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4, m_constructionContext->getMemoryManager());

        m_expression->appendOpCode(
            XPathExpression::eFROM_ROOT,
            theArgs);

        m_expression->appendOpCode(XPathExpression::eNODETYPE_ROOT);

        // Tell how long the entire step is.
        m_expression->updateOpCodeLength(newOpPos);
    }

    if(m_token.empty() == false)
    {
        RelativeLocationPath();
    }

    // Terminate for safety.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    m_expression->updateOpCodeLength(XPathExpression::eOP_LOCATIONPATH,
                                     opPos);
}


void
XPathProcessorImpl::RelativeLocationPath()
{
    Step();

    while(tokenIs(XalanUnicode::charSolidus) == true)
    {
        nextToken();

        Step();
    }
}
  

void
XPathProcessorImpl::Step()
{
    const int   opPos = m_expression->opCodeMapLength();

    if(m_token.empty() == true)
    {
        error(XalanMessages::ExpectedNodeTest);
    }
    else if(tokenIs(s_dotString) == true)
    {
        nextToken();

        if(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
        {
            error(XalanMessages::IllegalSyntaxOfPredicatesSelf);
        }

        const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4, m_constructionContext->getMemoryManager());

        m_expression->appendOpCode(XPathExpression::eFROM_SELF,
                                   theArgs);

        m_expression->appendOpCode(XPathExpression::eNODETYPE_NODE);

        // Tell how long the entire step is.
        m_expression->updateOpCodeLength(opPos);
    }
    else if(tokenIs(s_dotDotString) == true)
    {
        nextToken();

        if(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
        {
            error(XalanMessages::IllegalSyntaxOfPredicatesParent);
        }

        // Tell how long the step is without the predicate
        const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4,m_constructionContext->getMemoryManager());

        m_expression->appendOpCode(XPathExpression::eFROM_PARENT,
                                   theArgs);

        m_expression->appendOpCode(XPathExpression::eNODETYPE_NODE);

        // Tell how long the entire step is.
        m_expression->updateOpCodeLength(opPos);
    }
    else if (tokenIs(XalanUnicode::charAsterisk) ||
             tokenIs(XalanUnicode::charCommercialAt) ||
             tokenIs(XalanUnicode::charSolidus) ||
             (tokenIs(XalanUnicode::charLowLine) ||
              XalanXMLChar::isLetter(m_token[0])))
    {
        Basis();

        while(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
        {
            Predicate();
        }

        // Tell how long the entire step is.
        m_expression->updateOpCodeLength(opPos);
    }
    else if (tokenIs(XalanUnicode::charRightParenthesis) == false)
    {
        error(
            XalanMessages::UnexpectedTokenFound_1Param,
            m_token);
    }
}


void
XPathProcessorImpl::Basis()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    XPathExpression::eOpCodes   axisType = XPathExpression::eENDOP;

    // The next blocks guarantee that a FROM_XXX will be added.
    if(lookahead(s_axisString, 1) == true)
    {
        axisType = AxisName();

        nextToken();
        nextToken();
    }
    else if(tokenIs(XalanUnicode::charCommercialAt) == true)
    {
        axisType = XPathExpression::eFROM_ATTRIBUTES;

        m_expression->appendOpCode(XPathExpression::eFROM_ATTRIBUTES);

        nextToken();
    }
    else if(tokenIs(XalanUnicode::charSolidus) == true)
    {
        // Check the current token in the expression.  It's
        // actually the next token in this context.
        //
        const XalanDOMString&   theNextToken = getTokenRelative(0);

        if (isAxis(theNextToken) == false && isNodeTest(theNextToken) == false)
        {
            nextToken();

            error(XalanMessages::ExpectedAxis); 
        }
        else
        {
            // Tell how long the step is without the predicate
            const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4, m_constructionContext->getMemoryManager());

            m_expression->appendOpCode(XPathExpression::eFROM_DESCENDANTS_OR_SELF,
                                       theArgs);

            m_expression->appendOpCode(XPathExpression::eNODETYPE_NODE);

            // Tell how long the step is without the predicate
            m_expression->updateOpCodeLengthAfterNodeTest(opPos);

            return; // make a quick exit...
        }
    }
    else
    {
        axisType = XPathExpression::eFROM_CHILDREN;

        m_expression->appendOpCode(XPathExpression::eFROM_CHILDREN);
    }

    NodeTest();

    // Tell how long the step is without the predicate
    m_expression->updateOpCodeLengthAfterNodeTest(opPos);
}


XPathExpression::eOpCodes
XPathProcessorImpl::AxisName()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    const XPathExpression::eOpCodes     theOpCode =
        getAxisToken(m_token);

    if (theOpCode == XPathExpression::eENDOP)
    {
        error(
            XalanMessages::IllegalAxisName_1Param,
            m_token); 
    }
    else
    {
        m_expression->appendOpCode(theOpCode);
    }

    return theOpCode;
}


int
XPathProcessorImpl::NodeTest()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    int     nodeTestPos = -1;

    if (lookahead(XalanUnicode::charLeftParenthesis, 1) == true)
    {
        const XPathExpression::eOpCodes     theOpCode = getNodeTypeToken(m_token);

        if (theOpCode == XPathExpression::eENDOP)
        {
            error(
                XalanMessages::UnknownNodeType_1Param,
                m_token);
        }
        else
        {
            nextToken();

            nodeTestPos = m_expression->appendOpCode(theOpCode);

            consumeExpected(XalanUnicode::charLeftParenthesis);

            if(XPathExpression::eNODETYPE_PI == theOpCode)
            {
                if(tokenIs(XalanUnicode::charRightParenthesis) == false)
                {
                    Literal();
                }
            }

            consumeExpected(XalanUnicode::charRightParenthesis);
        }
    }
    else
    {
        // Assume name of attribute or element.
        m_expression->appendOpCode(XPathExpression::eNODENAME);

        if(lookahead(XalanUnicode::charColon, 1) == true)
        {
            if(tokenIs(XalanUnicode::charAsterisk) == true)
            {
                m_expression->appendOpCode(XPathExpression::eELEMWILDCARD);
            }
            else
            {
                // Replace the token in the queue with the actual namespace...
                replaceTokenWithNamespaceToken();

                m_expression->pushCurrentTokenOnOpCodeMap();
            }

            nextToken();

            consumeExpected(XalanUnicode::charColon);
        }
        else
        {
            m_expression->appendOpCode(XPathExpression::eEMPTY);
        }

        if (tokenIs(XalanUnicode::charAsterisk) == true)
        {
            m_expression->appendOpCode(XPathExpression::eELEMWILDCARD);
        }
        else if (isNodeTest(m_token) == false)
        {
            error(XalanMessages::ExpectedNodeTest);
        }
        else
        {
            m_expression->pushCurrentTokenOnOpCodeMap();
        }

        nextToken();
    }

    return nodeTestPos;
}


void
XPathProcessorImpl::Predicate()
{
    if(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
    {
        nextToken();

        PredicateExpr();        

        consumeExpected(XalanUnicode::charRightSquareBracket);
    }
}


void
XPathProcessorImpl::PredicateExpr()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    m_expression->appendOpCode(XPathExpression::eOP_PREDICATE);

    m_positionPredicateStack.push_back(false);

    Expr();

    // Terminate for safety.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    m_expression->updateOpCodeLength(XPathExpression::eOP_PREDICATE,
                                     opPos);

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

    if (m_positionPredicateStack.back() == true)
    {
        m_expression->replaceOpCode(
            opPos,
            XPathExpression::eOP_PREDICATE,
            XPathExpression::eOP_PREDICATE_WITH_POSITION);
    }

    m_positionPredicateStack.pop_back();
}


void
XPathProcessorImpl::QName()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    // If there is no prefix, we have to fake things out...
    if (lookahead(XalanUnicode::charColon, 1) == false)
    {
        m_expression->insertToken(s_emptyString);

        m_expression->pushCurrentTokenOnOpCodeMap();

        nextToken();
    }
    else
    {
        // Replace the token in the queue with the actual namespace...
        replaceTokenWithNamespaceToken();

        m_expression->pushCurrentTokenOnOpCodeMap();

        nextToken();

        consumeExpected(XalanUnicode::charColon);
    }

    m_expression->pushCurrentTokenOnOpCodeMap();

    nextToken();
}


void
XPathProcessorImpl::NCName()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    m_expression->pushCurrentTokenOnOpCodeMap();

    nextToken();
}


void
XPathProcessorImpl::Literal()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    if(isCurrentLiteral() == true)
    {
        m_expression->pushArgumentOnOpCodeMap(
            m_constructionContext->getPooledString(m_token.c_str() + 1, m_token.length() - 2));

        nextToken();
    }
    else
    {
        error(XalanMessages::LiteralArgumentIsRequired); 
    }
}


void
XPathProcessorImpl::Number()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    if(m_token.empty() == false)
    {
        const double    num = DoubleSupport::toDouble(m_token, m_constructionContext->getMemoryManager());

        const XPathConstructionContext::GetCachedString     theGuard(*m_constructionContext);
 
        XalanDOMString&     theStringValue = theGuard.get();
 
        NumberToDOMString(num, theStringValue);

        m_expression->pushNumberLiteralOnOpCodeMap(num);

        m_expression->pushArgumentOnOpCodeMap(num, m_constructionContext->getPooledString(theStringValue));

        nextToken();
    }
}


void
XPathProcessorImpl::Pattern()
{
    while(true)
    {
        LocationPathPattern();

        if(tokenIs(XalanUnicode::charVerticalLine) == true)
        {
            nextToken();
        }
        else
        {
            break;
        }
    }
}


void
XPathProcessorImpl::LocationPathPattern()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    m_expression->appendOpCode(XPathExpression::eOP_LOCATIONPATHPATTERN);

    if(lookahead(XalanUnicode::charLeftParenthesis, 1) == true &&
                (tokenIs(s_functionIDString) == true ||
                 tokenIs(s_functionKeyString) == true))
    {
        IdKeyPattern();

        if(tokenIs(XalanUnicode::charSolidus) == true && lookahead(XalanUnicode::charSolidus, 1) == true)
        {
            const int   newOpPos = m_expression->opCodeMapLength();

            // Tell how long the step is without the predicate
            const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4, m_constructionContext->getMemoryManager());

            m_expression->appendOpCode(XPathExpression::eMATCH_ANY_ANCESTOR_WITH_FUNCTION_CALL,
                                       theArgs);

            m_expression->updateOpCodeLength(newOpPos);

            nextToken();
        }
    }
    else if(tokenIs(XalanUnicode::charSolidus) == true)
    {
        const int   newOpPos = m_expression->opCodeMapLength();

        // Tell how long the step is without the predicate
        const XPathExpression::OpCodeMapValueVectorType     theArgs(1, 4, m_constructionContext->getMemoryManager());

        if(lookahead(XalanUnicode::charSolidus, 1) == true)
        {
            m_expression->appendOpCode(
                XPathExpression::eMATCH_ANY_ANCESTOR_WITH_PREDICATE,
                theArgs);

            m_expression->appendOpCode(XPathExpression::eNODETYPE_NODE);

            nextToken();
        }
        else
        {
            m_expression->appendOpCode(XPathExpression::eFROM_ROOT,
                                       theArgs);

            m_expression->appendOpCode(XPathExpression::eNODETYPE_ROOT);
        }

        m_expression->updateOpCodeLength(newOpPos);

        nextToken();
    }

    if(m_token.empty() == false)
    {
        if (!tokenIs(XalanUnicode::charVerticalLine) == true)
        {
            RelativePathPattern();
        }
        else if (lookahead(XalanUnicode::charVerticalLine, -1) == true)
        {
            error(
                XalanMessages::UnexpectedTokenFound_1Param,
                m_token);
        }
    }

    // Terminate for safety.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    m_expression->updateOpCodeLength(XPathExpression::eOP_LOCATIONPATHPATTERN,
                                     opPos);
}


void
XPathProcessorImpl::IdKeyPattern()
{
    m_requireLiterals = true;

    FunctionCall();

    m_requireLiterals = false;
}


void
XPathProcessorImpl::RelativePathPattern()
{    
    StepPattern();

    while(tokenIs(XalanUnicode::charSolidus) == true)
    {
        nextToken();

        StepPattern();
    }
}


void
XPathProcessorImpl::StepPattern()
{
    AbbreviatedNodeTestStep();
}


void
XPathProcessorImpl::AbbreviatedNodeTestStep()
{
    assert(m_xpath != 0);
    assert(m_expression != 0);

    const int   opPos = m_expression->opCodeMapLength();

    int         matchTypePos = -1;

    XPathExpression::eOpCodes   axisType = XPathExpression::eENDOP;

    // The next blocks guarantee that a MATCH_XXX will be added.
    if(tokenIs(XalanUnicode::charCommercialAt) == true)
    {
        axisType = XPathExpression::eMATCH_ATTRIBUTE;

        m_expression->appendOpCode(axisType);

        nextToken();
    }
    else if(lookahead(s_axisString, 1) == true)
    {
        if(tokenIs(s_attributeString) == true)
        {
            axisType = XPathExpression::eMATCH_ATTRIBUTE;

            m_expression->appendOpCode(axisType);
        }
        else if(tokenIs(s_childString) == true)
        {
            matchTypePos = m_expression->opCodeMapLength();

            axisType = XPathExpression::eMATCH_IMMEDIATE_ANCESTOR;

            m_expression->appendOpCode(axisType);
        }
        else
        {
            error(XalanMessages::OnlyChildAndAttributeAxesAreAllowed); 
        }

        nextToken();
        nextToken();
    }
    else if(tokenIs(XalanUnicode::charSolidus) == true)
    {
        if(lookahead(s_axisString, 2) == false &&
           lookahead(XalanUnicode::charCommercialAt, 1) == false)
        {
            matchTypePos = m_expression->opCodeMapLength();

            axisType = XPathExpression::eMATCH_IMMEDIATE_ANCESTOR;

            m_expression->appendOpCode(axisType);
        }
        else
        {
            nextToken();

            // This matches an abbreviated step "@foo"
            if (tokenIs(XalanUnicode::charCommercialAt) == true)
            {
                axisType = XPathExpression::eMATCH_ATTRIBUTE;

                m_expression->appendOpCode(axisType);
            }
            else
            {
                // This matches the attribute or child axis: attribute::name or child::name.
                if(tokenIs(s_attributeString) == true)
                {
                    axisType = XPathExpression::eMATCH_ATTRIBUTE;

                    m_expression->appendOpCode(axisType);
                }
                else if(tokenIs(s_childString) == true)
                {
                    matchTypePos = m_expression->opCodeMapLength();

                    axisType = XPathExpression::eMATCH_IMMEDIATE_ANCESTOR;

                    m_expression->appendOpCode(axisType);
                }
                else
                {
                    error(XalanMessages::OnlyChildAndAttributeAxesAreAllowed); 
                }

                nextToken();
            }
        }

        nextToken();
    }
    else
    {
        if(tokenIs(XalanUnicode::charSolidus) == true)
        {
            nextToken();
        }

        matchTypePos = m_expression->opCodeMapLength();

        axisType = XPathExpression::eMATCH_IMMEDIATE_ANCESTOR;

        m_expression->appendOpCode(axisType);
    }

    // Make room for telling how long the step is without the predicate.
    // This will be replaced by the right value.
    m_expression->appendOpCode(XPathExpression::eENDOP);

    NodeTest();

    m_expression->updateOpCodeLengthAfterNodeTest(opPos);

    while(tokenIs(XalanUnicode::charLeftSquareBracket) == true)
    {
        Predicate();
    }

    if(matchTypePos > -1 && tokenIs(XalanUnicode::charSolidus) == true && lookahead(XalanUnicode::charSolidus, 1) == true)
    {
        assert(m_expression->opCodeMapLength() > matchTypePos);

        m_expression->setOpCodeMapValue(matchTypePos, XPathExpression::eMATCH_ANY_ANCESTOR);
    }

    m_expression->updateOpCodeLength(opPos);
}


bool
XPathProcessorImpl::isValidFunction(const XalanDOMString&   key)
{
    bool    fResult = true;

    if(XPath::isInstalledFunction(key) == false)
    {
        if (searchTable(s_functionTable, s_functionTableSize, key).m_opCode == XPathExpression::eENDOP)
        {
            fResult = false;
        }
    }

    return fResult;
}


bool
XPathProcessorImpl::isCurrentLiteral() const
{
    const t_size_type   theLength = m_token.length();

    if (theLength <= 1)
    {
        return false;
    }
    else
    {
        const t_size_type   last = theLength - 1;

        const XalanDOMChar  c0 = m_tokenChar;
        const XalanDOMChar  cX = m_token[last];

        if((c0 == XalanUnicode::charQuoteMark && cX == XalanUnicode::charQuoteMark) ||
           (c0 == XalanUnicode::charApostrophe && cX == XalanUnicode::charApostrophe))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}


bool
XPathProcessorImpl::isAxis(const XalanDOMString&    theToken)
{
    const XalanDOMString::size_type     theLength =
        theToken.length();

    if (theLength == 0)
    {
        return false;
    }
    else if (theLength == 1 &&
             theToken[0] == XalanUnicode::charCommercialAt)
    {
        return true;
    }
    else if (equals(theToken, s_dotString) == true ||
             equals(theToken, s_dotDotString) == true)
    {
        return true;
    }
    else
    {
        const XPathExpression::eOpCodes     theOpCode =
            getAxisToken(theToken);

        if (theOpCode != XPathExpression::eENDOP)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}


bool
XPathProcessorImpl::isNodeTest(const XalanDOMString&    theToken)
{
    const XalanDOMString::size_type     theLength = theToken.length();

    if (theLength == 0)
    {
        return false;
    }
    else if (theLength == 1 &&
             theToken[0] == XalanUnicode::charAsterisk)
    {
        return true;
    }
    else if (theToken[0] == XalanUnicode::charLowLine ||
             XalanXMLChar::isLetter(theToken[0]) == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}


const XPathProcessorImpl::TableEntry&
XPathProcessorImpl::searchTable(
        const TableEntry        theTable[],
        size_type               theTableSize,
        const XalanDOMString&   theString)
{
    const TableEntry*   theFirst = theTable;
    const TableEntry*   theLast = &theTable[theTableSize - 1];

    while(theFirst <= theLast)
    {
        const TableEntry*   theCurrent = theFirst + (theLast - theFirst) / 2;
        assert(theCurrent->m_string[0] != 0);

        const int   theResult = compare(theString.c_str(), theCurrent->m_string);

        if (theResult < 0)
        {
            theLast = theCurrent - 1;
        }
        else if (theResult > 0)
        {
            theFirst = theCurrent + 1;
        }
        else
        {
            return *theCurrent;
        }
    }

    return s_dummyEntry;
}


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


const XalanDOMChar  XPathProcessorImpl::s_functionIDString[] =
{
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_d,
    0
};

// This shouldn't really be here, since it's not part of the XPath standard,
// but rather a part ofthe XSLT standard.
const XalanDOMChar  XPathProcessorImpl::s_functionKeyString[] =
{
    XalanUnicode::charLetter_k,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_y,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_orString[] =
{
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_r,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_andString[] =
{
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_d,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_divString[] =
{
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_v,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_modString[] =
{
    XalanUnicode::charLetter_m,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_d,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_dotString[] =
{
    XalanUnicode::charFullStop,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_dotDotString[] =
{
    XalanUnicode::charFullStop,
    XalanUnicode::charFullStop,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_axisString[] =
{
    XalanUnicode::charColon,
    XalanUnicode::charColon,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_attributeString[] =
{
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_b,
    XalanUnicode::charLetter_u,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_e,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_childString[] =
{
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_h,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_d,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_lastString[] =
{
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_t,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_positionString[] =
{
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_n,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_asteriskString[] =
{
    XalanUnicode::charAsterisk,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_commentString[] =
{
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_m,
    XalanUnicode::charLetter_m,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_t,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_piString[] =
{
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_u,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_n,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_nodeString[] =
{
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_e,
    0
};

const XalanDOMChar  XPathProcessorImpl::s_textString[] =
{
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_x,
    XalanUnicode::charLetter_t,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_ancestorString[] =
{
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_r,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_ancestorOrSelfString[] =
{
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_r,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_r,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_f,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_descendantString[] =
{
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_t,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_descendantOrSelfString[] =
{
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_t,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_r,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_f,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_followingString[] =
{
    XalanUnicode::charLetter_f,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_w,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_followingSiblingString[] =
{
    XalanUnicode::charLetter_f,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_w,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_b,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_parentString[] =
{
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_t,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_precedingString[] =
{
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_precedingSiblingString[] =
{
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_r,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    XalanUnicode::charHyphenMinus,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_b,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_g,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_selfString[] =
{
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_f,
    0
};

const XalanDOMChar      XPathProcessorImpl::s_namespaceString[] =
{
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_m,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_s,
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    0
};


const XPathProcessorImpl::TableEntry    XPathProcessorImpl::s_functionTable[] =
{
    { XPathFunctionTable::s_not, XPathExpression::eOP_FUNCTION_NOT },
    { XPathFunctionTable::s_sum, XPathExpression::eOP_FUNCTION_SUM },
    { XPathProcessorImpl::s_lastString, XPathExpression::eOP_FUNCTION_LAST },
    { XPathFunctionTable::s_name, XPathExpression::eOP_FUNCTION_NAME_0 },
    { XPathProcessorImpl::s_nodeString, XPathExpression::eNODETYPE_NODE },
    { XPathProcessorImpl::s_textString, XPathExpression::eNODETYPE_TEXT },
    { XPathFunctionTable::s_true, XPathExpression::eOP_FUNCTION_TRUE },
    { XPathFunctionTable::s_count, XPathExpression::eOP_FUNCTION_COUNT  },
    { XPathFunctionTable::s_false, XPathExpression::eOP_FUNCTION_FALSE },
    { XPathFunctionTable::s_floor, XPathExpression::eOP_FUNCTION_FLOOR },
    { XPathFunctionTable::s_round, XPathExpression::eOP_FUNCTION_ROUND },
    { XPathFunctionTable::s_number, XPathExpression::eOP_FUNCTION_NUMBER_0 },
    { XPathFunctionTable::s_boolean, XPathExpression::eOP_FUNCTION_BOOLEAN },
    { XPathFunctionTable::s_ceiling, XPathExpression::eOP_FUNCTION_CEILING },
    { XPathProcessorImpl::s_commentString, XPathExpression::eNODETYPE_COMMENT },
    { XPathProcessorImpl::s_positionString, XPathExpression::eOP_FUNCTION_POSITION },
    { XPathFunctionTable::s_localName, XPathExpression::eOP_FUNCTION_LOCALNAME_0 },
    { XPathFunctionTable::s_stringLength, XPathExpression::eOP_FUNCTION_STRINGLENGTH_0 },
    { XPathProcessorImpl::s_piString, XPathExpression::eNODETYPE_PI },
};

const XPathProcessorImpl::size_type     XPathProcessorImpl::s_functionTableSize =
    sizeof(s_functionTable) / sizeof(s_functionTable[0]);


const XPathProcessorImpl::TableEntry    XPathProcessorImpl::s_nodeTypeTable[] =
{
    { XPathProcessorImpl::s_asteriskString, XPathExpression::eNODETYPE_ANYELEMENT },
    { XPathProcessorImpl::s_nodeString, XPathExpression::eNODETYPE_NODE },
    { XPathProcessorImpl::s_textString, XPathExpression::eNODETYPE_TEXT },
    { XPathProcessorImpl::s_commentString, XPathExpression::eNODETYPE_COMMENT },
    { XPathProcessorImpl::s_piString, XPathExpression::eNODETYPE_PI },
};

const XPathProcessorImpl::size_type     XPathProcessorImpl::s_nodeTypeTableSize =
    sizeof(s_nodeTypeTable) / sizeof(s_nodeTypeTable[0]);


const XPathProcessorImpl::TableEntry    XPathProcessorImpl::s_axisTable[] =
{
    { XPathProcessorImpl::s_selfString, XPathExpression::eFROM_SELF },
    { XPathProcessorImpl::s_childString, XPathExpression::eFROM_CHILDREN },
    { XPathProcessorImpl::s_parentString, XPathExpression::eFROM_PARENT },
    { XPathProcessorImpl::s_ancestorString, XPathExpression::eFROM_ANCESTORS },
    { XPathProcessorImpl::s_attributeString, XPathExpression::eFROM_ATTRIBUTES },
    { XPathProcessorImpl::s_followingString, XPathExpression::eFROM_FOLLOWING },
    { XPathProcessorImpl::s_namespaceString, XPathExpression::eFROM_NAMESPACE },
    { XPathProcessorImpl::s_precedingString, XPathExpression::eFROM_PRECEDING },
    { XPathProcessorImpl::s_descendantString, XPathExpression::eFROM_DESCENDANTS },
    { XPathProcessorImpl::s_ancestorOrSelfString, XPathExpression::eFROM_ANCESTORS_OR_SELF },
    { XPathProcessorImpl::s_followingSiblingString, XPathExpression::eFROM_FOLLOWING_SIBLINGS },
    { XPathProcessorImpl::s_precedingSiblingString, XPathExpression::eFROM_PRECEDING_SIBLINGS },
    { XPathProcessorImpl::s_descendantOrSelfString, XPathExpression::eFROM_DESCENDANTS_OR_SELF },
};

const XPathProcessorImpl::size_type     XPathProcessorImpl::s_axisTableSize =
    sizeof(s_axisTable) / sizeof(s_axisTable[0]);


const XPathProcessorImpl::TableEntry    XPathProcessorImpl::s_dummyEntry =
{
    0, XPathExpression::eENDOP
};


}