/**************************************************************************** | |
** | |
** 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$ | |
** | |
****************************************************************************/ | |
#include "lupdate.h" | |
#include <translator.h> | |
#include <QtCore/QDebug> | |
#include <QtCore/QFile> | |
#include <QtCore/QRegExp> | |
#include <QtCore/QStack> | |
#include <QtCore/QStack> | |
#include <QtCore/QString> | |
#include <QtCore/QTextCodec> | |
#include <QtCore/QCoreApplication> | |
#include <iostream> | |
#include <ctype.h> | |
QT_BEGIN_NAMESPACE | |
class LU { | |
Q_DECLARE_TR_FUNCTIONS(LUpdate) | |
}; | |
enum { Tok_Eof, Tok_class, Tok_return, Tok_tr, | |
Tok_translate, Tok_Ident, Tok_Package, | |
Tok_Comment, Tok_String, Tok_Colon, Tok_Dot, | |
Tok_LeftBrace, Tok_RightBrace, Tok_LeftParen, | |
Tok_RightParen, Tok_Comma, Tok_Semicolon, | |
Tok_Integer, Tok_Plus, Tok_PlusPlus, Tok_PlusEq, Tok_null }; | |
class Scope | |
{ | |
public: | |
QString name; | |
enum Type {Clazz, Function, Other} type; | |
int line; | |
Scope(const QString & name, Type type, int line) : | |
name(name), | |
type(type), | |
line(line) | |
{} | |
~Scope() | |
{} | |
}; | |
/* | |
The tokenizer maintains the following global variables. The names | |
should be self-explanatory. | |
*/ | |
static QString yyFileName; | |
static QChar yyCh; | |
static QString yyIdent; | |
static QString yyComment; | |
static QString yyString; | |
static qlonglong yyInteger; | |
static int yyParenDepth; | |
static int yyLineNo; | |
static int yyCurLineNo; | |
static int yyParenLineNo; | |
static int yyTok; | |
// the string to read from and current position in the string | |
static QString yyInStr; | |
static int yyInPos; | |
// The parser maintains the following global variables. | |
static QString yyPackage; | |
static QStack<Scope*> yyScope; | |
static QString yyDefaultContext; | |
std::ostream &yyMsg(int line = 0) | |
{ | |
return std::cerr << qPrintable(yyFileName) << ':' << (line ? line : yyLineNo) << ": "; | |
} | |
static QChar getChar() | |
{ | |
if (yyInPos >= yyInStr.size()) | |
return EOF; | |
QChar c = yyInStr[yyInPos++]; | |
if (c.unicode() == '\n') | |
++yyCurLineNo; | |
return c.unicode(); | |
} | |
static int getToken() | |
{ | |
const char tab[] = "bfnrt\"\'\\"; | |
const char backTab[] = "\b\f\n\r\t\"\'\\"; | |
yyIdent.clear(); | |
yyComment.clear(); | |
yyString.clear(); | |
while ( yyCh != EOF ) { | |
yyLineNo = yyCurLineNo; | |
if ( yyCh.isLetter() || yyCh.toLatin1() == '_' ) { | |
do { | |
yyIdent.append(yyCh); | |
yyCh = getChar(); | |
} while ( yyCh.isLetterOrNumber() || yyCh.toLatin1() == '_' ); | |
if (yyTok != Tok_Dot) { | |
switch ( yyIdent.at(0).toLatin1() ) { | |
case 'r': | |
if ( yyIdent == QLatin1String("return") ) | |
return Tok_return; | |
break; | |
case 'c': | |
if ( yyIdent == QLatin1String("class") ) | |
return Tok_class; | |
break; | |
case 'n': | |
if ( yyIdent == QLatin1String("null") ) | |
return Tok_null; | |
break; | |
} | |
} | |
switch ( yyIdent.at(0).toLatin1() ) { | |
case 'T': | |
// TR() for when all else fails | |
if ( yyIdent == QLatin1String("TR") ) | |
return Tok_tr; | |
break; | |
case 'p': | |
if( yyIdent == QLatin1String("package") ) | |
return Tok_Package; | |
break; | |
case 't': | |
if ( yyIdent == QLatin1String("tr") ) | |
return Tok_tr; | |
if ( yyIdent == QLatin1String("translate") ) | |
return Tok_translate; | |
} | |
return Tok_Ident; | |
} else { | |
switch ( yyCh.toLatin1() ) { | |
case '/': | |
yyCh = getChar(); | |
if ( yyCh == QLatin1Char('/') ) { | |
do { | |
yyCh = getChar(); | |
if (yyCh == EOF) | |
break; | |
yyComment.append(yyCh); | |
} while (yyCh != QLatin1Char('\n')); | |
return Tok_Comment; | |
} else if ( yyCh == QLatin1Char('*') ) { | |
bool metAster = false; | |
bool metAsterSlash = false; | |
while ( !metAsterSlash ) { | |
yyCh = getChar(); | |
if ( yyCh == EOF ) { | |
yyMsg() << qPrintable(LU::tr("Unterminated Java comment.\n")); | |
return Tok_Comment; | |
} | |
yyComment.append( yyCh ); | |
if ( yyCh == QLatin1Char('*') ) | |
metAster = true; | |
else if ( metAster && yyCh == QLatin1Char('/') ) | |
metAsterSlash = true; | |
else | |
metAster = false; | |
} | |
yyComment.chop(2); | |
yyCh = getChar(); | |
return Tok_Comment; | |
} | |
break; | |
case '"': | |
yyCh = getChar(); | |
while ( yyCh != EOF && yyCh != QLatin1Char('\n') && yyCh != QLatin1Char('"') ) { | |
if ( yyCh == QLatin1Char('\\') ) { | |
yyCh = getChar(); | |
if ( yyCh == QLatin1Char('u') ) { | |
yyCh = getChar(); | |
uint unicode(0); | |
for (int i = 4; i > 0; --i) { | |
unicode = unicode << 4; | |
if( yyCh.isDigit() ) { | |
unicode += yyCh.digitValue(); | |
} | |
else { | |
int sub(yyCh.toLower().toAscii() - 87); | |
if( sub > 15 || sub < 10) { | |
yyMsg() << qPrintable(LU::tr("Invalid Unicode value.\n")); | |
break; | |
} | |
unicode += sub; | |
} | |
yyCh = getChar(); | |
} | |
yyString.append(QChar(unicode)); | |
} | |
else if ( yyCh == QLatin1Char('\n') ) { | |
yyCh = getChar(); | |
} | |
else { | |
yyString.append( QLatin1Char(backTab[strchr( tab, yyCh.toAscii() ) - tab]) ); | |
yyCh = getChar(); | |
} | |
} else { | |
yyString.append(yyCh); | |
yyCh = getChar(); | |
} | |
} | |
if ( yyCh != QLatin1Char('"') ) | |
yyMsg() << qPrintable(LU::tr("Unterminated string.\n")); | |
yyCh = getChar(); | |
return Tok_String; | |
case ':': | |
yyCh = getChar(); | |
return Tok_Colon; | |
case '\'': | |
yyCh = getChar(); | |
if ( yyCh == QLatin1Char('\\') ) | |
yyCh = getChar(); | |
do { | |
yyCh = getChar(); | |
} while ( yyCh != EOF && yyCh != QLatin1Char('\'') ); | |
yyCh = getChar(); | |
break; | |
case '{': | |
yyCh = getChar(); | |
return Tok_LeftBrace; | |
case '}': | |
yyCh = getChar(); | |
return Tok_RightBrace; | |
case '(': | |
if (yyParenDepth == 0) | |
yyParenLineNo = yyCurLineNo; | |
yyParenDepth++; | |
yyCh = getChar(); | |
return Tok_LeftParen; | |
case ')': | |
if (yyParenDepth == 0) | |
yyParenLineNo = yyCurLineNo; | |
yyParenDepth--; | |
yyCh = getChar(); | |
return Tok_RightParen; | |
case ',': | |
yyCh = getChar(); | |
return Tok_Comma; | |
case '.': | |
yyCh = getChar(); | |
return Tok_Dot; | |
case ';': | |
yyCh = getChar(); | |
return Tok_Semicolon; | |
case '+': | |
yyCh = getChar(); | |
if (yyCh == QLatin1Char('+')) { | |
yyCh = getChar(); | |
return Tok_PlusPlus; | |
} | |
if( yyCh == QLatin1Char('=') ){ | |
yyCh = getChar(); | |
return Tok_PlusEq; | |
} | |
return Tok_Plus; | |
case '0': | |
case '1': | |
case '2': | |
case '3': | |
case '4': | |
case '5': | |
case '6': | |
case '7': | |
case '8': | |
case '9': | |
{ | |
QByteArray ba; | |
ba += yyCh.toLatin1(); | |
yyCh = getChar(); | |
bool hex = yyCh == QLatin1Char('x'); | |
if ( hex ) { | |
ba += yyCh.toLatin1(); | |
yyCh = getChar(); | |
} | |
while ( hex ? isxdigit(yyCh.toLatin1()) : yyCh.isDigit() ) { | |
ba += yyCh.toLatin1(); | |
yyCh = getChar(); | |
} | |
bool ok; | |
yyInteger = ba.toLongLong(&ok); | |
if (ok) return Tok_Integer; | |
break; | |
} | |
default: | |
yyCh = getChar(); | |
} | |
} | |
} | |
return Tok_Eof; | |
} | |
static bool match( int t ) | |
{ | |
bool matches = ( yyTok == t ); | |
if ( matches ) | |
yyTok = getToken(); | |
return matches; | |
} | |
static bool matchString( QString &s ) | |
{ | |
if ( yyTok != Tok_String ) | |
return false; | |
s = yyString; | |
yyTok = getToken(); | |
while ( yyTok == Tok_Plus ) { | |
yyTok = getToken(); | |
if (yyTok == Tok_String) | |
s += yyString; | |
else { | |
yyMsg() << qPrintable(LU::tr( | |
"String used in translation can contain only literals" | |
" concatenated with other literals, not expressions or numbers.\n")); | |
return false; | |
} | |
yyTok = getToken(); | |
} | |
return true; | |
} | |
static bool matchStringOrNull(QString &s) | |
{ | |
bool matches = matchString(s); | |
if (!matches) { | |
matches = (yyTok == Tok_null); | |
if (matches) | |
yyTok = getToken(); | |
} | |
return matches; | |
} | |
/* | |
* match any expression that can return a number, which can be | |
* 1. Literal number (e.g. '11') | |
* 2. simple identifier (e.g. 'm_count') | |
* 3. simple function call (e.g. 'size()' ) | |
* 4. function call on an object (e.g. 'list.size()') | |
* 5. function call on an object (e.g. 'list->size()') | |
* | |
* Other cases: | |
* size(2,4) | |
* list().size() | |
* list(a,b).size(2,4) | |
* etc... | |
*/ | |
static bool matchExpression() | |
{ | |
if (match(Tok_Integer)) { | |
return true; | |
} | |
int parenlevel = 0; | |
while (match(Tok_Ident) || parenlevel > 0) { | |
if (yyTok == Tok_RightParen) { | |
if (parenlevel == 0) break; | |
--parenlevel; | |
yyTok = getToken(); | |
} else if (yyTok == Tok_LeftParen) { | |
yyTok = getToken(); | |
if (yyTok == Tok_RightParen) { | |
yyTok = getToken(); | |
} else { | |
++parenlevel; | |
} | |
} else if (yyTok == Tok_Ident) { | |
continue; | |
} else if (parenlevel == 0) { | |
return false; | |
} | |
} | |
return true; | |
} | |
static const QString context() | |
{ | |
QString context(yyPackage); | |
bool innerClass = false; | |
for (int i = 0; i < yyScope.size(); ++i) { | |
if (yyScope.at(i)->type == Scope::Clazz) { | |
if (innerClass) | |
context.append(QLatin1String("$")); | |
else | |
context.append(QLatin1String(".")); | |
context.append(yyScope.at(i)->name); | |
innerClass = true; | |
} | |
} | |
return context.isEmpty() ? yyDefaultContext : context; | |
} | |
static void recordMessage( | |
Translator *tor, const QString &context, const QString &text, const QString &comment, | |
const QString &extracomment, bool plural) | |
{ | |
TranslatorMessage msg( | |
context, text, comment, QString(), | |
yyFileName, yyLineNo, QStringList(), | |
TranslatorMessage::Unfinished, plural); | |
msg.setExtraComment(extracomment.simplified()); | |
tor->extend(msg); | |
} | |
static void parse( Translator *tor ) | |
{ | |
QString text; | |
QString com; | |
QString extracomment; | |
yyCh = getChar(); | |
yyTok = getToken(); | |
while ( yyTok != Tok_Eof ) { | |
switch ( yyTok ) { | |
case Tok_class: | |
yyTok = getToken(); | |
if(yyTok == Tok_Ident) { | |
yyScope.push(new Scope(yyIdent, Scope::Clazz, yyLineNo)); | |
} | |
else { | |
yyMsg() << qPrintable(LU::tr("'class' must be followed by a class name.\n")); | |
break; | |
} | |
while (!match(Tok_LeftBrace)) { | |
yyTok = getToken(); | |
} | |
break; | |
case Tok_tr: | |
yyTok = getToken(); | |
if ( match(Tok_LeftParen) && matchString(text) ) { | |
com.clear(); | |
bool plural = false; | |
if ( match(Tok_RightParen) ) { | |
// no comment | |
} else if (match(Tok_Comma) && matchStringOrNull(com)) { //comment | |
if ( match(Tok_RightParen)) { | |
// ok, | |
} else if (match(Tok_Comma)) { | |
plural = true; | |
} | |
} | |
if (!text.isEmpty()) | |
recordMessage(tor, context(), text, com, extracomment, plural); | |
} | |
break; | |
case Tok_translate: | |
{ | |
QString contextOverride; | |
yyTok = getToken(); | |
if ( match(Tok_LeftParen) && | |
matchString(contextOverride) && | |
match(Tok_Comma) && | |
matchString(text) ) { | |
com.clear(); | |
bool plural = false; | |
if (!match(Tok_RightParen)) { | |
// look for comment | |
if ( match(Tok_Comma) && matchStringOrNull(com)) { | |
if (!match(Tok_RightParen)) { | |
if (match(Tok_Comma) && matchExpression() && match(Tok_RightParen)) { | |
plural = true; | |
} else { | |
break; | |
} | |
} | |
} else { | |
break; | |
} | |
} | |
if (!text.isEmpty()) | |
recordMessage(tor, contextOverride, text, com, extracomment, plural); | |
} | |
} | |
break; | |
case Tok_Ident: | |
yyTok = getToken(); | |
break; | |
case Tok_Comment: | |
if (yyComment.startsWith(QLatin1Char(':'))) { | |
yyComment.remove(0, 1); | |
extracomment.append(yyComment); | |
} | |
yyTok = getToken(); | |
break; | |
case Tok_RightBrace: | |
if ( yyScope.isEmpty() ) { | |
yyMsg() << qPrintable(LU::tr("Excess closing brace.\n")); | |
} | |
else | |
delete (yyScope.pop()); | |
extracomment.clear(); | |
yyTok = getToken(); | |
break; | |
case Tok_LeftBrace: | |
yyScope.push(new Scope(QString(), Scope::Other, yyLineNo)); | |
yyTok = getToken(); | |
break; | |
case Tok_Semicolon: | |
extracomment.clear(); | |
yyTok = getToken(); | |
break; | |
case Tok_Package: | |
yyTok = getToken(); | |
while(!match(Tok_Semicolon)) { | |
switch(yyTok) { | |
case Tok_Ident: | |
yyPackage.append(yyIdent); | |
break; | |
case Tok_Dot: | |
yyPackage.append(QLatin1String(".")); | |
break; | |
default: | |
yyMsg() << qPrintable(LU::tr("'package' must be followed by package name.\n")); | |
break; | |
} | |
yyTok = getToken(); | |
} | |
break; | |
default: | |
yyTok = getToken(); | |
} | |
} | |
if ( !yyScope.isEmpty() ) | |
yyMsg(yyScope.top()->line) << qPrintable(LU::tr("Unbalanced opening brace.\n")); | |
else if ( yyParenDepth != 0 ) | |
yyMsg(yyParenLineNo) << qPrintable(LU::tr("Unbalanced opening parenthesis.\n")); | |
} | |
bool loadJava(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; | |
} | |
yyDefaultContext = cd.m_defaultContext; | |
yyInPos = -1; | |
yyFileName = filename; | |
yyPackage.clear(); | |
yyScope.clear(); | |
yyTok = -1; | |
yyParenDepth = 0; | |
yyCurLineNo = 0; | |
yyParenLineNo = 1; | |
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); | |
yyInStr = ts.readAll(); | |
yyInPos = 0; | |
yyFileName = filename; | |
yyCurLineNo = 1; | |
yyParenLineNo = 1; | |
parse(&translator); | |
// Java uses UTF-16 internally and Jambi makes UTF-8 for tr() purposes of it. | |
translator.setCodecName("UTF-8"); | |
return true; | |
} | |
QT_END_NAMESPACE |