qtranslator.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
 
#include "qplatformdefs.h"
 
#include "qtranslator.h"
 
#ifndef QT_NO_TRANSLATION
 
#include "qfileinfo.h"
#include "qstring.h"
#include "qstringlist.h"
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
#include "qdatastream.h"
#include "qendian.h"
#include "qfile.h"
#include "qalgorithms.h"
#include "qtranslator_p.h"
#include "qlocale.h"
#include "qlogging.h"
#include "qloggingcategory.h"
#include "qdebug.h"
#include "qendian.h"
#include "qresource.h"
 
#if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY)
#  define QT_USE_MMAP
#  include "private/qcore_unix_p.h"
// for mmap
#  include <sys/mman.h>
#endif
 
#include <stdlib.h>
#include <new>
 
#include "qobject_p.h"
 
#include <vector>
#include <memory>
 
#include <QtCore/qmutex.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcTranslator, "qt.core.qtranslator")
 
namespace {
enum Tag { Tag_End = 1, Tag_SourceText16, Tag_Translation, Tag_Context16, Tag_Obsolete1,
           Tag_SourceText, Tag_Context, Tag_Comment, Tag_Obsolete2 };
}
 
/*
$ mcookie
3cb86418caef9c95cd211cbf60a1bddd
$
*/
 
// magic number for the file
static const int MagicLength = 16;
static const uchar magic[MagicLength] = {
    0x3c, 0xb8, 0x64, 0x18, 0xca, 0xef, 0x9c, 0x95,
    0xcd, 0x21, 0x1c, 0xbf, 0x60, 0xa1, 0xbd, 0xdd
};
 
static inline QString dotQmLiteral() { return QStringLiteral(".qm"); }
 
static bool match(const uchar *found, uint foundLen, const char *target, uint targetLen)
{
    // catch the case if \a found has a zero-terminating symbol and \a len includes it.
    // (normalize it to be without the zero-terminating symbol)
    if (foundLen > 0 && found[foundLen-1] == '\0')
        --foundLen;
    return ((targetLen == foundLen) && memcmp(found, target, foundLen) == 0);
}
 
static void elfHash_continue(const char *name, uint &h)
{
    const uchar *k;
    uint g;
 
    k = (const uchar *) name;
    while (*k) {
        h = (h << 4) + *k++;
        if ((g = (h & 0xf0000000)) != 0)
            h ^= g >> 24;
        h &= ~g;
    }
}
 
static void elfHash_finish(uint &h)
{
    if (!h)
        h = 1;
}
 
static uint elfHash(const char *name)
{
    uint hash = 0;
    elfHash_continue(name, hash);
    elfHash_finish(hash);
    return hash;
}
 
/*
   \internal
 
   Determines whether \a rules are valid "numerus rules". Test input with this
   function before calling numerusHelper, below.
 */
static bool isValidNumerusRules(const uchar *rules, uint rulesSize)
{
    // Disabled computation of maximum numerus return value
    // quint32 numerus = 0;
 
    if (rulesSize == 0)
        return true;
 
    quint32 offset = 0;
    do {
        uchar opcode = rules[offset];
        uchar op = opcode & Q_OP_MASK;
 
        if (opcode & 0x80)
            return false; // Bad op
 
        if (++offset == rulesSize)
            return false; // Missing operand
 
        // right operand
        ++offset;
 
        switch (op)
        {
        case Q_EQ:
        case Q_LT:
        case Q_LEQ:
            break;
 
        case Q_BETWEEN:
            if (offset != rulesSize) {
                // third operand
                ++offset;
                break;
            }
            return false; // Missing operand
 
        default:
            return false; // Bad op (0)
        }
 
        // ++numerus;
        if (offset == rulesSize)
            return true;
 
    } while (((rules[offset] == Q_AND)
                || (rules[offset] == Q_OR)
                || (rules[offset] == Q_NEWRULE))
            && ++offset != rulesSize);
 
    // Bad op
    return false;
}
 
