Make RCC handle bigger binaries

Traditionally, RCC in "C mode" was meant to bundle small resources into
a binary, like help texts or an occasional icon. RCC produces a .cpp
file containing the actual data in a char array which is then passed
to the compiler and linker as a normal source file. Larger resources
should be compiled in RCC's binary mode and loaded at run time.

Current Qt Quick use tries to deploy large hunks of data in "C mode",
causing heavy compiler/system load.

This patch works around the issue by splitting the process into
three parts:

1. Create a C++ skeleton, as usual, but use a placeholder array
   with "easily compilable" (mostly NULs) data instead.
2. Compile the skeleton file.
3. Replace the placeholder data with the real binary data.

time (qmake5 ; make clean ; make) takes 1.3 s real time for a
100 MB resource here, and there is still room for improving patching
performance if really needed.

Change-Id: I10a1645fd86a95a7d5663c89e19b05cb3b43ed1b
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

1 files changed, 45 insertions, 7 deletions

diff --git a/src/tools/rcc/main.cpp b/src/tools/rcc/main.cpp
index 972c59ef2e..99833101d2 100644
--- a/src/tools/rcc/main.cpp
+++ b/src/tools/rcc/main.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -123,6 +123,11 @@ int runRcc(int argc, char *argv[])
     outputOption.setValueName(QStringLiteral("file"));
     parser.addOption(outputOption);
 
+    QCommandLineOption tempOption(QStringList() << QStringLiteral("t") << QStringLiteral("temp"));
+    tempOption.setDescription(QStringLiteral("Use temporary <file> for big resources."));
+    tempOption.setValueName(QStringLiteral("file"));
+    parser.addOption(tempOption);
+
     QCommandLineOption nameOption(QStringLiteral("name"), QStringLiteral("Create an external initialization function with <name>."), QStringLiteral("name"));
     parser.addOption(nameOption);
 
@@ -141,6 +146,9 @@ int runRcc(int argc, char *argv[])
     QCommandLineOption binaryOption(QStringLiteral("binary"), QStringLiteral("Output a binary file for use as a dynamic resource."));
     parser.addOption(binaryOption);
 
+    QCommandLineOption passOption(QStringLiteral("pass"), QStringLiteral("Pass number for big resources"), QStringLiteral("number"));
+    parser.addOption(passOption);
+
     QCommandLineOption namespaceOption(QStringLiteral("namespace"), QStringLiteral("Turn off namespace macros."));
     parser.addOption(namespaceOption);
 
@@ -161,7 +169,6 @@ int runRcc(int argc, char *argv[])
 
     QString errorMsg;
     RCCResourceLibrary library;
-    QString outFilename = parser.value(outputOption);
     if (parser.isSet(nameOption))
         library.setInitName(parser.value(nameOption));
     if (parser.isSet(rootOption)) {
@@ -178,6 +185,14 @@ int runRcc(int argc, char *argv[])
         library.setCompressThreshold(parser.value(thresholdOption).toInt());
     if (parser.isSet(binaryOption))
         library.setFormat(RCCResourceLibrary::Binary);
+    if (parser.isSet(passOption)) {
+        if (parser.value(passOption) == QStringLiteral("1"))
+            library.setFormat(RCCResourceLibrary::Pass1);
+        else if (parser.value(passOption) == QStringLiteral("2"))
+            library.setFormat(RCCResourceLibrary::Pass2);
+        else
+            errorMsg = QLatin1String("Pass number must be 1 or 2");
+    }
     if (parser.isSet(namespaceOption))
         library.setUseNameSpace(!library.useNameSpace());
     if (parser.isSet(verboseOption))
@@ -194,6 +209,9 @@ int runRcc(int argc, char *argv[])
         }
     }
 
+    QString outFilename = parser.value(outputOption);
+    QString tempFilename = parser.value(tempOption);
+
     if (projectRequested) {
         return createProject(outFilename);
     }
@@ -217,11 +235,21 @@ int runRcc(int argc, char *argv[])
     if (!library.readFiles(list, errorDevice))
         return 1;
 
-    // open output
     QFile out;
-    QIODevice::OpenMode mode = QIODevice::WriteOnly;
-    if (library.format() == RCCResourceLibrary::C_Code)
-        mode |= QIODevice::Text;
+
+    // open output
+    QIODevice::OpenMode mode = QIODevice::NotOpen;
+    switch (library.format()) {
+        case RCCResourceLibrary::C_Code:
+        case RCCResourceLibrary::Pass1:
+            mode = QIODevice::WriteOnly | QIODevice::Text;
+            break;
+        case RCCResourceLibrary::Pass2:
+        case RCCResourceLibrary::Binary:
+            mode = QIODevice::WriteOnly;
+            break;
+    }
+
 
     if (outFilename.isEmpty() || outFilename == QLatin1String("-")) {
         // using this overload close() only flushes.
@@ -245,7 +273,17 @@ int runRcc(int argc, char *argv[])
         return 0;
     }
 
-    return library.output(out, errorDevice) ? 0 : 1;
+    QFile temp;
+    if (!tempFilename.isEmpty()) {
+        temp.setFileName(tempFilename);
+        if (!temp.open(QIODevice::ReadOnly)) {
+            const QString msg = QString::fromUtf8("Unable to open temporary file %1 for reading: %2\n")
+                    .arg(outFilename).arg(out.errorString());
+            errorDevice.write(msg.toUtf8());
+            return 1;
+        }
+    }
+    return library.output(out, temp, errorDevice) ? 0 : 1;
 }
 
 Q_CORE_EXPORT extern QBasicAtomicInt qt_qhash_seed; // from qhash.cpp