Revision control
++ // Copyright (C) 2026 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 "private/qtparsetemporal_p.h"
++
++ #include "private/qcalendarmath_p.h"
++ #include "private/qlocale_p.h"
++ #include "private/qstringiterator_p.h"
++ #include "private/qttemporalpattern_p.h"
++
++ #include <algorithm> // sort, stable_sort
++ #include <QtCore/qxpfunctional.h>
++ #include <optional>
++ #include <utility> // exchange, move, pair
++ #include <vector>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++ using namespace QtParseTemporal;
++ using namespace QtTemporalPattern;
++
++ struct PartialParse
++ {
++ ParsedTemporal results;
++ int periodInDay = -1; // 0: am, 1: pm
++ int hourMod12 = 0; // 1 through 12
++ int yearWithinCentury = -1; // 0 through 99
++ static constexpr int UnknownAmHour = -12, UnknownPmHour = 36;
++ enum Flaw : quint16 {
++ // Flaws that justify prefering a shorter parse without the flaw over
++ // longer with it, in order of decreasing severity:
++ Irreconcilable = 1, // field values cannot be reconciled
++ // Ideally continuations() would catch irreconcilable issues, but if one
++ // is expensive to spot it can be left for resolve() to flag up.
++ LegacyResolves = 2, // field values can only be resolved by ignoring timeType
++ ResolutionChanges = 4, // resolved values don't match parsed values
++ ZeroPad = 8, // used zero-padded part of text where field didn't require it
++ Narrow = 0x10, // used fewer digits from text than field width, where allowed
++
++ // Flaws not worth giving up a longer parse over, in decreasing order of
++ // strength of preference among those of equal length:
++ SelfResolved = 0x100, // ambiguous field values resolve cleanly
++ };
++ Q_DECLARE_FLAGS(Flaws, Flaw)
++ Flaws wanton = {};
++
++ // Constructor for initial empty parse:
++ PartialParse(qsizetype from) { results.startIndex = results.endIndex = from; }
++ // Constructors extending a parse with something more:
++ PartialParse(const PartialParse &base, const QtParseCommon::ParsedText &more)
++ : PartialParse(base)
++ {
++ Q_ASSERT(results.endIndex == more.startIndex);
++ results.endIndex = more.endIndex;
++ }
++ PartialParse(const PartialParse &base, const QtParseTimeZone::ParsedZone &more)
++ : PartialParse(base, (const QtParseCommon::ParsedText &)more)
++ {
++ results.zone = more.zone;
++ results.timeType = more.timeType;
++ }
++
++ Qt::weak_ordering compare(const PartialParse &alt) const noexcept
++ {
++ // Measures of how this->wanton differs from alt.wanton: it's worse if
++ // it has a flaw that alt lacks, better if the opposite. Here, "less" is
++ // used to mean "this is better than alt" as we sort better entries
++ // earlier in our lists of partial parse candidates.
++ const auto order = [better = alt.wanton & ~wanton,
++ worse = wanton & ~alt.wanton](Flaw test) {
++ Q_ASSERT(!(worse & better)); // So at most one of these testFlag()s is true:
++ if (better.testFlag(test))
++ return Qt::weak_ordering::less;
++ if (worse.testFlag(test))
++ return Qt::weak_ordering::greater;
++ return Qt::weak_ordering::equivalent;
++ };
++
++ if (auto res = order(Flaw::Irreconcilable); res != 0)
++ return res;
++
++ // In decreasing order of severity
++ if (auto res = order(Flaw::LegacyResolves); res != 0)
++ return res;
++ if (auto res = order(Flaw::ResolutionChanges); res != 0)
++ return res;
++ if (auto res = order(Flaw::Narrow); res != 0)
++ return res;
++
++ // The above take precedence over size: a shorter parse without those
++ // flaws is better than a longer one with them.
++
++ // Longer is better, to be understood as "sorts before" i.e. less than.
++ if (auto res = Qt::compareThreeWay(alt.results.size(), results.size()); res != 0)
++ return res;
++
++ // The following remains as a preference only among matches of the same
++ // length: it's nice to avoid, but a longer parse is still better.
++
++ if (auto res = order(Flaw::ZeroPad); res != 0)
++ return res;
++ if (auto res = order(Flaw::SelfResolved); res != 0)
++ return res;
++
++ return Qt::weak_ordering::equivalent;
++ }
++ };
++ Q_DECLARE_OPERATORS_FOR_FLAGS(PartialParse::Flaws)
++
++ QLocaleData::DigitSequence
++ parseDigitSequence(QStringView text, qsizetype from, const QLocale &locale, bool allowSign)
++ {
++ const auto *const data = QLocalePrivate::get(locale)->m_data;
++ using DS = QLocaleData::DigitSequence;
++ DS::Options flags;
++ if (allowSign)
++ flags.setFlag(DS::Option::AllowSign, true);
++ return data->digitSequence(text, flags, from);
++ }
++
++ std::vector<PartialParse> spacePadExtend(std::vector<PartialParse> matched, QStringView text)
++ {
++ // Pass the whole text: the results.endIndex of the last entry in matched is
++ // an index into it that we shall use to add entries that extend that entry.
++ Q_ASSERT(!matched.empty());
++ // Assumes matched.back()'s last field is allowed to end in space-padding
++ // and inserts a partial parse resulting from accepting each subsequent
++ // space as extending the match. Each longer match is inserted before all
++ // shorter matches. Only extensions of matched.back() are added, so call
++ // after adding each entry to matched, if adding several.
++ const qsizetype position = matched.size() - 1;
++ PartialParse copy = matched.back();
++ QStringIterator iter(text, copy.results.endIndex);
++ while (iter.hasNext() && QChar::isSpace(iter.next())) {
++ Q_ASSERT(iter.index() > copy.results.endIndex);
++ copy.results.endIndex = iter.index();
++ matched.insert(matched.begin() + position, copy);
++ }
++ return matched;
++ }
++
++ QtParseCommon::ParsedText matchedAt(QStringView text, qsizetype from, const QString &sought,
++ TemporalFieldFlags flags)
++ {
++ using F = TemporalFieldFlag;
++ const bool allowLeadingSpace = flags.testFlag(F::SpacePad);
++ Q_ASSERT(sought.size() > 0);
++ // Note: returns the first match within text[from:]. If sought is all space
++ // and SpacePad is set, there may be later matches if text[from:] starts
++ // with more space than (possibly some non-matching spaces, then) that.
++ // caller is expected to follow the match implied by the return from this
++ // with more generated by spacePadExtend().
++
++ const auto beginLength = [flex = flags.testFlag(F::FlexSpace),
++ strict = flags.testFlag(F::StrictSpace)]
++ (QStringView view, QStringView target, Qt::CaseSensitivity cs = Qt::CaseSensitive) {
++ // Technical hitch: case-insensitive comparison may match a string of
++ // different length. Roll a brute-force length-determining version:
++ const auto matchFront = [cs](QStringView view, QStringView target) -> qsizetype {
++ if (target.isEmpty()) // Only empty matches empty.
++ return 0;
++ if (view.startsWith(target, cs)) {
++ qsizetype length = target.size();
++ // Non-empty target can't be matched by view.first(0) so length
++ // == 1 won't satisfy this loop condition and, as length is
++ // initially > 0, we don't need to bounds-check this:
++ while (view.first(length - 1).startsWith(target, cs))
++ --length;
++ // We know view as a whole does start with target, so this won't
++ // run past length == view.size():
++ while (!view.first(length).startsWith(target, cs))
++ ++length;
++ Q_ASSERT(length > 0);
++ return length;
++ }
++ return -1;
++ };
++ const auto spacingForward = [](QStringIterator &iter) {
++ // Steps iter past next non-space, returns index at which it appeared.
++ qsizetype used;
++ do {
++ used = iter.index();
++ } while (iter.hasNext() && QChar::isSpace(iter.next()));
++ return used;
++ };
++ const auto matchingSpace = [](char32_t need, char32_t have) {
++ constexpr char32_t ASCIImax = 0x7f;
++ // Treat SPACE and non-ASCII spaces as equivalent:
++ if (need == U' ' || need > ASCIImax)
++ return have == U' ' || have > ASCIImax;
++ // Otherwise, require exact match:
++ return need == have;
++ };
++
++ constexpr qsizetype failed = 0;
++ qsizetype matched = 0;
++ if (flex || !strict) {
++ QStringIterator iter(target);
++ // Advance through the string; on each space, check match since last
++ // space then matching of spaces; and prune view, target past match.
++ while (iter.hasNext()) {
++ qsizetype head = iter.index();
++ if (const char32_t tgt = iter.next(); QChar::isSpace(tgt)) {
++ // Match any non-space stepped over since start or last space:
++ qsizetype same = head ? matchFront(view, target.first(head)) : 0;
++ if (same < 0)
++ return failed;
++ QStringIterator viter(view, same);
++ // Require at least one spacing character in view to match target's:
++ if (!viter.hasNext())
++ return failed;
++ if (const char32_t got = viter.next(); !QChar::isSpace(got))
++ return failed;
++ else if (flex)
++ same = spacingForward(viter);
++ else if (!matchingSpace(tgt, got))
++ return failed;
++ else
++ same = viter.index();
++ matched += same;
++ view = view.sliced(same);
++ target = target.sliced(flex ? spacingForward(iter) : iter.index());
++ iter = QStringIterator(target);
++ // In the flex case, the next iteration will step over a non-space:
++ Q_ASSERT(!flex || !iter.hasNext() || !QChar::isSpace(iter.peekNext()));
++ }
++ }
++ // If target isn't empty, it's a spacing-free tail, to be checked
++ // the same way we would the whole would be in strict mode.
++ }
++ const qsizetype tail = matchFront(view, target);
++ if (tail < 0)
++ return failed;
++ return matched + tail;
++ };
++ // TODO: consider a comparison that ignores Unicode invisibles, like BiDi
++ // markers, when matching.
++ qsizetype offset = 0;
++ do {
++ QStringView view = text.sliced(from + offset);
++ if (flags.testFlag(F::IgnoreCase)) {
++ if (qsizetype match = beginLength(view, sought, Qt::CaseInsensitive))
++ return {from, from + offset + match};
++ } else if (flags.testAnyFlags(F::LowerCase | F::UpperCase)) {
++ // If either case is specified, only match specified cases.
++ // If both cases are specified, accept either (but not mixed).
++ if (flags.testFlag(F::LowerCase)) {
++ if (qsizetype match = beginLength(view, sought.toLower()))
++ return {from, from + offset + match};
++ }
++ if (flags.testFlag(F::UpperCase)) {
++ if (qsizetype match = beginLength(view, sought.toUpper()))
++ return {from, from + offset + match};
++ }
++ // Otherwise, only an exact match is accepted:
++ } else if (qsizetype match = beginLength(view, sought)) {
++ return {from, from + offset + match};
++ }
++
++ // No match at this position; maybe later if leading space is allowed:
++ if (!allowLeadingSpace) {
++ Q_ASSERT(!offset);
++ break;
++ }
++
++ // Consume one space at a time until we find a match:
++ QStringIterator iter(text.sliced(from), offset);
++ if (!iter.hasNext() || !QChar::isSpace(iter.next()))
++ break;
++
++ Q_ASSERT(iter.index() > offset);
++ offset = iter.index();
++ } while (text.size() >= offset + sought.size() / 2);
++ // Loop wants to test text.size() >= offset + sought.size(), but see beginLength().
++ return {};
++ }
++
++ bool longerEarlier(const PartialParse &left, const PartialParse &right)
++ {
++ // True if we want left before right in our sorted lists.
++ // We want longer matches before shorter:
++ return left.results.endIndex > right.results.endIndex;
++ }
++
++ void forEachLocaleFormat(TemporalFieldFlags flags,
++ qxp::function_ref<void(QLocale::FormatType) const> action)
++ {
++ using Flag = TemporalFieldFlag;
++ constexpr auto Widths = FieldGroup::WidthMask;
++ if (matchesFlagWithin(flags, Flag::Wide, Widths))
++ action(QLocale::LongFormat);
++ if (matchesFlagsWithin(flags, Flag::Short | Flag::Abbreviated, Widths))
++ action(QLocale::ShortFormat);
++ if (matchesFlagWithin(flags, Flag::Narrow, Widths))
++ action(QLocale::NarrowFormat);
++ }
++
++ class TemporalFieldMatcher
++ {
++ const QLocale locale;
++ const QCalendar calendar;
++ const std::optional<int> baseYear;
++
++ // Numeric
++ struct FieldConfig
++ {
++ // Where to write the int, once read:
++ int &(*target)(PartialParse &);
++ bool alreadySet = false; // Did base parse already know this field ?
++ // Acceptable values:
++ int maxValue = 0; // 0 means unbounded
++ bool allowZero = false;
++ // Form of the parsed text:
++ qsizetype width; // min digits
++ qsizetype maxDigits = 0; // <= 0 means unbounded
++ // If unbounded, beyond max(width, roundAfter, -maxDigits) prefer fewer digits to more.
++ qsizetype roundAfter = -1; // >= 0: is fractional part: round to this many digits
++ // (Values with fewer than roundAfter digits will also be *=10'd up to match.)
++ // Special cases for year:
++ bool allowSign = false;
++ bool allowNegative = false;
++ };
++ // For use as FieldConfig::target:
++ static int &millisTarget(PartialParse &grow) { return grow.results.millis; }
++ static int &secondTarget(PartialParse &grow) { return grow.results.second; }
++ static int &minuteTarget(PartialParse &grow) { return grow.results.minute; }
++ static int &hourTarget(PartialParse &grow) { return grow.results.hour; }
++ static int &hourMod12Target(PartialParse &grow) { return grow.hourMod12; }
++ static int &dayOfWeekTarget(PartialParse &grow) { return grow.results.dayOfWeek; }
++ static int &dayOfMonthTarget(PartialParse &grow) { return grow.results.dayOfMonth; }
++ static int &monthTarget(PartialParse &grow) { return grow.results.month; }
++ static int &yearTarget(PartialParse &grow)
++ {
++ // Always called on a freshly-copied grow that shall be discarded unless
++ // year was previously unset or equal to the value about to be set. In
++ // the latter case we already have that value to return a reference to
++ // and in the former the caller already knows to overwrite, so setting
++ // any value will suffice to give us a reference it can overwrite:
++ if (!grow.results.year)
++ grow.results.year = 0;
++ return *grow.results.year;
++ }
++ static int &yearWithinCenturyTarget(PartialParse &grow) { return grow.yearWithinCentury; }
++
++ std::vector<PartialParse>
++ numericExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags, FieldConfig &&config) const;
++
++ // Verbal, Standalone:
++ std::vector<PartialParse> monthNameExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const;
++ std::vector<PartialParse> dayNameExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const;
++ std::pair<qsizetype, int> dayPeriodPrefix(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const;
++ public:
++ TemporalFieldMatcher(const QLocale &loc, QCalendar cal, std::optional<int> centuryStart)
++ : locale(loc), calendar(cal), baseYear(centuryStart)
++ {}
++
++ std::vector<PartialParse> continuations(const PartialParse &base, QStringView text,
++ const TemporalField &field) const;
++ bool isSelfConsistent(const PartialParse &parsed, TemporalFieldCategory category) const;
++ bool resolve(PartialParse &parsed) const;
++ };
++
++ bool TemporalFieldMatcher::isSelfConsistent(const PartialParse &parse,
++ TemporalFieldCategory category) const
++ {
++ // Take into account calendar, and potentially baseYear, but only do cheap
++ // checks. This will be run on *each* candidate parse after *each* field,
++ // need not check conditions the current field could not have affected.
++ using Cat = TemporalFieldCategory;
++ if (category == Cat::Literal) // Can't have introduced any inconsistency.
++ return true;
++
++ const bool newYear = category == Cat::Year || category == Cat::YearWithinCentury;
++ if (newYear && parse.yearWithinCentury >= 0 && parse.results.year
++ && (*parse.results.year - parse.yearWithinCentury) % 100) {
++ return false;
++ }
++
++ const bool newDate = (newYear || category == Cat::Month || category == Cat::DayOfMonth
++ || category == Cat::DayOfWeek);
++ if (newDate && parse.results.month && parse.results.dayOfMonth) {
++ // Calendrical calculations: somewhat expensive, but still arithmetic.
++ if (parse.results.year) {
++ if (!calendar.isDateValid(*parse.results.year, parse.results.month,
++ parse.results.dayOfMonth)) {
++ return false;
++ }
++ if (parse.results.dayOfWeek) {
++ QDate date = calendar.dateFromParts(*parse.results.year, parse.results.month,
++ parse.results.dayOfMonth);
++ if (calendar.dayOfWeek(date) != parse.results.dayOfWeek)
++ return false;
++ }
++ } else if (calendar.daysInMonth(parse.results.month) < parse.results.dayOfMonth) {
++ return false;
++ }
++ }
++
++ if ((category == Cat::PeriodInDay && parse.results.hour >= 0)
++ || (category == Cat::Hour && parse.periodInDay >= 0)) {
++ // 00, 01, ... 11 are 12, 1, ... 11 am; 12, 13, ... 23 are 12, 1, ..., 11 pm.
++ if (parse.periodInDay ? parse.results.hour < 12 : parse.results.hour >= 12)
++ return false;
++ }
++
++ if ((category == Cat::Hour && parse.hourMod12 > 0)
++ || (category == Cat::HourMod12 && parse.results.hour >= 0)) {
++ if ((parse.results.hour - parse.hourMod12) % 12)
++ return false;
++ }
++ return true;
++ }
++
++ bool TemporalFieldMatcher::resolve(PartialParse &parse) const
++ {
++ // Final pass, modifying parsed as needed, true if parse.result has been
++ // given a value consistent with all fields of parse. Applies fully rigorous
++ // checks, given what isSelfConsistent() already checked. May record flaws
++ // in parse.wanton where relevant tests reveal them.
++ if (parse.yearWithinCentury >= 0) {
++ if (parse.results.year) {
++ // Previously checked by isSelfConsistent():
++ Q_ASSERT((*parse.results.year - parse.yearWithinCentury) % 100 == 0);
++ } else if (baseYear) {
++ const auto baseSplit =QRoundingDown::qDivMod<100>(*baseYear);
++ int year = baseSplit.quotient * 100 + parse.yearWithinCentury;
++ if (parse.yearWithinCentury < baseSplit.remainder)
++ year += 100;
++
++ if (parse.results.month) {
++ // Check the year has this month and, if given, enough days in
++ // it for dayOfMonth:
++ const auto enough = [dom = parse.results.dayOfMonth](int dim) {
++ return dim > 0 && (!dom || dom <= dim);
++ };
++ if (!enough(calendar.daysInMonth(parse.results.month, year))) {
++ // Search outwards for a better century:
++ bool fixed = false;
++ for (int off = 1; off < 10; ++off) {
++ int offset = off * 100;
++ if (enough(calendar.daysInMonth(parse.results.month, year + offset))) {
++ year += offset;
++ fixed = true;
++ break;
++ }
++ if (enough(calendar.daysInMonth(parse.results.month, year - offset))) {
++ year -= offset;
++ fixed = true;
++ break;
++ }
++ }
++ // No century within a millennium each way will do:
++ if (!fixed)
++ return false;
++ }
++
++ if (parse.results.dayOfMonth) {
++ if (parse.results.dayOfWeek) {
++ QCalendar::YearMonthDay ymd
++ = { year, parse.results.month, parse.results.dayOfMonth };
++ const QDate resolved
++ = calendar.matchCenturyToWeekday(ymd, parse.results.dayOfWeek);
++ if (!resolved.isValid())
++ return false;
++ year = resolved.year(calendar);
++ } else {
++ const QDate resolved(year, parse.results.month, parse.results.dayOfMonth);
++ if (!resolved.isValid())
++ return false;
++ }
++ }
++ }
++
++ parse.results.year = year;
++ }
++ }
++
++ if (parse.results.hour < 0 && parse.hourMod12 > 0) {
++ Q_ASSERT(parse.hourMod12 <= 12);
++ parse.results.hour = parse.hourMod12 < 12 || parse.periodInDay < 0 ? parse.hourMod12 : 0;
++ if (parse.periodInDay > 0)
++ parse.results.hour += 12;
++ }
++
++ if (parse.results.year && parse.results.month && parse.results.dayOfMonth
++ && parse.results.zone.isValid() && parse.results.hour >= 0) {
++ // Should be able to construct a datetime with this:
++ const QDate date(*parse.results.year, parse.results.month, parse.results.dayOfMonth,
++ calendar);
++ Q_ASSERT(date.isValid()); // Should be ensured by earlier checks.
++ const QTime time = parse.results.time(QTime());
++ Q_ASSERT(time.isValid()); // Should be ensured by earlier checks.
++
++ // Is the given time in a transition of the given zone, on the given date ?
++ if (!Q_LIKELY(QDateTime(date, time, parse.results.zone,
++ QDateTime::TransitionResolution::Reject).isValid())) {
++ // Ambiguity, gap or outright borkage.
++ using Flaw = PartialParse::Flaw;
++ QDateTime dt(date, time, parse.results.zone, parse.results.resolveType());
++ if (!dt.isValid()) {
++ // Fall back to default resolution (same as LegacyBehavior):
++ dt = QDateTime(date, time, parse.results.zone);
++ // If that succeeded, Abbreviated (bad); otherwise Narrow (worse).
++ parse.wanton |= dt.isValid() ? Flaw::LegacyResolves : Flaw::Irreconcilable;
++ }
++ if (dt.date() != date || dt.time() != time
++ || dt.timeRepresentation() != parse.results.zone) {
++ // OK, resolution *worked* but didn't get exactly what we asked
++ // for (presumably a spring-forward's gap):
++ parse.wanton |= Flaw::ResolutionChanges;
++ // ... but we don't change parse.results because they should
++ // reflect what parsing learned; the caller can rediscover this.
++ } else {
++ // We got what we asked for (presumably the expected branch of a
++ // fall-back):
++ parse.wanton |= Flaw::SelfResolved;
++ }
++ }
++ }
++
++ if (parse.results.hour < 0) {
++ // Leave ParsedTemporal::time() a clue to am/pm, if known:
++ if (parse.periodInDay > 0)
++ parse.results.hour = PartialParse::UnknownPmHour;
++ else if (parse.periodInDay == 0)
++ parse.results.hour = PartialParse::UnknownAmHour;
++ }
++ return true;
++ }
++
++ std::vector<PartialParse>
++ TemporalFieldMatcher::numericExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags, FieldConfig &&config) const
++ {
++ std::vector<PartialParse> matches;
++
++ using Flag = TemporalFieldFlag;
++ qsizetype leadingSpace = 0;
++ const bool spacePad = flags.testFlag(Flag::SpacePad);
++ if (spacePad) {
++ QStringIterator iter(text, base.results.endIndex);
++ while (iter.hasNext() && QChar::isSpace(iter.next()))
++ ++leadingSpace;
++ // If that's used up the string, the code below shall reject the field.
++ }
++
++ const auto parsed = parseDigitSequence(text, base.results.endIndex + leadingSpace,
++ locale, config.allowSign);
++ if (parsed.sign == '-' && !config.allowNegative)
++ return matches;
++ const bool zeroPad = flags.testFlag(Flag::ZeroPad);
++ // If !zeroPad, we allow < config.width but flag with Narrow in wanton fields.
++ const int width = zeroPad || spacePad ? qMax(1, config.width - leadingSpace) : 1;
++ // This is necessarily positive: the use of chop(1) below depends on that.
++
++ QByteArrayView digits{parsed.digits};
++ // Parsed field must be representable in an int, so don't try to read more
++ // digits than an int can hold (digits10 is how many 9s in a row an int can
++ // hold; but int can hold some sequences one digit longer than that):
++ constexpr int intMaxDigits = std::numeric_limits<int>::digits10 + 1;
++ if (digits.size() > intMaxDigits)
++ digits = digits.first(intMaxDigits);
++ // Take config and flags into account, too:
++ if (config.maxDigits > 0) {
++ // Allow config.width to override config.maxDigits:
++ const int maxWidth = qMax(config.maxDigits, config.width);
++ if (digits.size() > maxWidth)
++ digits = digits.first(maxWidth);
++ } else if (flags.testFlag(Flag::YearSignIso8601) && !parsed.sign) {
++ // Limit width because a field longer than width would need a sign.
++ const int maxWidth = qMax(-config.maxDigits, config.width > 0 ? config.width : 1);
++ if (digits.size() > maxWidth)
++ digits = digits.first(maxWidth);
++ }
++ // For unbounded, work out in advance when to switch from prepending to
++ // appending; otherwise, set a cut-off that'll be true already.
++ const qsizetype appendThreshold = config.maxDigits <= 0
++ ? qMax(-config.maxDigits, qMax(config.width, config.roundAfter)) - 1
++ : digits.size();
++
++ for (; digits.size() >= width; digits.chop(1)) {
++ bool ok = false;
++ unsigned whole = digits.toUInt(&ok);
++ if (!ok)
++ continue;
++ if (config.maxValue > 0 && config.roundAfter < 0 && whole > unsigned(config.maxValue))
++ continue;
++
++ auto optvalue = [whole, forbidZero = !config.allowZero,
++ negate = parsed.sign == '-']() -> std::optional<int> {
++ constexpr unsigned maxInt = std::numeric_limits<int>::max();
++ if (negate && whole == 1 + maxInt)
++ return std::numeric_limits<int>::min();
++ if (whole > maxInt || (forbidZero && !whole))
++ return {};
++ return negate ? -int(whole) : int(whole);
++ }();
++ if (!optvalue) // Overflow or too low
++ continue;
++ int value = *optvalue;
++
++ if (config.roundAfter >= 0) {
++ // Fractional part
++ if (digits.size() < config.roundAfter) {
++ // Interpolate omitted zero-padding up to rounding size:
++ for (int i = int(digits.size()); i < config.roundAfter; ++i)
++ value *= 10;
++ } else if (digits.size() > config.roundAfter) {
++ double v = value;
++ for (int i = int(digits.size()); i > config.roundAfter; --i)
++ v /= 10.;
++ // A timestamp that's before the end of a specified second
++ // should be rounded to the last we can before that second,
++ // especially if it's the last second of its minute, in turn
++ // especially if that's the last second of its hour (and so on).
++ value = v > config.maxValue ? config.maxValue : qRound(v);
++ // There may of course be use-cases where rounding up to the
++ // next second is desired. If it turns out those are
++ // significant, we can perhaps add a field option for it.
++ }
++ // else: exact match to number of digits, nothing to frob.
++ }
++
++ PartialParse grow = base;
++ int &target = config.target(grow);
++ if (!config.alreadySet) // If not previously set, store:
++ target = value;
++ else if (target != value) // Conflicts with earlier field: skip this reading.
++ continue;
++ grow.results.endIndex = parsed.digitBounds[digits.size()];
++
++ if (!zeroPad && digits.size() > qMax(1, config.width)
++ && (config.roundAfter < 0 ? digits.startsWith('0') : digits.endsWith('0'))) {
++ grow.wanton |= PartialParse::Flaw::ZeroPad;
++ }
++ if (digits.size() + leadingSpace < config.width) // (can only happen if !zeroPad)
++ grow.wanton |= PartialParse::Flaw::Narrow;
++
++ // Entries in matches are all longer than this one, as we're reducing
++ // digits. Mostly we want shorter after longer, but (for example) we
++ // prefer 4-digit years over longer matches.
++ if (digits.size() > appendThreshold)
++ matches.insert(matches.begin(), std::move(grow));
++ else
++ matches.push_back(std::move(grow));
++ }
++ return matches;
++ }
++
++ /* Some month names may be prefixes of others.
++ For example, the English long forms of Islamic calendar month names include:
++ * RabiÊ» I, RabiÊ» II
++ * Jumada I, Jumada II
++ Their short-forms are likewise:
++ * Rab. I, Rab. II
++ * Jum. I, Jum. II
++ In each case, one month name is a prefix of the next month's name.
++
++ In any sane format, greedy parsing shall suffice but ill-considered formats
++ happen. So the initial parse recognizes every possible match and we sort out
++ any mistakes greed might make as we parse later fields.
++ */
++ std::vector<PartialParse>
++ TemporalFieldMatcher::monthNameExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const
++ {
++ std::vector<PartialParse> matches;
++ using Flag = TemporalFieldFlag;
++
++ const auto addIfMatch = [&matches, &base, text, flags](int month, const QString &name) {
++ // tryEachMonth() has ensured this:
++ Q_ASSERT(!base.results.month || base.results.month == month);
++ if (name.isEmpty()) // Locale doesn't know this month's name.
++ return;
++ // If matchedAt(), add to matches:
++ auto match = matchedAt(text, base.results.endIndex, name, flags);
++ if (match) {
++ matches.emplace_back(base, match).results.month = month;
++ if (flags.testFlag(Flag::SpacePad))
++ matches = spacePadExtend(std::move(matches), text);
++ }
++ };
++
++ constexpr auto Forms = FieldGroup::FormMask;
++ constexpr int noYear = QCalendar::Unspecified;
++ const bool verb = matchesFlagWithin(flags, Flag::Verbal, Forms);
++ const bool lone = matchesFlagWithin(flags, Flag::Standalone, Forms);
++ const int year = base.results.year ? *base.results.year : noYear;
++ // We could try to take account of baseYear, when yearWithinCentury is
++ // known, but that's susceptible to tweaks and perturbation from other
++ // fields, so stick with noYear and the usual naming of months if we don't
++ // know year. We can consider adding a QCalendar::parseMonthName() that can
++ // consult the internal lists of localized month names, both for efficiency
++ // and to ensure we try all names, including those that appear only in some
++ // years. If we do that, its return should package month number, whether the
++ // month appears in all years and whether it was standalone or plain, along
++ // with the start and end indices of the match within the text.
++ const auto tryEachNameType = [&](QLocale::FormatType form, int month) {
++ if (lone)
++ addIfMatch(month, calendar.standaloneMonthName(locale, month, year, form));
++ if (verb)
++ addIfMatch(month, calendar.monthName(locale, month, year, form));
++ };
++ // This could in principle, for non-system locales, be done more efficiently
++ // by walking the internal ';'-joined list of month names QCalendarBackend
++ // can give us. The entanglement between QCalendarBackend and QLocale
++ // internals is, however, already quite untidy enough, so leave that for
++ // if/when we discover it's a significant bottle-neck and/or we've unpicked
++ // the existing entanglement a bit first.
++
++ const auto tryEachMonth = [month = base.results.month,
++ bound = calendar.maximumMonthsInYear(),
++ &tryEachNameType](QLocale::FormatType form) {
++ if (month > 0) {
++ tryEachNameType(form, month);
++ } else {
++ for (int i = bound; i > 0; --i)
++ tryEachNameType(form, i);
++ }
++ };
++ forEachLocaleFormat(flags, tryEachMonth);
++
++ return matches;
++ }
++
++ std::vector<PartialParse>
++ TemporalFieldMatcher::dayNameExtend(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const
++ {
++ std::vector<PartialParse> matches;
++ using Flag = TemporalFieldFlag;
++
++ const auto addIfMatch = [&matches, &base, text, flags](int dow, const QString &name) {
++ // tryEachDayOfWeek() has ensured this:
++ Q_ASSERT(!base.results.dayOfWeek || base.results.dayOfWeek == dow);
++ if (name.isEmpty()) // Locale doesn't know this day of the week's name.
++ return;
++ // If matchedAt(), add to matches:
++ auto match = matchedAt(text, base.results.endIndex, name, flags);
++ if (match) {
++ matches.emplace_back(base, match).results.dayOfWeek = dow;
++ if (flags.testFlag(Flag::SpacePad))
++ matches = spacePadExtend(std::move(matches), text);
++ }
++ };
++
++ constexpr auto Forms = FieldGroup::FormMask;
++ const bool verb = matchesFlagWithin(flags, Flag::Verbal, Forms);
++ const bool lone = matchesFlagWithin(flags, Flag::Standalone, Forms);
++ const auto tryEachNameType = [&](QLocale::FormatType form, int dow) {
++ if (lone)
++ addIfMatch(dow, calendar.standaloneWeekDayName(locale, dow, form));
++ if (verb)
++ addIfMatch(dow, calendar.weekDayName(locale, dow, form));
++ };
++ // As for month names (see above), some collaboration with QCalendarBackend
++ // might make this more efficient for non-system locales, at the expense of
++ // adding to the existing tangle of complexity.
++
++ const auto tryEachDayOfWeek = [dow = base.results.dayOfWeek,
++ &tryEachNameType](QLocale::FormatType form) {
++ if (dow > 0) {
++ tryEachNameType(form, dow);
++ } else {
++ // Iterate possible day numbers. Issue: some calendars might have
++ // intercalary days with numbers > 7. When that happens, we may
++ // need to let this run past 7 until it's seen some empty answers.
++ for (int i = 1; i <= 7; ++i)
++ tryEachNameType(form, i);
++ }
++ };
++ forEachLocaleFormat(flags, tryEachDayOfWeek);
++
++ std::sort(matches.begin(), matches.end(), longerEarlier);
++ return matches;
++ }
++
++ std::pair<qsizetype, int>
++ TemporalFieldMatcher::dayPeriodPrefix(const PartialParse &base, QStringView text,
++ TemporalFieldFlags flags) const
++ {
++ std::pair<qsizetype, int> result = {0, -1};
++ for (int i = 0; i < 2; ++i) {
++ if (base.periodInDay >= 0 && base.periodInDay != i)
++ continue;
++ if (const QString token = i ? locale.pmText() : locale.amText(); !token.isEmpty()) {
++ if (auto match = matchedAt(text, base.results.endIndex, token, flags);
++ match.endIndex > result.first) {
++ result = { match.endIndex, i };
++ }
++ }
++ }
++ return result;
++ }
++
++ /*!
++ \internal
++ Find all matches to \a field, within \a text, that extend \a base.
++
++ Each match must begin at offset \c{base.results.endIndex} within \a text.
++ For each match, update a copy of \a base with the match's result, to include
++ in the returned list.
++
++ May use \c calendar to determine the range of values allowed for field.
++ Does not attempt to determine consistency between fields; see resolve() and
++ isSelfConsistent() for that. Updates the copy's member holding the value
++ described by \a field to reflect the match.
++
++ Ignores base.result.startIndex and base.result.bounds and updates each
++ copy's .endIndex to reflect the end of the match. (This leaves the caller to
++ decide whether to transfer that to .bounds.)
++
++ For fields that allow space padding, this consumes leading space as
++ necessary to make a match and includes a match for each end position at
++ which it could end; before any dangling space and after each space that
++ follows. Later calls to \c continuations() shall filter out any earlier
++ matches that precludes later fields matching just after its end. Successive
++ space-padded fields surrounded by large amounts of space are apt to lead to
++ many matches, as are final space-padded fields followed by large amounts of
++ space. (TODO: we can almost certainly mitigate this with a trivial
++ heuristic, once everything is working.)
++
++ For those matches with various flaws, relative to the field specification
++ (such as using zero padding when not obliged to), the copy's .wanton records
++ that flaw.
++
++ Sort order of the returned list should put entries likely to represent more
++ suitable matches (ignoring .wanton complications) earlier. For most fields,
++ that means longer matches come first. (For full year field matches with > 4
++ digits, though, that reverses.)
++ */
++ std::vector<PartialParse>
++ TemporalFieldMatcher::continuations(const PartialParse &base, QStringView text,
++ const TemporalField &field) const
++ {
++ std::vector<PartialParse> matches;
++ const qsizetype textPos = base.results.endIndex;
++ switch (field.category) {
++ using Cat = TemporalFieldCategory;
++ using Flag = TemporalFieldFlag;
++ case Cat::EndCategories:
++ Q_UNREACHABLE();
++ case Cat::Literal:
++ if (auto match = matchedAt(text, textPos, field.literal, field.options)) {
++ matches.emplace_back(base, match);
++ if (field.options.testFlag(Flag::SpacePad))
++ matches = spacePadExtend(std::move(matches), text);
++ }
++ break;
++ case Cat::TimeZone:
++ if (const auto zones = QtParseTimeZone::prefix(text, locale, textPos, field.options);
++ !zones.isEmpty()) {
++ for (const auto &match : zones) {
++ matches.emplace_back(base, match);
++ if (field.options.testFlag(Flag::SpacePad))
++ matches = spacePadExtend(std::move(matches), text);
++ }
++ }
++ break;
++
++ // case Cat::MillisecondInDay: break;
++ case Cat::SecondFraction:
++ // QTime, QDateTime only support millisecond precision, so use 3 as roundAfter.
++ // That's also maxDigits, unless RoundFraction => unlimited.
++ matches = numericExtend(base, text, field.options,
++ {millisTarget, base.results.millis >= 0, 999, true, field.width,
++ field.options.testFlag(Flag::RoundFraction) ? 0 : 3, 3});
++ break;
++ case Cat::Second:
++ matches = numericExtend(base, text, field.options,
++ {secondTarget, base.results.second >= 0, 59, true, field.width, 2});
++ break;
++ // case Cat::MinuteFraction: break;
++ case Cat::Minute:
++ matches = numericExtend(base, text, field.options,
++ {minuteTarget, base.results.minute >= 0, 59, true, field.width, 2});
++ break;
++ // case Cat::HourFraction: break;
++ case Cat::HourMod12:
++ matches = numericExtend(base, text, field.options,
++ {hourMod12Target, base.hourMod12 > 0, 12, false, field.width, 2});
++ break;
++ case Cat::Hour:
++ matches = numericExtend(base, text, field.options,
++ {hourTarget, base.results.hour >= 0, 23, true, field.width, 2});
++ break;
++ case Cat::PeriodInDay: // am/pm; LDML also has noon, midnight, "at night" and others.
++ if (const auto match = dayPeriodPrefix(base, text, field.options); match.second >= 0) {
++ // Ensured by dayPeriodPrefix:
++ Q_ASSERT(base.periodInDay < 0 || base.periodInDay == match.second);
++ PartialParse &grow = matches.emplace_back(base);
++ grow.results.endIndex = match.first;
++ grow.periodInDay = match.second;
++ if (field.options.testFlag(Flag::SpacePad))
++ matches = spacePadExtend(std::move(matches), text);
++ }
++ break;
++
++ case Cat::DayOfWeek:
++ matches = dayNameExtend(base, text, field.options);
++ break;
++ case Cat::DayOfMonth: {
++ const int maxDays = calendar.maximumDaysInMonth();
++ matches = numericExtend(base, text, field.options,
++ {dayOfMonthTarget, base.results.dayOfMonth > 0, maxDays, false,
++ field.width, maxDays < 10 ? 1 : maxDays < 100 ? 2 : 3});
++ }
++ break;
++ // case Cat::DayOfYear: break;
++ // case Cat::JulianDay: break;
++ // case Cat::WeekOfMonth: break;
++ // case Cat::WeekOfYear: break;
++ case Cat::Month:
++ // Verbal and Standalone, in so far as supported:
++ matches = monthNameExtend(base, text, field.options);
++ if (matchesFlagWithin(field.options, Flag::Numeric, FieldGroup::FormMask)) {
++ auto extend = numericExtend(base, text, field.options,
++ {monthTarget, base.results.month > 0,
++ calendar.maximumMonthsInYear(), false, field.width, 2});
++ if (matches.empty())
++ matches = std::move(extend);
++ else
++ matches.insert(matches.end(), extend.begin(), extend.end());
++ }
++ std::sort(matches.begin(), matches.end(), longerEarlier);
++ break;
++ // case Cat::Quarter: break;
++ case Cat::YearWithinCentury:
++ matches = numericExtend(base, text, field.options,
++ {yearWithinCenturyTarget, base.yearWithinCentury >= 0,
++ 99, true, field.width, 2});
++ break;
++ case Cat::Year:
++ matches = numericExtend(base, text, field.options,
++ {yearTarget, bool(base.results.year), 0, calendar.hasYearZero(),
++ field.width, -4, -1, true, calendar.isProleptic()});
++ break;
++ // case Cat::RelatedGregorianYear: break;
++ // case Cat::Century: break;
++ // case Cat::Era: break;
++ }
++ return matches;
++ }
++
++ } // nameless namespace
++
++ namespace QtParseTemporal {
++ QDate ParsedTemporal::date(QCalendar cal, QDate defaults) const
++ {
++ if (defaults.isValid()) {
++ QDate draft(year ? *year : defaults.year(cal), month ? month : defaults.month(cal),
++ dayOfMonth ? dayOfMonth : defaults.day(cal), cal);
++
++ if (dayOfWeek && draft.isValid() && draft.dayOfWeek(cal) != dayOfWeek) {
++ // Defaults conflict with parsed day of the week.
++ if (!dayOfMonth) {
++ // (Assumes no intercalary days.)
++ // Number of days to the nearest with the right day of the week:
++ const int offset = (dayOfWeek + 10 - draft.dayOfWeek(cal)) % 7 - 3;
++ Q_ASSERT(offset != 0); // Otherwise, day of week matched, already.
++ Q_ASSERT(-4 < offset && offset < 4);
++ // Prefer closer unless nearby has more in common with what we asked for:
++ QDate closer = draft.addDays(offset);
++ QDate nearby = draft.addDays(offset < 0 ? offset + 7 : offset - 7);
++ if (nearby.isValid()
++ && (!closer.isValid()
++ || (closer.dayOfWeek(cal) != dayOfWeek
++ && nearby.dayOfWeek(cal) == dayOfWeek)
++ || (closer.month(cal) != draft.month(cal)
++ && nearby.month(cal) == draft.month(cal)))) {
++ // (We could also give year(cal) the same treatment, but
++ // different year, for dates within ten days of one another,
++ // plies different month, so check would be redundant.)
++ std::swap(nearby, draft);
++ } else if (closer.isValid() && closer.dayOfWeek(cal) == dayOfWeek) {
++ std::swap(closer, draft);
++ }
++
++ } else if (!month) {
++ Q_ASSERT(draft.day() == dayOfMonth);
++ auto use = [&draft, cal, dow=dayOfWeek](int yr, int mon, int day) {
++ QDate maybe(yr, mon, day, cal);
++ if (!maybe.isValid() || maybe.dayOfWeek(cal) != dow)
++ return false;
++ std::swap(maybe, draft);
++ return true;
++ };
++ // Find nearest month with the right dayOfMonth and dayOfWeek.
++ // If year was specified we're limited to it; otherwise,
++ // draft.year() is derived from defaults so the search can
++ // spread to nearby years.
++ int loYear = draft.year(cal), hiYear = loYear;
++ int loMon = draft.month(cal), hiMon = loMon;
++ bool maybeLo = true, maybeHi = true;
++ while (maybeLo || maybeHi) {
++ if (maybeHi) {
++ if (hiMon < cal.monthsInYear(hiYear)) {
++ ++hiMon;
++ } else if (year) {
++ Q_ASSERT(hiYear == *year);
++ maybeHi = false;
++ } else if (hiYear + 1 || cal.hasYearZero()) {
++ ++hiYear;
++ hiMon = 1;
++ } else if (cal.isProleptic()) {
++ hiYear = +1;
++ hiMon = 1;
++ } else {
++ maybeHi = false;
++ }
++ }
++ if (maybeHi && use(hiYear, hiMon, dayOfMonth))
++ break;
++
++ if (maybeLo) {
++ if (loMon > 1) {
++ --loMon;
++ } else if (year) {
++ Q_ASSERT(loYear == *year);
++ maybeLo = false;
++ } else if (loYear - 1 || cal.hasYearZero()) {
++ --loYear;
++ loMon = cal.monthsInYear(loYear);
++ } else if (cal.isProleptic()) {
++ loYear = -1;
++ loMon = cal.monthsInYear(loYear);
++ } else {
++ maybeLo = false;
++ }
++ }
++ if (maybeLo && use(loYear, loMon, dayOfMonth))
++ break;
++
++ // Avoid looping for ever: if we can't find a match within a
++ // 30 year window we probably never shall. If we haven't
++ // found a match by then, the likelihood that the input has
++ // a typo in it is fairly high, in any case.
++ if (hiYear - loYear > 30)
++ break;
++ }
++ } else if (!year) {
++ // As for resolve()'s handling of two-digit centuries:
++ QCalendar::YearMonthDay ymd = { draft.year(cal), month, dayOfMonth };
++ QDate maybe = cal.matchCenturyToWeekday(ymd, dayOfWeek);
++ if (maybe.isValid() && maybe.dayOfWeek(cal) == dayOfWeek)
++ std::swap(maybe, draft);
++ }
++ if (draft.dayOfWeek(cal) != dayOfWeek)
++ return {};
++ }
++ return draft;
++ }
++ if (year && month && dayOfMonth)
++ return QDate(*year, month, dayOfMonth, cal);
++ return {};
++ }
++
++ QTime ParsedTemporal::time(QTime defaults) const
++ {
++ if (defaults.isValid()) {
++ int hr = defaults.hour();
++ // hour: -1 means we have no information, less means unknown am, > 24 means unknown pm.
++ if (hour < -1) // UnknownAmHour
++ hr = hr % 12;
++ else if (hour > 24) // UnknownPmHour
++ hr = hr % 12 + 12;
++ else if (hour >= 0)
++ hr = hour;
++ // (Note: hour == 24 is currently unused but may be relevant for 24:00:00 in future.)
++ return QTime(hr,
++ minute < 0 ? defaults.minute() : minute,
++ second < 0 ? defaults.second() : second,
++ millis < 0 ? defaults.msec() : millis);
++ }
++
++ if (hour < 0 || hour > 24)
++ return {};
++ if (minute < 0)
++ return QTime(hour, 0);
++ if (second < 0)
++ return QTime(hour, minute);
++ if (millis < 0)
++ return QTime(hour, minute, second);
++ return QTime(hour, minute, second, millis);
++ }
++
++ ParsedTemporal prefix(QStringView text, QSpan<const QtTemporalPattern::TemporalField> fields,
++ const QLocale &locale, QCalendar cal,
++ std::optional<int> baseYear, qsizetype from)
++ {
++ if (from < 0 || from >= text.size())
++ return {};
++
++ const TemporalFieldMatcher matcher(locale, cal, baseYear);
++ // Technically this is the correct (empty) result when fields.isEmpty():
++ std::vector<PartialParse> maybe;
++ maybe.emplace_back(from);
++
++ qsizetype toCome = fields.size();
++ for (const QtTemporalPattern::TemporalField &field : fields) {
++ --toCome;
++ const std::vector<PartialParse> prior = std::exchange(maybe, {});
++ for (const PartialParse &base : prior) {
++ std::vector<PartialParse> more
++ = matcher.continuations(base, text, field);
++ for (PartialParse &candidate : more) {
++ // Consistency won't have been changed by a literal field:
++ if ((field.category == TemporalFieldCategory::Literal
++ || matcher.isSelfConsistent(candidate, field.category))) {
++ if (toCome) // Earlier fields' ends go in bounds:
++ candidate.results.bounds.push_back(candidate.results.endIndex);
++ else if (!matcher.resolve(candidate)) // Last field: makes sense of it all.
++ continue;
++ maybe.push_back(std::move(candidate));
++ }
++ }
++ }
++ if (maybe.empty()) // No point continuing
++ return {};
++ }
++ // Now select our most favourable entry from maybe.
++
++ // Although we've, thus far, prefered sensible-length matches over longer
++ // ones in individual numeric fields, so that later numeric fields can take
++ // up the slack and win, we still want to be greedy over-all, so prefer
++ // overall longer matches to shorter ones. None the less, between matches of
++ // equal length, preserve our preference, up to now, for sane lengths of
++ // each field within that, as long as later fields are taking up the slack.
++ // That preference can be fine-tuned via .wanton, see PartialParse::Flaw.
++ PartialParse best = maybe.front();
++ for (const PartialParse &match : QSpan{maybe}.sliced(1)) {
++ if (match.compare(best) < 0)
++ best = match;
++ }
++ return best.results;
++ }
++
++ } // QtParseTemporal
++
++ QT_END_NAMESPACE