qdebug.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2016 Intel Corporation.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#ifdef QT_NO_DEBUG
#undef QT_NO_DEBUG
#endif
#ifdef qDebug
#undef qDebug
#endif
 
#include "qdebug.h"
#include "private/qdebug_p.h"
#include "qmetaobject.h"
#include <private/qtextstream_p.h>
#include <private/qtools_p.h>
#include <ctype.h>
 
QT_BEGIN_NAMESPACE
 
using QtMiscUtils::toHexUpper;
using QtMiscUtils::toHexLower;
using QtMiscUtils::fromHex;
 
/*
    Returns a human readable representation of the first \a maxSize
    characters in \a data.
*/
QByteArray QtDebugUtils::toPrintable(const char *data, int len, int maxSize)
{
    if (!data)
        return "(null)";
 
    QByteArray out;
    for (int i = 0; i < qMin(len, maxSize); ++i) {
        char c = data[i];
        if (isprint(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.
 
// Has been defined in the header / inlined before Qt 5.4
QDebug::~QDebug()
{
    if (stream && !--stream->ref) {
        if (stream->space && stream->buffer.endsWith(QLatin1Char(' ')))
            stream->buffer.chop(1);
        if (stream->message_output) {
            qt_message_output(stream->type,
                              stream->context,
                              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(QLatin1Char('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(uint ucs4)
{ return QChar::isPrint(ucs4); }
static inline bool isPrintable(ushort uc)
{ return QChar::isPrint(uc); }
static inline bool isPrintable(uchar c)
{ return c >= ' ' && c < 0x7f; }
 
template <typename Char>
static inline void putEscapedString(QTextStreamPrivate *d, const Char *begin, int length, bool isUnicode = true)
{
    QChar quote(QLatin1Char('"'));
    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[] = { QLatin1Char('"'), QLatin1Char('"') };
                d->write(quotes, 2);
            }
            lastWasHexEscape = false;
        }
 
        if (sizeof(Char) == sizeof(QChar)) {
            // Surrogate characters are category Cs (Other_Surrogate), so isPrintable = false for them
            int 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)
        int buflen = 2;
        ushort buf[sizeof "\\U12345678" - 1];
        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
                    uint 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(ushort(*p) >> 12);
            buf[3] = toHexUpper(ushort(*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, int(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 ushort *>(begin), int(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, int(length)) : QString::fromUtf8(begin, int(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),
                         int(length), content == ContainsLatin1);
    }
}
 
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(QLatin1Char(' ')))
                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(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(value);
 
    if (enumScope)
        debug << ')';
 
    return debug;
}
#endif // !QT_NO_QOBJECT
 
QT_END_NAMESPACE