| /**************************************************************************** |
| ** |
| ** 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 <profileevaluator.h> |
| |
| #include <QtCore/QCoreApplication> |
| #include <QtCore/QDebug> |
| #include <QtCore/QDir> |
| #include <QtCore/QFile> |
| #include <QtCore/QFileInfo> |
| #include <QtCore/QString> |
| #include <QtCore/QStringList> |
| #include <QtCore/QTextCodec> |
| #include <QtCore/QTranslator> |
| #include <QtCore/QLibraryInfo> |
| |
| #include <iostream> |
| |
| static QString m_defaultExtensions; |
| |
| static void printOut(const QString & out) |
| { |
| QTextStream stream(stdout); |
| stream << out; |
| } |
| |
| static void printErr(const QString & out) |
| { |
| QTextStream stream(stderr); |
| stream << out; |
| } |
| |
| class LU { |
| Q_DECLARE_TR_FUNCTIONS(LUpdate) |
| }; |
| |
| static void recursiveFileInfoList(const QDir &dir, |
| const QSet<QString> &nameFilters, QDir::Filters filter, |
| QFileInfoList *fileinfolist) |
| { |
| foreach (const QFileInfo &fi, dir.entryInfoList(filter)) |
| if (fi.isDir()) |
| recursiveFileInfoList(QDir(fi.absoluteFilePath()), nameFilters, filter, fileinfolist); |
| else if (nameFilters.contains(fi.suffix())) |
| fileinfolist->append(fi); |
| } |
| |
| static void printUsage() |
| { |
| printOut(LU::tr( |
| "Usage:\n" |
| " lupdate [options] [project-file]...\n" |
| " lupdate [options] [source-file|path|@lst-file]... -ts ts-files|@lst-file\n\n" |
| "lupdate is part of Qt's Linguist tool chain. It extracts translatable\n" |
| "messages from Qt UI files, C++, Java and JavaScript/QtScript source code.\n" |
| "Extracted messages are stored in textual translation source files (typically\n" |
| "Qt TS XML). New and modified messages can be merged into existing TS files.\n\n" |
| "Options:\n" |
| " -help Display this information and exit.\n" |
| " -no-obsolete\n" |
| " Drop all obsolete strings.\n" |
| " -extensions <ext>[,<ext>]...\n" |
| " Process files with the given extensions only.\n" |
| " The extension list must be separated with commas, not with whitespace.\n" |
| " Default: '%1'.\n" |
| " -pluralonly\n" |
| " Only include plural form messages.\n" |
| " -silent\n" |
| " Do not explain what is being done.\n" |
| " -no-sort\n" |
| " Do not sort contexts in TS files.\n" |
| " -no-recursive\n" |
| " Do not recursively scan the following directories.\n" |
| " -recursive\n" |
| " Recursively scan the following directories (default).\n" |
| " -I <includepath> or -I<includepath>\n" |
| " Additional location to look for include files.\n" |
| " May be specified multiple times.\n" |
| " -locations {absolute|relative|none}\n" |
| " Specify/override how source code references are saved in TS files.\n" |
| " Default is absolute.\n" |
| " -no-ui-lines\n" |
| " Do not record line numbers in references to UI files.\n" |
| " -disable-heuristic {sametext|similartext|number}\n" |
| " Disable the named merge heuristic. Can be specified multiple times.\n" |
| " -pro <filename>\n" |
| " Name of a .pro file. Useful for files with .pro file syntax but\n" |
| " different file suffix. Projects are recursed into and merged.\n" |
| " -source-language <language>[_<region>]\n" |
| " Specify the language of the source strings for new files.\n" |
| " Defaults to POSIX if not specified.\n" |
| " -target-language <language>[_<region>]\n" |
| " Specify the language of the translations for new files.\n" |
| " Guessed from the file name if not specified.\n" |
| " -ts <ts-file>...\n" |
| " Specify the output file(s). This will override the TRANSLATIONS\n" |
| " and nullify the CODECFORTR from possibly specified project files.\n" |
| " -codecfortr <codec>\n" |
| " Specify the codec assumed for tr() calls. Effective only with -ts.\n" |
| " -version\n" |
| " Display the version of lupdate and exit.\n" |
| " @lst-file\n" |
| " Read additional file names (one per line) from lst-file.\n" |
| ).arg(m_defaultExtensions)); |
| } |
| |
| static void updateTsFiles(const Translator &fetchedTor, const QStringList &tsFileNames, |
| bool setCodec, const QString &sourceLanguage, const QString &targetLanguage, |
| UpdateOptions options, bool *fail) |
| { |
| QDir dir; |
| QString err; |
| foreach (const QString &fileName, tsFileNames) { |
| QString fn = dir.relativeFilePath(fileName); |
| ConversionData cd; |
| Translator tor; |
| cd.m_sortContexts = !(options & NoSort); |
| if (QFile(fileName).exists()) { |
| if (!tor.load(fileName, cd, QLatin1String("auto"))) { |
| printErr(cd.error()); |
| *fail = true; |
| continue; |
| } |
| tor.resolveDuplicates(); |
| cd.clearErrors(); |
| if (setCodec && fetchedTor.codec() != tor.codec()) |
| printErr(LU::tr("lupdate warning: Codec for tr() '%1' disagrees with" |
| " existing file's codec '%2'. Expect trouble.\n") |
| .arg(QString::fromLatin1(fetchedTor.codecName()), |
| QString::fromLatin1(tor.codecName()))); |
| if (!targetLanguage.isEmpty() && targetLanguage != tor.languageCode()) |
| printErr(LU::tr("lupdate warning: Specified target language '%1' disagrees with" |
| " existing file's language '%2'. Ignoring.\n") |
| .arg(targetLanguage, tor.languageCode())); |
| if (!sourceLanguage.isEmpty() && sourceLanguage != tor.sourceLanguageCode()) |
| printErr(LU::tr("lupdate warning: Specified source language '%1' disagrees with" |
| " existing file's language '%2'. Ignoring.\n") |
| .arg(sourceLanguage, tor.sourceLanguageCode())); |
| } else { |
| if (setCodec) |
| tor.setCodec(fetchedTor.codec()); |
| if (!targetLanguage.isEmpty()) |
| tor.setLanguageCode(targetLanguage); |
| else |
| tor.setLanguageCode(Translator::guessLanguageCodeFromFileName(fileName)); |
| if (!sourceLanguage.isEmpty()) |
| tor.setSourceLanguageCode(sourceLanguage); |
| } |
| tor.makeFileNamesAbsolute(QFileInfo(fileName).absoluteDir()); |
| if (options & NoLocations) |
| tor.setLocationsType(Translator::NoLocations); |
| else if (options & RelativeLocations) |
| tor.setLocationsType(Translator::RelativeLocations); |
| else if (options & AbsoluteLocations) |
| tor.setLocationsType(Translator::AbsoluteLocations); |
| if (options & Verbose) |
| printOut(LU::tr("Updating '%1'...\n").arg(fn)); |
| |
| UpdateOptions theseOptions = options; |
| if (tor.locationsType() == Translator::NoLocations) // Could be set from file |
| theseOptions |= NoLocations; |
| Translator out = merge(tor, fetchedTor, theseOptions, err); |
| if (setCodec) |
| out.setCodec(fetchedTor.codec()); |
| |
| if ((options & Verbose) && !err.isEmpty()) { |
| printOut(err); |
| err.clear(); |
| } |
| if (options & PluralOnly) { |
| if (options & Verbose) |
| printOut(LU::tr("Stripping non plural forms in '%1'...\n").arg(fn)); |
| out.stripNonPluralForms(); |
| } |
| if (options & NoObsolete) |
| out.stripObsoleteMessages(); |
| out.stripEmptyContexts(); |
| |
| out.normalizeTranslations(cd); |
| if (!cd.errors().isEmpty()) { |
| printErr(cd.error()); |
| cd.clearErrors(); |
| } |
| if (!out.save(fileName, cd, QLatin1String("auto"))) { |
| printErr(cd.error()); |
| *fail = true; |
| } |
| } |
| } |
| |
| static QStringList getSources(const char *var, const char *vvar, const QStringList &baseVPaths, |
| const QString &projectDir, const ProFileEvaluator &visitor) |
| { |
| QStringList vPaths = visitor.absolutePathValues(QLatin1String(vvar), projectDir); |
| vPaths += baseVPaths; |
| vPaths.removeDuplicates(); |
| return visitor.absoluteFileValues(QLatin1String(var), projectDir, vPaths, 0); |
| } |
| |
| static QStringList getSources(const ProFileEvaluator &visitor, const QString &projectDir) |
| { |
| QStringList baseVPaths; |
| baseVPaths += visitor.absolutePathValues(QLatin1String("VPATH"), projectDir); |
| baseVPaths << projectDir; // QMAKE_ABSOLUTE_SOURCE_PATH |
| baseVPaths += visitor.absolutePathValues(QLatin1String("DEPENDPATH"), projectDir); |
| baseVPaths.removeDuplicates(); |
| |
| QStringList sourceFiles; |
| |
| // app/lib template |
| sourceFiles += getSources("SOURCES", "VPATH_SOURCES", baseVPaths, projectDir, visitor); |
| |
| sourceFiles += getSources("FORMS", "VPATH_FORMS", baseVPaths, projectDir, visitor); |
| sourceFiles += getSources("FORMS3", "VPATH_FORMS3", baseVPaths, projectDir, visitor); |
| |
| QStringList vPathsInc = baseVPaths; |
| vPathsInc += visitor.absolutePathValues(QLatin1String("INCLUDEPATH"), projectDir); |
| vPathsInc.removeDuplicates(); |
| sourceFiles += visitor.absoluteFileValues(QLatin1String("HEADERS"), projectDir, vPathsInc, 0); |
| |
| sourceFiles.removeDuplicates(); |
| sourceFiles.sort(); |
| |
| return sourceFiles; |
| } |
| |
| static void processSources(Translator &fetchedTor, |
| const QStringList &sourceFiles, ConversionData &cd) |
| { |
| QStringList sourceFilesCpp; |
| for (QStringList::const_iterator it = sourceFiles.begin(); it != sourceFiles.end(); ++it) { |
| if (it->endsWith(QLatin1String(".java"), Qt::CaseInsensitive)) |
| loadJava(fetchedTor, *it, cd); |
| else if (it->endsWith(QLatin1String(".ui"), Qt::CaseInsensitive) |
| || it->endsWith(QLatin1String(".jui"), Qt::CaseInsensitive)) |
| loadUI(fetchedTor, *it, cd); |
| else if (it->endsWith(QLatin1String(".js"), Qt::CaseInsensitive) |
| || it->endsWith(QLatin1String(".qs"), Qt::CaseInsensitive)) |
| loadQScript(fetchedTor, *it, cd); |
| else if (it->endsWith(QLatin1String(".qml"), Qt::CaseInsensitive)) |
| loadQml(fetchedTor, *it, cd); |
| else |
| sourceFilesCpp << *it; |
| } |
| loadCPP(fetchedTor, sourceFilesCpp, cd); |
| if (!cd.error().isEmpty()) |
| printErr(cd.error()); |
| } |
| |
| static void processProjects( |
| bool topLevel, bool nestComplain, const QStringList &proFiles, |
| UpdateOptions options, const QByteArray &codecForSource, |
| const QString &targetLanguage, const QString &sourceLanguage, |
| Translator *parentTor, bool *fail); |
| |
| static void processProject( |
| bool nestComplain, const QFileInfo &pfi, ProFileEvaluator &visitor, |
| UpdateOptions options, const QByteArray &_codecForSource, |
| const QString &targetLanguage, const QString &sourceLanguage, |
| Translator *fetchedTor, bool *fail) |
| { |
| QByteArray codecForSource = _codecForSource; |
| QStringList tmp = visitor.values(QLatin1String("CODECFORSRC")); |
| if (!tmp.isEmpty()) { |
| codecForSource = tmp.last().toLatin1(); |
| if (!QTextCodec::codecForName(codecForSource)) { |
| printErr(LU::tr("lupdate warning: Codec for source '%1' is invalid." |
| " Falling back to codec for tr().\n") |
| .arg(QString::fromLatin1(codecForSource))); |
| codecForSource.clear(); |
| } |
| } |
| if (visitor.templateType() == ProFileEvaluator::TT_Subdirs) { |
| QStringList subProFiles; |
| QDir proDir(pfi.absoluteDir()); |
| foreach (const QString &subdir, visitor.values(QLatin1String("SUBDIRS"))) { |
| QString subPro = QDir::cleanPath(proDir.absoluteFilePath(subdir)); |
| QFileInfo subInfo(subPro); |
| if (subInfo.isDir()) |
| subProFiles << (subPro + QLatin1Char('/') |
| + subInfo.fileName() + QLatin1String(".pro")); |
| else |
| subProFiles << subPro; |
| } |
| processProjects(false, nestComplain, subProFiles, options, codecForSource, |
| targetLanguage, sourceLanguage, fetchedTor, fail); |
| } else { |
| ConversionData cd; |
| cd.m_noUiLines = options & NoUiLines; |
| cd.m_codecForSource = codecForSource; |
| cd.m_includePath = visitor.values(QLatin1String("INCLUDEPATH")); |
| QStringList sourceFiles = getSources(visitor, pfi.absolutePath()); |
| QSet<QString> sourceDirs; |
| sourceDirs.insert(QDir::cleanPath(pfi.absolutePath()) + QLatin1Char('/')); |
| foreach (const QString &sf, sourceFiles) |
| sourceDirs.insert(sf.left(sf.lastIndexOf(QLatin1Char('/')) + 1)); |
| QStringList rootList = sourceDirs.toList(); |
| rootList.sort(); |
| for (int prev = 0, curr = 1; curr < rootList.length(); ) |
| if (rootList.at(curr).startsWith(rootList.at(prev))) |
| rootList.removeAt(curr); |
| else |
| prev = curr++; |
| cd.m_projectRoots = QSet<QString>::fromList(rootList); |
| processSources(*fetchedTor, sourceFiles, cd); |
| } |
| } |
| |
| static void processProjects( |
| bool topLevel, bool nestComplain, const QStringList &proFiles, |
| UpdateOptions options, const QByteArray &codecForSource, |
| const QString &targetLanguage, const QString &sourceLanguage, |
| Translator *parentTor, bool *fail) |
| { |
| foreach (const QString &proFile, proFiles) { |
| ProFileEvaluator visitor; |
| visitor.setVerbose(options & Verbose); |
| |
| QHash<QString, QStringList> lupdateConfig; |
| lupdateConfig.insert(QLatin1String("CONFIG"), QStringList(QLatin1String("lupdate_run"))); |
| visitor.addVariables(lupdateConfig); |
| |
| QFileInfo pfi(proFile); |
| ProFile pro(pfi.absoluteFilePath()); |
| if (!visitor.queryProFile(&pro) || !visitor.accept(&pro)) { |
| if (topLevel) |
| *fail = true; |
| continue; |
| } |
| |
| if (visitor.contains(QLatin1String("TRANSLATIONS"))) { |
| if (parentTor) { |
| if (topLevel) { |
| printErr(LU::tr("lupdate warning: TS files from command line " |
| "will override TRANSLATIONS in %1.\n").arg(proFile)); |
| goto noTrans; |
| } else if (nestComplain) { |
| printErr(LU::tr("lupdate warning: TS files from command line " |
| "prevent recursing into %1.\n").arg(proFile)); |
| continue; |
| } |
| } |
| QStringList tsFiles; |
| QDir proDir(pfi.absolutePath()); |
| foreach (const QString &tsFile, visitor.values(QLatin1String("TRANSLATIONS"))) |
| tsFiles << QFileInfo(proDir, tsFile).filePath(); |
| if (tsFiles.isEmpty()) { |
| // This might mean either a buggy PRO file or an intentional detach - |
| // we can't know without seeing the actual RHS of the assignment ... |
| // Just assume correctness and be silent. |
| continue; |
| } |
| Translator tor; |
| bool setCodec = false; |
| QStringList tmp = visitor.values(QLatin1String("CODEC")) |
| + visitor.values(QLatin1String("DEFAULTCODEC")) |
| + visitor.values(QLatin1String("CODECFORTR")); |
| if (!tmp.isEmpty()) { |
| tor.setCodecName(tmp.last().toLatin1()); |
| setCodec = true; |
| } |
| processProject(false, pfi, visitor, options, codecForSource, |
| targetLanguage, sourceLanguage, &tor, fail); |
| updateTsFiles(tor, tsFiles, setCodec, sourceLanguage, targetLanguage, options, fail); |
| continue; |
| } |
| noTrans: |
| if (!parentTor) { |
| if (topLevel) |
| printErr(LU::tr("lupdate warning: no TS files specified. Only diagnostics " |
| "will be produced for '%1'.\n").arg(proFile)); |
| Translator tor; |
| processProject(nestComplain, pfi, visitor, options, codecForSource, |
| targetLanguage, sourceLanguage, &tor, fail); |
| } else { |
| processProject(nestComplain, pfi, visitor, options, codecForSource, |
| targetLanguage, sourceLanguage, parentTor, fail); |
| } |
| } |
| } |
| |
| int main(int argc, char **argv) |
| { |
| QCoreApplication app(argc, argv); |
| #ifndef Q_OS_WIN32 |
| QTranslator translator; |
| QTranslator qtTranslator; |
| QString sysLocale = QLocale::system().name(); |
| QString resourceDir = QLibraryInfo::location(QLibraryInfo::TranslationsPath); |
| if (translator.load(QLatin1String("linguist_") + sysLocale, resourceDir) |
| && qtTranslator.load(QLatin1String("qt_") + sysLocale, resourceDir)) { |
| app.installTranslator(&translator); |
| app.installTranslator(&qtTranslator); |
| } |
| #endif // Q_OS_WIN32 |
| |
| m_defaultExtensions = QLatin1String("java,jui,ui,c,c++,cc,cpp,cxx,ch,h,h++,hh,hpp,hxx,js,qs,qml"); |
| |
| QStringList args = app.arguments(); |
| QStringList tsFileNames; |
| QStringList proFiles; |
| QMultiHash<QString, QString> allCSources; |
| QSet<QString> projectRoots; |
| QStringList sourceFiles; |
| QStringList includePath; |
| QString targetLanguage; |
| QString sourceLanguage; |
| QByteArray codecForTr; |
| |
| UpdateOptions options = |
| Verbose | // verbose is on by default starting with Qt 4.2 |
| HeuristicSameText | HeuristicSimilarText | HeuristicNumber; |
| int numFiles = 0; |
| bool metTsFlag = false; |
| bool recursiveScan = true; |
| |
| QString extensions = m_defaultExtensions; |
| QSet<QString> extensionsNameFilters; |
| |
| for (int i = 1; i < argc; ++i) { |
| QString arg = args.at(i); |
| if (arg == QLatin1String("-help") |
| || arg == QLatin1String("--help") |
| || arg == QLatin1String("-h")) { |
| printUsage(); |
| return 0; |
| } else if (arg == QLatin1String("-pluralonly")) { |
| options |= PluralOnly; |
| continue; |
| } else if (arg == QLatin1String("-noobsolete") |
| || arg == QLatin1String("-no-obsolete")) { |
| options |= NoObsolete; |
| continue; |
| } else if (arg == QLatin1String("-silent")) { |
| options &= ~Verbose; |
| continue; |
| } else if (arg == QLatin1String("-target-language")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The option -target-language requires a parameter.\n")); |
| return 1; |
| } |
| targetLanguage = args[i]; |
| continue; |
| } else if (arg == QLatin1String("-source-language")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The option -source-language requires a parameter.\n")); |
| return 1; |
| } |
| sourceLanguage = args[i]; |
| continue; |
| } else if (arg == QLatin1String("-disable-heuristic")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The option -disable-heuristic requires a parameter.\n")); |
| return 1; |
| } |
| arg = args[i]; |
| if (arg == QLatin1String("sametext")) { |
| options &= ~HeuristicSameText; |
| } else if (arg == QLatin1String("similartext")) { |
| options &= ~HeuristicSimilarText; |
| } else if (arg == QLatin1String("number")) { |
| options &= ~HeuristicNumber; |
| } else { |
| printErr(LU::tr("Invalid heuristic name passed to -disable-heuristic.\n")); |
| return 1; |
| } |
| continue; |
| } else if (arg == QLatin1String("-locations")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The option -locations requires a parameter.\n")); |
| return 1; |
| } |
| if (args[i] == QLatin1String("none")) { |
| options |= NoLocations; |
| } else if (args[i] == QLatin1String("relative")) { |
| options |= RelativeLocations; |
| } else if (args[i] == QLatin1String("absolute")) { |
| options |= AbsoluteLocations; |
| } else { |
| printErr(LU::tr("Invalid parameter passed to -locations.\n")); |
| return 1; |
| } |
| continue; |
| } else if (arg == QLatin1String("-no-ui-lines")) { |
| options |= NoUiLines; |
| continue; |
| } else if (arg == QLatin1String("-verbose")) { |
| options |= Verbose; |
| continue; |
| } else if (arg == QLatin1String("-no-recursive")) { |
| recursiveScan = false; |
| continue; |
| } else if (arg == QLatin1String("-recursive")) { |
| recursiveScan = true; |
| continue; |
| } else if (arg == QLatin1String("-no-sort") |
| || arg == QLatin1String("-nosort")) { |
| options |= NoSort; |
| continue; |
| } else if (arg == QLatin1String("-version")) { |
| printOut(QObject::tr("lupdate version %1\n").arg(QLatin1String(QT_VERSION_STR))); |
| return 0; |
| } else if (arg == QLatin1String("-codecfortr")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The -codecfortr option should be followed by a codec name.\n")); |
| return 1; |
| } |
| codecForTr = args[i].toLatin1(); |
| continue; |
| } else if (arg == QLatin1String("-ts")) { |
| metTsFlag = true; |
| continue; |
| } else if (arg == QLatin1String("-extensions")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The -extensions option should be followed by an extension list.\n")); |
| return 1; |
| } |
| extensions = args[i]; |
| continue; |
| } else if (arg == QLatin1String("-pro")) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The -pro option should be followed by a filename of .pro file.\n")); |
| return 1; |
| } |
| proFiles += args[i]; |
| numFiles++; |
| continue; |
| } else if (arg.startsWith(QLatin1String("-I"))) { |
| if (arg.length() == 2) { |
| ++i; |
| if (i == argc) { |
| printErr(LU::tr("The -I option should be followed by a path.\n")); |
| return 1; |
| } |
| includePath += args[i]; |
| } else { |
| includePath += args[i].mid(2); |
| } |
| continue; |
| } else if (arg.startsWith(QLatin1String("-")) && arg != QLatin1String("-")) { |
| printErr(LU::tr("Unrecognized option '%1'.\n").arg(arg)); |
| return 1; |
| } |
| |
| QStringList files; |
| if (arg.startsWith(QLatin1String("@"))) { |
| QFile lstFile(arg.mid(1)); |
| if (!lstFile.open(QIODevice::ReadOnly)) { |
| printErr(LU::tr("lupdate error: List file '%1' is not readable.\n") |
| .arg(lstFile.fileName())); |
| return 1; |
| } |
| while (!lstFile.atEnd()) |
| files << QString::fromLocal8Bit(lstFile.readLine().trimmed()); |
| } else { |
| files << arg; |
| } |
| if (metTsFlag) { |
| foreach (const QString &file, files) { |
| bool found = false; |
| foreach (const Translator::FileFormat &fmt, Translator::registeredFileFormats()) { |
| if (file.endsWith(QLatin1Char('.') + fmt.extension, Qt::CaseInsensitive)) { |
| QFileInfo fi(file); |
| if (!fi.exists() || fi.isWritable()) { |
| tsFileNames.append(QFileInfo(file).absoluteFilePath()); |
| } else { |
| printErr(LU::tr("lupdate warning: For some reason, '%1' is not writable.\n") |
| .arg(file)); |
| } |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| printErr(LU::tr("lupdate error: File '%1' has no recognized extension.\n") |
| .arg(file)); |
| return 1; |
| } |
| } |
| numFiles++; |
| } else { |
| foreach (const QString &file, files) { |
| QFileInfo fi(file); |
| if (!fi.exists()) { |
| printErr(LU::tr("lupdate error: File '%1' does not exist.\n").arg(file)); |
| return 1; |
| } |
| if (file.endsWith(QLatin1String(".pro"), Qt::CaseInsensitive) |
| || file.endsWith(QLatin1String(".pri"), Qt::CaseInsensitive)) { |
| proFiles << file; |
| } else if (fi.isDir()) { |
| if (options & Verbose) |
| printOut(LU::tr("Scanning directory '%1'...\n").arg(file)); |
| QDir dir = QDir(fi.filePath()); |
| projectRoots.insert(dir.absolutePath() + QLatin1Char('/')); |
| if (extensionsNameFilters.isEmpty()) { |
| foreach (QString ext, extensions.split(QLatin1Char(','))) { |
| ext = ext.trimmed(); |
| if (ext.startsWith(QLatin1Char('.'))) |
| ext.remove(0, 1); |
| extensionsNameFilters.insert(ext); |
| } |
| } |
| QDir::Filters filters = QDir::Files | QDir::NoSymLinks; |
| if (recursiveScan) |
| filters |= QDir::AllDirs | QDir::NoDotAndDotDot; |
| QFileInfoList fileinfolist; |
| recursiveFileInfoList(dir, extensionsNameFilters, filters, &fileinfolist); |
| int scanRootLen = dir.absolutePath().length(); |
| foreach (const QFileInfo &fi, fileinfolist) { |
| QString fn = QDir::cleanPath(fi.absoluteFilePath()); |
| sourceFiles << fn; |
| |
| if (!fn.endsWith(QLatin1String(".java")) |
| && !fn.endsWith(QLatin1String(".jui")) |
| && !fn.endsWith(QLatin1String(".ui")) |
| && !fn.endsWith(QLatin1String(".js")) |
| && !fn.endsWith(QLatin1String(".qs")) |
| && !fn.endsWith(QLatin1String(".qml"))) { |
| int offset = 0; |
| int depth = 0; |
| do { |
| offset = fn.lastIndexOf(QLatin1Char('/'), offset - 1); |
| QString ffn = fn.mid(offset + 1); |
| allCSources.insert(ffn, fn); |
| } while (++depth < 3 && offset > scanRootLen); |
| } |
| } |
| } else { |
| sourceFiles << QDir::cleanPath(fi.absoluteFilePath());; |
| projectRoots.insert(fi.absolutePath() + QLatin1Char('/')); |
| } |
| } |
| numFiles++; |
| } |
| } // for args |
| |
| if (numFiles == 0) { |
| printUsage(); |
| return 1; |
| } |
| |
| if (!targetLanguage.isEmpty() && tsFileNames.count() != 1) |
| printErr(LU::tr("lupdate warning: -target-language usually only" |
| " makes sense with exactly one TS file.\n")); |
| if (!codecForTr.isEmpty() && tsFileNames.isEmpty()) |
| printErr(LU::tr("lupdate warning: -codecfortr has no effect without -ts.\n")); |
| |
| bool fail = false; |
| if (proFiles.isEmpty()) { |
| if (tsFileNames.isEmpty()) |
| printErr(LU::tr("lupdate warning:" |
| " no TS files specified. Only diagnostics will be produced.\n")); |
| |
| Translator fetchedTor; |
| ConversionData cd; |
| cd.m_noUiLines = options & NoUiLines; |
| cd.m_projectRoots = projectRoots; |
| cd.m_includePath = includePath; |
| cd.m_allCSources = allCSources; |
| fetchedTor.setCodecName(codecForTr); |
| processSources(fetchedTor, sourceFiles, cd); |
| updateTsFiles(fetchedTor, tsFileNames, !codecForTr.isEmpty(), |
| sourceLanguage, targetLanguage, options, &fail); |
| } else { |
| if (!sourceFiles.isEmpty() || !includePath.isEmpty()) { |
| printErr(LU::tr("lupdate error:" |
| " Both project and source files / include paths specified.\n")); |
| return 1; |
| } |
| if (!tsFileNames.isEmpty()) { |
| Translator fetchedTor; |
| fetchedTor.setCodecName(codecForTr); |
| processProjects(true, true, proFiles, options, QByteArray(), |
| targetLanguage, sourceLanguage, &fetchedTor, &fail); |
| updateTsFiles(fetchedTor, tsFileNames, !codecForTr.isEmpty(), |
| sourceLanguage, targetLanguage, options, &fail); |
| } else { |
| processProjects(true, false, proFiles, options, QByteArray(), |
| targetLanguage, sourceLanguage, 0, &fail); |
| } |
| } |
| return fail ? 1 : 0; |
| } |
