1 ----------------------------------------------------------------------------

     2 --

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

     4 -- All rights reserved.

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

     6 --

     7 -- This file is part of the Qt Linguist of the Qt Toolkit.

     8 --

     9 -- $QT_BEGIN_LICENSE:LGPL$

    10 -- No Commercial Usage

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

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

    13 -- contained in the Technology Preview License Agreement accompanying

    14 -- this package.

    15 --

    16 -- GNU Lesser General Public License Usage

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

    18 -- General Public License version 2.1 as published by the Free Software

    19 -- Foundation and appearing in the file LICENSE.LGPL included in the

    20 -- packaging of this file.  Please review the following information to

    21 -- ensure the GNU Lesser General Public License version 2.1 requirements

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

    23 --

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

    25 -- rights.  These rights are described in the Nokia Qt LGPL Exception

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

    27 --

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

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

    30 --

    31 --

    32 --

    33 --

    34 --

    35 --

    36 --

    37 --

    38 -- $QT_END_LICENSE$

    39 --

    40 ----------------------------------------------------------------------------

    41 

    42 --------------------------------------------------------------------------------

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

    44 --------------------------------------------------------------------------------

    45 

    46 %parser         QScriptGrammar

    47 %merged_output  qscript.cpp

    48 %expect         3

    49 %expect-rr      1

    50 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    71 %token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"

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

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

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

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

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

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

    78 %token T_CONST "const"

    79 %token T_DEBUGGER "debugger"

    80 %token T_RESERVED_WORD "reserved word"

    81 

    82 %start Program

    83 

    84 /.

    85 #include <translator.h>

    86 

    87 #include <QtCore/qdebug.h>

    88 #include <QtCore/qnumeric.h>

    89 #include <QtCore/qstring.h>

    90 #include <QtCore/qtextcodec.h>

    91 #include <QtCore/qvariant.h>

    92 

    93 #include <ctype.h>

    94 #include <stdlib.h>

    95 #include <stdio.h>

    96 #include <string.h>

    97 

    98 QT_BEGIN_NAMESPACE

    99 

   100 static void recordMessage(

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

   102     const QString &extracomment, bool plural, const QString &fileName, int lineNo)

   103 {

   104     TranslatorMessage msg(

   105         context, text, comment, QString(),

   106         fileName, lineNo, QStringList(),

   107         TranslatorMessage::Unfinished, plural);

   108     msg.setExtraComment(extracomment.simplified());

   109     tor->replace(msg);

   110 }

   111 

   112 

   113 namespace QScript

   114 {

   115 

   116 class Lexer

   117 {

   118 public:

   119     Lexer();

   120     ~Lexer();

   121 

   122     void setCode(const QString &c, int lineno);

   123     int lex();

   124 

   125     int currentLineNo() const { return yylineno; }

   126     int currentColumnNo() const { return yycolumn; }

   127 

   128     int startLineNo() const { return startlineno; }

   129     int startColumnNo() const { return startcolumn; }

   130 

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

   132     int endColumnNo() const

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

   134 

   135     bool prevTerminator() const { return terminator; }

   136 

   137     enum State { Start,

   138                  Identifier,

   139                  InIdentifier,

   140                  InSingleLineComment,

   141                  InMultiLineComment,

   142                  InNum,

   143                  InNum0,

   144                  InHex,

   145                  InOctal,

   146                  InDecimal,

   147                  InExponentIndicator,

   148                  InExponent,

   149                  Hex,

   150                  Octal,

   151                  Number,

   152                  String,

   153                  Eof,

   154                  InString,

   155                  InEscapeSequence,

   156                  InHexEscape,

   157                  InUnicodeEscape,

   158                  Other,

   159                  Bad };

   160 

   161     enum Error {

   162         NoError,

   163         IllegalCharacter,

   164         UnclosedStringLiteral,

   165         IllegalEscapeSequence,

   166         IllegalUnicodeEscapeSequence,

   167         UnclosedComment,

   168         IllegalExponentIndicator,

   169         IllegalIdentifier

   170     };

   171 

   172     enum ParenthesesState {

   173         IgnoreParentheses,

   174         CountParentheses,

   175         BalancedParentheses

   176     };

   177 

   178     enum RegExpBodyPrefix {

   179         NoPrefix,

   180         EqualPrefix

   181     };

   182 

   183     bool scanRegExp(RegExpBodyPrefix prefix = NoPrefix);

   184 

   185     QString pattern;

   186     int flags;

   187 

   188     State lexerState() const

   189         { return state; }

   190 

   191     QString errorMessage() const

   192         { return errmsg; }

   193     void setErrorMessage(const QString &err)

   194         { errmsg = err; }

   195     void setErrorMessage(const char *err)

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

   197 

   198     Error error() const

   199         { return err; }

   200     void clearError()

   201         { err = NoError; }

   202 

   203 private:

   204     int yylineno;

   205     bool done;

   206     char *buffer8;

   207     QChar *buffer16;

   208     uint size8, size16;

   209     uint pos8, pos16;

   210     bool terminator;

   211     bool restrKeyword;

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

   213     bool delimited;

   214     int stackToken;

   215 

   216     State state;

   217     void setDone(State s);

   218     uint pos;

   219     void shift(uint p);

   220     int lookupKeyword(const char *);

   221 

   222     bool isWhiteSpace() const;

   223     bool isLineTerminator() const;

   224     bool isHexDigit(ushort c) const;

   225     bool isOctalDigit(ushort c) const;

   226 

   227     int matchPunctuator(ushort c1, ushort c2,

   228                          ushort c3, ushort c4);

   229     ushort singleEscape(ushort c) const;

   230     ushort convertOctal(ushort c1, ushort c2,

   231                          ushort c3) const;

   232 public:

   233     static unsigned char convertHex(ushort c1);

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

   235     static QChar convertUnicode(ushort c1, ushort c2,

   236                                  ushort c3, ushort c4);

   237     static bool isIdentLetter(ushort c);

   238     static bool isDecimalDigit(ushort c);

   239 

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

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

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

   243     inline QVariant val() const { return qsyylval; }

   244 

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

   246     int characterCount() const { return pos16; }

   247 

   248 private:

   249     void record8(ushort c);

   250     void record16(QChar c);

   251     void recordStartPos();

   252 

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

   254 

   255     void syncProhibitAutomaticSemicolon();

   256 

   257     const QChar *code;

   258     uint length;

   259     int yycolumn;

   260     int startlineno;

   261     int startcolumn;

   262     int bol;     // begin of line

   263 

   264     QVariant qsyylval;

   265 

   266     // current and following unicode characters

   267     ushort current, next1, next2, next3;

   268 

   269     struct keyword {

   270         const char *name;

   271         int token;

   272     };

   273 

   274     QString errmsg;

   275     Error err;

   276 

   277     bool wantRx;

   278     bool check_reserved;

   279 

   280     ParenthesesState parenthesesState;

   281     int parenthesesCount;

   282     bool prohibitAutomaticSemicolon;

   283 };

   284 

   285 } // namespace QScript

   286 

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

   288 

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

   290 

   291 namespace QScript {

   292 

   293 static int toDigit(char c)

   294 {

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

   296         return c - '0';

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

   298         return 10 + c - 'a';

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

   300         return 10 + c - 'A';

   301     return -1;

   302 }

   303 

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

   305 {

   306     if (size == 0)

   307         return qSNaN();

   308 

   309     double sign = 1.0;

   310     int i = 0;

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

   312         ++i;

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

   314         sign = -1.0;

   315         ++i;

   316     }

   317 

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

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

   320             && (radix < 34)) {

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

   322                 return 0;

   323             radix = 16;

   324             i += 2;

   325         } else {

   326             if (radix == 0) {

   327                 radix = 8;

   328                 ++i;

   329             }

   330         }

   331     } else if (radix == 0) {

   332         radix = 10;

   333     }

   334 

   335     int j = i;

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

   337         int d = toDigit(buf[i]);

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

   339             break;

   340     }

   341     double result;

   342     if (j == i) {

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

   344             result = qInf();

   345         else

   346             result = qSNaN();

   347     } else {

   348         result = 0;

   349         double multiplier = 1;

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

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

   352     }

   353     result *= sign;

   354     return result;

   355 }

   356 

   357 } // namespace QScript

   358 

   359 QScript::Lexer::Lexer()

   360     :

   361       yylineno(0),

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

   363       stackToken(-1), pos(0),

   364       code(0), length(0),

   365       bol(true),

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

   367       err(NoError),

   368       check_reserved(true),

   369       parenthesesState(IgnoreParentheses),

   370       prohibitAutomaticSemicolon(false)

   371 {

   372     // allocate space for read buffers

   373     buffer8 = new char[size8];

   374     buffer16 = new QChar[size16];

   375     flags = 0;

   376 

   377 }

   378 

   379 QScript::Lexer::~Lexer()

   380 {

   381     delete [] buffer8;

   382     delete [] buffer16;

   383 }

   384 

   385 void QScript::Lexer::setCode(const QString &c, int lineno)

   386 {

   387     errmsg = QString();

   388     yylineno = lineno;

   389     yycolumn = 1;

   390     restrKeyword = false;

   391     delimited = false;

   392     stackToken = -1;

   393     pos = 0;

   394     code = c.unicode();

   395     length = c.length();

   396     bol = true;

   397 

   398     // read first characters

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

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

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

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

   403 }

   404 

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

   406 {

   407     while (p--) {

   408         ++pos;

   409         ++yycolumn;

   410         current = next1;

   411         next1 = next2;

   412         next2 = next3;

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

   414     }

   415 }

   416 

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

   418 {

   419     state = s;

   420     done = true;

   421 }

   422 

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

   424 {

   425     switch (size) {

   426     case 2: {

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

   428             return QScriptGrammar::T_DO;

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

   430             return QScriptGrammar::T_IF;

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

   432             return QScriptGrammar::T_IN;

   433     }   break;

   434 

   435     case 3: {

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

   437             return QScriptGrammar::T_FOR;

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

   439             return QScriptGrammar::T_NEW;

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

   441             return QScriptGrammar::T_TRY;

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

   443             return QScriptGrammar::T_VAR;

   444         else if (check_reserved) {

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

   446                 return QScriptGrammar::T_RESERVED_WORD;

   447         }

   448     }   break;

   449 

   450     case 4: {

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

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

   453             return QScriptGrammar::T_CASE;

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

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

   456             return QScriptGrammar::T_ELSE;

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

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

   459             return QScriptGrammar::T_THIS;

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

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

   462             return QScriptGrammar::T_VOID;

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

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

   465             return QScriptGrammar::T_WITH;

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

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

   468             return QScriptGrammar::T_TRUE;

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

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

   471             return QScriptGrammar::T_NULL;

   472         else if (check_reserved) {

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

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

   475                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   478                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   481                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   484                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   487                 return QScriptGrammar::T_RESERVED_WORD;

   488         }

   489     }   break;

   490 

   491     case 5: {

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

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

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

   495             return QScriptGrammar::T_BREAK;

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

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

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

   499             return QScriptGrammar::T_CATCH;

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

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

   502                 && c[4] == QLatin1Char('w'))

   503             return QScriptGrammar::T_THROW;

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

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

   506                 && c[4] == QLatin1Char('e'))

   507             return QScriptGrammar::T_WHILE;

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

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

   510                 && c[4] == QLatin1Char('t'))

   511             return QScriptGrammar::T_CONST;

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

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

   514                 && c[4] == QLatin1Char('e'))

   515             return QScriptGrammar::T_FALSE;

   516         else if (check_reserved) {

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

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

   519                     && c[4] == QLatin1Char('t'))

   520                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   523                     && c[4] == QLatin1Char('r'))

   524                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   527                     && c[4] == QLatin1Char('l'))

   528                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   531                     && c[4] == QLatin1Char('s'))

   532                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   535                     && c[4] == QLatin1Char('t'))

   536                 return QScriptGrammar::T_RESERVED_WORD;

   537         }

   538     }   break;

   539 

   540     case 6: {

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

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

   543                 && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('e'))

   544             return QScriptGrammar::T_DELETE;

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

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

   547                 && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('n'))

   548             return QScriptGrammar::T_RETURN;

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

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

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

   552             return QScriptGrammar::T_SWITCH;

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

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

   555                 && c[4] == QLatin1Char('o') && c[5] == QLatin1Char('f'))

   556             return QScriptGrammar::T_TYPEOF;

   557         else if (check_reserved) {

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

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

   560                     && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t'))

   561                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   564                     && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c'))

   565                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   568                     && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('e'))

   569                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   572                     && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t'))

   573                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   576                     && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c'))

   577                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   580                     && c[4] == QLatin1Char('v') && c[5] == QLatin1Char('e'))

   581                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   584                     && c[4] == QLatin1Char('w') && c[5] == QLatin1Char('s'))

   585                 return QScriptGrammar::T_RESERVED_WORD;

   586         }

   587     }   break;

   588 

   589     case 7: {

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

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

   592                 && c[4] == QLatin1Char('u') && c[5] == QLatin1Char('l')

   593                 && c[6] == QLatin1Char('t'))

   594             return QScriptGrammar::T_DEFAULT;

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

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

   597                 && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('l')

   598                 && c[6] == QLatin1Char('y'))

   599             return QScriptGrammar::T_FINALLY;

   600         else if (check_reserved) {

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

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

   603                     && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('a')

   604                     && c[6] == QLatin1Char('n'))

   605                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   608                     && c[4] == QLatin1Char('n') && c[5] == QLatin1Char('d')

   609                     && c[6] == QLatin1Char('s'))

   610                 return QScriptGrammar::T_RESERVED_WORD;

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

   612                     && c[2] == QLatin1Char('c') && c[3] == QLatin1Char('k')

   613                     && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('g')

   614                     && c[6] == QLatin1Char('e'))

   615                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   618                     && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('t')

   619                     && c[6] == QLatin1Char('e'))

   620                 return QScriptGrammar::T_RESERVED_WORD;

   621         }

   622     }   break;

   623 

   624     case 8: {

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

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

   627                 && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('n')

   628                 && c[6] == QLatin1Char('u') && c[7] == QLatin1Char('e'))

   629             return QScriptGrammar::T_CONTINUE;

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

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

   632                 && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i')

   633                 && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n'))

   634             return QScriptGrammar::T_FUNCTION;

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

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

   637                 && c[4] == QLatin1Char('g') && c[5] == QLatin1Char('g')

   638                 && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('r'))

   639             return QScriptGrammar::T_DEBUGGER;

   640         else if (check_reserved) {

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

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

   643                     && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('a')

   644                     && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('t'))

   645                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   648                     && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i')

   649                     && c[6] == QLatin1Char('l') && c[7] == QLatin1Char('e'))

   650                 return QScriptGrammar::T_RESERVED_WORD;

   651         }

   652     }   break;

   653 

   654     case 9: {

   655         if (check_reserved) {

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

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

   658                     && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('f')

   659                     && c[6] == QLatin1Char('a') && c[7] == QLatin1Char('c')

   660                     && c[8] == QLatin1Char('e'))

   661                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   664                     && c[4] == QLatin1Char('s') && c[5] == QLatin1Char('i')

   665                     && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n')

   666                     && c[8] == QLatin1Char('t'))

   667                 return QScriptGrammar::T_RESERVED_WORD;

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

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

   670                     && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('c')

   671                     && c[6] == QLatin1Char('t') && c[7] == QLatin1Char('e')

   672                     && c[8] == QLatin1Char('d'))

   673                 return QScriptGrammar::T_RESERVED_WORD;

   674         }

   675     }   break;

   676 

   677     case 10: {

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

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

   680                 && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('n')

   681                 && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('e')

   682                 && c[8] == QLatin1Char('o') && c[9] == QLatin1Char('f'))

   683             return QScriptGrammar::T_INSTANCEOF;

   684         else if (check_reserved) {

   685             if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m')

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

   687                     && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('m')

   688                     && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n')

   689                     && c[8] == QLatin1Char('t') && c[9] == QLatin1Char('s'))

   690                 return QScriptGrammar::T_RESERVED_WORD;

   691         }

   692     }   break;

   693 

   694     case 12: {

   695         if (check_reserved) {

   696             if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('y')

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

   698                     && c[4] == QLatin1Char('h') && c[5] == QLatin1Char('r')

   699                     && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n')

   700                     && c[8] == QLatin1Char('i') && c[9] == QLatin1Char('z')

   701                     && c[10] == QLatin1Char('e') && c[11] == QLatin1Char('d'))

   702                 return QScriptGrammar::T_RESERVED_WORD;

   703         }

   704     }   break;

   705 

   706     } // switch

   707 

   708     return -1;

   709 }

   710 

   711 int QScript::Lexer::lex()

   712 {

   713     int token = 0;

   714     state = Start;

   715     ushort stringType = 0; // either single or double quotes

   716     pos8 = pos16 = 0;

   717     done = false;

   718     terminator = false;

   719 

   720     // did we push a token on the stack previously ?

   721     // (after an automatic semicolon insertion)

   722     if (stackToken >= 0) {

   723         setDone(Other);

   724         token = stackToken;

   725         stackToken = -1;

   726     }

   727 

   728     while (!done) {

   729         switch (state) {

   730         case Start:

   731             if (isWhiteSpace()) {

   732                 // do nothing

   733             } else if (current == '/' && next1 == '/') {

   734                 recordStartPos();

   735                 shift(1);

   736                 state = InSingleLineComment;

   737             } else if (current == '/' && next1 == '*') {

   738                 recordStartPos();

   739                 shift(1);

   740                 state = InMultiLineComment;

   741             } else if (current == 0) {

   742                 syncProhibitAutomaticSemicolon();

   743                 if (!terminator && !delimited && !prohibitAutomaticSemicolon) {

   744                     // automatic semicolon insertion if program incomplete

   745                     token = QScriptGrammar::T_SEMICOLON;

   746                     stackToken = 0;

   747                     setDone(Other);

   748                 } else {

   749                     setDone(Eof);

   750                 }

   751             } else if (isLineTerminator()) {

   752                 shiftWindowsLineBreak();

   753                 yylineno++;

   754                 yycolumn = 0;

   755                 bol = true;

   756                 terminator = true;

   757                 syncProhibitAutomaticSemicolon();

   758                 if (restrKeyword) {

   759                     token = QScriptGrammar::T_SEMICOLON;

   760                     setDone(Other);

   761                 }

   762             } else if (current == '"' || current == '\'') {

   763                 recordStartPos();

   764                 state = InString;

   765                 stringType = current;

   766             } else if (isIdentLetter(current)) {

   767                 recordStartPos();

   768                 record16(current);

   769                 state = InIdentifier;

   770             } else if (current == '0') {

   771                 recordStartPos();

   772                 record8(current);

   773                 state = InNum0;

   774             } else if (isDecimalDigit(current)) {

   775                 recordStartPos();

   776                 record8(current);

   777                 state = InNum;

   778             } else if (current == '.' && isDecimalDigit(next1)) {

   779                 recordStartPos();

   780                 record8(current);

   781                 state = InDecimal;

   782             } else {

   783                 recordStartPos();

   784                 token = matchPunctuator(current, next1, next2, next3);

   785                 if (token != -1) {

   786                     if (terminator && !delimited && !prohibitAutomaticSemicolon

   787                         && (token == QScriptGrammar::T_PLUS_PLUS

   788                             || token == QScriptGrammar::T_MINUS_MINUS)) {

   789                         // automatic semicolon insertion

   790                         stackToken = token;

   791                         token = QScriptGrammar::T_SEMICOLON;

   792                     }

   793                     setDone(Other);

   794                 }

   795                 else {

   796                     setDone(Bad);

   797                     err = IllegalCharacter;

   798                     errmsg = QLatin1String("Illegal character");

   799                 }

   800             }

   801             break;

   802         case InString:

   803             if (current == stringType) {

   804                 shift(1);

   805                 setDone(String);

   806             } else if (current == 0 || isLineTerminator()) {

   807                 setDone(Bad);

   808                 err = UnclosedStringLiteral;

   809                 errmsg = QLatin1String("Unclosed string at end of line");

   810             } else if (current == '\\') {

   811                 state = InEscapeSequence;

   812             } else {

   813                 record16(current);

   814             }

   815             break;

   816             // Escape Sequences inside of strings

   817         case InEscapeSequence:

   818             if (isOctalDigit(current)) {

   819                 if (current >= '0' && current <= '3' &&

   820                      isOctalDigit(next1) && isOctalDigit(next2)) {

   821                     record16(convertOctal(current, next1, next2));

   822                     shift(2);

   823                     state = InString;

   824                 } else if (isOctalDigit(current) &&

   825                             isOctalDigit(next1)) {

   826                     record16(convertOctal('0', current, next1));

   827                     shift(1);

   828                     state = InString;

   829                 } else if (isOctalDigit(current)) {

   830                     record16(convertOctal('0', '0', current));

   831                     state = InString;

   832                 } else {

   833                     setDone(Bad);

   834                     err = IllegalEscapeSequence;

   835                     errmsg = QLatin1String("Illegal escape squence");

   836                 }

   837             } else if (current == 'x')

   838                 state = InHexEscape;

   839             else if (current == 'u')

   840                 state = InUnicodeEscape;

   841             else {

   842                 record16(singleEscape(current));

   843                 state = InString;

   844             }

   845             break;

   846         case InHexEscape:

   847             if (isHexDigit(current) && isHexDigit(next1)) {

   848                 state = InString;

   849                 record16(QLatin1Char(convertHex(current, next1)));

   850                 shift(1);

   851             } else if (current == stringType) {

   852                 record16(QLatin1Char('x'));

   853                 shift(1);

   854                 setDone(String);

   855             } else {

   856                 record16(QLatin1Char('x'));

   857                 record16(current);

   858                 state = InString;

   859             }

   860             break;

   861         case InUnicodeEscape:

   862             if (isHexDigit(current) && isHexDigit(next1) &&

   863                  isHexDigit(next2) && isHexDigit(next3)) {

   864                 record16(convertUnicode(current, next1, next2, next3));

   865                 shift(3);

   866                 state = InString;

   867             } else if (current == stringType) {

   868                 record16(QLatin1Char('u'));

   869                 shift(1);

   870                 setDone(String);

   871             } else {

   872                 setDone(Bad);

   873                 err = IllegalUnicodeEscapeSequence;

   874                 errmsg = QLatin1String("Illegal unicode escape sequence");

   875             }

   876             break;

   877         case InSingleLineComment:

   878             if (isLineTerminator()) {

   879                 shiftWindowsLineBreak();

   880                 yylineno++;

   881                 yycolumn = 0;

   882                 terminator = true;

   883                 bol = true;

   884                 if (restrKeyword) {

   885                     token = QScriptGrammar::T_SEMICOLON;

   886                     setDone(Other);

   887                 } else

   888                     state = Start;

   889             } else if (current == 0) {

   890                 setDone(Eof);

   891             }

   892             break;

   893         case InMultiLineComment:

   894             if (current == 0) {

   895                 setDone(Bad);

   896                 err = UnclosedComment;

   897                 errmsg = QLatin1String("Unclosed comment at end of file");

   898             } else if (isLineTerminator()) {

   899                 shiftWindowsLineBreak();

   900                 yylineno++;

   901             } else if (current == '*' && next1 == '/') {

   902                 state = Start;

   903                 shift(1);

   904             }

   905             break;

   906         case InIdentifier:

   907             if (isIdentLetter(current) || isDecimalDigit(current)) {

   908                 record16(current);

   909                 break;

   910             }

   911             setDone(Identifier);

   912             break;

   913         case InNum0:

   914             if (current == 'x' || current == 'X') {

   915                 record8(current);

   916                 state = InHex;

   917             } else if (current == '.') {

   918                 record8(current);

   919                 state = InDecimal;

   920             } else if (current == 'e' || current == 'E') {

   921                 record8(current);

   922                 state = InExponentIndicator;

   923             } else if (isOctalDigit(current)) {

   924                 record8(current);

   925                 state = InOctal;

   926             } else if (isDecimalDigit(current)) {

   927                 record8(current);

   928                 state = InDecimal;

   929             } else {

   930                 setDone(Number);

   931             }

   932             break;

   933         case InHex:

   934             if (isHexDigit(current))

   935                 record8(current);

   936             else

   937                 setDone(Hex);

   938             break;

   939         case InOctal:

   940             if (isOctalDigit(current)) {

   941                 record8(current);

   942             } else if (isDecimalDigit(current)) {

   943                 record8(current);

   944                 state = InDecimal;

   945             } else {

   946                 setDone(Octal);

   947             }

   948             break;

   949         case InNum:

   950             if (isDecimalDigit(current)) {

   951                 record8(current);

   952             } else if (current == '.') {

   953                 record8(current);

   954                 state = InDecimal;

   955             } else if (current == 'e' || current == 'E') {

   956                 record8(current);

   957                 state = InExponentIndicator;

   958             } else {

   959                 setDone(Number);

   960             }

   961             break;

   962         case InDecimal:

   963             if (isDecimalDigit(current)) {

   964                 record8(current);

   965             } else if (current == 'e' || current == 'E') {

   966                 record8(current);

   967                 state = InExponentIndicator;

   968             } else {

   969                 setDone(Number);

   970             }

   971             break;

   972         case InExponentIndicator:

   973             if (current == '+' || current == '-') {

   974                 record8(current);

   975             } else if (isDecimalDigit(current)) {

   976                 record8(current);

   977                 state = InExponent;

   978             } else {

   979                 setDone(Bad);

   980                 err = IllegalExponentIndicator;

   981                 errmsg = QLatin1String("Illegal syntax for exponential number");

   982             }

   983             break;

   984         case InExponent:

   985             if (isDecimalDigit(current)) {

   986                 record8(current);

   987             } else {

   988                 setDone(Number);

   989             }

   990             break;

   991         default:

   992             Q_ASSERT_X(0, "Lexer::lex", "Unhandled state in switch statement");

   993         }

   994 

   995         // move on to the next character

   996         if (!done)

   997             shift(1);

   998         if (state != Start && state != InSingleLineComment)

   999             bol = false;

  1000     }

  1001 

  1002     // no identifiers allowed directly after numeric literal, e.g. "3in" is bad

  1003     if ((state == Number || state == Octal || state == Hex)

  1004          && isIdentLetter(current)) {

  1005         state = Bad;

  1006         err = IllegalIdentifier;

  1007         errmsg = QLatin1String("Identifier cannot start with numeric literal");

  1008     }

  1009 

  1010     // terminate string

  1011     buffer8[pos8] = '\0';

  1012 

  1013     double dval = 0;

  1014     if (state == Number) {

  1015         dval = qstrtod(buffer8, 0, 0);

  1016     } else if (state == Hex) { // scan hex numbers

  1017         dval = QScript::integerFromString(buffer8, pos8, 16);

  1018         state = Number;

  1019     } else if (state == Octal) {   // scan octal number

  1020         dval = QScript::integerFromString(buffer8, pos8, 8);

  1021         state = Number;

  1022     }

  1023 

  1024     restrKeyword = false;

  1025     delimited = false;

  1026 

  1027     switch (parenthesesState) {

  1028     case IgnoreParentheses:

  1029         break;

  1030     case CountParentheses:

  1031         if (token == QScriptGrammar::T_RPAREN) {

  1032             --parenthesesCount;

  1033             if (parenthesesCount == 0)

  1034                 parenthesesState = BalancedParentheses;

  1035         } else if (token == QScriptGrammar::T_LPAREN) {

  1036             ++parenthesesCount;

  1037         }

  1038         break;

  1039     case BalancedParentheses:

  1040         parenthesesState = IgnoreParentheses;

  1041         break;

  1042     }

  1043 

  1044     switch (state) {

  1045     case Eof:

  1046         return 0;

  1047     case Other:

  1048         if(token == QScriptGrammar::T_RBRACE || token == QScriptGrammar::T_SEMICOLON)

  1049             delimited = true;

  1050         return token;

  1051     case Identifier:

  1052         if ((token = findReservedWord(buffer16, pos16)) < 0) {

  1053             /* TODO: close leak on parse error. same holds true for String */

  1054             qsyylval = QString(buffer16, pos16);

  1055             return QScriptGrammar::T_IDENTIFIER;

  1056         }

  1057         if (token == QScriptGrammar::T_CONTINUE || token == QScriptGrammar::T_BREAK

  1058             || token == QScriptGrammar::T_RETURN || token == QScriptGrammar::T_THROW) {

  1059             restrKeyword = true;

  1060         } else if (token == QScriptGrammar::T_IF || token == QScriptGrammar::T_FOR

  1061                    || token == QScriptGrammar::T_WHILE || token == QScriptGrammar::T_WITH) {

  1062             parenthesesState = CountParentheses;

  1063             parenthesesCount = 0;

  1064         } else if (token == QScriptGrammar::T_DO) {

  1065             parenthesesState = BalancedParentheses;

  1066         }

  1067         return token;

  1068     case String:

  1069         qsyylval = QString(buffer16, pos16);

  1070         return QScriptGrammar::T_STRING_LITERAL;

  1071     case Number:

  1072         qsyylval = dval;

  1073         return QScriptGrammar::T_NUMERIC_LITERAL;

  1074     case Bad:

  1075         return -1;

  1076     default:

  1077         Q_ASSERT(!"unhandled numeration value in switch");

  1078         return -1;

  1079     }

  1080 }

  1081 

  1082 bool QScript::Lexer::isWhiteSpace() const

  1083 {

  1084     return (current == ' ' || current == '\t' ||

  1085              current == 0x0b || current == 0x0c);

  1086 }

  1087 

  1088 bool QScript::Lexer::isLineTerminator() const

  1089 {

  1090     return (current == '\n' || current == '\r');

  1091 }

  1092 

  1093 bool QScript::Lexer::isIdentLetter(ushort c)

  1094 {

  1095     /* TODO: allow other legitimate unicode chars */

  1096     return ((c >= 'a' && c <= 'z')

  1097             || (c >= 'A' && c <= 'Z')

  1098             || c == '$'

  1099             || c == '_');

  1100 }

  1101 

  1102 bool QScript::Lexer::isDecimalDigit(ushort c)

  1103 {

  1104     return (c >= '0' && c <= '9');

  1105 }

  1106 

  1107 bool QScript::Lexer::isHexDigit(ushort c) const

  1108 {

  1109     return ((c >= '0' && c <= '9')

  1110             || (c >= 'a' && c <= 'f')

  1111             || (c >= 'A' && c <= 'F'));

  1112 }

  1113 

  1114 bool QScript::Lexer::isOctalDigit(ushort c) const

  1115 {

  1116     return (c >= '0' && c <= '7');

  1117 }

  1118 

  1119 int QScript::Lexer::matchPunctuator(ushort c1, ushort c2,

  1120                             ushort c3, ushort c4)

  1121 {

  1122     if (c1 == '>' && c2 == '>' && c3 == '>' && c4 == '=') {

  1123         shift(4);

  1124         return QScriptGrammar::T_GT_GT_GT_EQ;

  1125     } else if (c1 == '=' && c2 == '=' && c3 == '=') {

  1126         shift(3);

  1127         return QScriptGrammar::T_EQ_EQ_EQ;

  1128     } else if (c1 == '!' && c2 == '=' && c3 == '=') {

  1129         shift(3);

  1130         return QScriptGrammar::T_NOT_EQ_EQ;

  1131     } else if (c1 == '>' && c2 == '>' && c3 == '>') {

  1132         shift(3);

  1133         return QScriptGrammar::T_GT_GT_GT;

  1134     } else if (c1 == '<' && c2 == '<' && c3 == '=') {