/*
   \internal
 
   This function does no validation of input and assumes it is well-behaved,
   these assumptions can be checked with isValidNumerusRules, above.
 
   Determines which translation to use based on the value of \a n. The return
   value is an index identifying the translation to be used.
 
   \a rules is a character array of size \a rulesSize containing bytecode that
   operates on the value of \a n and ultimately determines the result.
 
   This function has O(1) space and O(rulesSize) time complexity.
 */
static uint numerusHelper(int n, const uchar *rules, uint rulesSize)
{
    uint result = 0;
    uint i = 0;
 
    if (rulesSize == 0)
        return 0;
 
    for (;;) {
        bool orExprTruthValue = false;
 
        for (;;) {
            bool andExprTruthValue = true;
 
            for (;;) {
                bool truthValue = true;
                int opcode = rules[i++];
 
                int leftOperand = n;
                if (opcode & Q_MOD_10) {
                    leftOperand %= 10;
                } else if (opcode & Q_MOD_100) {
                    leftOperand %= 100;
                } else if (opcode & Q_LEAD_1000) {
                    while (leftOperand >= 1000)
                        leftOperand /= 1000;
                }
 
                int op = opcode & Q_OP_MASK;
                int rightOperand = rules[i++];
 
                switch (op) {
                case Q_EQ:
                    truthValue = (leftOperand == rightOperand);
                    break;
                case Q_LT:
                    truthValue = (leftOperand < rightOperand);
                    break;
                case Q_LEQ:
                    truthValue = (leftOperand <= rightOperand);
                    break;
                case Q_BETWEEN:
                    int bottom = rightOperand;
                    int top = rules[i++];
                    truthValue = (leftOperand >= bottom && leftOperand <= top);
                }
 
                if (opcode & Q_NOT)
                    truthValue = !truthValue;
 
                andExprTruthValue = andExprTruthValue && truthValue;
 
                if (i == rulesSize || rules[i] != Q_AND)
                    break;
                ++i;
            }
 
            orExprTruthValue = orExprTruthValue || andExprTruthValue;
 
            if (i == rulesSize || rules[i] != Q_OR)
                break;
            ++i;
        }
 
        if (orExprTruthValue)
            return result;
 
        ++result;
 
        if (i == rulesSize)
            return result;
 
        i++; // Q_NEWRULE
    }
 
    Q_ASSERT(false);
    return 0;
}
 
class QTranslatorPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QTranslator)
public:
    enum { Contexts = 0x2f, Hashes = 0x42, Messages = 0x69, NumerusRules = 0x88, Dependencies = 0x96, Language = 0xa7 };
 
    mutable QMutex lock;
 
    QTranslatorPrivate() :
#if defined(QT_USE_MMAP)
          used_mmap(0),
#endif
          unmapPointer(nullptr), unmapLength(0), resource(nullptr),
          messageArray(nullptr), offsetArray(nullptr), contextArray(nullptr), numerusRulesArray(nullptr),
          messageLength(0), offsetLength(0), contextLength(0), numerusRulesLength(0) {}
 
#if defined(QT_USE_MMAP)
    bool used_mmap : 1;
#endif
    char *unmapPointer;     // used memory (mmap, new or resource file)
    qsizetype unmapLength;
 
    // The resource object in case we loaded the translations from a resource
    std::unique_ptr<QResource> resource;
 
    // used if the translator has dependencies
    std::vector<std::unique_ptr<QTranslator>> subTranslators;
 
    // Pointers and offsets into unmapPointer[unmapLength] array, or user
    // provided data array
    const uchar *messageArray;
    const uchar *offsetArray;
    const uchar *contextArray;
    const uchar *numerusRulesArray;
    uint messageLength;
    uint offsetLength;
    uint contextLength;
    uint numerusRulesLength;
 
    QString language;
    QString filePath;
 
    bool load_translation(const QStringList &languages, const QString &filename, const QString &prefix,
                          const QString &directory, const QString &suffix);
    bool do_load(const QString &filename, const QString &directory);
    bool do_load(const uchar *data, qsizetype len, const QString &directory);
    QString do_translate(const char *context, const char *sourceText, const char *comment,
                         int n) const;
    void clear();
};
 
