QtBase: use printf-style qWarning/qDebug where possible (II)

The printf-style version of QDebug expands to a lot less code than the
std::ostream-style version. Of course, you pay in type safety (but
compilers warn about it these days), you cannot stream complex Qt
types and streaming QStrings is awkward, but in many cases you
actually improve on readability.

But the main reason is that something that's not supposed to be
executed under normal operation has no business bloating executable
code size.

This is not an attempt at converting all qWarnings() to printf-style,
only the low-hanging fruit.

In this second part, replace
   qWarning() << "" << non-QString
with
   qWarning("..%.", non-QString).

QString (and QUrl etc) have special escaping handling when streamed
into QDebug, so leave those alone. They also seem to expand to less
code than the qPrintable() alternative, so there's no reason to
replace them.

Saves 2KiB, 3.4KiB, ~750b and ~450b in text size in QtCore, Gui,
Network and Widgets, resp., on optimized GCC 5.3 AMD64 builds.

Change-Id: Iae6823e543544347e628ca1060d6d51e3b04d3f4
Reviewed-by: Kai Koehne <kai.koehne@qt.io>

6 files changed, 23 insertions, 22 deletions

diff --git a/src/corelib/codecs/qicucodec.cpp b/src/corelib/codecs/qicucodec.cpp
index aa2095d9da..ee9f1d0048 100644
--- a/src/corelib/codecs/qicucodec.cpp
+++ b/src/corelib/codecs/qicucodec.cpp
@@ -527,7 +527,7 @@ QTextCodec *QIcuCodec::codecForNameUnlocked(const char *name)
     // check whether there is really a converter for the name available.
     UConverter *conv = ucnv_open(standardName, &error);
     if (!conv) {
-        qDebug() << "codecForName: ucnv_open failed" << standardName << u_errorName(error);
+        qDebug("codecForName: ucnv_open failed %s %s", standardName, u_errorName(error));
         return 0;
     }
     //qDebug() << "QIcuCodec: Standard name for " << name << "is" << standardName;
@@ -577,7 +577,7 @@ UConverter *QIcuCodec::getConverter(QTextCodec::ConverterState *state) const
             ucnv_setSubstChars(static_cast<UConverter *>(state->d),
                                state->flags & QTextCodec::ConvertInvalidToNull ? "\0" : "?", 1, &error);
             if (U_FAILURE(error))
-                qDebug() << "getConverter(state) ucnv_open failed" << m_name << u_errorName(error);
+                qDebug("getConverter(state) ucnv_open failed %s %s", m_name, u_errorName(error));
         }
         conv = static_cast<UConverter *>(state->d);
     }
@@ -587,7 +587,7 @@ UConverter *QIcuCodec::getConverter(QTextCodec::ConverterState *state) const
         conv = ucnv_open(m_name, &error);
         ucnv_setSubstChars(conv, "?", 1, &error);
         if (U_FAILURE(error))
-            qDebug() << "getConverter(no state) ucnv_open failed" << m_name << u_errorName(error);
+            qDebug("getConverter(no state) ucnv_open failed %s %s", m_name, u_errorName(error));
     }
     return conv;
 }
@@ -610,7 +610,7 @@ QString QIcuCodec::convertToUnicode(const char *chars, int length, QTextCodec::C
                        &chars, end,
                        0, false, &error);
         if (!U_SUCCESS(error) && error != U_BUFFER_OVERFLOW_ERROR) {
-            qDebug() << "convertToUnicode failed:" << u_errorName(error);
+            qDebug("convertToUnicode failed: %s", u_errorName(error));
             break;
         }
 
@@ -647,7 +647,7 @@ QByteArray QIcuCodec::convertFromUnicode(const QChar *unicode, int length, QText
                          &uc, end,
                          0, false, &error);
         if (!U_SUCCESS(error))
-            qDebug() << "convertFromUnicode failed:" << u_errorName(error);
+            qDebug("convertFromUnicode failed: %s", u_errorName(error));
         convertedChars = ch - string.data();
         if (uc >= end)
             break;
diff --git a/src/corelib/io/qfsfileengine.cpp b/src/corelib/io/qfsfileengine.cpp
index 7a04939cdb..098bc49468 100644
--- a/src/corelib/io/qfsfileengine.cpp
+++ b/src/corelib/io/qfsfileengine.cpp
@@ -545,7 +545,7 @@ bool QFSFileEnginePrivate::seekFdFh(qint64 pos)
     } else {
         // Unbuffered stdio mode.
         if (QT_LSEEK(fd, QT_OFF_T(pos), SEEK_SET) == -1) {
-            qWarning() << "QFile::at: Cannot set file position" << pos;
+            qWarning("QFile::at: Cannot set file position %lld", pos);
             q->setError(QFile::PositionError, qt_error_string(errno));
             return false;
         }
diff --git a/src/corelib/io/qlockfile_win.cpp b/src/corelib/io/qlockfile_win.cpp
index 261363f320..ba4a091965 100644
--- a/src/corelib/io/qlockfile_win.cpp
+++ b/src/corelib/io/qlockfile_win.cpp
@@ -100,7 +100,7 @@ QLockFile::LockError QLockFilePrivate::tryLock_sys()
                 ? QLockFile::LockFailedError
                 : QLockFile::PermissionError;
         default:
-            qWarning() << "Got unexpected locking error" << lastError;
+            qWarning("Got unexpected locking error %llu", quint64(lastError));
             return QLockFile::UnknownError;
         }
     }
