---------------------------------------------------------------------------- -- -- Copyright (C) 2011 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$ -- GNU Lesser General Public License Usage -- 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. -- -- GNU General Public License Usage -- Alternatively, this file may be used under the terms of the GNU General -- Public License version 3.0 as published by the Free Software Foundation -- and appearing in the file LICENSE.GPL included in the packaging of this -- file. Please review the following information to ensure the GNU General -- Public License version 3.0 requirements will be met: -- http://www.gnu.org/copyleft/gpl.html. -- -- Other Usage -- Alternatively, this file may be used in accordance with the terms and -- conditions contained in a signed written agreement between you and Nokia. -- -- -- -- -- -- $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 #include #include #include #include #include #include #include #include #include #include #include QT_BEGIN_NAMESPACE class LU { Q_DECLARE_TR_FUNCTIONS(LUpdate) }; static QString MagicComment(QLatin1String("TRANSLATOR")); static void recordMessage( Translator *tor, const QString &context, const QString &text, const QString &comment, const QString &extracomment, const QString &msgid, const TranslatorMessage::ExtraData &extra, bool plural, const QString &fileName, int lineNo) { TranslatorMessage msg( context, text, comment, QString(), fileName, lineNo, QStringList(), TranslatorMessage::Unfinished, plural); msg.setExtraComment(extracomment.simplified()); msg.setId(msgid); msg.setExtras(extra); tor->extend(msg); } namespace QScript { class CommentProcessor { public: virtual ~CommentProcessor() {} virtual void processComment(const QChar *chars, int length) = 0; }; class Lexer { public: Lexer(CommentProcessor *); ~Lexer(); void setCode(const QString &c, const QString &fileName, int lineno); int lex(); QString fileName() const { return yyfilename; } 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: QString yyfilename; 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(); void processComment(const QChar *, int); 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; CommentProcessor *commentProcessor; }; } // 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 QScript::Lexer::Lexer(QScript::CommentProcessor *proc) : 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), prohibitAutomaticSemicolon(false), commentProcessor(proc) { // allocate space for read buffers buffer8 = new char[size8]; buffer16 = new QChar[size16]; flags = 0; } QScript::Lexer::~Lexer() { delete [] buffer8; delete [] buffer16; } void QScript::Lexer::setCode(const QString &c, const QString &fileName, int lineno) { errmsg = QString(); yyfilename = fileName; 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; else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h') && c[2] == QLatin1Char('r') && c[3] == QLatin1Char('o') && c[4] == QLatin1Char('w')) return QScriptGrammar::T_THROW; else if (c[0] == QLatin1Char('w') && c[1] == QLatin1Char('h') && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('l') && c[4] == QLatin1Char('e')) return QScriptGrammar::T_WHILE; else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('s') && c[4] == QLatin1Char('t')) return QScriptGrammar::T_CONST; else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('a') && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('s') && c[4] == QLatin1Char('e')) return QScriptGrammar::T_FALSE; else if (check_reserved) { if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('h') && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('r') && c[4] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('u') && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('e') && c[4] == QLatin1Char('r')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('i') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('a') && c[4] == QLatin1Char('l')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('l') && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('s') && c[4] == QLatin1Char('s')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('l') && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('a') && c[4] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 6: { if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('e') && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('e')) return QScriptGrammar::T_DELETE; else if (c[0] == QLatin1Char('r') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('u') && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('n')) return QScriptGrammar::T_RETURN; else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('w') && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('c') && c[5] == QLatin1Char('h')) return QScriptGrammar::T_SWITCH; else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('y') && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('e') && c[4] == QLatin1Char('o') && c[5] == QLatin1Char('f')) return QScriptGrammar::T_TYPEOF; else if (check_reserved) { if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('x') && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('o') && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('t') && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('b') && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m') && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('o') && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('u') && c[2] == QLatin1Char('b') && c[3] == QLatin1Char('l') && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('a') && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('i') && c[4] == QLatin1Char('v') && c[5] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h') && c[2] == QLatin1Char('r') && c[3] == QLatin1Char('o') && c[4] == QLatin1Char('w') && c[5] == QLatin1Char('s')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 7: { if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('f') && c[3] == QLatin1Char('a') && c[4] == QLatin1Char('u') && c[5] == QLatin1Char('l') && c[6] == QLatin1Char('t')) return QScriptGrammar::T_DEFAULT; else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('i') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('a') && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('l') && c[6] == QLatin1Char('y')) return QScriptGrammar::T_FINALLY; else if (check_reserved) { if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('l') && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('a') && c[6] == QLatin1Char('n')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('x') && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e') && c[4] == QLatin1Char('n') && c[5] == QLatin1Char('d') && c[6] == QLatin1Char('s')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('a') && c[2] == QLatin1Char('c') && c[3] == QLatin1Char('k') && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('g') && c[6] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('r') && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('v') && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('t') && c[6] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 8: { if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('n') && c[6] == QLatin1Char('u') && c[7] == QLatin1Char('e')) return QScriptGrammar::T_CONTINUE; else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('u') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('c') && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i') && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n')) return QScriptGrammar::T_FUNCTION; else if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('b') && c[3] == QLatin1Char('u') && c[4] == QLatin1Char('g') && c[5] == QLatin1Char('g') && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('r')) return QScriptGrammar::T_DEBUGGER; else if (check_reserved) { if (c[0] == QLatin1Char('a') && c[1] == QLatin1Char('b') && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('a') && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('a') && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i') && c[6] == QLatin1Char('l') && c[7] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 9: { if (check_reserved) { if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n') && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e') && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('f') && c[6] == QLatin1Char('a') && c[7] == QLatin1Char('c') && c[8] == QLatin1Char('e')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r') && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('n') && c[4] == QLatin1Char('s') && c[5] == QLatin1Char('i') && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n') && c[8] == QLatin1Char('t')) return QScriptGrammar::T_RESERVED_WORD; else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('r') && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('c') && c[6] == QLatin1Char('t') && c[7] == QLatin1Char('e') && c[8] == QLatin1Char('d')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 10: { if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n') && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('t') && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('n') && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('e') && c[8] == QLatin1Char('o') && c[9] == QLatin1Char('f')) return QScriptGrammar::T_INSTANCEOF; else if (check_reserved) { if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m') && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('l') && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('m') && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n') && c[8] == QLatin1Char('t') && c[9] == QLatin1Char('s')) return QScriptGrammar::T_RESERVED_WORD; } } break; case 12: { if (check_reserved) { if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('y') && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('c') && c[4] == QLatin1Char('h') && c[5] == QLatin1Char('r') && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n') && c[8] == QLatin1Char('i') && c[9] == QLatin1Char('z') && c[10] == QLatin1Char('e') && c[11] == QLatin1Char('d')) return QScriptGrammar::T_RESERVED_WORD; } } break; } // switch return -1; } int QScript::Lexer::lex() { int token = 0; state = Start; ushort stringType = 0; // either single or double quotes pos8 = pos16 = 0; done = false; terminator = false; // did we push a token on the stack previously ? // (after an automatic semicolon insertion) if (stackToken >= 0) { setDone(Other); token = stackToken; stackToken = -1; } while (!done) { switch (state) { case Start: if (isWhiteSpace()) { // do nothing } else if (current == '/' && next1 == '/') { recordStartPos(); shift(1); Q_ASSERT(pos16 == 0); state = InSingleLineComment; } else if (current == '/' && next1 == '*') { recordStartPos(); shift(1); Q_ASSERT(pos16 == 0); state = InMultiLineComment; } else if (current == 0) { syncProhibitAutomaticSemicolon(); if (!terminator && !delimited && !prohibitAutomaticSemicolon) { // automatic semicolon insertion if program incomplete token = QScriptGrammar::T_SEMICOLON; stackToken = 0; setDone(Other); } else { setDone(Eof); } } else if (isLineTerminator()) { shiftWindowsLineBreak(); yylineno++; yycolumn = 0; bol = true; terminator = true; syncProhibitAutomaticSemicolon(); if (restrKeyword) { token = QScriptGrammar::T_SEMICOLON; setDone(Other); } } else if (current == '"' || current == '\'') { recordStartPos(); state = InString; stringType = current; } else if (isIdentLetter(current)) { recordStartPos(); record16(current); state = InIdentifier; } else if (current == '0') { recordStartPos(); record8(current); state = InNum0; } else if (isDecimalDigit(current)) { recordStartPos(); record8(current); state = InNum; } else if (current == '.' && isDecimalDigit(next1)) { recordStartPos(); record8(current); state = InDecimal; } else { recordStartPos(); token = matchPunctuator(current, next1, next2, next3); if (token != -1) { if (terminator && !delimited && !prohibitAutomaticSemicolon && (token == QScriptGrammar::T_PLUS_PLUS || token == QScriptGrammar::T_MINUS_MINUS)) { // automatic semicolon insertion stackToken = token; token = QScriptGrammar::T_SEMICOLON; } setDone(Other); } else { setDone(Bad); err = IllegalCharacter; errmsg = LU::tr("Illegal character"); } } break; case InString: if (current == stringType) { shift(1); setDone(String); } else if (current == 0 || isLineTerminator()) { setDone(Bad); err = UnclosedStringLiteral; errmsg = LU::tr("Unclosed string at end of line"); } else if (current == '\\') { state = InEscapeSequence; } else { record16(current); } break; // Escape Sequences inside of strings case InEscapeSequence: if (isOctalDigit(current)) { if (current >= '0' && current <= '3' && isOctalDigit(next1) && isOctalDigit(next2)) { record16(convertOctal(current, next1, next2)); shift(2); state = InString; } else if (isOctalDigit(current) && isOctalDigit(next1)) { record16(convertOctal('0', current, next1)); shift(1); state = InString; } else if (isOctalDigit(current)) { record16(convertOctal('0', '0', current)); state = InString; } else { setDone(Bad); err = IllegalEscapeSequence; errmsg = LU::tr("Illegal escape sequence"); } } else if (current == 'x') state = InHexEscape; else if (current == 'u') state = InUnicodeEscape; else { record16(singleEscape(current)); state = InString; } break; case InHexEscape: if (isHexDigit(current) && isHexDigit(next1)) { state = InString; record16(QLatin1Char(convertHex(current, next1))); shift(1); } else if (current == stringType) { record16(QLatin1Char('x')); shift(1); setDone(String); } else { record16(QLatin1Char('x')); record16(current); state = InString; } break; case InUnicodeEscape: if (isHexDigit(current) && isHexDigit(next1) && isHexDigit(next2) && isHexDigit(next3)) { record16(convertUnicode(current, next1, next2, next3)); shift(3); state = InString; } else if (current == stringType) { record16(QLatin1Char('u')); shift(1); setDone(String); } else { setDone(Bad); err = IllegalUnicodeEscapeSequence; errmsg = LU::tr("Illegal unicode escape sequence"); } break; case InSingleLineComment: if (isLineTerminator()) { record16(current); // include newline processComment(buffer16, pos16); shiftWindowsLineBreak(); yylineno++; yycolumn = 0; pos16 = 0; terminator = true; bol = true; if (restrKeyword) { token = QScriptGrammar::T_SEMICOLON; setDone(Other); } else state = Start; } else if (current == 0) { setDone(Eof); } else { record16(current); } break; case InMultiLineComment: if (current == 0) { setDone(Bad); err = UnclosedComment; errmsg = LU::tr("Unclosed comment at end of file"); } else if (isLineTerminator()) { shiftWindowsLineBreak(); yylineno++; } else if (current == '*' && next1 == '/') { processComment(buffer16, pos16); pos16 = 0; state = Start; shift(1); } else { record16(current); } break; case InIdentifier: if (isIdentLetter(current) || isDecimalDigit(current)) { record16(current); break; } setDone(Identifier); break; case InNum0: if (current == 'x' || current == 'X') { record8(current); state = InHex; } else if (current == '.') { record8(current); state = InDecimal; } else if (current == 'e' || current == 'E') { record8(current); state = InExponentIndicator; } else if (isOctalDigit(current)) { record8(current); state = InOctal; } else if (isDecimalDigit(current)) { record8(current); state = InDecimal; } else { setDone(Number); } break; case InHex: if (isHexDigit(current)) record8(current); else setDone(Hex); break; case InOctal: if (isOctalDigit(current)) { record8(current); } else if (isDecimalDigit(current)) { record8(current); state = InDecimal; } else { setDone(Octal); } break; case InNum: if (isDecimalDigit(current)) { record8(current); } else if (current == '.') { record8(current); state = InDecimal; } else if (current == 'e' || current == 'E') { record8(current); state = InExponentIndicator; } else { setDone(Number); } break; case InDecimal: if (isDecimalDigit(current)) { record8(current); } else if (current == 'e' || current == 'E') { record8(current); state = InExponentIndicator; } else { setDone(Number); } break; case InExponentIndicator: if (current == '+' || current == '-') { record8(current); } else if (isDecimalDigit(current)) { record8(current); state = InExponent; } else { setDone(Bad); err = IllegalExponentIndicator; errmsg = LU::tr("Illegal syntax for exponential number"); } break; case InExponent: if (isDecimalDigit(current)) { record8(current); } else { setDone(Number); } break; default: Q_ASSERT_X(0, "Lexer::lex", "Unhandled state in switch statement"); } // move on to the next character if (!done) shift(1); if (state != Start && state != InSingleLineComment) bol = false; } // no identifiers allowed directly after numeric literal, e.g. "3in" is bad if ((state == Number || state == Octal || state == Hex) && isIdentLetter(current)) { state = Bad; err = IllegalIdentifier; errmsg = LU::tr("Identifier cannot start with numeric literal"); } // terminate string buffer8[pos8] = '\0'; double dval = 0; if (state == Number) { dval = qstrtod(buffer8, 0, 0); } else if (state == Hex) { // scan hex numbers dval = QScript::integerFromString(buffer8, pos8, 16); state = Number; } else if (state == Octal) { // scan octal number dval = QScript::integerFromString(buffer8, pos8, 8); state = Number; } restrKeyword = false; delimited = false; switch (parenthesesState) { case IgnoreParentheses: break; case CountParentheses: if (token == QScriptGrammar::T_RPAREN) { --parenthesesCount; if (parenthesesCount == 0) parenthesesState = BalancedParentheses; } else if (token == QScriptGrammar::T_LPAREN) { ++parenthesesCount; } break; case BalancedParentheses: parenthesesState = IgnoreParentheses; break; } switch (state) { case Eof: return 0; case Other: if(token == QScriptGrammar::T_RBRACE || token == QScriptGrammar::T_SEMICOLON) delimited = true; return token; case Identifier: if ((token = findReservedWord(buffer16, pos16)) < 0) { /* TODO: close leak on parse error. same holds true for String */ qsyylval = QString(buffer16, pos16); return QScriptGrammar::T_IDENTIFIER; } if (token == QScriptGrammar::T_CONTINUE || token == QScriptGrammar::T_BREAK || token == QScriptGrammar::T_RETURN || token == QScriptGrammar::T_THROW) { restrKeyword = true; } else if (token == QScriptGrammar::T_IF || token == QScriptGrammar::T_FOR || token == QScriptGrammar::T_WHILE || token == QScriptGrammar::T_WITH) { parenthesesState = CountParentheses; parenthesesCount = 0; } else if (token == QScriptGrammar::T_DO) { parenthesesState = BalancedParentheses; } return token; case String: qsyylval = QString(buffer16, pos16); return QScriptGrammar::T_STRING_LITERAL; case Number: qsyylval = dval; return QScriptGrammar::T_NUMERIC_LITERAL; case Bad: return -1; default: Q_ASSERT(!"unhandled numeration value in switch"); return -1; } } bool QScript::Lexer::isWhiteSpace() const { return (current == ' ' || current == '\t' || current == 0x0b || current == 0x0c); } bool QScript::Lexer::isLineTerminator() const { return (current == '\n' || current == '\r'); } bool QScript::Lexer::isIdentLetter(ushort c) { /* TODO: allow other legitimate unicode chars */ return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '$' || c == '_'); } bool QScript::Lexer::isDecimalDigit(ushort c) { return (c >= '0' && c <= '9'); } bool QScript::Lexer::isHexDigit(ushort c) const { return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); } bool QScript::Lexer::isOctalDigit(ushort c) const { return (c >= '0' && c <= '7'); } int QScript::Lexer::matchPunctuator(ushort c1, ushort c2, ushort c3, ushort c4) { if (c1 == '>' && c2 == '>' && c3 == '>' && c4 == '=') { shift(4); return QScriptGrammar::T_GT_GT_GT_EQ; } else if (c1 == '=' && c2 == '=' && c3 == '=') { shift(3); return QScriptGrammar::T_EQ_EQ_EQ; } else if (c1 == '!' && c2 == '=' && c3 == '=') { shift(3); return QScriptGrammar::T_NOT_EQ_EQ; } else if (c1 == '>' && c2 == '>' && c3 == '>') { shift(3); return QScriptGrammar::T_GT_GT_GT; } else if (c1 == '<' && c2 == '<' && c3 == '=') { shift(3); return QScriptGrammar::T_LT_LT_EQ; } else if (c1 == '>' && c2 == '>' && c3 == '=') { shift(3); return QScriptGrammar::T_GT_GT_EQ; } else if (c1 == '<' && c2 == '=') { shift(2); return QScriptGrammar::T_LE; } else if (c1 == '>' && c2 == '=') { shift(2); return QScriptGrammar::T_GE; } else if (c1 == '!' && c2 == '=') { shift(2); return QScriptGrammar::T_NOT_EQ; } else if (c1 == '+' && c2 == '+') { shift(2); return QScriptGrammar::T_PLUS_PLUS; } else if (c1 == '-' && c2 == '-') { shift(2); return QScriptGrammar::T_MINUS_MINUS; } else if (c1 == '=' && c2 == '=') { shift(2); return QScriptGrammar::T_EQ_EQ; } else if (c1 == '+' && c2 == '=') { shift(2); return QScriptGrammar::T_PLUS_EQ; } else if (c1 == '-' && c2 == '=') { shift(2); return QScriptGrammar::T_MINUS_EQ; } else if (c1 == '*' && c2 == '=') { shift(2); return QScriptGrammar::T_STAR_EQ; } else if (c1 == '/' && c2 == '=') { shift(2); return QScriptGrammar::T_DIVIDE_EQ; } else if (c1 == '&' && c2 == '=') { shift(2); return QScriptGrammar::T_AND_EQ; } else if (c1 == '^' && c2 == '=') { shift(2); return QScriptGrammar::T_XOR_EQ; } else if (c1 == '%' && c2 == '=') { shift(2); return QScriptGrammar::T_REMAINDER_EQ; } else if (c1 == '|' && c2 == '=') { shift(2); return QScriptGrammar::T_OR_EQ; } else if (c1 == '<' && c2 == '<') { shift(2); return QScriptGrammar::T_LT_LT; } else if (c1 == '>' && c2 == '>') { shift(2); return QScriptGrammar::T_GT_GT; } else if (c1 == '&' && c2 == '&') { shift(2); return QScriptGrammar::T_AND_AND; } else if (c1 == '|' && c2 == '|') { shift(2); return QScriptGrammar::T_OR_OR; } switch(c1) { case '=': shift(1); return QScriptGrammar::T_EQ; case '>': shift(1); return QScriptGrammar::T_GT; case '<': shift(1); return QScriptGrammar::T_LT; case ',': shift(1); return QScriptGrammar::T_COMMA; case '!': shift(1); return QScriptGrammar::T_NOT; case '~': shift(1); return QScriptGrammar::T_TILDE; case '?': shift(1); return QScriptGrammar::T_QUESTION; case ':': shift(1); return QScriptGrammar::T_COLON; case '.': shift(1); return QScriptGrammar::T_DOT; case '+': shift(1); return QScriptGrammar::T_PLUS; case '-': shift(1); return QScriptGrammar::T_MINUS; case '*': shift(1); return QScriptGrammar::T_STAR; case '/': shift(1); return QScriptGrammar::T_DIVIDE_; case '&': shift(1); return QScriptGrammar::T_AND; case '|': shift(1); return QScriptGrammar::T_OR; case '^': shift(1); return QScriptGrammar::T_XOR; case '%': shift(1); return QScriptGrammar::T_REMAINDER; case '(': shift(1); return QScriptGrammar::T_LPAREN; case ')': shift(1); return QScriptGrammar::T_RPAREN; case '{': shift(1); return QScriptGrammar::T_LBRACE; case '}': shift(1); return QScriptGrammar::T_RBRACE; case '[': shift(1); return QScriptGrammar::T_LBRACKET; case ']': shift(1); return QScriptGrammar::T_RBRACKET; case ';': shift(1); return QScriptGrammar::T_SEMICOLON; default: return -1; } } ushort QScript::Lexer::singleEscape(ushort c) const { switch(c) { case 'b': return 0x08; case 't': return 0x09; case 'n': return 0x0A; case 'v': return 0x0B; case 'f': return 0x0C; case 'r': return 0x0D; case '"': return 0x22; case '\'': return 0x27; case '\\': return 0x5C; default: return c; } } ushort QScript::Lexer::convertOctal(ushort c1, ushort c2, ushort c3) const { return ((c1 - '0') * 64 + (c2 - '0') * 8 + c3 - '0'); } unsigned char QScript::Lexer::convertHex(ushort c) { if (c >= '0' && c <= '9') return (c - '0'); else if (c >= 'a' && c <= 'f') return (c - 'a' + 10); else return (c - 'A' + 10); } unsigned char QScript::Lexer::convertHex(ushort c1, ushort c2) { return ((convertHex(c1) << 4) + convertHex(c2)); } QChar QScript::Lexer::convertUnicode(ushort c1, ushort c2, ushort c3, ushort c4) { return QChar((convertHex(c3) << 4) + convertHex(c4), (convertHex(c1) << 4) + convertHex(c2)); } void QScript::Lexer::record8(ushort c) { Q_ASSERT(c <= 0xff); // enlarge buffer if full if (pos8 >= size8 - 1) { char *tmp = new char[2 * size8]; memcpy(tmp, buffer8, size8 * sizeof(char)); delete [] buffer8; buffer8 = tmp; size8 *= 2; } buffer8[pos8++] = (char) c; } void QScript::Lexer::record16(QChar c) { // enlarge buffer if full if (pos16 >= size16 - 1) { QChar *tmp = new QChar[2 * size16]; memcpy(tmp, buffer16, size16 * sizeof(QChar)); delete [] buffer16; buffer16 = tmp; size16 *= 2; } buffer16[pos16++] = c; } void QScript::Lexer::recordStartPos() { startlineno = yylineno; startcolumn = yycolumn; } bool QScript::Lexer::scanRegExp(RegExpBodyPrefix prefix) { pos16 = 0; bool lastWasEscape = false; if (prefix == EqualPrefix) record16(QLatin1Char('=')); while (1) { if (isLineTerminator() || current == 0) { errmsg = LU::tr("Unterminated regular expression literal"); return false; } else if (current != '/' || lastWasEscape == true) { record16(current); lastWasEscape = !lastWasEscape && (current == '\\'); } else { pattern = QString(buffer16, pos16); pos16 = 0; shift(1); break; } shift(1); } flags = 0; while (isIdentLetter(current)) { record16(current); shift(1); } return true; } void QScript::Lexer::syncProhibitAutomaticSemicolon() { if (parenthesesState == BalancedParentheses) { // we have seen something like "if (foo)", which means we should // never insert an automatic semicolon at this point, since it would // then be expanded into an empty statement (ECMA-262 7.9.1) prohibitAutomaticSemicolon = true; parenthesesState = IgnoreParentheses; } else { prohibitAutomaticSemicolon = false; } } void QScript::Lexer::processComment(const QChar *chars, int length) { commentProcessor->processComment(chars, length); } class Translator; class QScriptParser: protected $table, public QScript::CommentProcessor { public: QVariant val; struct Location { int startLine; int startColumn; int endLine; int endColumn; }; public: QScriptParser(); ~QScriptParser(); void setLexer(QScript::Lexer *); void setTranslator(Translator *); bool parse(); QString fileName() const { return lexer->fileName(); } inline QString errorMessage() const { return error_message; } inline int errorLineNumber() const { return error_lineno; } inline int errorColumnNumber() const { return error_column; } protected: inline void reallocateStack(); inline QVariant &sym(int index) { return sym_stack [tos + index - 1]; } inline Location &loc(int index) { return location_stack [tos + index - 2]; } std::ostream &yyMsg(int line = 0); virtual void processComment(const QChar *, int); protected: int tos; int stack_size; QVector sym_stack; int *state_stack; Location *location_stack; QString error_message; int error_lineno; int error_column; private: QScript::Lexer *lexer; Translator *translator; QString trcontext; QString extracomment; QString msgid; QString sourcetext; TranslatorMessage::ExtraData extra; }; inline void QScriptParser::reallocateStack() { if (! stack_size) stack_size = 128; else stack_size <<= 1; sym_stack.resize(stack_size); state_stack = reinterpret_cast (qRealloc(state_stack, stack_size * sizeof(int))); location_stack = reinterpret_cast (qRealloc(location_stack, stack_size * sizeof(Location))); } inline static bool automatic(QScript::Lexer *lexer, int token) { return (token == $table::T_RBRACE) || (token == 0) || lexer->prevTerminator(); } QScriptParser::QScriptParser(): tos(0), stack_size(0), sym_stack(0), state_stack(0), location_stack(0), lexer(0), translator(0) { } QScriptParser::~QScriptParser() { if (stack_size) { qFree(state_stack); qFree(location_stack); } } static inline QScriptParser::Location location(QScript::Lexer *lexer) { QScriptParser::Location loc; loc.startLine = lexer->startLineNo(); loc.startColumn = lexer->startColumnNo(); loc.endLine = lexer->endLineNo(); loc.endColumn = lexer->endColumnNo(); return loc; } void QScriptParser::setLexer(QScript::Lexer *lex) { lexer = lex; } void QScriptParser::setTranslator(Translator *tor) { translator = tor; } bool QScriptParser::parse() { Q_ASSERT(lexer != 0); Q_ASSERT(translator != 0); trcontext = QFileInfo(fileName()).baseName(); const int INITIAL_STATE = 0; int yytoken = -1; int saved_yytoken = -1; int identLineNo = -1; reallocateStack(); tos = 0; state_stack[++tos] = INITIAL_STATE; while (true) { const int state = state_stack [tos]; if (yytoken == -1 && - TERMINAL_COUNT != action_index [state]) { if (saved_yytoken == -1) { yytoken = lexer->lex(); location_stack [tos] = location(lexer); } else { yytoken = saved_yytoken; saved_yytoken = -1; } } int act = t_action (state, yytoken); if (act == ACCEPT_STATE) return true; else if (act > 0) { if (++tos == stack_size) reallocateStack(); sym_stack [tos] = lexer->val (); state_stack [tos] = act; location_stack [tos] = location(lexer); yytoken = -1; } else if (act < 0) { int r = - act - 1; tos -= rhs [r]; act = state_stack [tos++]; switch (r) { ./ PrimaryExpression: T_THIS ; PrimaryExpression: T_IDENTIFIER ; /. case $rule_number: { sym(1) = sym(1).toByteArray(); identLineNo = lexer->startLineNo(); } break; ./ PrimaryExpression: T_NULL ; PrimaryExpression: T_TRUE ; PrimaryExpression: T_FALSE ; PrimaryExpression: T_NUMERIC_LITERAL ; PrimaryExpression: T_STRING_LITERAL ; PrimaryExpression: T_DIVIDE_ ; /: #define Q_SCRIPT_REGEXPLITERAL_RULE1 $rule_number :/ /. case $rule_number: { bool rx = lexer->scanRegExp(QScript::Lexer::NoPrefix); if (!rx) { error_message = lexer->errorMessage(); error_lineno = lexer->startLineNo(); error_column = lexer->startColumnNo(); return false; } } break; ./ PrimaryExpression: T_DIVIDE_EQ ; /: #define Q_SCRIPT_REGEXPLITERAL_RULE2 $rule_number :/ /. case $rule_number: { bool rx = lexer->scanRegExp(QScript::Lexer::EqualPrefix); if (!rx) { error_message = lexer->errorMessage(); error_lineno = lexer->startLineNo(); error_column = lexer->startColumnNo(); return false; } } break; ./ PrimaryExpression: T_LBRACKET ElisionOpt T_RBRACKET ; PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ; PrimaryExpression: T_LBRACKET ElementList T_COMMA ElisionOpt T_RBRACKET ; PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ; PrimaryExpression: T_LPAREN Expression T_RPAREN ; ElementList: ElisionOpt AssignmentExpression ; ElementList: ElementList T_COMMA ElisionOpt AssignmentExpression ; Elision: T_COMMA ; Elision: Elision T_COMMA ; ElisionOpt: ; ElisionOpt: Elision ; PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ; PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ; PropertyName: T_IDENTIFIER ; PropertyName: T_STRING_LITERAL ; PropertyName: T_NUMERIC_LITERAL ; PropertyName: ReservedIdentifier ; ReservedIdentifier: T_BREAK ; ReservedIdentifier: T_CASE ; ReservedIdentifier: T_CATCH ; ReservedIdentifier: T_CONST ; ReservedIdentifier: T_CONTINUE ; ReservedIdentifier: T_DEBUGGER ; ReservedIdentifier: T_DEFAULT ; ReservedIdentifier: T_DELETE ; ReservedIdentifier: T_DO ; ReservedIdentifier: T_ELSE ; ReservedIdentifier: T_FALSE ; ReservedIdentifier: T_FINALLY ; ReservedIdentifier: T_FOR ; ReservedIdentifier: T_FUNCTION ; ReservedIdentifier: T_IF ; ReservedIdentifier: T_IN ; ReservedIdentifier: T_INSTANCEOF ; ReservedIdentifier: T_NEW ; ReservedIdentifier: T_NULL ; ReservedIdentifier: T_RESERVED_WORD ; ReservedIdentifier: T_RETURN ; ReservedIdentifier: T_SWITCH ; ReservedIdentifier: T_THIS ; ReservedIdentifier: T_THROW ; ReservedIdentifier: T_TRUE ; ReservedIdentifier: T_TRY ; ReservedIdentifier: T_TYPEOF ; ReservedIdentifier: T_VAR ; ReservedIdentifier: T_VOID ; ReservedIdentifier: T_WHILE ; ReservedIdentifier: T_WITH ; PropertyIdentifier: T_IDENTIFIER ; PropertyIdentifier: ReservedIdentifier ; MemberExpression: PrimaryExpression ; MemberExpression: FunctionExpression ; MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ; MemberExpression: MemberExpression T_DOT PropertyIdentifier ; MemberExpression: T_NEW MemberExpression Arguments ; NewExpression: MemberExpression ; NewExpression: T_NEW NewExpression ; CallExpression: MemberExpression Arguments ; /. case $rule_number: { QString name = sym(1).toString(); if ((name == QLatin1String("qsTranslate")) || (name == QLatin1String("QT_TRANSLATE_NOOP"))) { if (!sourcetext.isEmpty()) yyMsg(identLineNo) << qPrintable(LU::tr("//% cannot be used with %1(). Ignoring\n").arg(name)); QVariantList args = sym(2).toList(); if (args.size() < 2) { yyMsg(identLineNo) << qPrintable(LU::tr("%1() requires at least two arguments.\n").arg(name)); } else { if ((args.at(0).type() != QVariant::String) || (args.at(1).type() != QVariant::String)) { yyMsg(identLineNo) << qPrintable(LU::tr("%1(): both arguments must be literal strings.\n").arg(name)); } else { QString context = args.at(0).toString(); QString text = args.at(1).toString(); QString comment = args.value(2).toString(); bool plural = (args.size() > 4); recordMessage(translator, context, text, comment, extracomment, msgid, extra, plural, fileName(), identLineNo); } } sourcetext.clear(); extracomment.clear(); msgid.clear(); extra.clear(); } else if ((name == QLatin1String("qsTr")) || (name == QLatin1String("QT_TR_NOOP"))) { if (!sourcetext.isEmpty()) yyMsg(identLineNo) << qPrintable(LU::tr("//% cannot be used with %1(). Ignoring\n").arg(name)); QVariantList args = sym(2).toList(); if (args.size() < 1) { yyMsg(identLineNo) << qPrintable(LU::tr("%1() requires at least one argument.\n").arg(name)); } else { if (args.at(0).type() != QVariant::String) { yyMsg(identLineNo) << qPrintable(LU::tr("%1(): text to translate must be a literal string.\n").arg(name)); } else { QString text = args.at(0).toString(); QString comment = args.value(1).toString(); bool plural = (args.size() > 2); recordMessage(translator, trcontext, text, comment, extracomment, msgid, extra, plural, fileName(), identLineNo); } } sourcetext.clear(); extracomment.clear(); msgid.clear(); extra.clear(); } else if ((name == QLatin1String("qsTrId")) || (name == QLatin1String("QT_TRID_NOOP"))) { if (!msgid.isEmpty()) yyMsg(identLineNo) << qPrintable(LU::tr("//= cannot be used with %1(). Ignoring\n").arg(name)); QVariantList args = sym(2).toList(); if (args.size() < 1) { yyMsg(identLineNo) << qPrintable(LU::tr("%1() requires at least one argument.\n").arg(name)); } else { if (args.at(0).type() != QVariant::String) { yyMsg(identLineNo) << qPrintable(LU::tr("%1(): identifier must be a literal string.\n").arg(name)); } else { msgid = args.at(0).toString(); bool plural = (args.size() > 1); recordMessage(translator, QString(), sourcetext, QString(), extracomment, msgid, extra, plural, fileName(), identLineNo); } } sourcetext.clear(); extracomment.clear(); msgid.clear(); extra.clear(); } } break; ./ CallExpression: CallExpression Arguments ; CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ; CallExpression: CallExpression T_DOT PropertyIdentifier ; Arguments: T_LPAREN T_RPAREN ; /. case $rule_number: { sym(1) = QVariantList(); } break; ./ Arguments: T_LPAREN ArgumentList T_RPAREN ; /. case $rule_number: { sym(1) = sym(2); } break; ./ ArgumentList: AssignmentExpression ; /. case $rule_number: { sym(1) = QVariantList() << sym(1); } break; ./ ArgumentList: ArgumentList T_COMMA AssignmentExpression ; /. case $rule_number: { sym(1) = sym(1).toList() << sym(3); } break; ./ LeftHandSideExpression: NewExpression ; LeftHandSideExpression: CallExpression ; PostfixExpression: LeftHandSideExpression ; PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ; PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ; UnaryExpression: PostfixExpression ; UnaryExpression: T_DELETE UnaryExpression ; UnaryExpression: T_VOID UnaryExpression ; UnaryExpression: T_TYPEOF UnaryExpression ; UnaryExpression: T_PLUS_PLUS UnaryExpression ; UnaryExpression: T_MINUS_MINUS UnaryExpression ; UnaryExpression: T_PLUS UnaryExpression ; UnaryExpression: T_MINUS UnaryExpression ; UnaryExpression: T_TILDE UnaryExpression ; UnaryExpression: T_NOT UnaryExpression ; MultiplicativeExpression: UnaryExpression ; MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ; MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ; MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ; AdditiveExpression: MultiplicativeExpression ; AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ; /. case $rule_number: { if ((sym(1).type() == QVariant::String) || (sym(3).type() == QVariant::String)) sym(1) = sym(1).toString() + sym(3).toString(); else sym(1) = QVariant(); } break; ./ AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ; ShiftExpression: AdditiveExpression ; ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ; ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ; ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ; RelationalExpression: ShiftExpression ; RelationalExpression: RelationalExpression T_LT ShiftExpression ; RelationalExpression: RelationalExpression T_GT ShiftExpression ; RelationalExpression: RelationalExpression T_LE ShiftExpression ; RelationalExpression: RelationalExpression T_GE ShiftExpression ; RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ; RelationalExpression: RelationalExpression T_IN ShiftExpression ; RelationalExpressionNotIn: ShiftExpression ; RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ; RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ; RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ; RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ; RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ; EqualityExpression: RelationalExpression ; EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ; EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ; EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ; EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ; EqualityExpressionNotIn: RelationalExpressionNotIn ; EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ; EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn; EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ; EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ; BitwiseANDExpression: EqualityExpression ; BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ; BitwiseANDExpressionNotIn: EqualityExpressionNotIn ; BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ; BitwiseXORExpression: BitwiseANDExpression ; BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ; BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ; BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ; BitwiseORExpression: BitwiseXORExpression ; BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ; BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ; BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ; LogicalANDExpression: BitwiseORExpression ; LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ; LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ; LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ; LogicalORExpression: LogicalANDExpression ; LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ; LogicalORExpressionNotIn: LogicalANDExpressionNotIn ; LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ; ConditionalExpression: LogicalORExpression ; ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ; ConditionalExpressionNotIn: LogicalORExpressionNotIn ; ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ; AssignmentExpression: ConditionalExpression ; AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ; AssignmentExpressionNotIn: ConditionalExpressionNotIn ; AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ; AssignmentOperator: T_EQ ; AssignmentOperator: T_STAR_EQ ; AssignmentOperator: T_DIVIDE_EQ ; AssignmentOperator: T_REMAINDER_EQ ; AssignmentOperator: T_PLUS_EQ ; AssignmentOperator: T_MINUS_EQ ; AssignmentOperator: T_LT_LT_EQ ; AssignmentOperator: T_GT_GT_EQ ; AssignmentOperator: T_GT_GT_GT_EQ ; AssignmentOperator: T_AND_EQ ; AssignmentOperator: T_XOR_EQ ; AssignmentOperator: T_OR_EQ ; Expression: AssignmentExpression ; Expression: Expression T_COMMA AssignmentExpression ; ExpressionOpt: ; ExpressionOpt: Expression ; ExpressionNotIn: AssignmentExpressionNotIn ; ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ; ExpressionNotInOpt: ; ExpressionNotInOpt: ExpressionNotIn ; Statement: Block ; /. case $rule_number: ./ Statement: VariableStatement ; /. case $rule_number: ./ Statement: EmptyStatement ; /. case $rule_number: ./ Statement: ExpressionStatement ; /. case $rule_number: ./ Statement: IfStatement ; /. case $rule_number: ./ Statement: IterationStatement ; /. case $rule_number: ./ Statement: ContinueStatement ; /. case $rule_number: ./ Statement: BreakStatement ; /. case $rule_number: ./ Statement: ReturnStatement ; /. case $rule_number: ./ Statement: WithStatement ; /. case $rule_number: ./ Statement: LabelledStatement ; /. case $rule_number: ./ Statement: SwitchStatement ; /. case $rule_number: ./ Statement: ThrowStatement ; /. case $rule_number: ./ Statement: TryStatement ; /. case $rule_number: ./ Statement: DebuggerStatement ; /. case $rule_number: if (!sourcetext.isEmpty() || !extracomment.isEmpty() || !msgid.isEmpty() || !extra.isEmpty()) { yyMsg() << qPrintable(LU::tr("Discarding unconsumed meta data\n")); sourcetext.clear(); extracomment.clear(); msgid.clear(); extra.clear(); } break; ./ Block: T_LBRACE StatementListOpt T_RBRACE ; StatementList: Statement ; StatementList: StatementList Statement ; StatementListOpt: ; StatementListOpt: StatementList ; VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ; -- automatic semicolon VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ; VariableDeclarationKind: T_CONST ; VariableDeclarationKind: T_VAR ; VariableDeclarationList: VariableDeclaration ; VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ; VariableDeclarationListNotIn: VariableDeclarationNotIn ; VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ; VariableDeclaration: T_IDENTIFIER InitialiserOpt ; VariableDeclarationNotIn: T_IDENTIFIER InitialiserNotInOpt ; Initialiser: T_EQ AssignmentExpression ; InitialiserOpt: ; InitialiserOpt: Initialiser ; InitialiserNotIn: T_EQ AssignmentExpressionNotIn ; InitialiserNotInOpt: ; InitialiserNotInOpt: InitialiserNotIn ; EmptyStatement: T_SEMICOLON ; ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon ExpressionStatement: Expression T_SEMICOLON ; IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ; IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ; IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ; -- automatic semicolon IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ; IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ; IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ; IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ; IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ; IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ; ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ; -- automatic semicolon ContinueStatement: T_CONTINUE T_SEMICOLON ; ContinueStatement: T_CONTINUE T_IDENTIFIER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon ContinueStatement: T_CONTINUE T_IDENTIFIER T_SEMICOLON ; BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ; -- automatic semicolon BreakStatement: T_BREAK T_SEMICOLON ; BreakStatement: T_BREAK T_IDENTIFIER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon BreakStatement: T_BREAK T_IDENTIFIER T_SEMICOLON ; ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ; -- automatic semicolon ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ; WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ; SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ; CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ; CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ; CaseClauses: CaseClause ; CaseClauses: CaseClauses CaseClause ; CaseClausesOpt: ; CaseClausesOpt: CaseClauses ; CaseClause: T_CASE Expression T_COLON StatementListOpt ; DefaultClause: T_DEFAULT T_COLON StatementListOpt ; LabelledStatement: T_IDENTIFIER T_COLON Statement ; ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon ThrowStatement: T_THROW Expression T_SEMICOLON ; TryStatement: T_TRY Block Catch ; TryStatement: T_TRY Block Finally ; TryStatement: T_TRY Block Catch Finally ; Catch: T_CATCH T_LPAREN T_IDENTIFIER T_RPAREN Block ; Finally: T_FINALLY Block ; DebuggerStatement: T_DEBUGGER ; FunctionDeclaration: T_FUNCTION T_IDENTIFIER T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ; FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ; FormalParameterList: T_IDENTIFIER ; FormalParameterList: FormalParameterList T_COMMA T_IDENTIFIER ; FormalParameterListOpt: ; FormalParameterListOpt: FormalParameterList ; FunctionBodyOpt: ; FunctionBodyOpt: FunctionBody ; FunctionBody: SourceElements ; Program: SourceElements ; SourceElements: SourceElement ; SourceElements: SourceElements SourceElement ; SourceElement: Statement ; SourceElement: FunctionDeclaration ; IdentifierOpt: ; IdentifierOpt: T_IDENTIFIER ; PropertyNameAndValueListOpt: ; PropertyNameAndValueListOpt: PropertyNameAndValueList ; /. } // switch state_stack [tos] = nt_action (act, lhs [r] - TERMINAL_COUNT); if (rhs[r] > 1) { location_stack[tos - 1].endLine = location_stack[tos + rhs[r] - 2].endLine; location_stack[tos - 1].endColumn = location_stack[tos + rhs[r] - 2].endColumn; location_stack[tos] = location_stack[tos + rhs[r] - 1]; } } else { if (saved_yytoken == -1 && automatic (lexer, yytoken) && t_action (state, T_AUTOMATIC_SEMICOLON) > 0) { saved_yytoken = yytoken; yytoken = T_SEMICOLON; continue; } else if ((state == INITIAL_STATE) && (yytoken == 0)) { // accept empty input yytoken = T_SEMICOLON; continue; } int ers = state; int shifts = 0; int reduces = 0; int expected_tokens [3]; for (int tk = 0; tk < TERMINAL_COUNT; ++tk) { int k = t_action (ers, tk); if (! k) continue; else if (k < 0) ++reduces; else if (spell [tk]) { if (shifts < 3) expected_tokens [shifts] = tk; ++shifts; } } error_message.clear (); if (shifts && shifts < 3) { bool first = true; for (int s = 0; s < shifts; ++s) { if (first) error_message += QLatin1String ("Expected "); //: Beginning of the string that contains //: comma-separated list of expected tokens error_message += LU::tr("Expected "); else error_message += QLatin1String (", "); first = false; error_message += QLatin1String("`"); error_message += QLatin1String (spell [expected_tokens [s]]); error_message += QLatin1String("'"); } } if (error_message.isEmpty()) error_message = lexer->errorMessage(); error_lineno = lexer->startLineNo(); error_column = lexer->startColumnNo(); return false; } } return false; } std::ostream &QScriptParser::yyMsg(int line) { return std::cerr << qPrintable(fileName()) << ':' << (line ? line : lexer->startLineNo()) << ": "; } void QScriptParser::processComment(const QChar *chars, int length) { if (!length) return; // Try to match the logic of the C++ parser. if (*chars == QLatin1Char(':') && chars[1].isSpace()) { extracomment += QString(chars+2, length-2); } else if (*chars == QLatin1Char('=') && chars[1].isSpace()) { msgid = QString(chars+2, length-2).simplified(); } else if (*chars == QLatin1Char('~') && chars[1].isSpace()) { QString text = QString(chars+2, length-2).trimmed(); int k = text.indexOf(QLatin1Char(' ')); if (k > -1) extra.insert(text.left(k), text.mid(k + 1).trimmed()); } else if (*chars == QLatin1Char('%') && chars[1].isSpace()) { sourcetext.reserve(sourcetext.length() + length-2); ushort *ptr = (ushort *)sourcetext.data() + sourcetext.length(); int p = 2, c; forever { if (p >= length) break; c = chars[p++].unicode(); if (isspace(c)) continue; if (c != '"') { yyMsg() << qPrintable(LU::tr("Unexpected character in meta string\n")); break; } forever { if (p >= length) { whoops: yyMsg() << qPrintable(LU::tr("Unterminated meta string\n")); break; } c = chars[p++].unicode(); if (c == '"') break; if (c == '\\') { if (p >= length) goto whoops; c = chars[p++].unicode(); if (c == '\n') goto whoops; *ptr++ = '\\'; } *ptr++ = c; } } sourcetext.resize(ptr - (ushort *)sourcetext.data()); } else { int idx = 0; ushort c; while ((c = chars[idx].unicode()) == ' ' || c == '\t' || c == '\n') ++idx; if (!memcmp(chars + idx, MagicComment.unicode(), MagicComment.length() * 2)) { idx += MagicComment.length(); QString comment = QString(chars + idx, length - idx).simplified(); int k = comment.indexOf(QLatin1Char(' ')); if (k == -1) { trcontext = comment; } else { trcontext = comment.left(k); comment.remove(0, k + 1); TranslatorMessage msg( trcontext, QString(), comment, QString(), fileName(), lexer->startLineNo(), QStringList(), TranslatorMessage::Finished, /*plural=*/false); msg.setExtraComment(extracomment.simplified()); extracomment.clear(); translator->append(msg); translator->setExtras(extra); extra.clear(); } } } } bool loadQScript(Translator &translator, const QString &filename, ConversionData &cd) { QFile file(filename); if (!file.open(QIODevice::ReadOnly)) { cd.appendError(LU::tr("Cannot open %1: %2").arg(filename, file.errorString())); return false; } QTextStream ts(&file); QByteArray codecName; if (!cd.m_codecForSource.isEmpty()) codecName = cd.m_codecForSource; else codecName = translator.codecName(); // Just because it should be latin1 already ts.setCodec(QTextCodec::codecForName(codecName)); ts.setAutoDetectUnicode(true); QString code = ts.readAll(); QScriptParser parser; QScript::Lexer lexer(&parser); lexer.setCode(code, filename, /*lineNumber=*/1); parser.setLexer(&lexer); parser.setTranslator(&translator); if (!parser.parse()) { std::cerr << qPrintable(filename) << ':' << parser.errorLineNumber() << ": " << qPrintable(parser.errorMessage()) << std::endl; return false; } // Java uses UTF-16 internally and Jambi makes UTF-8 for tr() purposes of it. translator.setCodecName("UTF-8"); return true; } QT_END_NAMESPACE ./