/*!
    \class QTranslator
    \inmodule QtCore
 
    \brief The QTranslator class provides internationalization support for text
    output.
 
    \ingroup i18n
 
    An object of this class contains a set of translations from a
    source language to a target language. QTranslator provides
    functions to look up translations in a translation file.
    Translation files are created using \l{Qt Linguist}.
 
    The most common use of QTranslator is to: load a translation
    file, and install it using QCoreApplication::installTranslator().
 
    Here's an example \c main() function using the
    QTranslator:
 
    \snippet hellotrmain.cpp 0
 
    Note that the translator must be created \e before the
    application's widgets.
 
    Most applications will never need to do anything else with this
    class. The other functions provided by this class are useful for
    applications that work on translator files.
 
    \section1 Looking up Translations
 
    It is possible to look up a translation using translate() (as tr()
    and QCoreApplication::translate() do). The translate() function takes
    up to three parameters:
 
    \list
    \li The \e context - usually the class name for the tr() caller.
    \li The \e {source text} - usually the argument to tr().
    \li The \e disambiguation - an optional string that helps disambiguate
       different uses of the same text in the same context.
    \endlist
 
    For example, the "Cancel" in a dialog might have "Anuluj" when the
    program runs in Polish (in this case the source text would be
    "Cancel"). The context would (normally) be the dialog's class
    name; there would normally be no comment, and the translated text
    would be "Anuluj".
 
    But it's not always so simple. The Spanish version of a printer
    dialog with settings for two-sided printing and binding would
    probably require both "Activado" and "Activada" as translations
    for "Enabled". In this case the source text would be "Enabled" in
    both cases, and the context would be the dialog's class name, but
    the two items would have disambiguations such as "two-sided printing"
    for one and "binding" for the other. The disambiguation enables the
    translator to choose the appropriate gender for the Spanish version,
    and enables Qt to distinguish between translations.
 
    \section1 Using Multiple Translations
 
    Multiple translation files can be installed in an application.
    Translations are searched for in the reverse order in which they were
    installed, so the most recently installed translation file is searched
    for translations first and the earliest translation file is searched
    last. The search stops as soon as a translation containing a matching
    string is found.
 
    This mechanism makes it possible for a specific translation to be
    "selected" or given priority over the others; simply uninstall the
    translator from the application by passing it to the
    QCoreApplication::removeTranslator() function and reinstall it with
    QCoreApplication::installTranslator(). It will then be the first
    translation to be searched for matching strings.
 
    \section1 Security Considerations
 
    Only install translation files from trusted sources.
 
    Translation files are binary files that are generated from text-based
    translation source files. The format of these binary files is strictly
    defined by Qt and any manipulation of the data in the binary file may
    crash the application when the file is loaded. Furthermore, even well-formed
    translation files may contain misleading or malicious translations.
 
    \sa QCoreApplication::installTranslator(), QCoreApplication::removeTranslator(),
        QObject::tr(), QCoreApplication::translate(), {I18N Example},
        {Hello tr() Example}, {Arrow Pad Example}, {Troll Print Example}
*/
 
/*!
    Constructs an empty message file object with parent \a parent that
    is not connected to any file.
*/
 
QTranslator::QTranslator(QObject * parent)
    : QObject(*new QTranslatorPrivate, parent)
{
}
 
/*!
    Destroys the object and frees any allocated resources.
*/
 
QTranslator::~QTranslator()
{
    if (QCoreApplication::instanceExists())
        QCoreApplication::removeTranslator(this);
    Q_D(QTranslator);
    d->clear();
}
 
