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
++
++ #include <private/qhitrace_p.h>
++ #include <private/qtools_p.h>
++
++ #include <QtCore/qlogging.h>
++
++ #include <hitrace/trace.h>
++
++ #include <cstdarg>
++ #include <cstdio>
++ #include <cstring>
++ #include <type_traits>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++
++ constexpr char elidedMark[] = "...";
++ constexpr char16_t firstPrintable = 0x20;
++ constexpr char16_t lastPrintable = 0x7e;
++ constexpr char escapeMark = '\\';
++ constexpr char unicodeEscape = 'u';
++ constexpr char separatorReplacement = ' ';
++ constexpr int escapeDigits = 2 * sizeof(char16_t);
++ constexpr int bitsPerHexDigit = 4;
++ constexpr qsizetype shortEscapeSize = 2;
++ constexpr qsizetype unicodeEscapeSize = 2 + escapeDigits;
++ constexpr int32_t unregisteredListener = -1;
++
++ Q_CONSTINIT int32_t qtHiTraceListener = unregisteredListener;
++
++ bool isSeparator(QChar unit)
++ {
++ return unit == u',' || unit == u'=' || unit == u'|';
++ }
++
++ bool isWrittenVerbatim(QChar unit)
++ {
++ return unit.unicode() >= firstPrintable && unit.unicode() <= lastPrintable
++ && unit != QLatin1Char(escapeMark);
++ }
++
++ char shortEscape(QChar unit)
++ {
++ switch (unit.unicode()) {
++ case '\\':
++ return '\\';
++ case '\b':
++ return 'b';
++ case '\f':
++ return 'f';
++ case '\n':
++ return 'n';
++ case '\r':
++ return 'r';
++ case '\t':
++ return 't';
++ default:
++ return 0;
++ }
++ }
++
++ qsizetype escapedSize(QChar unit)
++ {
++ if (isWrittenVerbatim(unit))
++ return 1;
++ return shortEscape(unit) ? shortEscapeSize : unicodeEscapeSize;
++ }
++
++ QByteArray escaped(QStringView text)
++ {
++ QByteArray result;
++ result.reserve(text.size());
++ for (const QChar unit : text) {
++ if (isSeparator(unit)) {
++ result += separatorReplacement;
++ continue;
++ }
++ if (isWrittenVerbatim(unit)) {
++ result += char(unit.unicode());
++ continue;
++ }
++ result += escapeMark;
++ if (const char shortForm = shortEscape(unit)) {
++ result += shortForm;
++ continue;
++ }
++ result += unicodeEscape;
++ for (int digit = escapeDigits - 1; digit >= 0; --digit)
++ result += QtMiscUtils::toHexLower(unit.unicode() >> (digit * bitsPerHexDigit));
++ }
++ return result;
++ }
++
++ struct FittingUnits
++ {
++ qsizetype count = 0;
++ qsizetype escapedSize = 0;
++ };
++
++ template <typename Iterator>
++ bool startsSurrogatePair(Iterator unit, Iterator end)
++ {
++ constexpr bool isReversed = std::is_same_v<Iterator, QStringView::const_reverse_iterator>;
++ if (unit + 1 == end)
++ return false;
++ const QChar high = isReversed ? unit[1] : unit[0];
++ const QChar low = isReversed ? unit[0] : unit[1];
++ return high.isHighSurrogate() && low.isLowSurrogate();
++ }
++
++ template <typename Iterator>
++ FittingUnits fittingUnits(Iterator unit, Iterator end, qsizetype maximumSize)
++ {
++ FittingUnits fitting;
++ while (unit != end) {
++ const qsizetype step = startsSurrogatePair(unit, end) ? 2 : 1;
++ qsizetype stepSize = escapedSize(unit[0]);
++ if (step == 2)
++ stepSize += escapedSize(unit[1]);
++ if (fitting.escapedSize + stepSize > maximumSize)
++ break;
++ fitting.escapedSize += stepSize;
++ fitting.count += step;
++ unit += step;
++ }
++ return fitting;
++ }
++
++ QByteArray elided(QStringView value, qsizetype maximumSize)
++ {
++ Q_ASSERT(maximumSize >= qtHiTraceSmallestValueBudget);
++
++ if (fittingUnits(value.cbegin(), value.cend(), maximumSize).count == value.size())
++ return escaped(value);
++
++ const qsizetype kept = maximumSize - (qsizetype(sizeof(elidedMark)) - 1);
++ const FittingUnits head = fittingUnits(value.cbegin(), value.cend(), kept / 2);
++ const FittingUnits tail =
++ fittingUnits(value.crbegin(), value.crend(), kept - head.escapedSize);
++ return escaped(value.first(head.count)) + elidedMark + escaped(value.last(tail.count));
++ }
++
++ void qtHiTraceStatusChanged(bool enabled)
++ {
++ qtHiTraceEnabled.storeRelaxed(enabled);
++ }
++
++ void qtHiTraceWatchStatus()
++ {
++ const int32_t listener = OH_HiTrace_RegisterTraceListener(qtHiTraceStatusChanged);
++ if (listener < 0) {
++ qtHiTraceEnabled.storeRelaxed(true);
++ qWarning("Qt tracing: OH_HiTrace_RegisterTraceListener() failed with %d, so tracepoint "
++ "arguments are rendered whether or not a capture is running",
++ listener);
++ return;
++ }
++
++ qtHiTraceListener = listener;
++ if (OH_HiTrace_IsTraceEnabled())
++ qtHiTraceEnabled.storeRelaxed(true);
++ }
++
++ void qtHiTraceUnwatchStatus()
++ {
++ if (qtHiTraceListener != unregisteredListener)
++ OH_HiTrace_UnregisterTraceListener(qtHiTraceListener);
++ }
++
++ } // namespace
++
++ QByteArray qtHiTraceArgument(const char *value, qsizetype maximumSize)
++ {
++ return elided(QString::fromUtf8(value), maximumSize);
++ }
++
++ QByteArray qtHiTraceArgument(const QString &value, qsizetype maximumSize)
++ {
++ return elided(value, maximumSize);
++ }
++
++ const char *qtHiTraceFormatArguments(int sliceNameSize, const char *format, ...)
++ {
++ Q_CONSTINIT static thread_local char renderedArguments[qtHiTraceRecordBudget] = {};
++
++ const int budget = qtHiTraceRecordBudget - sliceNameSize;
++ if (budget <= int(sizeof(elidedMark)))
++ return "";
++
++ va_list values;
++ va_start(values, format);
++ const int renderedSize = std::vsnprintf(renderedArguments, budget, format, values);
++ va_end(values);
++
++ if (renderedSize < 0)
++ return "";
++ if (renderedSize >= budget) {
++ std::memcpy(renderedArguments + budget - sizeof(elidedMark), elidedMark,
++ sizeof(elidedMark));
++ }
++ return renderedArguments;
++ }
++
++ Q_CONSTINIT QBasicAtomicInteger<bool> qtHiTraceEnabled = Q_BASIC_ATOMIC_INITIALIZER(false);
++
++ Q_CONSTRUCTOR_FUNCTION(qtHiTraceWatchStatus)
++ Q_DESTRUCTOR_FUNCTION(qtHiTraceUnwatchStatus)
++
++ QT_END_NAMESPACE