qcoloroutput.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
// Qt-Security score:significant
 
#include "qcoloroutput_p.h"
 
#include <QtCore/qfile.h>
#include <QtCore/qhash.h>
 
#ifdef Q_OS_WIN
#include <qt_windows.h>
#else
#include <unistd.h>
#endif
 
QT_BEGIN_NAMESPACE
 
class QColorOutputPrivate
{
public:
    QColorOutputPrivate()
    {
        m_coloringEnabled = isColoringPossible();
        m_hyperLinkSupport = m_coloringEnabled;
    }
 
    ~QColorOutputPrivate() { fflush(stderr); }
 
    static const char *const foregrounds[];
    static const char *const backgrounds[];
 
    inline void write(const QString &msg)
    {
        m_buffer.append(msg.toLocal8Bit());
    }
 
    static QString escapeCode(const QString &in)
    {
        const ushort escapeChar = 0x1B;
        QString result;
        result.append(QChar(escapeChar));
        result.append(QLatin1Char('['));
        result.append(in);
        result.append(QLatin1Char('m'));
        return result;
    }
 
    void insertColor(int id, QColorOutput::ColorCode code) { m_colorMapping.insert(id, code); }
    QColorOutput::ColorCode color(int id) const { return m_colorMapping.value(id); }
    bool containsColor(int id) const { return m_colorMapping.contains(id); }
 
    void setSilent(bool silent) { m_silent = silent; }
    bool isSilent() const { return m_silent; }
 
    void setCurrentColorID(int colorId) { m_currentColorID = colorId; }
 
    bool coloringEnabled() const { return m_coloringEnabled; }
    bool hasHyperLinkSupport() const { return m_hyperLinkSupport; }
    void setHyperLinkSupport(bool v) { m_hyperLinkSupport = v; }
 
    void flushBuffer()
    {
        fwrite(m_buffer.constData(), size_t(1), size_t(m_buffer.size()), stderr);
        m_buffer.clear();
    }
 
    qsizetype bufferSize() const { return m_buffer.size(); }
 
    void truncateBuffer(qsizetype size) { m_buffer.truncate(size); }
 
private:
    QByteArray                  m_buffer;
    QColorOutput::ColorMapping  m_colorMapping;
    int                         m_currentColorID = -1;
    bool                        m_coloringEnabled = false;
    bool                        m_hyperLinkSupport = false;
    bool                        m_silent = false;
 