/*!
 
    Loads \a filename + \a suffix (".qm" if the \a suffix is not
    specified), which may be an absolute file name or relative to \a
    directory. Returns \c true if the translation is successfully loaded;
    otherwise returns \c false.
 
    If \a directory is not specified, the current directory is used
    (i.e., as \l{QDir::}{currentPath()}).
 
    The previous contents of this translator object are discarded.
 
    If the file name does not exist, other file names are tried
    in the following order:
 
    \list 1
    \li File name without \a suffix appended.
    \li File name with text after a character in \a search_delimiters
       stripped ("_." is the default for \a search_delimiters if it is
       an empty string) and \a suffix.
    \li File name stripped without \a suffix appended.
    \li File name stripped further, etc.
    \endlist
 
    For example, an application running in the fr_CA locale
    (French-speaking Canada) might call load("foo.fr_ca",
    "/opt/foolib"). load() would then try to open the first existing
    readable file from this list:
 
    \list 1
    \li \c /opt/foolib/foo.fr_ca.qm
    \li \c /opt/foolib/foo.fr_ca
    \li \c /opt/foolib/foo.fr.qm
    \li \c /opt/foolib/foo.fr
    \li \c /opt/foolib/foo.qm
    \li \c /opt/foolib/foo
    \endlist
 
    Usually, it is better to use the QTranslator::load(const QLocale &,
    const QString &, const QString &, const QString &, const QString &)
    function instead, because it uses \l{QLocale::uiLanguages()} and not simply
    the locale name, which refers to the formatting of dates and numbers and not
    necessarily the UI language.
*/
 
bool QTranslator::load(const QString & filename, const QString & directory,
                       const QString & search_delimiters,
                       const QString & suffix)
{
    Q_D(QTranslator);
    QMutexLocker locker(&d->lock);
    d->clear();
 
    QString prefix;
    if (QFileInfo(filename).isRelative()) {
        prefix = directory;
        if (prefix.size() && !prefix.endsWith(u'/'))
            prefix += u'/';
    }
 
    const QString suffixOrDotQM = suffix.isNull() ? dotQmLiteral() : suffix;
    QStringView fname(filename);
    QString realname;
    const QString delims = search_delimiters.isNull() ? QStringLiteral("_.") : search_delimiters;
 
    for (;;) {
        QFileInfo fi;
 
        realname = prefix + fname + suffixOrDotQM;
        fi.setFile(realname);
        if (fi.isReadable() && fi.isFile())
            break;
 
        realname = prefix + fname;
        fi.setFile(realname);
        if (fi.isReadable() && fi.isFile())
            break;
 
        qsizetype rightmost = 0;
        for (auto ch : delims)
            rightmost = std::max(rightmost, fname.lastIndexOf(ch));
 
        // no truncations? fail
        if (rightmost == 0)
            return false;
 
        fname.truncate(rightmost);
    }
 
    // realname is now the fully qualified name of a readable file.
    return d->do_load(realname, directory);
}
 
bool QTranslatorPrivate::do_load(const QString &realname, const QString &directory)
{
    QTranslatorPrivate *d = this;
    bool ok = false;
 
    if (realname.startsWith(u':')) {
        // If the translation is in a non-compressed resource file, the data is already in
        // memory, so no need to use QFile to copy it again.
        Q_ASSERT(!d->resource);
        d->resource = std::make_unique<QResource>(realname);
        if (resource->isValid() && resource->compressionAlgorithm() == QResource::NoCompression
                && resource->size() >= MagicLength
                && !memcmp(resource->data(), magic, MagicLength)) {
            d->unmapLength = resource->size();
            d->unmapPointer = reinterpret_cast<char *>(const_cast<uchar *>(resource->data()));
#if defined(QT_USE_MMAP)
            d->used_mmap = false;
#endif
            ok = true;
        } else {
            resource = nullptr;
        }
    }
 
    if (!ok) {
        QFile file(realname);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Unbuffered))
            return false;
 
        qint64 fileSize = file.size();
        if (fileSize < MagicLength || fileSize > std::numeric_limits<qsizetype>::max())
            return false;
 
        {
            char magicBuffer[MagicLength];
            if (MagicLength != file.read(magicBuffer, MagicLength)
                    || memcmp(magicBuffer, magic, MagicLength))
                return false;
        }
 
        d->unmapLength = qsizetype(fileSize);
 
#ifdef QT_USE_MMAP
 
#ifndef MAP_FILE
#define MAP_FILE 0
#endif
#ifndef MAP_FAILED
#define MAP_FAILED reinterpret_cast<void *>(-1)
#endif
 
        int fd = file.handle();
        if (fd >= 0) {
            int protection = PROT_READ;                 // read-only memory
            int flags = MAP_FILE | MAP_PRIVATE;         // swap-backed map from file
            void *ptr = QT_MMAP(nullptr, d->unmapLength,// any address, whole file
                                protection, flags,
                                fd, 0);                 // from offset 0 of fd
            if (ptr != MAP_FAILED) {
                file.close();
                d->used_mmap = true;
                d->unmapPointer = static_cast<char *>(ptr);
                ok = true;
            }
        }
