qdebug.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdebug.h"
#include "private/qdebug_p.h"
#include "qmetaobject.h"
#include <private/qlogging_p.h>
#include <private/qtextstream_p.h>
#include <private/qtools_p.h>
 
#include <array>
#include <q20chrono.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QtMiscUtils;
 
/*
    Returns a human readable representation of the first \a maxSize
    characters in \a data. The size, \a len, is a 64-bit quantity to
    avoid truncation due to implicit conversions in callers.
*/
QByteArray QtDebugUtils::toPrintable(const char *data, qint64 len, qsizetype maxSize)
{
    if (!data)
        return "(null)";
 
    QByteArray out;
    for (qsizetype i = 0; i < qMin(len, maxSize); ++i) {
        char c = data[i];
        if (isAsciiPrintable(c)) {
            out += c;
        } else {
            switch (c) {
            case '\n':
                out += "\\n";
                break;
            case '\r':
                out += "\\r";
                break;
            case '\t':
                out += "\\t";
                break;
            default: {
                const char buf[] = {
                    '\\',
                    'x',
                    toHexLower(uchar(c) / 16),
                    toHexLower(uchar(c) % 16),
                    0
                };
                out += buf;
            }
            }
        }
    }
 
    if (maxSize < len)
        out += "...";
 
    return out;
}
 
// This file is needed to force compilation of QDebug into the kernel library.
 
QDebug::~QDebug()
{
    if (stream && !--stream->ref) {
        if (stream->space && stream->buffer.endsWith(u' '))
            stream->buffer.chop(1);
        if (stream->message_output) {
            QInternalMessageLogContext ctxt(stream->context);
            qt_message_output(stream->type,
                              ctxt,
                              stream->buffer);
        }
        delete stream;
    }
}
 
void QDebug::putUcs4(uint ucs4)
{
    maybeQuote('\'');
    if (ucs4 < 0x20) {
        stream->ts << "\\x" << Qt::hex << ucs4 << Qt::reset;
    } else if (ucs4 < 0x80) {
        stream->ts << char(ucs4);
    } else {
        if (ucs4 < 0x10000)
            stream->ts << "\\u" << qSetFieldWidth(4);
        else
            stream->ts << "\\U" << qSetFieldWidth(8);
        stream->ts << Qt::hex << qSetPadChar(u'0') << ucs4 << Qt::reset;
    }
    maybeQuote('\'');
}
 
// These two functions return true if the character should be printed by QDebug.
// For QByteArray, this is technically identical to US-ASCII isprint();
// for QString, we use QChar::isPrint, which requires a full UCS-4 decode.
static inline bool isPrintable(char32_t ucs4) { return QChar::isPrint(ucs4); }
static inline bool isPrintable(char16_t uc) { return QChar::isPrint(uc); }
static inline bool isPrintable(uchar c)
{ return isAsciiPrintable(c); }
 
