/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtXmlPatterns module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QByteArray>

#include "qquerytransformparser_p.h"

#include "qxquerytokenizer_p.h"

#include "qtokenlookup.cpp"

QT_BEGIN_NAMESPACE

namespace QPatternist

{

#define handleWhitespace()                      \

{                                               \

    const TokenType t = consumeWhitespace();    \

    if(t != SUCCESS)                            \

        return Token(t);                        \

}

XQueryTokenizer::XQueryTokenizer(const QString &query,

                                 const QUrl &location,

                                 const State startingState) : Tokenizer(location)

                                                            , m_data(query)

                                                            , m_length(query.length())

                                                            , m_state(startingState)

                                                            , m_pos(0)

                                                            , m_line(1)

                                                            , m_columnOffset(0)

                                                            , m_scanOnly(false)

{

    Q_ASSERT(location.isValid() || location.isEmpty());

}

const QChar XQueryTokenizer::current() const

{

    if(m_pos < m_length)

        return m_data.at(m_pos);

    else

        return QChar();

}

char XQueryTokenizer::peekCurrent() const

{

    return current().toAscii();

}

int XQueryTokenizer::peekForColonColon() const

{

    /* Note, we don't modify m_pos in this function, so we need to do offset

     * calculations. */

    int pos = m_pos;

    while(pos < m_length)

    {

        switch(m_data.at(pos).toAscii())

        {

            /* Fallthrough these four. */

            case ' ':

            case '\t':

            case '\n':

            case '\r':

                break;

            case ':':

            {

                if(peekAhead((pos - m_pos) + 1) == ':')

                    return pos - m_pos;

                /* Fallthrough. */

            }

            default:

                return -1;

        }

        ++pos;

    }

    return -1;

}

Tokenizer::Token XQueryTokenizer::tokenAndChangeState(const TokenType code,

                                                      const State s,

                                                      const int advance)

{

    Q_ASSERT(advance >= 0);

    m_pos += advance;

    setState(s);

    return Token(code);

}

Tokenizer::Token XQueryTokenizer::tokenAndChangeState(const TokenType code,

                                                      const QString &value,

                                                      const State s)

{

    setState(s);

    return Token(code, value);

}

Tokenizer::Token XQueryTokenizer::tokenAndAdvance(const TokenType code,

                                                  const int advance)

{

    Q_ASSERT(advance >= 0);

    m_pos += advance;

    return Token(code);

}

QString XQueryTokenizer::normalizeEOL(const QString &input,

                                      const CharacterSkips &characterSkips)

{

    const int len = input.count();

    QString result;

    /* The likely hood is rather high it'll be the same content. */

    result.reserve(len);

    for(int i = 0; i < len; ++i)

    {

        const QChar &at = input.at(i);

        if(characterSkips.contains(i))

        {

            result.append(at);

            continue;

        }

        switch(input.at(i).unicode())

        {

            case '\r':

            {

                if(i + 1 < len && input.at(i + 1) == QLatin1Char('\n'))

                    ++i;

                /* Else, fallthrough. */

            }

            case '\n':

            {

                result.append(QLatin1Char('\n'));

                continue;

            }

            default:

            {

                result.append(at);

            }

        }

    }

    return result;

}

Tokenizer::TokenType XQueryTokenizer::consumeComment()

{

    /* Below, we return ERROR instead of END_OF_FILE such that the parser

     * sees an invalid comment. */

    while(m_pos < m_length)

    {

        switch(peekCurrent())

        {

            case ':':

            {

                ++m_pos; /* Consume ':' */

                if(atEnd())

                    return ERROR;

                if(peekCurrent() == ')')

                {

                    ++m_pos; /* Consume ')' */

                    return SUCCESS; /* The comment closed nicely. */

                }

                continue; /* We don't want to increment m_pos twice. */

            }

            case '(':

            { /* It looks like the start of a comment. */

                ++m_pos;

                if(atEnd())

                    return END_OF_FILE;

                else if(peekCurrent() == ':')

                {

                    /* And it is a nested comment -- parse it. */

                    const TokenType retval = consumeComment();

                    if(retval == SUCCESS)

                        continue; /* Continue with our "own" comment. */

                    else

                        return retval; /* Return the error in the nested comment. */

                }

                break;

            }

            case '\n':

            /* Fallthrough. */

            case '\r':

            {

                /* We want to count \r\n as a single line break. */

                if(peekAhead() == '\n')

                    ++m_pos;

                m_columnOffset = m_pos;

                ++m_line;

                break;

            }

        }

        ++m_pos;

    }

    return ERROR; /* Error: we reached the end while inside a comment. */

}

bool XQueryTokenizer::consumeRawWhitespace()

{

    while(m_pos < m_length)

    {

        switch(peekCurrent())

        {

            case ' ':

            case '\t':

                break;

            case '\n':

            case '\r':

            {

                if(peekAhead() == '\n')

                    ++m_pos;

                m_columnOffset = m_pos;

                ++m_line;

                break;

            }

            default:

                return false;

        }

        ++m_pos;

    }

    return true;

}

Tokenizer::TokenType XQueryTokenizer::consumeWhitespace()

{

    while(m_pos < m_length)

    {

        switch(peekCurrent())

        {

            case ' ':

            case '\t':

                break;

            case '\n':

            case '\r':

            {

                /* We want to count \r\n as a single line break. */

                if(peekAhead() == '\n')

                    ++m_pos;

                m_columnOffset = m_pos;

                ++m_line;

                break;

            }

            case '(':

            {

                if(peekAhead() == ':')

                {

                    m_pos += 2; /* Consume "(:" */

                    const TokenType comment = consumeComment();

                    if(comment == SUCCESS)

                        continue;

                    else

                        return comment;

                }

            }

            default:

                return SUCCESS;

        }

        ++m_pos;

    }

    return END_OF_FILE;

}

char XQueryTokenizer::peekAhead(const int length) const

{

    if(m_pos + length < m_length)

        return m_data.at(m_pos + length).toAscii();

    else

        return 0;

}

Tokenizer::Token XQueryTokenizer::error()

{

    return Token(ERROR);

}

bool XQueryTokenizer::isDigit(const char ch)

{

    return ch >= '0' && ch <= '9';

}

/* Replace with function in QXmlUtils. Write test cases for this. */

bool XQueryTokenizer::isNCNameStart(const QChar ch)

{

    if(ch == QLatin1Char('_'))

        return true;

    switch(ch.category())

    {

        case QChar::Letter_Lowercase:

        case QChar::Letter_Uppercase:

        case QChar::Letter_Other:

        case QChar::Letter_Titlecase:

        case QChar::Number_Letter:

            return true;

        default:

            return false;

    }

}

bool XQueryTokenizer::isNCNameBody(const QChar ch)

{

    switch(ch.unicode())

    {

        case '.':

        case '_':

        case '-':

            return true;

    }

    switch(ch.category())

    {

        case QChar::Letter_Lowercase:

        case QChar::Letter_Uppercase:

        case QChar::Letter_Other:

        case QChar::Letter_Titlecase:

        case QChar::Number_Letter:

        case QChar::Mark_SpacingCombining:

        case QChar::Mark_Enclosing:

        case QChar::Mark_NonSpacing:

        case QChar::Letter_Modifier:

        case QChar::Number_DecimalDigit:

            return true;

        default:

            return false;

    }

}

bool XQueryTokenizer::isPhraseKeyword(const TokenType code)

{

    switch(code)

    {

        /* Fallthrough all these. */

        case CASTABLE:

        case CAST:

        case COPY_NAMESPACES:

        case DECLARE:

        case EMPTY:

        case MODULE:

        case IMPORT:

        case INSTANCE:

        case ORDER:

        case ORDERING:

        case XQUERY:

        case STABLE:

        case TREAT:

            return true;

        default:

            return false;

    }

}

bool XQueryTokenizer::isOperatorKeyword(const TokenType code)

{

    switch(code)

    {

        /* Fallthrough all these. */

        case AS:

        case ASCENDING:

        case AT:

        case CASE:

        case CAST:

        case CASTABLE:

        case EQ:

        case EXTERNAL:

        case GE:

        case G_EQ:

        case G_GT:

        case G_LT:

        case G_NE:

        case GT:

        case IN:

        case INHERIT:

        case INSTANCE:

        case IS:

        case ITEM:

        case LE:

        case LT:

        case NE:

        case NO_INHERIT:

        case NO_PRESERVE:

        case OF:

        case PRESERVE:

        case RETURN:

        case STABLE:

        case TO:

        case TREAT:

            return true;

        default:

            return false;

    };

}

bool XQueryTokenizer::isTypeToken(const TokenType t)

{

    switch(t)

    {

        /* Fallthrough all these. */

        case ATTRIBUTE:

        case COMMENT:

        case DOCUMENT:

        case DOCUMENT_NODE:

        case ELEMENT:

        case ITEM:

        case NODE:

        case PROCESSING_INSTRUCTION:

        case SCHEMA_ATTRIBUTE:

        case SCHEMA_ELEMENT:

        case TEXT:

            return true;

        default:

            return false;

    }

}

Tokenizer::Token XQueryTokenizer::tokenizeNCNameOrQName()

{

    const int start = m_pos;

    const Token t1 = tokenizeNCName();

    if(t1.hasError())

        return t1;

    if(peekCurrent() != ':' || peekAhead() == '=')

        return t1;

    ++m_pos;

    const Token t2 = tokenizeNCName();

    if(t2.hasError())

        return t2;

    else

        return Token(QNAME, m_data.mid(start, m_pos - start));

}

Tokenizer::Token XQueryTokenizer::tokenizeNumberLiteral()

{

    setState(Operator);

    const int startPos = m_pos;

    bool hasDot = false;

    bool isXPath20 = false;

    for(; m_pos < m_length; ++m_pos)

    {

        QChar ch(current());

        char cell = ch.cell();

        if(cell == 'e' || cell == 'E')

        {

            isXPath20 = true;

            ++m_pos;

            ch = current();

            if(ch.row() != 0)

                break;

            cell = ch.cell();

            if(cell == '+' || cell == '-')

                continue;

        }

        if(isNCNameStart(ch))

            return error();

        if(cell < '0' || cell > '9')

        {

            if(cell == '.' && !hasDot)

                hasDot = true;

            else

                break;

        }

    }