#endif // QT_USE_MMAP
 
        if (!ok) {
            d->unmapPointer = new (std::nothrow) char[d->unmapLength];
            if (d->unmapPointer) {
                file.seek(0);
                qint64 readResult = file.read(d->unmapPointer, d->unmapLength);
                if (readResult == qint64(unmapLength))
                    ok = true;
            }
        }
    }
 
    if (ok) {
        const QString base_dir =
                !directory.isEmpty() ? directory : QFileInfo(realname).absolutePath();
        if (d->do_load(reinterpret_cast<const uchar *>(d->unmapPointer), d->unmapLength,
                       base_dir)) {
            d->filePath = realname;
            return true;
        }
    }
 
#if defined(QT_USE_MMAP)
    if (used_mmap) {
        used_mmap = false;
        munmap(unmapPointer, unmapLength);
    } else
#endif
    if (!d->resource)
        delete [] unmapPointer;
 
    d->resource = nullptr;
    d->unmapPointer = nullptr;
    d->unmapLength = 0;
 
    return false;
}
 
bool QTranslatorPrivate::load_translation(const QStringList &languages,
                                          const QString &filename,
                                          const QString &prefix,
                                          const QString &directory,
                                          const QString &suffix)
{
    qCDebug(lcTranslator).noquote().nospace() << "Searching translation for "
                          << filename << prefix << languages << suffix
                          << " in " << directory;
    QString path;
    if (QFileInfo(filename).isRelative()) {
        path = directory;
        if (!path.isEmpty() && !path.endsWith(u'/'))
            path += u'/';
    }
    const QString suffixOrDotQM = suffix.isNull() ? dotQmLiteral() : suffix;
 
    QString realname;
    realname += path + filename + prefix; // using += in the hope for some reserve capacity
    const qsizetype realNameBaseSize = realname.size();
 
    // see http://www.unicode.org/reports/tr35/#LanguageMatching for inspiration
 
    // For each name returned by locale.uiLanguages(), also try a lowercase
    // version. Since these languages are used to create file names, this is
    // important on case-sensitive file systems, where otherwise a file called
    // something like "prefix_en_us.qm" won't be found under the "en_US"
    // locale. Note that the Qt resource system is always case-sensitive, even
    // on Windows (in other words: this codepath is *not* UNIX-only).
 
    auto loadFile = [this, &realname, &directory] { return do_load(realname, directory); };
 
    for (const QString &localeName : languages) {
        QString loc = localeName;
        // First try this given name, then in lower-case form (if different):
        while (true) {
            // First, try with suffix:
            realname += loc + suffixOrDotQM;
            if (loadFile())
                return true;
 
            // Next, try without:
            realname.truncate(realNameBaseSize + loc.size());
            if (loadFile())
                return true;
            // Reset realname:
            realname.truncate(realNameBaseSize);
 
            // Non-trivial while-loop condition:
            if (loc != localeName) // loc was the lower-case form, we're done.
                break;
            loc = std::move(loc).toLower(); // Try lower-case next,
            if (loc == localeName) // but only if different.
                break;
        }
    }
 
    const qsizetype realNameBaseSizeFallbacks = path.size() + filename.size();
 
    // realname == path + filename + prefix;
    if (!suffix.isNull()) {
        realname.replace(realNameBaseSizeFallbacks, prefix.size(), suffix);
        // realname == path + filename;
        if (loadFile())
            return true;
        realname.replace(realNameBaseSizeFallbacks, suffix.size(), prefix);
    }
 
    // realname == path + filename + prefix;
    if (loadFile())
        return true;
 
    realname.truncate(realNameBaseSizeFallbacks);
    // realname == path + filename;
    return loadFile();
}
 