template <typename Char>
static inline void putEscapedString(QTextStreamPrivate *d, const Char *begin, size_t length, bool isUnicode = true)
{
    QChar quote(u'"');
    d->write(&quote, 1);
 
    bool lastWasHexEscape = false;
    const Char *end = begin + length;
    for (const Char *p = begin; p != end; ++p) {
        // check if we need to insert "" to break an hex escape sequence
        if (Q_UNLIKELY(lastWasHexEscape)) {
            if (fromHex(*p) != -1) {
                // yes, insert it
                QChar quotes[] = { quote, quote };
                d->write(quotes, 2);
            }
            lastWasHexEscape = false;
        }
 
        if (sizeof(Char) == sizeof(QChar)) {
            // Surrogate characters are category Cs (Other_Surrogate), so isPrintable = false for them
            qsizetype runLength = 0;
            while (p + runLength != end &&
                   isPrintable(p[runLength]) && p[runLength] != '\\' && p[runLength] != '"')
                ++runLength;
            if (runLength) {
                d->write(reinterpret_cast<const QChar *>(p), runLength);
                p += runLength - 1;
                continue;
            }
        } else if (isPrintable(*p) && *p != '\\' && *p != '"') {
            QChar c = QLatin1Char(*p);
            d->write(&c, 1);
            continue;
        }
 
        // print as an escape sequence (maybe, see below for surrogate pairs)
        qsizetype buflen = 2;
        char16_t buf[std::char_traits<char>::length("\\U12345678")];
        buf[0] = '\\';
 
        switch (*p) {
        case '"':
        case '\\':
            buf[1] = *p;
            break;
        case '\b':
            buf[1] = 'b';
            break;
        case '\f':
            buf[1] = 'f';
            break;
        case '\n':
            buf[1] = 'n';
            break;
        case '\r':
            buf[1] = 'r';
            break;
        case '\t':
            buf[1] = 't';
            break;
        default:
            if (!isUnicode) {
                // print as hex escape
                buf[1] = 'x';
                buf[2] = toHexUpper(uchar(*p) >> 4);
                buf[3] = toHexUpper(uchar(*p));
                buflen = 4;
                lastWasHexEscape = true;
                break;
            }
            if (QChar::isHighSurrogate(*p)) {
                if ((p + 1) != end && QChar::isLowSurrogate(p[1])) {
                    // properly-paired surrogates
                    char32_t ucs4 = QChar::surrogateToUcs4(*p, p[1]);
                    if (isPrintable(ucs4)) {
                        buf[0] = *p;
                        buf[1] = p[1];
                        buflen = 2;
                    } else {
                        buf[1] = 'U';
                        buf[2] = '0'; // toHexUpper(ucs4 >> 32);
                        buf[3] = '0'; // toHexUpper(ucs4 >> 28);
                        buf[4] = toHexUpper(ucs4 >> 20);
                        buf[5] = toHexUpper(ucs4 >> 16);
                        buf[6] = toHexUpper(ucs4 >> 12);
                        buf[7] = toHexUpper(ucs4 >> 8);
                        buf[8] = toHexUpper(ucs4 >> 4);
                        buf[9] = toHexUpper(ucs4);
                        buflen = 10;
                    }
                    ++p;
                    break;
                }
                // improperly-paired surrogates, fall through
            }
            buf[1] = 'u';
            buf[2] = toHexUpper(char16_t(*p) >> 12);
            buf[3] = toHexUpper(char16_t(*p) >> 8);
            buf[4] = toHexUpper(*p >> 4);
            buf[5] = toHexUpper(*p);
            buflen = 6;
        }
        d->write(reinterpret_cast<QChar *>(buf), buflen);
    }
 
    d->write(&quote, 1);
}
 
void QDebug::putString(const QChar *begin, size_t length)
{
    if (stream->noQuotes) {
        // no quotes, write the string directly too (no pretty-printing)
        // this respects the QTextStream state, though
        stream->ts.d_ptr->putString(begin, qsizetype(length));
    } else {
        // we'll reset the QTextStream formatting mechanisms, so save the state
        QDebugStateSaver saver(*this);
        stream->ts.d_ptr->params.reset();
        putEscapedString(stream->ts.d_ptr.data(), reinterpret_cast<const char16_t *>(begin), length);
    }
}
 
void QDebug::putByteArray(const char *begin, size_t length, Latin1Content content)
{
    if (stream->noQuotes) {
        // no quotes, write the string directly too (no pretty-printing)
        // this respects the QTextStream state, though
        QString string = content == ContainsLatin1 ? QString::fromLatin1(begin, qsizetype(length))
                                                   : QString::fromUtf8(begin, qsizetype(length));
        stream->ts.d_ptr->putString(string);
    } else {
        // we'll reset the QTextStream formatting mechanisms, so save the state
        QDebugStateSaver saver(*this);
        stream->ts.d_ptr->params.reset();
        putEscapedString(stream->ts.d_ptr.data(), reinterpret_cast<const uchar *>(begin),
                         length, content == ContainsLatin1);
    }
}
 
