/****************************************************************************

**

** Copyright (C) 2010 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$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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.

**

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

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

**

**

**

**

**

**

**

**

** $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 <iostream>

static QString m_defaultExtensions;

static void printErr(const QString & out)

{

    qWarning("%s", qPrintable(out));

}

static void printOut(const QString & out)

{

    std::cerr << qPrintable(out);

}

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(QObject::tr(

        "Usage:\n"

        "    lupdate [options] [project-file]...\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"

    ).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())

                qWarning("lupdate warning: Codec for tr() '%s' disagrees with "

                         "existing file's codec '%s'. Expect trouble.",

                         fetchedTor.codecName().constData(), tor.codecName().constData());

            if (!targetLanguage.isEmpty() && targetLanguage != tor.languageCode())

                qWarning("lupdate warning: Specified target language '%s' disagrees with "

                         "existing file's language '%s'. Ignoring.",

                         qPrintable(targetLanguage), qPrintable(tor.languageCode()));

            if (!sourceLanguage.isEmpty() && sourceLanguage != tor.sourceLanguageCode())

                qWarning("lupdate warning: Specified source language '%s' disagrees with "

                         "existing file's language '%s'. Ignoring.",

                         qPrintable(sourceLanguage), qPrintable(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(QObject::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(QObject::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

            sourceFilesCpp << *it;

    }

    loadCPP(fetchedTor, sourceFilesCpp, cd);

    if (!cd.error().isEmpty())

        printOut(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)) {

            qWarning("lupdate warning: Codec for source '%s' is invalid. "

                     "Falling back to codec for tr().", codecForSource.constData());

            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);

        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) {

                    std::cerr << "lupdate warning: TS files from command line "

                            "will override TRANSLATIONS in " << qPrintable(proFile) << ".\n";

                    goto noTrans;

                } else if (nestComplain) {

                    std::cerr << "lupdate warning: TS files from command line "

                            "prevent recursing into " << qPrintable(proFile) << ".\n";

                    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)

                std::cerr << "lupdate warning: no TS files specified. Only diagnostics "

                        "will be produced for '" << qPrintable(proFile) << "'.\n";

            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);

    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) {

                qWarning("The option -target-language requires a parameter.");

                return 1;

            }

            targetLanguage = args[i];

            continue;

        } else if (arg == QLatin1String("-source-language")) {

            ++i;

            if (i == argc) {

                qWarning("The option -source-language requires a parameter.");

                return 1;

            }

            sourceLanguage = args[i];

            continue;

        } else if (arg == QLatin1String("-disable-heuristic")) {

            ++i;

            if (i == argc) {

                qWarning("The option -disable-heuristic requires a parameter.");

                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 {

                qWarning("Invalid heuristic name passed to -disable-heuristic.");

                return 1;

            }

            continue;

        } else if (arg == QLatin1String("-locations")) {

            ++i;

            if (i == argc) {

                qWarning("The option -locations requires a parameter.");

                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 {

                qWarning("Invalid parameter passed to -locations.");

                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;