/*!
    \since 4.8
 
    Loads \a filename + \a prefix + \l{QLocale::uiLanguages()}{ui language
    name} + \a suffix (".qm" if the \a suffix is not specified), which may be
    an absolute file name or relative to \a directory. Returns \c true if the
    translation is successfully loaded; otherwise returns \c false.
 
    The previous contents of this translator object are discarded.
 
    If the file name does not exist, other file names are tried
    in the following order:
 
    \list 1
    \li File name without \a suffix appended.
    \li File name with ui language part after a "_" character stripped and \a suffix.
    \li File name with ui language part stripped without \a suffix appended.
    \li File name with ui language part stripped further, etc.
    \endlist
 
    For example, an application running in the \a locale with the following
    \l{QLocale::uiLanguages()}{ui languages} - "es", "fr-CA", "de" might call
    load(QLocale(), "foo", ".", "/opt/foolib", ".qm"). load() would
    replace '-' (dash) with '_' (underscore) in the ui language and then try to
    open the first existing readable file from this list:
 
    \list 1
    \li \c /opt/foolib/foo.es.qm
    \li \c /opt/foolib/foo.es
    \li \c /opt/foolib/foo.fr_CA.qm
    \li \c /opt/foolib/foo.fr_CA
    \li \c /opt/foolib/foo.fr.qm
    \li \c /opt/foolib/foo.fr
    \li \c /opt/foolib/foo.de.qm
    \li \c /opt/foolib/foo.de
    \li \c /opt/foolib/foo.qm
    \li \c /opt/foolib/foo.
    \li \c /opt/foolib/foo
    \endlist
 
    On operating systems where file system is case sensitive, QTranslator also
    tries to load a lower-cased version of the locale name.
*/
bool QTranslator::load(const QLocale & locale,
                       const QString & filename,
                       const QString & prefix,
                       const QString & directory,
                       const QString & suffix)
{
    Q_D(QTranslator);
    const QStringList languages = locale.uiLanguages(QLocale::TagSeparator::Underscore);
    qCDebug(lcTranslator) << "Requested UI languages" << languages;
    QMutexLocker locker(&d->lock);
    d->clear();
    return d->load_translation(languages, filename, prefix, directory, suffix);
}
 
/*!
  \overload load()
 
  Loads the QM file data \a data of length \a len into the
  translator.
 
  The data is not copied. The caller must be able to guarantee that \a data
  will not be deleted or modified.
 
  \a directory is only used to specify the base directory when loading the dependencies
  of a QM file. If the file does not have dependencies, this argument is ignored.
*/
bool QTranslator::load(const uchar *data, int len, const QString &directory)
{
    Q_D(QTranslator);
    QMutexLocker locker(&d->lock);
    d->clear();
 
    if (!data || len < MagicLength || memcmp(data, magic, MagicLength))
        return false;
 
    return d->do_load(data, len, directory);
}
 
static quint8 read8(const uchar *data)
{
    return qFromBigEndian<quint8>(data);
}
 
static quint16 read16(const uchar *data)
{
    return qFromBigEndian<quint16>(data);
}
 
static quint32 read32(const uchar *data)
{
    return qFromBigEndian<quint32>(data);
}
 
bool QTranslatorPrivate::do_load(const uchar *data, qsizetype len, const QString &directory)
{
    bool ok = true;
    const uchar *end = data + len;
 
    data += MagicLength;
 
    QStringList dependencies;
    while (data < end - 5) {
        quint8 tag = read8(data++);
        quint32 blockLen = read32(data);
        data += 4;
        if (!tag || !blockLen)
            break;
        if (quint32(end - data) < blockLen) {
            ok = false;
            break;
        }
 
        if (tag == QTranslatorPrivate::Language) {
            language = QString::fromUtf8((const char *)data, blockLen);
        } else if (tag == QTranslatorPrivate::Contexts) {
            contextArray = data;
            contextLength = blockLen;
        } else if (tag == QTranslatorPrivate::Hashes) {
            offsetArray = data;
            offsetLength = blockLen;
        } else if (tag == QTranslatorPrivate::Messages) {
            messageArray = data;
            messageLength = blockLen;
        } else if (tag == QTranslatorPrivate::NumerusRules) {
            numerusRulesArray = data;
            numerusRulesLength = blockLen;
        } else if (tag == QTranslatorPrivate::Dependencies) {
            QDataStream stream(QByteArray::fromRawData((const char*)data, blockLen));
            QString dep;
            while (!stream.atEnd()) {
                stream >> dep;
                dependencies.append(dep);
            }
        }
 
        data += blockLen;
    }
 
    if (ok && !isValidNumerusRules(numerusRulesArray, numerusRulesLength))
        ok = false;
    if (ok) {
        subTranslators.reserve(std::size_t(dependencies.size()));
        for (const QString &dependency : std::as_const(dependencies)) {
            auto translator = std::make_unique<QTranslator>();
            ok = translator->load(dependency, directory);
            if (!ok)
                break;
            subTranslators.push_back(std::move(translator));
        }
 
        // In case some dependencies fail to load, unload all the other ones too.
        if (!ok)
            subTranslators.clear();
    }
 
    if (!ok) {
        messageArray = nullptr;
        contextArray = nullptr;
        offsetArray = nullptr;
        numerusRulesArray = nullptr;
        messageLength = 0;
        contextLength = 0;
        offsetLength = 0;
        numerusRulesLength = 0;
    }
 
    return ok;
}
 
