Revision control
Copy as Markdown
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "validator.h"
#include "translator.h"
#ifndef LINGUIST_CONSOLE_APPLICATION
# include "phrase.h"
#endif
QT_USE_NAMESPACE
using namespace Qt::Literals::StringLiterals;
namespace {
static QString leadingWhitespace(const QString &str)
{
int i = 0;
for (; i < str.size(); i++) {
if (!str[i].isSpace()) {
break;
}
}
return str.left(i);
}
static QString trailingWhitespace(const QString &str)
{
int i = str.size();
while (--i >= 0) {
if (!str[i].isSpace()) {
break;
}
}
return str.mid(i + 1);
}
static Validator::Ending ending(QString str, QLocale::Language lang)
{
str = str.simplified();
if (str.isEmpty())
return Validator::End_None;
switch (str.at(str.size() - 1).unicode()) {
case 0x002e: // full stop
if (str.endsWith("..."_L1))
return Validator::End_Ellipsis;
else
return Validator::End_FullStop;
case 0x0589: // armenian full stop
case 0x06d4: // arabic full stop
case 0x3002: // ideographic full stop
return Validator::End_FullStop;
case 0x0021: // exclamation mark
case 0x003f: // question mark
case 0x00a1: // inverted exclamation mark
case 0x00bf: // inverted question mark
case 0x01c3: // latin letter retroflex click
case 0x037e: // greek question mark
case 0x061f: // arabic question mark
case 0x203c: // double exclamation mark
case 0x203d: // interrobang
case 0x2048: // question exclamation mark
case 0x2049: // exclamation question mark
case 0x2762: // heavy exclamation mark ornament
case 0xff01: // full width exclamation mark
case 0xff1f: // full width question mark
return Validator::End_Interrobang;
case 0x003b: // greek 'compatibility' questionmark
return lang == QLocale::Greek ? Validator::End_Interrobang : Validator::End_None;
case 0x003a: // colon
case 0xff1a: // full width colon
return Validator::End_Colon;
case 0x2026: // horizontal ellipsis
return Validator::End_Ellipsis;
default:
return Validator::End_None;
}
}
static bool haveMnemonic(const QString &str)
{
for (const ushort *p = (ushort *)str.constData();;) { // Assume null-termination
ushort c = *p++;
if (!c)
break;
if (c == '&') {
c = *p++;
if (!c)
return false;
// Matches QKeySequence::mnemonic(), except for
// '&#' - most likely the start of an NCR
// '& ' - too many false positives
if (c != '&' && c != ' ' && c != '#' && QChar(c).isPrint()) {
const ushort *pp = p;
for (; *p < 256 && isalpha(*p); p++)
;
if (pp == p || *p != ';')
return true;
// This looks like a HTML &entity;, so ignore it. As a HTML string
// won't contain accels anyway, we can stop scanning here.
break;
}
}
}
return false;
}
static QHash<int, int> countPlaceMarkers(const QString &str)
{
QHash<int, int> counts;
const QChar *c = str.unicode();
const QChar *cend = c + str.size();
while (c < cend) {
if (c->unicode() == '%') {
const QChar *escape_start = ++c;
while (c->isDigit())
++c;
const QChar *escape_end = c;
bool ok = true;
int markerIndex =
QString::fromRawData(escape_start, escape_end - escape_start).toInt(&ok);
if (ok)
counts[markerIndex]++;
} else {
++c;
}
}
return counts;
}
} // namespace
Validator Validator::fromSource(const QString &source, const Checks &checks,
const QLocale::Language &locale,
const QHash<QString, QList<Phrase *>> &phrases)
{
Q_UNUSED(phrases)
Validator v;
if (checks.accelerator)
v.m_haveMnemonic.emplace(haveMnemonic(source));
if (checks.punctuation)
v.m_ending.emplace(ending(source, locale));
if (checks.placeMarker)
v.m_placeMarkerCounts.emplace(countPlaceMarkers(source));
if (checks.surroundingWhiteSpace) {
v.m_leadingWhiteSpace.emplace(leadingWhitespace(source));
v.m_trailingWhiteSpace.emplace(trailingWhitespace(source));
}
#ifndef LINGUIST_CONSOLE_APPLICATION
if (checks.phraseMatch) {
v.m_matchingPhraseTargets.emplace();
QString fsource = friendlyString(source);
QStringList lookupWords = fsource.split(QLatin1Char(' '));
for (const QString &s : std::as_const(lookupWords))
if (auto wordPhrases = phrases.find(s); wordPhrases != phrases.constEnd())
for (const Phrase *p : *wordPhrases)
if (fsource == friendlyString(p->source()))
v.m_matchingPhraseTargets.value()[s].append(friendlyString(p->target()));
}
#endif
return v;
}
QList<Validator::Error> Validator::validate(QStringList translations, const TranslatorMessage &msg,
const QLocale::Language &locale,
QList<bool> countRefNeeds)
{
int i = 0;
QList<Error> errors;
for (QStringView translation : std::as_const(translations)) {
while (!translation.isEmpty()) {
auto sep = translation.indexOf(Translator::BinaryVariantSeparator);
if (sep < 0)
sep = translation.size();
const QString trans = translation.first(sep).toString();
const bool needsRef = msg.isPlural() && i < countRefNeeds.size() && countRefNeeds.at(i);
errors.append(validateTranslation(trans, locale, needsRef));
translation.slice(std::min(sep + 1, translation.size()));
}
i++;
}
return errors;
}
QList<Validator::Error> Validator::validateTranslation(const QString &translation,
const QLocale::Language &locale,
bool needsRef)
{
QList<Error> errors;
if (m_haveMnemonic && *m_haveMnemonic != haveMnemonic(translation))
errors.append(
{ *m_haveMnemonic ? MissingAccelerator : SuperfluousAccelerator, translation });
if (m_placeMarkerCounts) {
if (*m_placeMarkerCounts != countPlaceMarkers(translation))
errors.append({ PlaceMarkersDiffer, translation });
if (needsRef && !translation.contains(QLatin1String("%n"))
&& !translation.contains(QLatin1String("%Ln")))
errors.append({ NumerusMarkerMissing, translation });
}
if (m_ending && *m_ending != ending(translation, locale))
errors.append({ PunctuationDiffers, translation });
if (m_leadingWhiteSpace
&& (*m_leadingWhiteSpace != leadingWhitespace(translation)
|| *m_trailingWhiteSpace != trailingWhitespace(translation)))
errors.append({ SurroundingWhitespaceDiffers, translation });
#ifndef LINGUIST_CONSOLE_APPLICATION
if (m_matchingPhraseTargets) {
const QString ftranslation = friendlyString(translation);
for (auto itr = m_matchingPhraseTargets->cbegin(); itr != m_matchingPhraseTargets->cend();
itr++) {
bool found = false;
for (const QString &target : itr.value()) {
if (ftranslation.indexOf(target) >= 0) {
found = true;
break;
}
}
if (!found)
errors.append({ IgnoredPhrasebook, itr.key() });
}
}
#endif
return errors;
}