static QByteArray timeUnit(qint64 num, qint64 den)
{
    using namespace std::chrono;
    using namespace q20::chrono;
 
    if (num == 1 && den > 1) {
        // sub-multiple of seconds
        char prefix = '\0';
        auto tryprefix = [&](auto d, char c) {
            static_assert(decltype(d)::num == 1, "not an SI prefix");
            if (den == decltype(d)::den)
                prefix = c;
        };
 
        // "u" should be "µ", but debugging output is not always UTF-8-safe
        tryprefix(std::milli{}, 'm');
        tryprefix(std::micro{}, 'u');
        tryprefix(std::nano{}, 'n');
        tryprefix(std::pico{}, 'p');
        tryprefix(std::femto{}, 'f');
        tryprefix(std::atto{}, 'a');
        // uncommon ones later
        tryprefix(std::centi{}, 'c');
        tryprefix(std::deci{}, 'd');
        if (prefix) {
            char unit[3] = { prefix, 's' };
            return QByteArray(unit, sizeof(unit) - 1);
        }
    }
 
    const char *unit = nullptr;
    if (num > 1 && den == 1) {
        // multiple of seconds - but we don't use SI prefixes
        auto tryunit = [&](auto d, const char *name) {
            static_assert(decltype(d)::period::den == 1, "not a multiple of a second");
            if (unit || num % decltype(d)::period::num)
                return;
            unit = name;
            num /= decltype(d)::period::num;
        };
        tryunit(years{}, "yr");
        tryunit(weeks{}, "wk");
        tryunit(days{}, "d");
        tryunit(hours{}, "h");
        tryunit(minutes{}, "min");
    }
    if (!unit)
        unit = "s";
 
    if (num == 1 && den == 1)
        return unit;
    if (Q_UNLIKELY(num < 1 || den < 1))
        return QString::asprintf("<invalid time unit %lld/%lld>", num, den).toLatin1();
 
    // uncommon units: will return something like "[2/3]s"
    //  strlen("[/]min") = 6
    char buf[2 * (std::numeric_limits<qint64>::digits10 + 2) + 10];
    size_t len = 0;
    auto appendChar = [&](char c) {
        Q_ASSERT(len < sizeof(buf));
        buf[len++] = c;
    };
    auto appendNumber = [&](qint64 value) {
        if (value >= 10'000 && (value % 1000) == 0)
            len += qsnprintf(buf + len, sizeof(buf) - len, "%.6g", double(value));  // "1e+06"
        else
            len += qsnprintf(buf + len, sizeof(buf) - len, "%lld", value);
    };
    appendChar('[');
    appendNumber(num);
    if (den != 1) {
        appendChar('/');
        appendNumber(den);
    }
    appendChar(']');
    memcpy(buf + len, unit, strlen(unit));
    return QByteArray(buf, len + strlen(unit));
}
 
void QDebug::putTimeUnit(qint64 num, qint64 den)
{
    stream->ts << timeUnit(num, den); // ### optimize
}
 
namespace {
 
#ifdef QT_SUPPORTS_INT128
 
constexpr char Q_INT128_MIN_STR[] = "-170141183460469231731687303715884105728";
 
constexpr int Int128BufferSize = sizeof(Q_INT128_MIN_STR);
using Int128Buffer = std::array<char, Int128BufferSize>;
                                           // numeric_limits<qint128>::digits10 may not exist
 
static char *i128ToStringHelper(Int128Buffer &buffer, quint128 n)
{
    auto dst = buffer.data() + buffer.size();
    *--dst = '\0'; // NUL-terminate
    if (n == 0) {
        *--dst = '0'; // and done
    } else {
        while (n != 0) {
            *--dst = "0123456789"[n % 10];
            n /= 10;
        }
    }
    return dst;
}
#endif // QT_SUPPORTS_INT128
 
[[maybe_unused]]
static const char *int128Warning()
{
    const char *msg = "Qt was not compiled with int128 support.";
    qWarning("%s", msg);
    return msg;
}
 
} // unnamed namespace
 
void QDebug::putInt128([[maybe_unused]] const void *p)
{
#ifdef QT_SUPPORTS_INT128
    Q_ASSERT(p);
    qint128 i;
    memcpy(&i, p, sizeof(i)); // alignment paranoia
    if (i == Q_INT128_MIN) {
        // -i is not representable, hardcode the result:
        stream->ts << Q_INT128_MIN_STR;
    } else {
        Int128Buffer buffer;
        auto dst = i128ToStringHelper(buffer, i < 0 ? -i : i);
        if (i < 0)
            *--dst = '-';
        stream->ts << dst;
    }
    return;
#endif // QT_SUPPORTS_INT128
    stream->ts << int128Warning();
}
 
void QDebug::putUInt128([[maybe_unused]] const void *p)
{
#ifdef QT_SUPPORTS_INT128
    Q_ASSERT(p);
    quint128 i;
    memcpy(&i, p, sizeof(i)); // alignment paranoia
    Int128Buffer buffer;
    stream->ts << i128ToStringHelper(buffer, i);
    return;
#endif // QT_SUPPORTS_INT128
    stream->ts << int128Warning();
}
 
 
QDebug &QDebug::resetFormat()
{
    stream->ts.reset();
    stream->space = true;
    stream->noQuotes = false;
    stream->verbosity = DefaultVerbosity;
    return *this;
}
 
class QDebugStateSaverPrivate
{
public:
    QDebugStateSaverPrivate(QDebug::Stream *stream)
        : m_stream(stream),
          m_spaces(stream->space),
          m_noQuotes(stream->noQuotes),
          m_verbosity(stream->verbosity),
          m_streamParams(stream->ts.d_ptr->params)
    {
    }
    void restoreState()
    {
        const bool currentSpaces = m_stream->space;
        if (currentSpaces && !m_spaces)
            if (m_stream->buffer.endsWith(u' '))
                m_stream->buffer.chop(1);
 
        m_stream->space = m_spaces;
        m_stream->noQuotes = m_noQuotes;
        m_stream->ts.d_ptr->params = m_streamParams;
        m_stream->verbosity = m_verbosity;
 
        if (!currentSpaces && m_spaces)
            m_stream->ts << ' ';
    }
 
    QDebug::Stream *m_stream;
 
    // QDebug state
    const bool m_spaces;
    const bool m_noQuotes;
    const int m_verbosity;
 
    // QTextStream state
    const QTextStreamPrivate::Params m_streamParams;
};
 
 
QDebugStateSaver::QDebugStateSaver(QDebug &dbg)
    : d(new QDebugStateSaverPrivate(dbg.stream))
{
}
 
QDebugStateSaver::~QDebugStateSaver()
{
    d->restoreState();
}
 
void qt_QMetaEnum_flagDebugOperator(QDebug &debug, size_t sizeofT, int value)
{
    qt_QMetaEnum_flagDebugOperator<int>(debug, sizeofT, value);
}
 
#ifndef QT_NO_QOBJECT
QDebug qt_QMetaEnum_debugOperator(QDebug &dbg, qint64 value, const QMetaObject *meta, const char *name)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    QMetaEnum me = meta->enumerator(meta->indexOfEnumerator(name));
 
    const int verbosity = dbg.verbosity();
    if (verbosity >= QDebug::DefaultVerbosity) {
        if (const char *scope = me.scope())
            dbg << scope << u"::";
    }
 
    const char *key = me.valueToKey(static_cast<int>(value));
    const bool scoped = me.isScoped() || verbosity & 1;
    if (scoped || !key)
        dbg << me.enumName() << (!key ? u"(" : u"::");
 
    if (key)
        dbg << key;
    else
        dbg << value << ')';
 
    return dbg;
}
 
QDebug qt_QMetaEnum_flagDebugOperator(QDebug &debug, quint64 value, const QMetaObject *meta, const char *name)
{
    const int verbosity = debug.verbosity();
 
    QDebugStateSaver saver(debug);
    debug.resetFormat();
    debug.noquote();
    debug.nospace();
 
    const QMetaEnum me = meta->enumerator(meta->indexOfEnumerator(name));
 
    const bool classScope = verbosity >= QDebug::DefaultVerbosity;
    if (classScope) {
        debug << u"QFlags<";
 
        if (const char *scope = me.scope())
            debug << scope << u"::";
    }
 
    const bool enumScope = me.isScoped() || verbosity > QDebug::MinimumVerbosity;
    if (enumScope) {
        debug << me.enumName();
        if (classScope)
            debug << '>';
        debug << '(';
    }
 
    debug << me.valueToKeys(static_cast<int>(value));
 
    if (enumScope)
        debug << ')';
 
    return debug;
}
#endif // !QT_NO_QOBJECT
 
QT_END_NAMESPACE