static QString getMessage(const uchar *m, const uchar *end, const char *context,
                          const char *sourceText, const char *comment, uint numerus)
{
    const uchar *tn = nullptr;
    uint tn_length = 0;
    const uint sourceTextLen = uint(strlen(sourceText));
    const uint contextLen = uint(strlen(context));
    const uint commentLen = uint(strlen(comment));
 
    for (;;) {
        uchar tag = 0;
        if (m < end)
            tag = read8(m++);
        switch ((Tag)tag) {
        case Tag_End:
            goto end;
        case Tag_Translation: {
            int len = read32(m);
            if (len & 1)
                return QString();
            m += 4;
            if (!numerus--) {
                tn_length = len;
                tn = m;
            }
            m += len;
            break;
        }
        case Tag_Obsolete1:
            m += 4;
            break;
        case Tag_SourceText: {
            quint32 len = read32(m);
            m += 4;
            if (!match(m, len, sourceText, sourceTextLen))
                return QString();
            m += len;
        }
            break;
        case Tag_Context: {
            quint32 len = read32(m);
            m += 4;
            if (!match(m, len, context, contextLen))
                return QString();
            m += len;
        }
            break;
        case Tag_Comment: {
            quint32 len = read32(m);
            m += 4;
            if (*m && !match(m, len, comment, commentLen))
                return QString();
            m += len;
        }
            break;
        default:
            return QString();
        }
    }
end:
    if (!tn)
        return QString();
    QString str(tn_length / 2, Qt::Uninitialized);
    qFromBigEndian<char16_t>(tn, str.size(), str.data());
    return str;
}
 
QString QTranslatorPrivate::do_translate(const char *context, const char *sourceText,
                                         const char *comment, int n) const
{
    if (context == nullptr)
        context = "";
    if (sourceText == nullptr)
        sourceText = "";
    if (comment == nullptr)
        comment = "";
 
    uint numerus = 0;
    size_t numItems = 0;
 
    if (!offsetLength)
        goto searchDependencies;
 
    /*
        Check if the context belongs to this QTranslator. If many
        translators are installed, this step is necessary.
    */
    if (contextLength) {
        quint16 hTableSize = read16(contextArray);
        uint g = elfHash(context) % hTableSize;
        const uchar *c = contextArray + 2 + (g << 1);
        quint16 off = read16(c);
        c += 2;
        if (off == 0)
            return QString();
        c = contextArray + (2 + (hTableSize << 1) + (off << 1));
 
        const uint contextLen = uint(strlen(context));
        for (;;) {
            quint8 len = read8(c++);
            if (len == 0)
                return QString();
            if (match(c, len, context, contextLen))
                break;
            c += len;
        }
    }
 
    numItems = offsetLength / (2 * sizeof(quint32));
    if (!numItems)
        goto searchDependencies;
 
    if (n >= 0)
        numerus = numerusHelper(n, numerusRulesArray, numerusRulesLength);
 
    for (;;) {
        quint32 h = 0;
        elfHash_continue(sourceText, h);
        elfHash_continue(comment, h);
        elfHash_finish(h);
 
        const uchar *start = offsetArray;
        const uchar *end = start + ((numItems - 1) << 3);
        while (start <= end) {
            const uchar *middle = start + (((end - start) >> 4) << 3);
            uint hash = read32(middle);
            if (h == hash) {
                start = middle;
                break;
            } else if (hash < h) {
                start = middle + 8;
            } else {
                end = middle - 8;
            }
        }
 
        if (start <= end) {
            // go back on equal key
            while (start != offsetArray && read32(start) == read32(start - 8))
                start -= 8;
 
            while (start < offsetArray + offsetLength) {
                quint32 rh = read32(start);
                start += 4;
                if (rh != h)
                    break;
                quint32 ro = read32(start);
                start += 4;
                QString tn = getMessage(messageArray + ro, messageArray + messageLength, context,
                                        sourceText, comment, numerus);
                if (!tn.isNull())
                    return tn;
            }
        }
        if (!comment[0])
            break;
        comment = "";
    }
 
searchDependencies:
    for (const auto &translator : subTranslators) {
        QString tn = translator->translate(context, sourceText, comment, n);
        if (!tn.isNull())
            return tn;
    }
    return QString();
}
 
