----------------------------------------------------------------------------

--

-- Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

-- All rights reserved.

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

--

-- This file is part of the Qt Linguist 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$

--

----------------------------------------------------------------------------

--------------------------------------------------------------------------------

-- Process with "qlalr --no-debug --no-lines qscript.g" to update qscript.cpp --

--------------------------------------------------------------------------------

%parser         QScriptGrammar

%merged_output  qscript.cpp

%expect         3

%expect-rr      1

%token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="

%token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"

%token T_COLON ":"              T_COMMA ";"                 T_CONTINUE "continue"

%token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"

%token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."

%token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="

%token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"

%token T_FUNCTION "function"    T_GE ">="                   T_GT ">"

%token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"

%token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"

%token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"

%token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("

%token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="

%token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"

%token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="

%token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"

%token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"

%token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"

%token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"

%token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"

%token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"

%token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"

%token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"

%token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"

%token T_VAR "var"              T_VOID "void"               T_WHILE "while"

%token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="

%token T_NULL "null"            T_TRUE "true"               T_FALSE "false"

%token T_CONST "const"

%token T_DEBUGGER "debugger"

%token T_RESERVED_WORD "reserved word"

%start Program

/.

#include <translator.h>

#include <QtCore/qdebug.h>

#include <QtCore/qnumeric.h>

#include <QtCore/qstring.h>

#include <QtCore/qtextcodec.h>

#include <QtCore/qvariant.h>

#include <iostream>

#include <ctype.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

QT_BEGIN_NAMESPACE

static void recordMessage(

    Translator *tor, const QString &context, const QString &text, const QString &comment,

{

    TranslatorMessage msg(

        context, text, comment, QString(),

        fileName, lineNo, QStringList(),

        TranslatorMessage::Unfinished, plural);

    msg.setExtraComment(extracomment.simplified());

    tor->extend(msg);

}

namespace QScript

{

class Lexer

{

public:

    ~Lexer();

    int lex();

    int currentLineNo() const { return yylineno; }

    int currentColumnNo() const { return yycolumn; }

    int startLineNo() const { return startlineno; }

    int startColumnNo() const { return startcolumn; }

    int endLineNo() const { return currentLineNo(); }

    int endColumnNo() const

    { int col = currentColumnNo(); return (col > 0) ? col - 1 : col; }

    bool prevTerminator() const { return terminator; }

    enum State { Start,

                 Identifier,

                 InIdentifier,

                 InSingleLineComment,

                 InMultiLineComment,

                 InNum,

                 InNum0,

                 InHex,

                 InOctal,

                 InDecimal,

                 InExponentIndicator,

                 InExponent,

                 Hex,

                 Octal,

                 Number,

                 String,

                 Eof,

                 InString,

                 InEscapeSequence,

                 InHexEscape,

                 InUnicodeEscape,

                 Other,

                 Bad };

    enum Error {

        NoError,

        IllegalCharacter,

        UnclosedStringLiteral,

        IllegalEscapeSequence,

        IllegalUnicodeEscapeSequence,

        UnclosedComment,

        IllegalExponentIndicator,

        IllegalIdentifier

    };

    enum ParenthesesState {

        IgnoreParentheses,

        CountParentheses,

        BalancedParentheses

    };

    enum RegExpBodyPrefix {

        NoPrefix,

        EqualPrefix

    };

    bool scanRegExp(RegExpBodyPrefix prefix = NoPrefix);

    QString pattern;

    int flags;

    State lexerState() const

        { return state; }

    QString errorMessage() const

        { return errmsg; }

    void setErrorMessage(const QString &err)

        { errmsg = err; }

    void setErrorMessage(const char *err)

        { setErrorMessage(QString::fromLatin1(err)); }

    Error error() const

        { return err; }

    void clearError()

        { err = NoError; }

private:

    int yylineno;

    bool done;

    char *buffer8;

    QChar *buffer16;

    uint size8, size16;

    uint pos8, pos16;

    bool terminator;

    bool restrKeyword;

    // encountered delimiter like "'" and "}" on last run

    bool delimited;

    int stackToken;

    State state;

    void setDone(State s);

    uint pos;

    void shift(uint p);

    int lookupKeyword(const char *);

    bool isWhiteSpace() const;

    bool isLineTerminator() const;

    bool isHexDigit(ushort c) const;

    bool isOctalDigit(ushort c) const;

    int matchPunctuator(ushort c1, ushort c2,

                         ushort c3, ushort c4);

    ushort singleEscape(ushort c) const;

    ushort convertOctal(ushort c1, ushort c2,

                         ushort c3) const;

public:

    static unsigned char convertHex(ushort c1);

    static unsigned char convertHex(ushort c1, ushort c2);

    static QChar convertUnicode(ushort c1, ushort c2,

                                 ushort c3, ushort c4);

    static bool isIdentLetter(ushort c);

    static bool isDecimalDigit(ushort c);

    inline int ival() const { return qsyylval.toInt(); }

    inline double dval() const { return qsyylval.toDouble(); }

    inline QString ustr() const { return qsyylval.toString(); }

    inline QVariant val() const { return qsyylval; }

    const QChar *characterBuffer() const { return buffer16; }

    int characterCount() const { return pos16; }

private:

    void record8(ushort c);

    void record16(QChar c);

    void recordStartPos();

    int findReservedWord(const QChar *buffer, int size) const;

    void syncProhibitAutomaticSemicolon();

    const QChar *code;

    uint length;

    int yycolumn;

    int startlineno;

    int startcolumn;

    int bol;     // begin of line

    QVariant qsyylval;

    // current and following unicode characters

    ushort current, next1, next2, next3;

    struct keyword {

        const char *name;

        int token;

    };

    QString errmsg;

    Error err;

    bool wantRx;

    bool check_reserved;

    ParenthesesState parenthesesState;

    int parenthesesCount;

    bool prohibitAutomaticSemicolon;

};

} // namespace QScript

extern double qstrtod(const char *s00, char const **se, bool *ok);

#define shiftWindowsLineBreak() if(current == '\r' && next1 == '\n') shift(1);

namespace QScript {

static int toDigit(char c)

{

    if ((c >= '0') && (c <= '9'))

        return c - '0';

    else if ((c >= 'a') && (c <= 'z'))

        return 10 + c - 'a';

    else if ((c >= 'A') && (c <= 'Z'))

        return 10 + c - 'A';

    return -1;

}

double integerFromString(const char *buf, int size, int radix)

{

    if (size == 0)

        return qSNaN();

    double sign = 1.0;

    int i = 0;

    if (buf[0] == '+') {

        ++i;

    } else if (buf[0] == '-') {

        sign = -1.0;

        ++i;

    }

    if (((size-i) >= 2) && (buf[i] == '0')) {

        if (((buf[i+1] == 'x') || (buf[i+1] == 'X'))

            && (radix < 34)) {

            if ((radix != 0) && (radix != 16))

                return 0;

            radix = 16;

            i += 2;

        } else {

            if (radix == 0) {

                radix = 8;

                ++i;

            }

        }

    } else if (radix == 0) {

        radix = 10;

    }

    int j = i;

    for ( ; i < size; ++i) {

        int d = toDigit(buf[i]);

        if ((d == -1) || (d >= radix))

            break;

    }

    double result;

    if (j == i) {

        if (!qstrcmp(buf, "Infinity"))

            result = qInf();

        else

            result = qSNaN();

    } else {

        result = 0;

        double multiplier = 1;

        for (--i ; i >= j; --i, multiplier *= radix)

            result += toDigit(buf[i]) * multiplier;

    }

    result *= sign;

    return result;

}

} // namespace QScript

    :

      yylineno(0),

      size8(128), size16(128), restrKeyword(false),

      stackToken(-1), pos(0),

      code(0), length(0),

      bol(true),

      current(0), next1(0), next2(0), next3(0),

      err(NoError),

      check_reserved(true),

      parenthesesState(IgnoreParentheses),

{

    // allocate space for read buffers

    buffer8 = new char[size8];

    buffer16 = new QChar[size16];

    flags = 0;

}

QScript::Lexer::~Lexer()

{

    delete [] buffer8;

    delete [] buffer16;

}

{

    errmsg = QString();

    yylineno = lineno;

    yycolumn = 1;

    restrKeyword = false;

    delimited = false;

    stackToken = -1;

    pos = 0;

    code = c.unicode();

    length = c.length();

    bol = true;

    // read first characters

    current = (length > 0) ? code[0].unicode() : 0;

    next1 = (length > 1) ? code[1].unicode() : 0;

    next2 = (length > 2) ? code[2].unicode() : 0;

    next3 = (length > 3) ? code[3].unicode() : 0;

}

void QScript::Lexer::shift(uint p)

{

    while (p--) {

        ++pos;

        ++yycolumn;

        current = next1;

        next1 = next2;

        next2 = next3;

        next3 = (pos + 3 < length) ? code[pos+3].unicode() : 0;

    }

}

void QScript::Lexer::setDone(State s)

{

    state = s;

    done = true;

}

int QScript::Lexer::findReservedWord(const QChar *c, int size) const

{

    switch (size) {

    case 2: {

        if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('o'))

            return QScriptGrammar::T_DO;

        else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('f'))

            return QScriptGrammar::T_IF;

        else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n'))

            return QScriptGrammar::T_IN;

    }   break;

    case 3: {

        if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('r'))

            return QScriptGrammar::T_FOR;

        else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('w'))

            return QScriptGrammar::T_NEW;

        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r') && c[2] == QLatin1Char('y'))

            return QScriptGrammar::T_TRY;

        else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('a') && c[2] == QLatin1Char('r'))

            return QScriptGrammar::T_VAR;

        else if (check_reserved) {

            if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n') && c[2] == QLatin1Char('t'))

                return QScriptGrammar::T_RESERVED_WORD;

        }

    }   break;

    case 4: {

        if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('a')

                && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('e'))

            return QScriptGrammar::T_CASE;

        else if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('l')

                && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('e'))

            return QScriptGrammar::T_ELSE;

        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h')

                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('s'))

            return QScriptGrammar::T_THIS;

        else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('o')

                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('d'))

            return QScriptGrammar::T_VOID;

        else if (c[0] == QLatin1Char('w') && c[1] == QLatin1Char('i')

                && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('h'))

            return QScriptGrammar::T_WITH;

        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r')

                && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('e'))

            return QScriptGrammar::T_TRUE;

        else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('u')

                && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('l'))

            return QScriptGrammar::T_NULL;

        else if (check_reserved) {

            if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('n')

                    && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('m'))

                return QScriptGrammar::T_RESERVED_WORD;

            else if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('y')

                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e'))

                return QScriptGrammar::T_RESERVED_WORD;

            else if (c[0] == QLatin1Char('l') && c[1] == QLatin1Char('o')

                    && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('g'))

                return QScriptGrammar::T_RESERVED_WORD;

            else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('h')

                    && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('r'))

                return QScriptGrammar::T_RESERVED_WORD;

            else if (c[0] == QLatin1Char('g') && c[1] == QLatin1Char('o')

                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('o'))

                return QScriptGrammar::T_RESERVED_WORD;

        }

    }   break;

    case 5: {

        if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('r')

                && c[2] == QLatin1Char('e') && c[3] == QLatin1Char('a')

                && c[4] == QLatin1Char('k'))

            return QScriptGrammar::T_BREAK;

        else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('a')

                && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('c')

                && c[4] == QLatin1Char('h'))

            return QScriptGrammar::T_CATCH;