QString QCoreApplication::translate(const char *context, const char *sourceText,

                                    const char *disambiguation, int n)

{

    QString result;

    if (!sourceText)

        return result;

    if (self && !self->d_func()->translators.isEmpty()) {

        QList<QTranslator*>::ConstIterator it;

        QTranslator *translationFile;

        for (it = self->d_func()->translators.constBegin(); it != self->d_func()->translators.constEnd(); ++it) {

            translationFile = *it;

            result = translationFile->translate(context, sourceText, disambiguation, n);

            if (!result.isNull())

                break;

        }

    }

    if (result.isNull())

        result = QString::fromUtf8(sourceText);

    replacePercentN(&result, n);

    return result;

}

static QString getMessage(const uchar *m, const uchar *end, const char *context,

                          const char *sourceText, const char *comment, uint numerus)

{

    const uchar *tn = ;

    uint tn_length = ;

    for (;;) {

        uchar tag = ;

        if (m < end)

            tag = read8(m++);

        switch((Tag)tag) {

        case Tag_End:

            goto end;

        case Tag_Translation: {

            int len = read32(m);

            if (len % )

                return QString();

            m += ;

            if (!numerus--) {

                tn_length = len;

                tn = m;

            }

            m += len;

            break;

        }

        case Tag_Obsolete1:

            m += ;

            break;

        case Tag_SourceText: {

            quint32 len = read32(m);

            m += ;

            if (!match(m, sourceText, len))

                return QString();

            m += len;

        }

            break;

        case Tag_Context: {

            quint32 len = read32(m);

            m += ;

            if (!match(m, context, len))

                return QString();

            m += len;

        }

            break;

        case Tag_Comment: {

            quint32 len = read32(m);

            m += ;

            if (*m && !match(m, comment, len))

                return QString();

            m += len;

        }

            break;

        default:

            return QString();

        }

    }

end:

    if (!tn)

        return QString();

    QString str = QString((const QChar *)tn, tn_length/);

    if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {

        for (int i = ; i < str.length(); ++i)

            str[i] = QChar((str.at(i).unicode() >> ) + ((str.at(i).unicode() << ) & 0xff00));

    }

    return str;

}

QString QTranslatorPrivate::do_translate(const char *context, const char *sourceText,

                                         const char *comment, int n) const

{

    if (context == )

        context = "";

    if (sourceText == )

        sourceText = "";

    if (comment == )

        comment = "";

    uint numerus = ;

    size_t numItems = ;

    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 +  + (g << );

        quint16 off = read16(c);

        c += ;

        if (off == )

            return QString();

        c = contextArray + ( + (hTableSize << ) + (off << ));

        for (;;) {

            quint8 len = read8(c++);

            if (len == )

                return QString();

            if (match(c, context, len))

                break;

            c += len;

        }

    }

    numItems = offsetLength / ( * sizeof(quint32));

    if (!numItems)

        goto searchDependencies;

    if (n >= )

        numerus = numerusHelper(n, numerusRulesArray, numerusRulesLength);

    for (;;) {

        quint32 h = ;

        elfHash_continue(sourceText, h);

        elfHash_continue(comment, h);

        elfHash_finish(h);

        const uchar *start = offsetArray;

        const uchar *end = start + ((numItems-) << );

        while (start <= end) {

            const uchar *middle = start + (((end - start) >> ) << );

            uint hash = read32(middle);

            if (h == hash) {

                start = middle;

                break;

            } else if (hash < h) {

                start = middle + ;

            } else {

                end = middle - ;

            }

        }

        if (start <= end) {

            // go back on equal key

            while (start != offsetArray && read32(start) == read32(start-))

                start -= ;

            while (start < offsetArray + offsetLength) {

                quint32 rh = read32(start);

                start += ;

                if (rh != h)

                    break;

                quint32 ro = read32(start);

                start += ;

                QString tn = getMessage(messageArray + ro, messageArray + messageLength, context,

                                        sourceText, comment, numerus);

                if (!tn.isNull())

                    return tn;

            }

        }

        if (!comment[])

            break;

        comment = "";

    }

searchDependencies:

    foreach (QTranslator *translator, subTranslators) {

        QString tn = translator->translate(context, sourceText, comment, n);

        if (!tn.isNull())

            return tn;

    }

    return QString();

}