diff --git a/src/corelib/kernel/qppsobject.cpp b/src/corelib/kernel/qppsobject.cpp
index dbff997c88..f716c1a92e 100644
--- a/src/corelib/kernel/qppsobject.cpp
+++ b/src/corelib/kernel/qppsobject.cpp
@@ -397,12 +397,12 @@ QByteArray QPpsObjectPrivate::encode(const QVariantMap &ppsData, bool *ok)
 void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, const QVariant &data,
                                    bool *ok)
 {
-    QString errorFunction;
+    const char *errorFunction;
     pps_encoder_error_t error = PPS_ENCODER_OK;
     switch (data.type()) {
     case QVariant::Bool:
         error = pps_encoder_add_bool(encoder, name, data.toBool());
-        errorFunction = QStringLiteral("pps_encoder_add_bool");
+        errorFunction = "pps_encoder_add_bool";
         break;
     // We want to support encoding uint even though libpps doesn't support it directly.
     // We can't encode uint as an int since that will lose precision (e.g. 2^31+1 can't be
@@ -411,41 +411,41 @@ void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, con
     case QVariant::UInt:
     case QVariant::Double:
         error = pps_encoder_add_double(encoder, name, data.toDouble());
-        errorFunction = QStringLiteral("pps_encoder_add_double");
+        errorFunction = "pps_encoder_add_double";
         break;
     case QVariant::Int:
         error = pps_encoder_add_int(encoder, name, data.toInt());
-        errorFunction = QStringLiteral("pps_encoder_add_int");
+        errorFunction = "pps_encoder_add_int";
         break;
     case QVariant::LongLong:
         error = pps_encoder_add_int64(encoder, name, data.toLongLong());
-        errorFunction = QStringLiteral("pps_encoder_add_int64");
+        errorFunction = "pps_encoder_add_int64";
         break;
     case QVariant::String:
         error = pps_encoder_add_string(encoder, name, data.toString().toUtf8().constData());
-        errorFunction = QStringLiteral("pps_encoder_add_string");
+        errorFunction = "pps_encoder_add_string";
         break;
     case QVariant::List:
         error = pps_encoder_start_array(encoder, name);
-        errorFunction = QStringLiteral("pps_encoder_start_array");
+        errorFunction = "pps_encoder_start_array";
         if (error == PPS_ENCODER_OK) {
             encodeArray(encoder, data.toList(), ok);
             error = pps_encoder_end_array(encoder);
-            errorFunction = QStringLiteral("pps_encoder_end_array");
+            errorFunction = "pps_encoder_end_array";
         }
         break;
     case QVariant::Map:
         error = pps_encoder_start_object(encoder, name);
-        errorFunction = QStringLiteral("pps_encoder_start_object");
+        errorFunction = "pps_encoder_start_object";
         if (error == PPS_ENCODER_OK) {
             encodeObject(encoder, data.toMap(), ok);
             error = pps_encoder_end_object(encoder);
-            errorFunction = QStringLiteral("pps_encoder_end_object");
+            errorFunction = "pps_encoder_end_object";
         }
         break;
     case QVariant::Invalid:
         error = pps_encoder_add_null(encoder, name);
-        errorFunction = QStringLiteral("pps_encoder_add_null");
+        errorFunction = "pps_encoder_add_null";
         break;
     default:
         qWarning("QPpsObjectPrivate::encodeData: the type of the parameter data is invalid");
@@ -454,7 +454,7 @@ void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, con
     }
 
     if (error != PPS_ENCODER_OK) {
-        qWarning() << "QPpsObjectPrivate::encodeData: " << errorFunction << " failed";
+        qWarning("QPpsObjectPrivate::encodeData: %s failed", errorFunction);
         *ok = false;
     } else {
         *ok = true;
diff --git a/src/corelib/kernel/qsystemsemaphore_posix.cpp b/src/corelib/kernel/qsystemsemaphore_posix.cpp
index 6137239467..9fbf5779b8 100644
--- a/src/corelib/kernel/qsystemsemaphore_posix.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_posix.cpp
@@ -147,7 +147,7 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
             if (::sem_post(semaphore) == -1) {
                 setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore (sem_post)"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-                qDebug() << QLatin1String("QSystemSemaphore::modify sem_post failed") << count << errno;
+                qDebug("QSystemSemaphore::modify sem_post failed %d %d", count, errno);
 #endif
                 // rollback changes to preserve the SysV semaphore behavior
                 for ( ; cnt < count; ++cnt) {
@@ -169,7 +169,7 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
             }
             setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore (sem_wait)"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-            qDebug() << QLatin1String("QSystemSemaphore::modify sem_wait failed") << count << errno;
+            qDebug("QSystemSemaphore::modify sem_wait failed %d %d", count, errno);
 #endif
             return false;
         }
diff --git a/src/corelib/kernel/qsystemsemaphore_systemv.cpp b/src/corelib/kernel/qsystemsemaphore_systemv.cpp
index f4fdfa5f58..1967899a58 100644
--- a/src/corelib/kernel/qsystemsemaphore_systemv.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_systemv.cpp
@@ -187,7 +187,8 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
         }
         setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-        qDebug() << QLatin1String("QSystemSemaphore::modify failed") << count << semctl(semaphore, 0, GETVAL) << errno << EIDRM << EINVAL;
+        qDebug("QSystemSemaphore::modify failed %d %d %d %d %d",
+               count, int(semctl(semaphore, 0, GETVAL)), int(errno), int(EIDRM), int(EINVAL);
 #endif
         return false;
     }