summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/tools/linguist/lupdate
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/tools/linguist/lupdate')
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/fetchtr.cpp824
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/lupdate.pro21
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/main.cpp241
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/merge.cpp129
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/numberh.cpp248
-rw-r--r--tqtinterface/qt4/tools/linguist/lupdate/sametexth.cpp97
6 files changed, 1560 insertions, 0 deletions
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/fetchtr.cpp b/tqtinterface/qt4/tools/linguist/lupdate/fetchtr.cpp
new file mode 100644
index 0000000..3d3f185
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/fetchtr.cpp
@@ -0,0 +1,824 @@
+/**********************************************************************
+** Copyright (C) 2005-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of TQt Linguist.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** Licensees holding valid TQt Commercial licenses may use this file in
+** accordance with the TQt Commercial License Agreement provided with
+** the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <metatranslator.h>
+
+#include <tqfile.h>
+#include <tqregexp.h>
+#include <tqstring.h>
+#include <tqtextstream.h>
+#include <tqvaluestack.h>
+#include <tqxml.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+/* qmake ignore TQ_OBJECT */
+
+static const char MagicComment[] = "TRANSLATOR ";
+
+static TQMap<TQCString, int> needs_TQ_OBJECT;
+static TQMap<TQCString, int> lacks_TQ_OBJECT;
+
+/*
+ The first part of this source file is the C++ tokenizer. We skip
+ most of C++; the only tokens that interest us are defined here.
+ Thus, the code fragment
+
+ int main()
+ {
+ printf( "Hello, world!\n" );
+ return 0;
+ }
+
+ is broken down into the following tokens (Tok_ omitted):
+
+ Ident Ident LeftParen RightParen
+ LeftBrace
+ Ident LeftParen String RightParen Semicolon
+ return Semicolon
+ RightBrace.
+
+ The 0 doesn't produce any token.
+*/
+
+enum { Tok_Eof, Tok_class, Tok_namespace, Tok_return, Tok_tr,
+ Tok_trUtf8, Tok_translate, Tok_TQ_OBJECT, Tok_Ident,
+ Tok_Comment, Tok_String, Tok_Arrow, Tok_Colon,
+ Tok_Gulbrandsen, Tok_LeftBrace, Tok_RightBrace, Tok_LeftParen,
+ Tok_RightParen, Tok_Comma, Tok_Semicolon };
+
+/*
+ The tokenizer maintains the following global variables. The names
+ should be self-explanatory.
+*/
+static TQCString yyFileName;
+static int yyCh;
+static char yyIdent[128];
+static size_t yyIdentLen;
+static char yyComment[65536];
+static size_t yyCommentLen;
+static char yyString[65536];
+static size_t yyStringLen;
+static TQValueStack<int> yySavedBraceDepth;
+static TQValueStack<int> yySavedParenDepth;
+static int yyBraceDepth;
+static int yyParenDepth;
+static int yyLineNo;
+static int yyCurLineNo;
+static int yyBraceLineNo;
+static int yyParenLineNo;
+
+// the file to read from (if reading from a file)
+static FILE *yyInFile;
+
+// the string to read from and current position in the string (otherwise)
+static TQString yyInStr;
+static int yyInPos;
+
+static int (*getChar)();
+
+static int getCharFromFile()
+{
+ int c = getc( yyInFile );
+ if ( c == '\n' )
+ yyCurLineNo++;
+ return c;
+}
+
+static int getCharFromString()
+{
+ if ( yyInPos == (int) yyInStr.length() ) {
+ return EOF;
+ } else {
+ return yyInStr[yyInPos++].latin1();
+ }
+}
+
+static void startTokenizer( const char *fileName, int (*getCharFunc)() )
+{
+ yyInPos = 0;
+ getChar = getCharFunc;
+
+ yyFileName = fileName;
+ yyCh = getChar();
+ yySavedBraceDepth.clear();
+ yySavedParenDepth.clear();
+ yyBraceDepth = 0;
+ yyParenDepth = 0;
+ yyCurLineNo = 1;
+ yyBraceLineNo = 1;
+ yyParenLineNo = 1;
+}
+
+static int getToken()
+{
+ const char tab[] = "abfnrtv";
+ const char backTab[] = "\a\b\f\n\r\t\v";
+ uint n;
+
+ yyIdentLen = 0;
+ yyCommentLen = 0;
+ yyStringLen = 0;
+
+ while ( yyCh != EOF ) {
+ yyLineNo = yyCurLineNo;
+
+ if ( isalpha(yyCh) || yyCh == '_' ) {
+ do {
+ if ( yyIdentLen < sizeof(yyIdent) - 1 )
+ yyIdent[yyIdentLen++] = (char) yyCh;
+ yyCh = getChar();
+ } while ( isalnum(yyCh) || yyCh == '_' );
+ yyIdent[yyIdentLen] = '\0';
+
+ switch ( yyIdent[0] ) {
+ case 'Q':
+ if ( strcmp(yyIdent + 1, "_OBJECT") == 0 ) {
+ return Tok_TQ_OBJECT;
+ } else if ( strcmp(yyIdent + 1, "T_TR_NOOP") == 0 ) {
+ return Tok_tr;
+ } else if ( strcmp(yyIdent + 1, "T_TRANSLATE_NOOP") == 0 ) {
+ return Tok_translate;
+ }
+ break;
+ case 'T':
+ // TR() for when all else fails
+ if ( qstricmp(yyIdent + 1, "R") == 0 )
+ return Tok_tr;
+ break;
+ case 'c':
+ if ( strcmp(yyIdent + 1, "lass") == 0 )
+ return Tok_class;
+ break;
+ case 'f':
+ /*
+ TQTranslator::tqfindMessage() has the same parameters as
+ TQApplication::translate().
+ */
+ if ( strcmp(yyIdent + 1, "indMessage") == 0 )
+ return Tok_translate;
+ break;
+ case 'n':
+ if ( strcmp(yyIdent + 1, "amespace") == 0 )
+ return Tok_namespace;
+ break;
+ case 'r':
+ if ( strcmp(yyIdent + 1, "eturn") == 0 )
+ return Tok_return;
+ break;
+ case 's':
+ if ( strcmp(yyIdent + 1, "truct") == 0 )
+ return Tok_class;
+ break;
+ case 't':
+ if ( strcmp(yyIdent + 1, "r") == 0 ) {
+ return Tok_tr;
+ } else if ( qstrcmp(yyIdent + 1, "rUtf8") == 0 ) {
+ return Tok_trUtf8;
+ } else if ( qstrcmp(yyIdent + 1, "ranslate") == 0 ) {
+ return Tok_translate;
+ }
+ }
+ return Tok_Ident;
+ } else {
+ switch ( yyCh ) {
+ case '#':
+ /*
+ Early versions of lupdate complained about
+ unbalanced braces in the following code:
+
+ #ifdef ALPHA
+ while ( beta ) {
+ #else
+ while ( gamma ) {
+ #endif
+ delta;
+ }
+
+ The code tqcontains, indeed, two opening braces for
+ one closing brace; yet there's no reason to panic.
+
+ The solution is to remember yyBraceDepth as it was
+ when #if, #ifdef or #ifndef was met, and to set
+ yyBraceDepth to that value when meeting #elif or
+ #else.
+ */
+ do {
+ yyCh = getChar();
+ } while ( isspace(yyCh) && yyCh != '\n' );
+
+ switch ( yyCh ) {
+ case 'i':
+ yyCh = getChar();
+ if ( yyCh == 'f' ) {
+ // if, ifdef, ifndef
+ yySavedBraceDepth.push( yyBraceDepth );
+ yySavedParenDepth.push( yyParenDepth );
+ }
+ break;
+ case 'e':
+ yyCh = getChar();
+ if ( yyCh == 'l' ) {
+ // elif, else
+ if ( !yySavedBraceDepth.isEmpty() ) {
+ yyBraceDepth = yySavedBraceDepth.top();
+ yyParenDepth = yySavedParenDepth.top();
+ }
+ } else if ( yyCh == 'n' ) {
+ // endif
+ if ( !yySavedBraceDepth.isEmpty() ) {
+ yySavedBraceDepth.pop();
+ yySavedParenDepth.pop();
+ }
+ }
+ }
+ while ( isalnum(yyCh) || yyCh == '_' )
+ yyCh = getChar();
+ break;
+ case '/':
+ yyCh = getChar();
+ if ( yyCh == '/' ) {
+ do {
+ yyCh = getChar();
+ } while ( yyCh != EOF && yyCh != '\n' );
+ } else if ( yyCh == '*' ) {
+ bool metAster = FALSE;
+ bool metAsterSlash = FALSE;
+
+ while ( !metAsterSlash ) {
+ yyCh = getChar();
+ if ( yyCh == EOF ) {
+ fprintf( stderr,
+ "%s: Unterminated C++ comment starting at"
+ " line %d\n",
+ (const char *) yyFileName, yyLineNo );
+ yyComment[yyCommentLen] = '\0';
+ return Tok_Comment;
+ }
+ if ( yyCommentLen < sizeof(yyComment) - 1 )
+ yyComment[yyCommentLen++] = (char) yyCh;
+
+ if ( yyCh == '*' )
+ metAster = TRUE;
+ else if ( metAster && yyCh == '/' )
+ metAsterSlash = TRUE;
+ else
+ metAster = FALSE;
+ }
+ yyCh = getChar();
+ yyCommentLen -= 2;
+ yyComment[yyCommentLen] = '\0';
+ return Tok_Comment;
+ }
+ break;
+ case '"':
+ yyCh = getChar();
+
+ while ( yyCh != EOF && yyCh != '\n' && yyCh != '"' ) {
+ if ( yyCh == '\\' ) {
+ yyCh = getChar();
+
+ if ( yyCh == '\n' ) {
+ yyCh = getChar();
+ } else if ( yyCh == 'x' ) {
+ TQCString hex = "0";
+
+ yyCh = getChar();
+ while ( isxdigit(yyCh) ) {
+ hex += (char) yyCh;
+ yyCh = getChar();
+ }
+ sscanf( hex, "%x", &n );
+ if ( yyStringLen < sizeof(yyString) - 1 )
+ yyString[yyStringLen++] = (char) n;
+ } else if ( yyCh >= '0' && yyCh < '8' ) {
+ TQCString oct = "";
+
+ do {
+ oct += (char) yyCh;
+ yyCh = getChar();
+ } while ( yyCh >= '0' && yyCh < '8' );
+ sscanf( oct, "%o", &n );
+ if ( yyStringLen < sizeof(yyString) - 1 )
+ yyString[yyStringLen++] = (char) n;
+ } else {
+ const char *p = strchr( tab, yyCh );
+ if ( yyStringLen < sizeof(yyString) - 1 )
+ yyString[yyStringLen++] = ( p == 0 ) ?
+ (char) yyCh : backTab[p - tab];
+ yyCh = getChar();
+ }
+ } else {
+ if ( yyStringLen < sizeof(yyString) - 1 )
+ yyString[yyStringLen++] = (char) yyCh;
+ yyCh = getChar();
+ }
+ }
+ yyString[yyStringLen] = '\0';
+
+ if ( yyCh != '"' )
+ qWarning( "%s:%d: Unterminated C++ string",
+ (const char *) yyFileName, yyLineNo );
+
+ if ( yyCh == EOF ) {
+ return Tok_Eof;
+ } else {
+ yyCh = getChar();
+ return Tok_String;
+ }
+ break;
+ case '-':
+ yyCh = getChar();
+ if ( yyCh == '>' ) {
+ yyCh = getChar();
+ return Tok_Arrow;
+ }
+ break;
+ case ':':
+ yyCh = getChar();
+ if ( yyCh == ':' ) {
+ yyCh = getChar();
+ return Tok_Gulbrandsen;
+ }
+ return Tok_Colon;
+ case '\'':
+ yyCh = getChar();
+ if ( yyCh == '\\' )
+ yyCh = getChar();
+
+ do {
+ yyCh = getChar();
+ } while ( yyCh != EOF && yyCh != '\'' );
+ yyCh = getChar();
+ break;
+ case '{':
+ if (yyBraceDepth == 0)
+ yyBraceLineNo = yyCurLineNo;
+ yyBraceDepth++;
+ yyCh = getChar();
+ return Tok_LeftBrace;
+ case '}':
+ if (yyBraceDepth == 0)
+ yyBraceLineNo = yyCurLineNo;
+ yyBraceDepth--;
+ 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_Semicolon;
+ default:
+ yyCh = getChar();
+ }
+ }
+ }
+ return Tok_Eof;
+}
+
+/*
+ The second part of this source file is the parser. It accomplishes
+ a very easy task: It tqfinds all strings inside a tr() or translate()
+ call, and possibly tqfinds out the context of the call. It supports
+ three cases: (1) the context is specified, as in
+ FunnyDialog::tr("Hello") or translate("FunnyDialog", "Hello");
+ (2) the call appears within an inlined function; (3) the call
+ appears within a function defined outside the class definition.
+*/
+
+static int yyTok;
+
+static bool match( int t )
+{
+ bool matches = ( yyTok == t );
+ if ( matches )
+ yyTok = getToken();
+ return matches;
+}
+
+static bool matchString( TQCString *s )
+{
+ bool matches = ( yyTok == Tok_String );
+ *s = "";
+ while ( yyTok == Tok_String ) {
+ *s += yyString;
+ yyTok = getToken();
+ }
+ return matches;
+}
+
+static bool matchEncoding( bool *utf8 )
+{
+ if ( yyTok == Tok_Ident ) {
+ if ( strcmp(yyIdent, "TQApplication") == 0 ) {
+ yyTok = getToken();
+ if ( yyTok == Tok_Gulbrandsen )
+ yyTok = getToken();
+ }
+ *utf8 = TQString( yyIdent ).endsWith( TQString("UTF8") );
+ yyTok = getToken();
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+static void parse( MetaTranslator *tor, const char *initialContext,
+ const char *defaultContext )
+{
+ TQMap<TQCString, TQCString> qualifiedContexts;
+ TQStringList namespaces;
+ TQCString context;
+ TQCString text;
+ TQCString com;
+ TQCString functionContext = initialContext;
+ TQCString prefix;
+ bool utf8 = FALSE;
+ bool missing_TQ_OBJECT = FALSE;
+
+ yyTok = getToken();
+ while ( yyTok != Tok_Eof ) {
+ switch ( yyTok ) {
+ case Tok_class:
+ /*
+ Partial support for inlined functions.
+ */
+ yyTok = getToken();
+ if ( yyBraceDepth == (int) namespaces.count() &&
+ yyParenDepth == 0 ) {
+ do {
+ /*
+ This code should execute only once, but we play
+ safe with impure definitions such as
+ 'class TQ_EXPORT TQMessageBox', in which case
+ 'TQMessageBox' is the class name, not 'TQ_EXPORT'.
+ */
+ functionContext = yyIdent;
+ yyTok = getToken();
+ } while ( yyTok == Tok_Ident );
+
+ while ( yyTok == Tok_Gulbrandsen ) {
+ yyTok = getToken();
+ functionContext += "::";
+ functionContext += yyIdent;
+ yyTok = getToken();
+ }
+
+ if ( yyTok == Tok_Colon ) {
+ missing_TQ_OBJECT = TRUE;
+ } else {
+ functionContext = defaultContext;
+ }
+ }
+ break;
+ case Tok_namespace:
+ yyTok = getToken();
+ if ( yyTok == Tok_Ident ) {
+ TQCString ns = yyIdent;
+ yyTok = getToken();
+ if ( yyTok == Tok_LeftBrace &&
+ yyBraceDepth == (int) namespaces.count() + 1 )
+ namespaces.append( TQString(ns) );
+ }
+ break;
+ case Tok_tr:
+ case Tok_trUtf8:
+ utf8 = ( yyTok == Tok_trUtf8 );
+ yyTok = getToken();
+ if ( match(Tok_LeftParen) && matchString(&text) ) {
+ com = "";
+ if ( match(Tok_RightParen) || (match(Tok_Comma) &&
+ matchString(&com) && match(Tok_RightParen)) ) {
+ if ( prefix.isNull() ) {
+ context = functionContext;
+ if ( !namespaces.isEmpty() )
+ context.prepend( (namespaces.join(TQString("::")) +
+ TQString("::")).latin1() );
+ } else {
+ context = prefix;
+ }
+ prefix = (const char *) 0;
+
+ if ( qualifiedContexts.tqcontains(context) )
+ context = qualifiedContexts[context];
+ tor->insert( MetaTranslatorMessage(context, text, com,
+ TQString(), utf8) );
+
+ if ( lacks_TQ_OBJECT.tqcontains(context) ) {
+ qWarning( "%s:%d: Class '%s' lacks TQ_OBJECT macro",
+ (const char *) yyFileName, yyLineNo,
+ (const char *) context );
+ lacks_TQ_OBJECT.remove( context );
+ } else {
+ needs_TQ_OBJECT.insert( context, 0 );
+ }
+ }
+ }
+ break;
+ case Tok_translate:
+ utf8 = FALSE;
+ yyTok = getToken();
+ if ( match(Tok_LeftParen) &&
+ matchString(&context) &&
+ match(Tok_Comma) &&
+ matchString(&text) ) {
+ com = "";
+ if ( match(Tok_RightParen) ||
+ (match(Tok_Comma) &&
+ matchString(&com) &&
+ (match(Tok_RightParen) ||
+ match(Tok_Comma) &&
+ matchEncoding(&utf8) &&
+ match(Tok_RightParen))) )
+ tor->insert( MetaTranslatorMessage(context, text, com,
+ TQString(), utf8) );
+ }
+ break;
+ case Tok_TQ_OBJECT:
+ missing_TQ_OBJECT = FALSE;
+ yyTok = getToken();
+ break;
+ case Tok_Ident:
+ if ( !prefix.isNull() )
+ prefix += "::";
+ prefix += yyIdent;
+ yyTok = getToken();
+ if ( yyTok != Tok_Gulbrandsen )
+ prefix = (const char *) 0;
+ break;
+ case Tok_Comment:
+ com = yyComment;
+ com = com.simplifyWhiteSpace();
+ if ( com.left(sizeof(MagicComment) - 1) == MagicComment ) {
+ com.remove( 0, sizeof(MagicComment) - 1 );
+ int k = com.tqfind( ' ' );
+ if ( k == -1 ) {
+ context = com;
+ } else {
+ context = com.left( k );
+ com.remove( 0, k + 1 );
+ tor->insert( MetaTranslatorMessage(context, "", com,
+ TQString(), FALSE) );
+ }
+
+ /*
+ Provide a backdoor for people using "using
+ namespace". See the manual for details.
+ */
+ k = 0;
+ while ( (k = context.tqfind("::", k)) != -1 ) {
+ qualifiedContexts.insert( context.mid(k + 2), context );
+ k++;
+ }
+ }
+ yyTok = getToken();
+ break;
+ case Tok_Arrow:
+ yyTok = getToken();
+ if ( yyTok == Tok_tr || yyTok == Tok_trUtf8 )
+ qWarning( "%s:%d: Cannot invoke tr() like this",
+ (const char *) yyFileName, yyLineNo );
+ break;
+ case Tok_Gulbrandsen:
+ // at top level?
+ if ( yyBraceDepth == (int) namespaces.count() && yyParenDepth == 0 )
+ functionContext = prefix;
+ yyTok = getToken();
+ break;
+ case Tok_RightBrace:
+ case Tok_Semicolon:
+ if ( yyBraceDepth >= 0 &&
+ yyBraceDepth + 1 == (int) namespaces.count() )
+ namespaces.remove( namespaces.fromLast() );
+ if ( yyBraceDepth == (int) namespaces.count() ) {
+ if ( missing_TQ_OBJECT ) {
+ if ( needs_TQ_OBJECT.tqcontains(functionContext) ) {
+ qWarning( "%s:%d: Class '%s' lacks TQ_OBJECT macro",
+ (const char *) yyFileName, yyLineNo,
+ (const char *) functionContext );
+ } else {
+ lacks_TQ_OBJECT.insert( functionContext, 0 );
+ }
+ }
+ functionContext = defaultContext;
+ missing_TQ_OBJECT = FALSE;
+ }
+ yyTok = getToken();
+ break;
+ default:
+ yyTok = getToken();
+ }
+ }
+
+ if ( yyBraceDepth != 0 )
+ fprintf( stderr,
+ "%s:%d: Unbalanced braces in C++ code (or abuse of the C++"
+ " preprocessor)\n",
+ (const char *)yyFileName, yyBraceLineNo );
+ else if ( yyParenDepth != 0 )
+ fprintf( stderr,
+ "%s:%d: Unbalanced parentheses in C++ code (or abuse of the C++"
+ " preprocessor)\n",
+ (const char *)yyFileName, yyParenLineNo );
+}
+
+void fetchtr_cpp( const char *fileName, MetaTranslator *tor,
+ const char *defaultContext, bool mustExist )
+{
+ yyInFile = fopen( fileName, "r" );
+ if ( yyInFile == 0 ) {
+ if ( mustExist )
+ fprintf( stderr,
+ "lupdate error: Cannot open C++ source file '%s': %s\n",
+ fileName, strerror(errno) );
+ return;
+ }
+
+ startTokenizer( fileName, getCharFromFile );
+ parse( tor, 0, defaultContext );
+ fclose( yyInFile );
+}
+
+/*
+ In addition to C++, we support TQt Designer UI files.
+*/
+
+/*
+ Fetches tr() calls in C++ code in UI files (inside "<function>"
+ tag). This mechanism is obsolete.
+*/
+void fetchtr_inlined_cpp( const char *fileName, const TQString& in,
+ MetaTranslator *tor, const char *context )
+{
+ yyInStr = in;
+ startTokenizer( fileName, getCharFromString );
+ parse( tor, context, 0 );
+ yyInStr = TQString();
+}
+
+class UiHandler : public TQXmlDefaultHandler
+{
+public:
+ UiHandler( MetaTranslator *translator, const char *fileName )
+ : tor( translator ), fname( fileName ), comment( "" ) { }
+
+ virtual bool startElement( const TQString& namespaceURI,
+ const TQString& localName, const TQString& qName,
+ const TQXmlAttributes& atts );
+ virtual bool endElement( const TQString& namespaceURI,
+ const TQString& localName, const TQString& qName );
+ virtual bool characters( const TQString& ch );
+ virtual bool fatalError( const TQXmlParseException& exception );
+
+private:
+ void flush();
+
+ MetaTranslator *tor;
+ TQCString fname;
+ TQString context;
+ TQString source;
+ TQString comment;
+
+ TQString accum;
+};
+
+bool UiHandler::startElement( const TQString& /* namespaceURI */,
+ const TQString& /* localName */,
+ const TQString& qName,
+ const TQXmlAttributes& atts )
+{
+ if ( qName == TQString("item") ) {
+ flush();
+ if ( !atts.value(TQString("text")).isEmpty() )
+ source = atts.value( TQString("text") );
+ } else if ( qName == TQString("string") ) {
+ flush();
+ }
+ accum.truncate( 0 );
+ return TRUE;
+}
+
+bool UiHandler::endElement( const TQString& /* namespaceURI */,
+ const TQString& /* localName */,
+ const TQString& qName )
+{
+ accum.tqreplace( TQRegExp(TQString("\r\n")), "\n" );
+
+ if ( qName == TQString("class") ) {
+ if ( context.isEmpty() )
+ context = accum;
+ } else if ( qName == TQString("string") ) {
+ source = accum;
+ } else if ( qName == TQString("comment") ) {
+ comment = accum;
+ flush();
+ } else if ( qName == TQString("function") ) {
+ fetchtr_inlined_cpp( (const char *) fname, accum, tor,
+ context.latin1() );
+ } else {
+ flush();
+ }
+ return TRUE;
+}
+
+bool UiHandler::characters( const TQString& ch )
+{
+ accum += ch;
+ return TRUE;
+}
+
+bool UiHandler::fatalError( const TQXmlParseException& exception )
+{
+ TQString msg;
+ msg.sprintf( "Parse error at line %d, column %d (%s).",
+ exception.lineNumber(), exception.columnNumber(),
+ exception.message().latin1() );
+ fprintf( stderr, "XML error: %s\n", msg.latin1() );
+ return FALSE;
+}
+
+void UiHandler::flush()
+{
+ if ( !context.isEmpty() && !source.isEmpty() )
+ tor->insert( MetaTranslatorMessage(context.utf8(), source.utf8(),
+ comment.utf8(), TQString(),
+ TRUE) );
+ source.truncate( 0 );
+ comment.truncate( 0 );
+}
+
+void fetchtr_ui( const char *fileName, MetaTranslator *tor,
+ const char * /* defaultContext */, bool mustExist )
+{
+ TQFile f( fileName );
+ if ( !f.open(IO_ReadOnly) ) {
+ if ( mustExist )
+ fprintf( stderr, "lupdate error: cannot open UI file '%s': %s\n",
+ fileName, strerror(errno) );
+ return;
+ }
+
+ TQTextStream t( &f );
+ TQXmlInputSource in( t );
+ TQXmlSimpleReader reader;
+ reader.setFeature( "http://xml.org/sax/features/namespaces", FALSE );
+ reader.setFeature( "http://xml.org/sax/features/namespace-prefixes", TRUE );
+ reader.setFeature( "http://trolltech.com/xml/features/report-whitespace"
+ "-only-CharData", FALSE );
+ TQXmlDefaultHandler *hand = new UiHandler( tor, fileName );
+ reader.setContentHandler( hand );
+ reader.setErrorHandler( hand );
+
+ if ( !reader.parse(in) )
+ fprintf( stderr, "%s: Parse error in UI file\n", fileName );
+ reader.setContentHandler( 0 );
+ reader.setErrorHandler( 0 );
+ delete hand;
+ f.close();
+}
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/lupdate.pro b/tqtinterface/qt4/tools/linguist/lupdate/lupdate.pro
new file mode 100644
index 0000000..1dad999
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/lupdate.pro
@@ -0,0 +1,21 @@
+TEMPLATE = app
+CONFIG += qt warn_on console
+HEADERS = ../shared/metatranslator.h \
+ ../shared/proparser.h
+SOURCES = fetchtr.cpp \
+ main.cpp \
+ merge.cpp \
+ numberh.cpp \
+ sametexth.cpp \
+ ../shared/metatranslator.cpp \
+ ../shared/proparser.cpp
+
+DEFINES += QT_INTERNAL_XML
+include( ../../../src/qt_professional.pri )
+
+TARGET = lupdate
+INCLUDEPATH += ../shared
+DESTDIR = ../../../bin
+
+target.path=$$bins.path
+INSTALLS += target
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/main.cpp b/tqtinterface/qt4/tools/linguist/lupdate/main.cpp
new file mode 100644
index 0000000..4bc833d
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/main.cpp
@@ -0,0 +1,241 @@
+/**********************************************************************
+** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of TQt Linguist.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** Licensees holding valid TQt Commercial licenses may use this file in
+** accordance with the TQt Commercial License Agreement provided with
+** the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <metatranslator.h>
+#include <proparser.h>
+
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqfileinfo.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
+#include <tqtextstream.h>
+
+#include <errno.h>
+#include <string.h>
+
+// defined in fetchtr.cpp
+extern void fetchtr_cpp( const char *fileName, MetaTranslator *tor,
+ const char *defaultContext, bool mustExist );
+extern void fetchtr_ui( const char *fileName, MetaTranslator *tor,
+ const char *defaultContext, bool mustExist );
+
+// defined in merge.cpp
+extern void merge( MetaTranslator *tor, const MetaTranslator *virginTor,
+ bool verbose );
+
+typedef TQValueList<MetaTranslatorMessage> TML;
+
+static void printUsage()
+{
+ fprintf( stderr, "Usage:\n"
+ " lupdate [options] project-file\n"
+ " lupdate [options] source-files -ts ts-files\n"
+ "Options:\n"
+ " -help Display this information and exit\n"
+ " -noobsolete\n"
+ " Drop all obsolete strings\n"
+ " -verbose\n"
+ " Explain what is being done\n"
+ " -version\n"
+ " Display the version of lupdate and exit\n" );
+}
+
+static void updateTsFiles( const MetaTranslator& fetchedTor,
+ const TQStringList& tsFileNames, const TQString& codec,
+ bool noObsolete, bool verbose )
+{
+ TQStringList::ConstIterator t = tsFileNames.begin();
+ while ( t != tsFileNames.end() ) {
+ MetaTranslator tor;
+ tor.load( *t );
+ if ( !codec.isEmpty() )
+ tor.setCodec( codec );
+ if ( verbose )
+ fprintf( stderr, "Updating '%s'...\n", (*t).latin1() );
+ merge( &tor, &fetchedTor, verbose );
+ if ( noObsolete )
+ tor.stripObsoleteMessages();
+ tor.stripEmptyContexts();
+ if ( !tor.save(*t) )
+ fprintf( stderr, "lupdate error: Cannot save '%s': %s\n",
+ (*t).latin1(), strerror(errno) );
+ ++t;
+ }
+}
+
+int main( int argc, char **argv )
+{
+ TQString defaultContext = "@default";
+ MetaTranslator fetchedTor;
+ TQCString codec;
+ TQStringList tsFileNames;
+
+ bool verbose = FALSE;
+ bool noObsolete = FALSE;
+ bool metSomething = FALSE;
+ int numFiles = 0;
+ bool standardSyntax = TRUE;
+ bool metTsFlag = FALSE;
+
+ int i;
+
+ for ( i = 1; i < argc; i++ ) {
+ if ( qstrcmp(argv[i], "-ts") == 0 )
+ standardSyntax = FALSE;
+ }
+
+ for ( i = 1; i < argc; i++ ) {
+ if ( qstrcmp(argv[i], "-help") == 0 ) {
+ printUsage();
+ return 0;
+ } else if ( qstrcmp(argv[i], "-noobsolete") == 0 ) {
+ noObsolete = TRUE;
+ continue;
+ } else if ( qstrcmp(argv[i], "-verbose") == 0 ) {
+ verbose = TRUE;
+ continue;
+ } else if ( qstrcmp(argv[i], "-version") == 0 ) {
+ fprintf( stderr, "lupdate version %s\n", TQT_VERSION_STR );
+ return 0;
+ } else if ( qstrcmp(argv[i], "-ts") == 0 ) {
+ metTsFlag = TRUE;
+ continue;
+ }
+
+ numFiles++;
+
+ TQString fullText;
+
+ if ( !metTsFlag ) {
+ TQFile f( argv[i] );
+ if ( !f.open(IO_ReadOnly) ) {
+ fprintf( stderr, "lupdate error: Cannot open file '%s': %s\n",
+ argv[i], strerror(errno) );
+ return 1;
+ }
+
+ TQTextStream t( &f );
+ fullText = t.read();
+ f.close();
+ }
+
+ TQString oldDir = TQDir::currentDirPath();
+ TQDir::setCurrent( TQFileInfo(argv[i]).dirPath() );
+
+ if ( standardSyntax ) {
+ fetchedTor = MetaTranslator();
+ codec.truncate( 0 );
+ tsFileNames.clear();
+
+ TQMap<TQString, TQString> tagMap = proFileTagMap( fullText );
+ TQMap<TQString, TQString>::Iterator it;
+
+ for ( it = tagMap.begin(); it != tagMap.end(); ++it ) {
+ TQStringList toks = TQStringList::split( ' ', it.data() );
+ TQStringList::Iterator t;
+
+ for ( t = toks.begin(); t != toks.end(); ++t ) {
+ if ( it.key() == "HEADERS" || it.key() == "SOURCES" ) {
+ fetchtr_cpp( *t, &fetchedTor, defaultContext, TRUE );
+ metSomething = TRUE;
+ } else if ( it.key() == "INTERFACES" ||
+ it.key() == "FORMS" ) {
+ fetchtr_ui( *t, &fetchedTor, defaultContext, TRUE );
+ fetchtr_cpp( *t + ".h", &fetchedTor, defaultContext,
+ FALSE );
+ metSomething = TRUE;
+ } else if ( it.key() == "TRANSLATIONS" ) {
+ tsFileNames.append( *t );
+ metSomething = TRUE;
+ } else if ( it.key() == "CODEC" ||
+ it.key() == "DEFAULTCODEC" ) {
+ codec = (*t).latin1();
+ }
+ }
+ }
+
+ updateTsFiles( fetchedTor, tsFileNames, codec, noObsolete,
+ verbose );
+
+ if ( !metSomething ) {
+ fprintf( stderr,
+ "lupdate warning: File '%s' does not look like a"
+ " project file\n",
+ argv[i] );
+ } else if ( tsFileNames.isEmpty() ) {
+ fprintf( stderr,
+ "lupdate warning: Met no 'TRANSLATIONS' entry in"
+ " project file '%s'\n",
+ argv[i] );
+ }
+ } else {
+ if ( metTsFlag ) {
+ if ( TQString(argv[i]).lower().endsWith(".ts") ) {
+ TQFileInfo fi( argv[i] );
+ if ( !fi.exists() || fi.isWritable() ) {
+ tsFileNames.append( argv[i] );
+ } else {
+ fprintf( stderr,
+ "lupdate warning: For some reason, I cannot"
+ " save '%s'\n",
+ argv[i] );
+ }
+ } else {
+ fprintf( stderr,
+ "lupdate error: File '%s' lacks .ts extension\n",
+ argv[i] );
+ }
+ } else {
+ TQFileInfo fi(argv[i]);
+ if ( TQString(argv[i]).lower().endsWith(".ui") ) {
+ fetchtr_ui( fi.fileName(), &fetchedTor, defaultContext, TRUE );
+ fetchtr_cpp( TQString(fi.fileName()) + ".h", &fetchedTor,
+ defaultContext, FALSE );
+ } else {
+ fetchtr_cpp( fi.fileName(), &fetchedTor, defaultContext, TRUE );
+ }
+ }
+ }
+ TQDir::setCurrent( oldDir );
+ }
+
+ if ( !standardSyntax )
+ updateTsFiles( fetchedTor, tsFileNames, codec, noObsolete, verbose );
+
+ if ( numFiles == 0 ) {
+ printUsage();
+ return 1;
+ }
+ return 0;
+}
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/merge.cpp b/tqtinterface/qt4/tools/linguist/lupdate/merge.cpp
new file mode 100644
index 0000000..bc409db
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/merge.cpp
@@ -0,0 +1,129 @@
+/**********************************************************************
+** Copyright (C) 2005-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of TQt Linguist.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** Licensees holding valid TQt Commercial licenses may use this file in
+** accordance with the TQt Commercial License Agreement provided with
+** the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <metatranslator.h>
+
+// defined in numberh.cpp
+extern void applyNumberHeuristic( MetaTranslator *tor, bool verbose );
+// defined in sametexth.cpp
+extern void applySameTextHeuristic( MetaTranslator *tor, bool verbose );
+
+typedef TQValueList<MetaTranslatorMessage> TML;
+
+/*
+ Merges two MetaTranslator objects into the first one. The first one
+ is a set of source texts and translations for a previous version of
+ the internationalized program; the second one is a set of fresh
+ source texts newly extracted from the source code, without any
+ translation yet.
+*/
+
+void merge( MetaTranslator *tor, const MetaTranslator *virginTor, bool verbose )
+{
+ int known = 0;
+ int neww = 0;
+ int obsoleted = 0;
+ TML all = tor->messages();
+ TML::Iterator it;
+
+ /*
+ The types of all the messages from the vernacular translator
+ are updated according to the virgin translator.
+ */
+ for ( it = all.begin(); it != all.end(); ++it ) {
+ MetaTranslatorMessage::Type newType;
+ MetaTranslatorMessage m = *it;
+
+ // skip context comment
+ if ( !TQCString((*it).sourceText()).isEmpty() ) {
+ if ( !virginTor->tqcontains((*it).context(), (*it).sourceText(),
+ (*it).comment()) ) {
+ newType = MetaTranslatorMessage::Obsolete;
+ if ( m.type() != MetaTranslatorMessage::Obsolete )
+ obsoleted++;
+ } else {
+ switch ( m.type() ) {
+ case MetaTranslatorMessage::Finished:
+ newType = MetaTranslatorMessage::Finished;
+ known++;
+ break;
+ case MetaTranslatorMessage::Unfinished:
+ default:
+ newType = MetaTranslatorMessage::Unfinished;
+ known++;
+ break;
+ case MetaTranslatorMessage::Obsolete:
+ newType = MetaTranslatorMessage::Unfinished;
+ neww++;
+ }
+ }
+
+ if ( newType != m.type() ) {
+ m.setType( newType );
+ tor->insert( m );
+ }
+ }
+ }
+
+ /*
+ Messages found only in the virgin translator are added to the
+ vernacular translator. Among these are all the context comments.
+ */
+ all = virginTor->messages();
+
+ for ( it = all.begin(); it != all.end(); ++it ) {
+ if ( !tor->tqcontains((*it).context(), (*it).sourceText(),
+ (*it).comment()) ) {
+ tor->insert( *it );
+ if ( !TQCString((*it).sourceText()).isEmpty() )
+ neww++;
+ }
+ }
+
+ /*
+ The same-text heuristic handles cases where a message has an
+ obsolete counterpart with a different context or comment.
+ */
+ applySameTextHeuristic( tor, verbose );
+
+ /*
+ The number heuristic handles cases where a message has an
+ obsolete counterpart with mostly numbers differing in the
+ source text.
+ */
+ applyNumberHeuristic( tor, verbose );
+
+ if ( verbose )
+ fprintf( stderr, " %d known, %d new and %d obsoleted messages\n", known,
+ neww, obsoleted );
+}
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/numberh.cpp b/tqtinterface/qt4/tools/linguist/lupdate/numberh.cpp
new file mode 100644
index 0000000..ba54dae
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/numberh.cpp
@@ -0,0 +1,248 @@
+/**********************************************************************
+** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of TQt Linguist.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** Licensees holding valid TQt Commercial licenses may use this file in
+** accordance with the TQt Commercial License Agreement provided with
+** the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <metatranslator.h>
+
+#include <tqmemarray.h>
+#include <tqcstring.h>
+#include <tqmap.h>
+#include <tqstringlist.h>
+
+#include <ctype.h>
+
+typedef TQMap<TQCString, MetaTranslatorMessage> TMM;
+typedef TQValueList<MetaTranslatorMessage> TML;
+
+static bool isDigitFriendly( int c )
+{
+ return ispunct((uchar)c) || isspace((uchar)c);
+}
+
+static int numberLength( const char *s )
+{
+ int i = 0;
+
+ if ( isdigit((uchar)s[0]) ) {
+ do {
+ i++;
+ } while (isdigit((uchar)s[i]) ||
+ (isDigitFriendly(s[i]) &&
+ (isdigit((uchar)s[i + 1]) ||
+ (isDigitFriendly(s[i + 1]) && isdigit((uchar)s[i + 2])))));
+ }
+ return i;
+}
+
+/*
+ Returns a version of 'key' where all numbers have been tqreplaced by zeroes. If
+ there were none, returns "".
+*/
+static TQCString zeroKey( const char *key )
+{
+ TQCString zeroed( (int)strlen(key) + 1 );
+ char *z = zeroed.data();
+ int i = 0, j = 0;
+ int len;
+ bool metSomething = FALSE;
+
+ while ( key[i] != '\0' ) {
+ len = numberLength( key + i );
+ if ( len > 0 ) {
+ i += len;
+ z[j++] = '0';
+ metSomething = TRUE;
+ } else {
+ z[j++] = key[i++];
+ }
+ }
+ z[j] = '\0';
+
+ if ( metSomething )
+ return zeroed;
+ else
+ return "";
+}
+
+static TQString translationAttempt( const TQString& oldTranslation,
+ const char *oldSource,
+ const char *newSource )
+{
+ int p = zeroKey( oldSource ).tqcontains( '0' );
+ int oldSourceLen = tqstrlen( oldSource );
+ TQString attempt;
+ TQStringList oldNumbers;
+ TQStringList newNumbers;
+ TQMemArray<bool> met( p );
+ TQMemArray<int> matchedYet( p );
+ int i, j;
+ int k = 0, ell, best;
+ int m, n;
+ int pass;
+
+ /*
+ This algorithm is hard to follow, so we'll consider an example
+ all along: oldTranslation is "XeT 3.0", oldSource is "TeX 3.0"
+ and newSource is "XeT 3.1".
+
+ First, we set up two tables: oldNumbers and newNumbers. In our
+ example, oldNumber[0] is "3.0" and newNumber[0] is "3.1".
+ */
+ for ( i = 0, j = 0; i < oldSourceLen; i++, j++ ) {
+ m = numberLength( oldSource + i );
+ n = numberLength( newSource + j );
+ if ( m > 0 ) {
+ oldNumbers.append( TQCString(oldSource + i, m + 1) );
+ newNumbers.append( TQCString(newSource + j, n + 1) );
+ i += m;
+ j += n;
+ met[k] = FALSE;
+ matchedYet[k] = 0;
+ k++;
+ }
+ }
+
+ /*
+ We now go over the old translation, "XeT 3.0", one letter at a
+ time, looking for numbers found in oldNumbers. Whenever such a
+ number is met, it is tqreplaced with its newNumber equivalent. In
+ our example, the "3.0" of "XeT 3.0" becomes "3.1".
+ */
+ for ( i = 0; i < (int) oldTranslation.length(); i++ ) {
+ attempt += oldTranslation[i];
+ for ( k = 0; k < p; k++ ) {
+ if ( oldTranslation[i] == oldNumbers[k][matchedYet[k]] )
+ matchedYet[k]++;
+ else
+ matchedYet[k] = 0;
+ }
+
+ /*
+ Let's tqfind out if the last character ended a match. We make
+ two passes over the data. In the first pass, we try to
+ match only numbers that weren't matched yet; if that fails,
+ the second pass does the trick. This is useful in some
+ suspicious cases, flagged below.
+ */
+ for ( pass = 0; pass < 2; pass++ ) {
+ best = p; // an impossible value
+ for ( k = 0; k < p; k++ ) {
+ if ( (!met[k] || pass > 0) &&
+ matchedYet[k] == (int) oldNumbers[k].length() &&
+ numberLength(oldTranslation.latin1() + (i + 1) -
+ matchedYet[k]) == matchedYet[k] ) {
+ // the longer the better
+ if ( best == p || matchedYet[k] > matchedYet[best] )
+ best = k;
+ }
+ }
+ if ( best != p ) {
+ attempt.truncate( attempt.length() - matchedYet[best] );
+ attempt += newNumbers[best];
+ met[best] = TRUE;
+ for ( k = 0; k < p; k++ )
+ matchedYet[k] = 0;
+ break;
+ }
+ }
+ }
+
+ /*
+ We flag two kinds of suspicious cases. They are identified as
+ such with comments such as "{2000?}" at the end.
+
+ Example of the first kind: old source text "TeX 3.0" translated
+ as "XeT 2.0" is flagged "TeX 2.0 {3.0?}", no matter what the
+ new text is.
+ */
+ for ( k = 0; k < p; k++ ) {
+ if ( !met[k] )
+ attempt += TQString( " {" ) + newNumbers[k] + TQString( "?}" );
+ }
+
+ /*
+ Example of the second kind: "1 of 1" translated as "1 af 1",
+ with new source text "1 of 2", generates "1 af 2 {1 or 2?}"
+ because it's not clear which of "1 af 2" and "2 af 1" is right.
+ */
+ for ( k = 0; k < p; k++ ) {
+ for ( ell = 0; ell < p; ell++ ) {
+ if ( k != ell && oldNumbers[k] == oldNumbers[ell] &&
+ newNumbers[k] < newNumbers[ell] )
+ attempt += TQString( " {" ) + newNumbers[k] + TQString( " or " ) +
+ newNumbers[ell] + TQString( "?}" );
+ }
+ }
+ return attempt;
+}
+
+/*
+ Augments a MetaTranslator with translations easily derived from
+ similar existing (probably obsolete) translations.
+
+ For example, if "TeX 3.0" is translated as "XeT 3.0" and "TeX 3.1"
+ has no translation, "XeT 3.1" is added to the translator and is
+ marked Unfinished.
+*/
+void applyNumberHeuristic( MetaTranslator *tor, bool verbose )
+{
+ TMM translated, untranslated;
+ TMM::Iterator t, u;
+ TML all = tor->messages();
+ TML::Iterator it;
+ int inserted = 0;
+
+ for ( it = all.begin(); it != all.end(); ++it ) {
+ if ( (*it).type() == MetaTranslatorMessage::Unfinished ) {
+ if ( (*it).translation().isEmpty() )
+ untranslated.insert(TQCString((*it).context()) + "\n" + (*it).sourceText() + "\n"
+ + (*it).comment(), *it);
+ } else if ( !(*it).translation().isEmpty() ) {
+ translated.insert( zeroKey((*it).sourceText()), *it );
+ }
+ }
+
+ for ( u = untranslated.begin(); u != untranslated.end(); ++u ) {
+ t = translated.tqfind( zeroKey((*u).sourceText()) );
+ if ( t != translated.end() && !t.key().isEmpty() &&
+ qstrcmp((*t).sourceText(), (*u).sourceText()) != 0 ) {
+ MetaTranslatorMessage m( *u );
+ m.setTranslation(translationAttempt((*t).translation(), (*t).sourceText(),
+ (*u).sourceText()));
+ tor->insert( m );
+ inserted++;
+ }
+ }
+ if ( verbose && inserted != 0 )
+ fprintf( stderr, " number heuristic provided %d translation%s\n",
+ inserted, inserted == 1 ? "" : "s" );
+}
diff --git a/tqtinterface/qt4/tools/linguist/lupdate/sametexth.cpp b/tqtinterface/qt4/tools/linguist/lupdate/sametexth.cpp
new file mode 100644
index 0000000..456ad7d
--- /dev/null
+++ b/tqtinterface/qt4/tools/linguist/lupdate/sametexth.cpp
@@ -0,0 +1,97 @@
+/**********************************************************************
+** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of TQt Linguist.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** Licensees holding valid TQt Commercial licenses may use this file in
+** accordance with the TQt Commercial License Agreement provided with
+** the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <metatranslator.h>
+
+#include <tqcstring.h>
+#include <tqmap.h>
+
+typedef TQMap<TQCString, MetaTranslatorMessage> TMM;
+typedef TQValueList<MetaTranslatorMessage> TML;
+
+/*
+ Augments a MetaTranslator with trivially derived translations.
+
+ For example, if "Enabled:" is consistendly translated as "Eingeschaltet:" no
+ matter the context or the comment, "Eingeschaltet:" is added as the
+ translation of any untranslated "Enabled:" text and is marked Unfinished.
+*/
+
+void applySameTextHeuristic( MetaTranslator *tor, bool verbose )
+{
+ TMM translated;
+ TMM avoid;
+ TMM::Iterator t;
+ TML untranslated;
+ TML::Iterator u;
+ TML all = tor->messages();
+ TML::Iterator it;
+ int inserted = 0;
+
+ for ( it = all.begin(); it != all.end(); ++it ) {
+ if ( (*it).type() == MetaTranslatorMessage::Unfinished ) {
+ if ( (*it).translation().isEmpty() )
+ untranslated.append( *it );
+ } else {
+ TQCString key = (*it).sourceText();
+ t = translated.tqfind( key );
+ if ( t != translated.end() ) {
+ /*
+ The same source text is translated at least two
+ different ways. Do nothing then.
+ */
+ if ( (*t).translation() != (*it).translation() ) {
+ translated.remove( key );
+ avoid.insert( key, *it );
+ }
+ } else if ( !avoid.tqcontains(key) &&
+ !(*it).translation().isEmpty() ) {
+ translated.insert( key, *it );
+ }
+ }
+ }
+
+ for ( u = untranslated.begin(); u != untranslated.end(); ++u ) {
+ TQCString key = (*u).sourceText();
+ t = translated.tqfind( key );
+ if ( t != translated.end() ) {
+ MetaTranslatorMessage m( *u );
+ m.setTranslation( (*t).translation() );
+ tor->insert( m );
+ inserted++;
+ }
+ }
+ if ( verbose && inserted != 0 )
+ fprintf( stderr, " same-text heuristic provided %d translation%s\n",
+ inserted, inserted == 1 ? "" : "s" );
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-15 00:29:30 +0000