    /*
     Returns true if it's suitable to send colored output to \c stderr.
     */
    inline bool isColoringPossible() const
    {
        static std::optional<bool> canColor;
        if (canColor.has_value())
            return canColor.value();
 
#if defined(Q_OS_WIN)
        HANDLE hErr = GetStdHandle(STD_ERROR_HANDLE);
        DWORD mode = 0;
 
        if (GetConsoleMode(hErr, &mode))
            canColor = SetConsoleMode(hErr, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
        else
            canColor = false;
#else
        /* We use QFile::handle() to get the file descriptor. It's a bit unsure
         * whether it's 2 on all platforms and in all cases, so hopefully this layer
         * of abstraction helps handle such cases. */
        canColor = isatty(fileno(stderr));
#endif
        return canColor.value();
    }
};
 
const char *const QColorOutputPrivate::foregrounds[] =
{
    "0;30",
    "0;34",
    "0;32",
    "0;36",
    "0;31",
    "0;35",
    "0;33",
    "0;37",
    "1;30",
    "1;34",
    "1;32",
    "1;36",
    "1;31",
    "1;35",
    "1;33",
    "1;37"
};
 
const char *const QColorOutputPrivate::backgrounds[] =
{
    "0;40",
    "0;44",
    "0;42",
    "0;46",
    "0;41",
    "0;45",
    "0;43"
};
 
/*!
  \class QColorOutput
  \nonreentrant
  \brief Outputs colored messages to \c stderr.
  \internal
 
  QColorOutput is a convenience class for outputting messages to \c
  stderr using color escape codes, as mandated in ECMA-48. QColorOutput
  will only color output when it is detected to be suitable. For
  instance, if \c stderr is detected to be attached to a file instead
  of a TTY, no coloring will be done.
 
  QColorOutput does its best attempt. but it is generally undefined
  what coloring or effect the various coloring flags has. It depends
  strongly on what terminal software that is being used.
 
  When using `echo -e 'my escape sequence'`, \c{\033} works as an
  initiator but not when printing from a C++ program, despite having
  escaped the backslash.  That's why we below use characters with
  value 0x1B.
 
  It can be convenient to subclass QColorOutput with a private scope,
  such that the functions are directly available in the class using
  it.
 
  \section1 Usage
 
  To output messages, call write() or writeUncolored(). write() takes
  as second argument an integer, which QColorOutput uses as a lookup
  key to find the color it should color the text in. The mapping from
  keys to colors is done using insertMapping(). Typically this is used
  by having enums for the various kinds of messages, which
  subsequently are registered.
 
  \code
  enum MyMessage
  {
    Error,
    Important
  };
 
  QColorOutput output;
  output.insertMapping(Error, QColorOutput::RedForeground);
  output.insertMapping(Import, QColorOutput::BlueForeground);
 
  output.write("This is important", Important);
  output.write("Jack, I'm only the selected official!", Error);
  \endcode
 
  \sa {http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x329.html}{Bash Prompt HOWTO, 6.1. Colors},
      {http://linuxgazette.net/issue51/livingston-blade.html}{Linux Gazette, Tweaking Eterm, Edward Livingston-Blade},
      {http://www.ecma-international.org/publications/standards/Ecma-048.htm}{Standard ECMA-48, Control Functions for Coded Character Sets, ECMA International},
      {http://en.wikipedia.org/wiki/ANSI_escape_code}{Wikipedia, ANSI escape code},
      {http://linuxgazette.net/issue65/padala.html}{Linux Gazette, So You Like Color!, Pradeep Padala}
 */
 
/*!
  \internal
  \enum QColorOutput::ColorCodeComponent
  \value BlackForeground
  \value BlueForeground
  \value GreenForeground
  \value CyanForeground
  \value RedForeground
  \value PurpleForeground
  \value BrownForeground
  \value LightGrayForeground
  \value DarkGrayForeground
  \value LightBlueForeground
  \value LightGreenForeground
  \value LightCyanForeground
  \value LightRedForeground
  \value LightPurpleForeground
  \value YellowForeground
  \value WhiteForeground
  \value BlackBackground
  \value BlueBackground
  \value GreenBackground
  \value CyanBackground
  \value RedBackground
  \value PurpleBackground
  \value BrownBackground
 
  \value DefaultColor QColorOutput performs no coloring. This typically
                     means black on white or white on black, depending
                     on the settings of the user's terminal.
 */
 
/*!
  \internal
  Constructs a QColorOutput instance, ready for use.
 */
QColorOutput::QColorOutput() : d(new QColorOutputPrivate) {}
 
// must be here so that QScopedPointer has access to the complete type
QColorOutput::~QColorOutput() = default;
 
bool QColorOutput::isSilent() const { return d->isSilent(); }
void QColorOutput::setSilent(bool silent) { d->setSilent(silent); }
 
/*!
 \internal
 Sends \a message to \c stderr, using the color looked up in the color mapping using \a colorID.
 
 If \a color isn't available in the color mapping, result and behavior is undefined.
 
 If \a colorID is 0, which is the default value, the previously used coloring is used. QColorOutput
 is initialized to not color at all.
 
 If \a message is empty, effects are undefined.
 
 \a message will be printed as is. For instance, no line endings will be inserted.
 */
void QColorOutput::write(QStringView message, int colorID)
{
    if (!d->isSilent())
        d->write(colorify(message, colorID));
}
 
void QColorOutput::writePrefixedMessage(const QString &message, QtMsgType type,
                                       const QString &prefix)
{
    static const QHash<QtMsgType, QString> prefixes = {
        {QtMsgType::QtCriticalMsg, QStringLiteral("Error")},
        {QtMsgType::QtWarningMsg, QStringLiteral("Warning")},
        {QtMsgType::QtInfoMsg, QStringLiteral("Info")},
        {QtMsgType::QtDebugMsg, QStringLiteral("Hint")}
    };
 
    Q_ASSERT(prefixes.contains(type));
    Q_ASSERT(prefix.isEmpty() || prefix.front().isUpper());
    write((prefix.isEmpty() ? prefixes[type] : prefix) + QStringLiteral(": "), type);
    writeUncolored(message);
}
 
/*!
 \internal
 Writes \a message to \c stderr as if for instance
 QTextStream would have been used, and adds a line ending at the end.
 
 This function can be practical to use such that one can use QColorOutput for all forms of writing.
 */
void QColorOutput::writeUncolored(const QString &message)
{
    if (!d->isSilent())
        d->write(message + QLatin1Char('\n'));
}
 
QString QColorOutput::linkify(const QString &link, const QString &message) const
{
    if (!d->hasHyperLinkSupport())
        return message;
    const QChar escape(0x1B);
    QString result;
    result += escape;
    result += u']';
    result += QString::number(8);
    result += QLatin1String(";;");
    result += link;
    result += escape;
    result += u'\\';
    result += message;
    result += escape;
    result += u']';
    result += QString::number(8);
    result += QLatin1String(";;");
    result += escape;
    result += u'\\';
    return result;
}
 
/*!
 \internal
 Treats \a message and \a colorID identically to write(), but instead of writing
 \a message to \c stderr, it is prepared for being written to \c stderr, but is then
 returned.
 
 This is useful when the colored string is inserted into a translated string(dividing
 the string into several small strings prevents proper translation).
 */
QString QColorOutput::colorify(const QStringView message, int colorID) const
{
    Q_ASSERT_X(colorID == -1 || d->containsColor(colorID), Q_FUNC_INFO,
               qPrintable(QString::fromLatin1("There is no color registered by id %1")
                          .arg(colorID)));
    Q_ASSERT_X(!message.isEmpty(), Q_FUNC_INFO,
               "It makes no sense to attempt to print an empty string.");
 
    if (colorID != -1)
        d->setCurrentColorID(colorID);
 
    if (d->coloringEnabled() && colorID != -1) {
        const int color = d->color(colorID);
 
        /* If DefaultColor is set, we don't want to color it. */
        if (color & DefaultColor)
            return message.toString();
 
        const int foregroundCode = (color & ForegroundMask) >> ForegroundShift;
        const int backgroundCode = (color & BackgroundMask) >> BackgroundShift;
        QString finalMessage;
        bool closureNeeded = false;
 
        if (foregroundCode > 0) {
            finalMessage.append(
                        QColorOutputPrivate::escapeCode(
                            QLatin1String(QColorOutputPrivate::foregrounds[foregroundCode - 1])));
            closureNeeded = true;
        }
 
        if (backgroundCode > 0) {
            finalMessage.append(
                        QColorOutputPrivate::escapeCode(
                            QLatin1String(QColorOutputPrivate::backgrounds[backgroundCode - 1])));
            closureNeeded = true;
        }
 
        finalMessage.append(message);
 
        if (closureNeeded)
            finalMessage.append(QColorOutputPrivate::escapeCode(QLatin1String("0")));
 
        return finalMessage;
    }
 
    return message.toString();
}
 
void QColorOutput::setHyperLinkSupport(bool v)
{
    d->setHyperLinkSupport(v);
}
 
void QColorOutput::flushBuffer()
{
    d->flushBuffer();
}
 
qsizetype QColorOutput::bufferSize() const
{
    return d->bufferSize();
}
 
void QColorOutput::truncateBuffer(qsizetype size)
{
    d->truncateBuffer(size);
}
 
/*!
  \internal
  Adds a color mapping from \a colorID to \a colorCode, for this QColorOutput instance.
 */
void QColorOutput::insertMapping(int colorID, const ColorCode colorCode)
{
    d->insertColor(colorID, colorCode);
}
 
QT_END_NAMESPACE