qtparseqttemporalformat.cpp

Go to the documentation of this file.

// 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/qtparseqttemporalformat_p.h"
 
#include "private/qlocale_p.h"
#include "private/qstringiterator_p.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace QtParseQtTemporalFormat {
 
inline constexpr char timeFormats[] = "Hhmsz"; // Omits [aA][pP]? deliberately.
inline constexpr char dateFormats[] = "Mdy";
 
ParsedDateTimeFormat prefix(QStringView pattern, QtTemporalPattern::DateTimeParts form)
{
    using namespace QtTemporalPattern;
 
    ParsedDateTimeFormat result;
    constexpr char32_t Invalid = ~char32_t(0);
    static_assert(Invalid > QChar::LastValidCodePoint);
    const bool includeDate = form.testFlag(DateTimePart::Date);
    const bool includeTime = form.testFlag(DateTimePart::Time);
    const bool includeZone = form.testFlag(DateTimePart::Zone);
 
    QStringIterator iter(pattern);
    char32_t pending = 0;
    const auto countRepeats = [&pending, &iter, &result](char32_t first, qsizetype bound) {
        // Consumes all repeats of \a first, returns min(bound, number of repeats).
        Q_ASSERT(!QChar::requiresSurrogates(first)); // It's always an ASCII format char
        Q_ASSERT(pending == 0);
        qsizetype count = 1; // We've already seen first
        result.endIndex = iter.index(); // ... and tacitly consumed it.
        while (iter.hasNext() && count < bound) {
            const auto read = iter.next(Invalid);
            if (read > QChar::LastValidCodePoint) {
                pending = Invalid;
                break;
            }
            if (read != first) {
                pending = read;
                break;
            }
            ++count;
            result.endIndex = iter.index();
        }
        return count;
    };
 
    constexpr char32_t SingleQuote = U'\'';
    static constexpr auto matchTimeFormats = QtPrivate::makeCharacterSetMatch<timeFormats>();
    static constexpr auto matchDateFormats = QtPrivate::makeCharacterSetMatch<dateFormats>();
    const auto isFormatChar = [includeDate, includeTime, includeZone](char32_t ch) {
        if (ch >= 0x80)
            return false;
        if (includeTime) {
            if (matchTimeFormats.matches(uchar(ch)) || ch == U'A' || ch == U'a')
                return true;
        }
        if (includeZone && ch == U't')
            return true;
        return includeDate && matchDateFormats.matches(uchar(ch));
    };
 
    constexpr auto formatCategory = [](uchar ch, int count) {
        using Cat = TemporalFieldCategory;
        switch (ch) {
        case 'A': // case 'P':
        case 'a': // case 'p':
            return Cat::PeriodInDay;
        case 'd': return count < 3 ? Cat::DayOfMonth : Cat::DayOfWeek;
        case 'H': return Cat::Hour;
        case 'h': return Cat::HourMod12;
        case 'M': return Cat::Month;
        case 'm': return Cat::Minute;
        case 's': return Cat::Second;
        case 't': return Cat::TimeZone;
        case 'y': return count < 3 ? Cat::YearWithinCentury : Cat::Year;
        case 'z': return Cat::SecondFraction;
        }
        // Should only be called with a ch that would pass an isFormatChar() check.
        Q_UNREACHABLE_RETURN(Cat::Literal);
    };
    constexpr auto formatFlags = [](uchar ch, int count) -> TemporalFieldFlags {
        using F = TemporalFieldFlag;
        constexpr TemporalFieldFlags TextCommon = F::IgnoreCase | F::FlexSpace;
        switch (ch) {
        case 'A': // case 'P':
            return count ? F::UpperCase | TextCommon : TextCommon;
        case 'a': // case 'p':
            return count ? F::LowerCase | TextCommon : TextCommon;
        case 'd': case 'M': // Day and Month share a pattern:
            switch (count) {
            case 2: return F::Numeric | F::ZeroPad;
            case 3: return F::Verbal | F::Abbreviated | TextCommon;
            default:
                return count < 2 ? F::Numeric : F::Verbal | F::Wide | TextCommon;
            };
            Q_UNREACHABLE();
            break;
        case 'H': case 'h': case 'm': case 's': // Shared pattern:
            return count > 1 ? F::Numeric | F::ZeroPad : F::Numeric;
        case 't':
            switch (count) {
            case 1: // 't': matches everything, serializes as abbreviation
                return F::AllowZSuffix | F::LocalTimeName;
                // The next two forms aren't localized - should they be ?
                // The issue is that they're documented to differ in whether
                // separators are used, but we don't control that (nor should
                // we, or the format author) for localized forms.
            case 2: // 'tt': offset (no-prefix, no separator)
                return F::Iso8601 | F::Numeric | F::ZeroPad;
            case 3: // 'ttt': offset (no-prefix, separator)
                return F::Iso8601 | F::Verbal | F::ZeroPad;
            default: // 'tttt': long name or IANA ID
                return F::LocalizedZone | F::Verbal | F::Standalone | F::Wide | F::Short;
                // This includes both metazone and exemplar city versions of long name.
            }
            Q_UNREACHABLE();
            break;
        case 'y':
            if (count > 2)
                return F::Numeric | F::ZeroPad | F::YearSignIso8601;
            return F::Numeric | F::ZeroPad;
        case 'z':
            if (count > 2)
                return F::Numeric | F::ZeroPad;
            return F::Numeric;
        }
        // Should only be called by branches that passed an isFormatChar() check.
        Q_UNREACHABLE_RETURN({});
    };
 
    const auto store = [&result](QString &&literal, qsizetype count,
                                 TemporalFieldFlags flags,
                                 TemporalFieldCategory category) {
        result.fields.append(TemporalField{std::move(literal), count, flags, category});
    };
 
    bool seenDayPeriod = false, seenHourMod12 = false; // See post-processing.
    while (pending <= QChar::LastValidCodePoint && (pending || iter.hasNext())) {
        char32_t ch;
        if (pending) {
            ch = std::exchange(pending, 0);
        } else {
            result.endIndex = iter.index();
            ch = iter.next(Invalid);
        }
        if (ch > QChar::LastValidCodePoint)
            break;
 
        if (ch < 0x80 && includeTime) {
            if (matchTimeFormats.matches(uchar(ch))) {
                qsizetype count = countRepeats(ch, ch == U'z' ? 3 : 2);
                if (ch == U'z' && count == 2) // Backwards compatibility
                    count = 1; // (but we still consume both 'z' characters from the format)
                store(QString(), count, formatFlags(uchar(ch), count),
                      formatCategory(uchar(ch), count));
                if (ch == U'h')
                    seenHourMod12 = true;
                continue;
            }
            if (ch == U'A' || ch == U'a') {
                // Follow old QDTP (for now, at least) in using count to represent case choice.
                qsizetype count = ch == U'a' ? 1 : 2;
                // AP or ap are just the same as A or a; but Ap or aP selects
                // locale-appropriate case:
                result.endIndex = iter.index();
                const auto read = iter.hasNext() ? iter.next(Invalid) : Invalid;
                if (read > QChar::LastValidCodePoint) {
                    pending = Invalid;
                } else if (read == U'P') {
                    if (ch == U'a')
                        count = 0;
                    result.endIndex = iter.index();
                } else if (read == U'p') {
                    if (ch == U'A')
                        count = 0;
                    result.endIndex = iter.index();
                } else {
                    pending = read;
                }
                store(QString(), count, formatFlags(uchar(ch), count),
                      formatCategory(uchar(ch), count));
                seenDayPeriod = true;
                continue;
            }
        }
        // Date and Zone fields are more straightforward, except for 'y':
        if (ch == U'y' && includeDate) {
            // For 'y', a pair is a year-within-century, double that for a full
            // year; beyond that, evenly many more are more of those but an odd
            // 'y' is a literal. We thus need to only consume 2 or 4 'y' tokens,
            // so can't use countRepeat() with its simple maximum. We need to
            // leave the odd 'y', if present, for a later iteration to consume
            // or, if it's all there is, for use as a literal - in which case we
            // mustn't have set pending. Fortunately 'y' is ASCII so we don't
            // have to worry about surrogates:
            qsizetype count = 1;
            QStringView tail = pattern.sliced(iter.index() - 1);
            if (tail.size() > 4)
                tail = tail.first(4);
            while (count < tail.size() && char32_t(tail[count].unicode()) == ch)
                ++count;
            if (count == 3)
                --count;
            if (count > 1) {
                Q_ASSERT(count == 2 || count == 4);
                // Advance iter over what we've accepted:
                iter.setPosition(iter.position() - 1 + count);
                store(QString(), count, formatFlags(uchar(ch), count),
                      formatCategory(uchar(ch), count));
                result.endIndex = iter.index();
                continue;
            }
            // else: fall through to treat the lone 'y' as a literal.
        } else if (ch < 0x80 && ((includeDate && matchDateFormats.matches(uchar(ch)))
                                 || (includeZone && ch == U't'))) {
            qsizetype count = countRepeats(ch, 4);
            store(QString(), count, formatFlags(uchar(ch), count),
                  formatCategory(uchar(ch), count));
            continue;
        }
        Q_ASSERT(pending == 0); // Everything that might set it has continue;d
 
        // Not a field indicator, so parse as a literal:
        QString literal;
        QString quote; // If non-null: unfinished quote, to be appended to literal when closed.
        if (ch == SingleQuote) { // Defer it to first iteration of loop below.
            pending = ch;
        } else {
            literal = QString(QStringView(QChar::fromUcs4(ch)));
            result.endIndex = iter.index();
        }
        while (pending <= QChar::LastValidCodePoint && (pending || iter.hasNext())) {
            if (pending) {
                ch = std::exchange(pending, 0);
            } else {
                if (quote.isNull()) // i.e. we're not in an incomplete quote
                    result.endIndex = iter.index();
                ch = iter.next(Invalid);
            }
            if (ch > QChar::LastValidCodePoint)
                break;
 
            if (ch == SingleQuote) {
                if (quote.isNull()) { // Provisionally start a quote
                    quote = u""_s; // empty is not null
                } else {
                    // Even if this is the first quote of a pair, denoting a
                    // single quote within the quote, there's a valid parse that
                    // ends at it, adding the quote-so-far to literal.
                    literal += quote;
                    result.endIndex = iter.index();
                    quote = QString(); // Set back to null
                }
                ch = iter.hasNext() ? iter.next(Invalid) : Invalid;
                if (ch == SingleQuote) {
                    // Paired single quote denotes a single quote:
                    if (quote.isNull()) {
                        // The quote we thought was ending actually continues:
                        // the continuation starts with a literal single quote.
                        quote = u"'"_s;
                    } else {
                        // Our provisionally-started quote was actually the
                        // first half of an pair of quotes not inside others.
                        Q_ASSERT(quote.isEmpty()); // We just set it.
                        quote = QString();
                        literal.append(u'\'');
                        result.endIndex = iter.index();
                    }
                    continue;
                }
 
                if (ch > QChar::LastValidCodePoint) {
                    pending = ch;
                    break;
                }
            }
 
            Q_ASSERT(ch != SingleQuote);
            if (quote.isNull() && isFormatChar(ch)) {
                pending = ch;
                break;
            }
            if (ch <= QChar::LastValidCodePoint) {
                if (quote.isNull()) {
                    result.endIndex = iter.index();
                    literal.append(QStringView(QChar::fromUcs4(ch)));
                } else {
                    quote.append(QStringView(QChar::fromUcs4(ch)));
                }
            }
        }
        // Even if we truncated due to an unclosed quote, we have a literal to
        // include in the prefix we can parse as a pattern:
        if (!literal.isEmpty()) {
            store(std::move(literal), 0,
                  TemporalFieldFlag::FlexSpace, TemporalFieldCategory::Literal);
        }
        // If we're in an unclosed quote, we cleared pending or marked it invalid:
        Q_ASSERT(quote.isNull() || !pending || pending > QChar::LastValidCodePoint);
    }
 
    // Post-process to deal with a quirk of the legacy format: if there's no
    // AM/PM field, then 'h' format is read as 'H' format.
    if (seenHourMod12 && !seenDayPeriod) {
        for (TemporalField &field : result.fields) {
            if (field.category == TemporalFieldCategory::HourMod12)
                field.category = TemporalFieldCategory::Hour;
        }
    }
 
    return result;
}
 
} // QtParseQtTemporalFormat
 
QT_END_NAMESPACE