/*
    Empties this translator of all contents.
*/
 
void QTranslatorPrivate::clear()
{
    Q_Q(QTranslator);
    if (unmapPointer && unmapLength) {
#if defined(QT_USE_MMAP)
        if (used_mmap) {
            used_mmap = false;
            munmap(unmapPointer, unmapLength);
        } else
#endif
        if (!resource)
            delete [] unmapPointer;
    }
 
    resource = nullptr;
    unmapPointer = nullptr;
    unmapLength = 0;
    messageArray = nullptr;
    contextArray = nullptr;
    offsetArray = nullptr;
    numerusRulesArray = nullptr;
    messageLength = 0;
    contextLength = 0;
    offsetLength = 0;
    numerusRulesLength = 0;
 
    subTranslators.clear();
 
    language.clear();
    filePath.clear();
 
    if (QCoreApplicationPrivate::isTranslatorInstalled(q))
        QCoreApplication::postEvent(QCoreApplication::instance(),
                                    new QEvent(QEvent::LanguageChange));
}
 
/*!
    \threadsafe
 
    Returns the translation for the key (\a context, \a sourceText,
    \a disambiguation). If none is found, also tries (\a context, \a
    sourceText, ""). If that still fails, returns a null string.
 
    \note Incomplete translations may result in unexpected behavior:
    If no translation for (\a context, \a sourceText, "")
    is provided, the method might in this case actually return a
    translation for a different \a disambiguation.
 
    If \a n is not -1, it is used to choose an appropriate form for
    the translation (e.g. "%n file found" vs. "%n files found").
 
    If you need to programmatically insert translations into a
    QTranslator, this function can be reimplemented.
 
    \sa load()
*/
QString QTranslator::translate(const char *context, const char *sourceText, const char *disambiguation,
                               int n) const
{
    Q_D(const QTranslator);
 
    // Return early to avoid a deadlock in case translate() is called
    // from a code path triggered by QTranslator::load()
    if (!d->lock.tryLock())
        return QString();
    QString result = d->do_translate(context, sourceText, disambiguation, n);
    d->lock.unlock();
    return result;
}
 
/*!
    Returns \c true if this translator is empty, otherwise returns \c false.
*/
bool QTranslator::isEmpty() const
{
    Q_D(const QTranslator);
    return !d->messageArray && !d->offsetArray && !d->contextArray
            && d->subTranslators.empty();
}
 
/*!
    \since 5.15
 
    Returns the target language as stored in the translation file.
 */
QString QTranslator::language() const
{
    Q_D(const QTranslator);
    return d->language;
}
 
/*!
    \since 5.15
 
    Returns the path of the loaded translation file.
 
    The file path is empty if no translation was loaded yet,
    the loading failed, or if the translation was not loaded
    from a file.
 */
QString QTranslator::filePath() const
{
    Q_D(const QTranslator);
    return d->filePath;
}
 
QT_END_NAMESPACE
 
#include "moc_qtranslator.cpp"
 
#endif // QT_NO_TRANSLATION