QMap => QHash

this should make the evaluator quite a lot faster. the total win for
qtbase/src is only 6%, though.

i made some effort to avoid that output files get randomized. however, i
didn't bother to keep debug output sorted.

Change-Id: Id9cef4674c0153c11ebbb65cb63bf8c229eb56e3
Reviewed-by: Joerg Bornemann <joerg.bornemann@nokia.com>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@nokia.com>

diff --git a/qmake/generators/mac/pbuilder_pbx.cpp b/qmake/generators/mac/pbuilder_pbx.cpp
index fe84c2b..d6b2235 100644 (file)
--- a/qmake/generators/mac/pbuilder_pbx.cpp
+++ b/qmake/generators/mac/pbuilder_pbx.cpp
@@ -168,8 +168,8 @@ ProjectBuilderMakefileGenerator::writeSubDirs(QTextStream &t)
                 if(tmp_proj.read(fn)) {
                     if(Option::debug_level) {
                         debug_msg(1, "Dumping all variables:");
-                        QMap<QString, QStringList> &vars = tmp_proj.variables();
-                        for(QMap<QString, QStringList>::Iterator it = vars.begin();
+                        QHash<QString, QStringList> &vars = tmp_proj.variables();
+                        for(QHash<QString, QStringList>::Iterator it = vars.begin();
                             it != vars.end(); ++it) {
                             if(it.key().left(1) != "." && !it.value().isEmpty())
                                 debug_msg(1, "%s: %s === %s", fn.toLatin1().constData(), it.key().toLatin1().constData(),

diff --git a/qmake/generators/mac/pbuilder_pbx.h b/qmake/generators/mac/pbuilder_pbx.h
index bf9749b..f4568be 100644 (file)
--- a/qmake/generators/mac/pbuilder_pbx.h
+++ b/qmake/generators/mac/pbuilder_pbx.h
@@ -56,7 +56,7 @@ class ProjectBuilderMakefileGenerator : public UnixMakefileGenerator
     bool writeMakefile(QTextStream &);
 
     QString pbxbuild();
-    QMap<QString, QString> keys;
+    QHash<QString, QString> keys;
     QString keyFor(const QString &file);
     QString findProgram(const QString &prog);
     QString fixForOutput(const QString &file);

diff --git a/qmake/generators/makefile.cpp b/qmake/generators/makefile.cpp
index 0a8da26..84525bc 100644 (file)
--- a/qmake/generators/makefile.cpp
+++ b/qmake/generators/makefile.cpp
@@ -165,7 +165,7 @@ MakefileGenerator::MakefileGenerator() :
 void
 MakefileGenerator::verifyCompilers()
 {
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     QStringList &quc = v["QMAKE_EXTRA_COMPILERS"];
     for(int i = 0; i < quc.size(); ) {
         bool error = false;
@@ -195,7 +195,7 @@ MakefileGenerator::initOutPaths()
         return;
     verifyCompilers();
     init_opath_already = true;
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     //for shadow builds
     if(!v.contains("QMAKE_ABSOLUTE_SOURCE_PATH")) {
         if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty() &&
@@ -317,7 +317,7 @@ QStringList
 MakefileGenerator::findFilesInVPATH(QStringList l, uchar flags, const QString &vpath_var)
 {
     QStringList vpath;
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     for(int val_it = 0; val_it < l.count(); ) {
         bool remove_file = false;
         QString &val = l[val_it];
@@ -411,7 +411,7 @@ MakefileGenerator::findFilesInVPATH(QStringList l, uchar flags, const QString &v
 void
 MakefileGenerator::initCompiler(const MakefileGenerator::Compiler &comp)
 {
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     QStringList &l = v[comp.variable_in];
     // find all the relevant file inputs
     if(!init_compiler_already.contains(comp.variable_in)) {
@@ -431,7 +431,7 @@ MakefileGenerator::init()
     verifyCompilers();
     init_already = true;
 
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     QStringList &quc = v["QMAKE_EXTRA_COMPILERS"];
 
     //make sure the COMPILERS are in the correct input/output chain order
@@ -875,8 +875,8 @@ MakefileGenerator::processPrlFile(QString &file)
                 debug_msg(2, "Ignored meta file %s [%s]", real_meta_file.toLatin1().constData(), libinfo.type().toLatin1().constData());
             } else {
                 ret = true;
-                QMap<QString, QStringList> &vars = libinfo.variables();
-                for(QMap<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it)
+                QHash<QString, QStringList> &vars = libinfo.variables();
+                for(QHash<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it)
                     processPrlVariable(it.key(), it.value());
                 if(try_replace_file && !libinfo.isEmpty("QMAKE_PRL_TARGET")) {
                     QString dir;
@@ -2138,23 +2138,22 @@ MakefileGenerator::writeExtraCompilerVariables(QTextStream &t)
 void
 MakefileGenerator::writeExtraVariables(QTextStream &t)
 {
-    bool first = true;
-    QMap<QString, QStringList> &vars = project->variables();
+    t << endl;
+
+    QStringList outlist;
+    QHash<QString, QStringList> &vars = project->variables();
     QStringList &exports = project->values("QMAKE_EXTRA_VARIABLES");
-    for(QMap<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it) {
-        for(QStringList::Iterator exp_it = exports.begin(); exp_it != exports.end(); ++exp_it) {
+    for (QHash<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it) {
+        for (QStringList::Iterator exp_it = exports.begin(); exp_it != exports.end(); ++exp_it) {
             QRegExp rx((*exp_it), Qt::CaseInsensitive, QRegExp::Wildcard);
-            if(rx.exactMatch(it.key())) {
-                if(first) {
-                    t << "\n####### Custom Variables" << endl;
-                    first = false;
-                }
-                t << "EXPORT_" << it.key() << " = " << it.value().join(" ") << endl;
-            }
+            if (rx.exactMatch(it.key()))
+                outlist << ("EXPORT_" + it.key() + " = " + it.value().join(" "));
         }
     }
-    if(!first)
-        t << endl;
+    if (!outlist.isEmpty()) {
+        t << "####### Custom Variables" << endl;
+        t << outlist.join("\n") << endl << endl;
+    }
 }
 
 bool

diff --git a/qmake/generators/metamakefile.cpp b/qmake/generators/metamakefile.cpp
index 19867f2..e60d1c4 100644 (file)
--- a/qmake/generators/metamakefile.cpp
+++ b/qmake/generators/metamakefile.cpp
@@ -218,8 +218,8 @@ BuildsMetaMakefileGenerator::write(const QString &oldpwd)
         // debugging
         if(Option::debug_level) {
             debug_msg(1, "Dumping all variables:");
-            QMap<QString, QStringList> &vars = project->variables();
-            for(QMap<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it) {
+            QHash<QString, QStringList> &vars = project->variables();
+            for(QHash<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it) {
                 if(!it.key().startsWith(".") && !it.value().isEmpty())
                     debug_msg(1, "%s === %s", it.key().toLatin1().constData(),
                               it.value().join(" :: ").toLatin1().constData());
@@ -237,7 +237,7 @@ MakefileGenerator
                   project->projectFile().toLatin1().constData(),build.toLatin1().constData());
 
         //initialize the base
-        QMap<QString, QStringList> basevars;
+        QHash<QString, QStringList> basevars;
         if(!project->isEmpty(build + ".CONFIG"))
             basevars["CONFIG"] += project->values(build + ".CONFIG");
         basevars["CONFIG"] += build;

diff --git a/qmake/generators/projectgenerator.cpp b/qmake/generators/projectgenerator.cpp
index 7bfadbf..ddbee4b 100644 (file)
--- a/qmake/generators/projectgenerator.cpp
+++ b/qmake/generators/projectgenerator.cpp
@@ -79,7 +79,7 @@ ProjectGenerator::init()
     project->read(QMakeProject::ReadFeatures);
     project->variables()["CONFIG"].clear();
 
-    QMap<QString, QStringList> &v = project->variables();
+    QHash<QString, QStringList> &v = project->variables();
     QString templ = Option::user_template.isEmpty() ? QString("app") : Option::user_template;
     if(!Option::user_template_prefix.isEmpty())
         templ.prepend(Option::user_template_prefix);

diff --git a/qmake/generators/win32/msvc_objectmodel.cpp b/qmake/generators/win32/msvc_objectmodel.cpp
index c506e38..96c230e 100644 (file)
--- a/qmake/generators/win32/msvc_objectmodel.cpp
+++ b/qmake/generators/win32/msvc_objectmodel.cpp
@@ -2303,13 +2303,14 @@ bool VCFilter::addExtraCompiler(const VCFilterFile &info)
         deps += CustomBuildTool.AdditionalDependencies;
         deps += cmd.left(cmd.indexOf(' '));
         // Make sure that all deps are only once
-        QMap<QString, bool> uniqDeps;
+        QHash<QString, bool> uniqDeps;
         for (int c = 0; c < deps.count(); ++c) {
             QString aDep = deps.at(c).trimmed();
             if (!aDep.isEmpty())
                 uniqDeps[aDep] = false;
         }
         CustomBuildTool.AdditionalDependencies = uniqDeps.keys();
+        CustomBuildTool.AdditionalDependencies.sort();
     }
 
     // Ensure that none of the output files are also dependencies. Or else, the custom buildstep

diff --git a/qmake/generators/win32/msvc_vcproj.cpp b/qmake/generators/win32/msvc_vcproj.cpp
index fc69881..55d3fa8 100644 (file)
--- a/qmake/generators/win32/msvc_vcproj.cpp
+++ b/qmake/generators/win32/msvc_vcproj.cpp
@@ -467,8 +467,8 @@ void VcprojGenerator::writeSubDirs(QTextStream &t)
                         Option::qmake_mode = old_mode;
                         if(Option::debug_level) {
                             debug_msg(1, "Dumping all variables:");
-                            QMap<QString, QStringList> &vars = tmp_proj.variables();
-                            for(QMap<QString, QStringList>::Iterator it = vars.begin();
+                            QHash<QString, QStringList> &vars = tmp_proj.variables();
+                            for(QHash<QString, QStringList>::Iterator it = vars.begin();
                                 it != vars.end(); ++it) {
                                 if(it.key().left(1) != "." && !it.value().isEmpty())
                                     debug_msg(1, "%s: %s === %s", fn.toLatin1().constData(), it.key().toLatin1().constData(),
@@ -1575,7 +1575,7 @@ void VcprojGenerator::outputVariables()
 {
 #if 0
     qDebug("Generator: MSVC.NET: List of current variables:");
-    for(QMap<QString, QStringList>::ConstIterator it = project->variables().begin(); it != project->variables().end(); ++it)
+    for(QHash<QString, QStringList>::ConstIterator it = project->variables().begin(); it != project->variables().end(); ++it)
         qDebug("Generator: MSVC.NET: %s => %s", qPrintable(it.key()), qPrintable(it.value().join(" | ")));
 #endif
 }

diff --git a/qmake/generators/win32/msvc_vcproj.h b/qmake/generators/win32/msvc_vcproj.h
index 5bb6b2d..35ac670 100644 (file)
--- a/qmake/generators/win32/msvc_vcproj.h
+++ b/qmake/generators/win32/msvc_vcproj.h
@@ -76,8 +76,8 @@ public:
     bool autogenPrecompCPP;
     static bool hasBuiltinCompiler(const QString &file);
 
-    QMap<QString, QStringList> extraCompilerSources;
-    QMap<QString, QStringList> extraCompilerOutputs;
+    QHash<QString, QStringList> extraCompilerSources;
+    QHash<QString, QStringList> extraCompilerOutputs;
     bool usePCH;
     VCProjectWriter *projectWriter;
 

diff --git a/qmake/meta.cpp b/qmake/meta.cpp
index b01c799..f5edff3 100644 (file)
--- a/qmake/meta.cpp
+++ b/qmake/meta.cpp
@@ -46,7 +46,7 @@
 
 QT_BEGIN_NAMESPACE
 
-QMap<QString, QMap<QString, QStringList> > QMakeMetaInfo::cache_vars;
+QHash<QString, QHash<QString, QStringList> > QMakeMetaInfo::cache_vars;
 
 QMakeMetaInfo::QMakeMetaInfo()
 {
@@ -140,8 +140,8 @@ QMakeMetaInfo::readLibtoolFile(const QString &f)
         dirf = "";
     else if(!dirf.isEmpty() && !dirf.endsWith(Option::output_dir))
         dirf += Option::dir_sep;
-    QMap<QString, QStringList> &v = proj.variables();
-    for(QMap<QString, QStringList>::Iterator it = v.begin(); it != v.end(); ++it) {
+    QHash<QString, QStringList> &v = proj.variables();
+    for(QHash<QString, QStringList>::Iterator it = v.begin(); it != v.end(); ++it) {
         QStringList lst = it.value();
         if(lst.count() == 1 && (lst.first().startsWith("'") || lst.first().startsWith("\"")) &&
            lst.first().endsWith(QString(lst.first()[0])))

diff --git a/qmake/meta.h b/qmake/meta.h
index 9c0c856..d20fc97 100644 (file)
--- a/qmake/meta.h
+++ b/qmake/meta.h
@@ -42,7 +42,7 @@
 #ifndef META_H
 #define META_H
 
-#include <qmap.h>
+#include <qhash.h>
 #include <qstringlist.h>
 #include <qstring.h>
 
@@ -52,9 +52,9 @@ class QMakeMetaInfo
 {
     bool readLibtoolFile(const QString &f);
     bool readPkgCfgFile(const QString &f);
-    QMap<QString, QStringList> vars;
+    QHash<QString, QStringList> vars;
     QString meta_type;
-    static QMap<QString, QMap<QString, QStringList> > cache_vars;
+    static QHash<QString, QHash<QString, QStringList> > cache_vars;
     void clear();
 public:
     QMakeMetaInfo();
@@ -67,7 +67,7 @@ public:
     bool isEmpty(const QString &v);
     QStringList &values(const QString &v);
     QString first(const QString &v);
-    QMap<QString, QStringList> &variables();
+    QHash<QString, QStringList> &variables();
 };
 
 inline bool QMakeMetaInfo::isEmpty(const QString &v)
@@ -92,7 +92,7 @@ inline QString QMakeMetaInfo::first(const QString &v)
 #endif
 }
 
-inline QMap<QString, QStringList> &QMakeMetaInfo::variables()
+inline QHash<QString, QStringList> &QMakeMetaInfo::variables()
 { return vars; }
 
 inline bool QMakeMetaInfo::libExists(QString lib)

diff --git a/qmake/project.cpp b/qmake/project.cpp
index c381d3a..eb2b10b 100644 (file)
--- a/qmake/project.cpp
+++ b/qmake/project.cpp
@@ -52,7 +52,6 @@
 #include <qregexp.h>
 #include <qtextstream.h>
 #include <qstack.h>
-#include <qhash.h>
 #include <qdebug.h>
 #ifdef Q_OS_UNIX
 #include <unistd.h>
@@ -79,12 +78,12 @@ enum ExpandFunc { E_MEMBER=1, E_FIRST, E_LAST, E_CAT, E_FROMFILE, E_EVAL, E_LIST
                   E_FIND, E_SYSTEM, E_UNIQUE, E_QUOTE, E_ESCAPE_EXPAND,
                   E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,
                   E_SIZE, E_SORT_DEPENDS, E_RESOLVE_DEPENDS };
-QMap<QString, ExpandFunc> qmake_expandFunctions()
+QHash<QString, ExpandFunc> qmake_expandFunctions()
 {
-    static QMap<QString, ExpandFunc> *qmake_expand_functions = 0;
+    static QHash<QString, ExpandFunc> *qmake_expand_functions = 0;
     if(!qmake_expand_functions) {
-        qmake_expand_functions = new QMap<QString, ExpandFunc>;
-        qmakeAddCacheClear(qmakeDeleteCacheClear<QMap<QString, ExpandFunc> >, (void**)&qmake_expand_functions);
+        qmake_expand_functions = new QHash<QString, ExpandFunc>;
+        qmakeAddCacheClear(qmakeDeleteCacheClear<QHash<QString, ExpandFunc> >, (void**)&qmake_expand_functions);
         qmake_expand_functions->insert("member", E_MEMBER);
         qmake_expand_functions->insert("first", E_FIRST);
         qmake_expand_functions->insert("last", E_LAST);
@@ -121,11 +120,11 @@ enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,
                 T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,
                 T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,
                 T_MESSAGE, T_WARNING, T_IF, T_OPTION };
-QMap<QString, TestFunc> qmake_testFunctions()
+QHash<QString, TestFunc> qmake_testFunctions()
 {
-    static QMap<QString, TestFunc> *qmake_test_functions = 0;
+    static QHash<QString, TestFunc> *qmake_test_functions = 0;
     if(!qmake_test_functions) {
-        qmake_test_functions = new QMap<QString, TestFunc>;
+        qmake_test_functions = new QHash<QString, TestFunc>;
         qmake_test_functions->insert("requires", T_REQUIRES);
         qmake_test_functions->insert("greaterThan", T_GREATERTHAN);
         qmake_test_functions->insert("lessThan", T_LESSTHAN);
@@ -347,10 +346,10 @@ struct ParsableBlock
 protected:
     int ref_cnt;
     virtual bool continueBlock() = 0;
-    bool eval(QMakeProject *p, QMap<QString, QStringList> &place);
+    bool eval(QMakeProject *p, QHash<QString, QStringList> &place);
 };
 
-bool ParsableBlock::eval(QMakeProject *p, QMap<QString, QStringList> &place)
+bool ParsableBlock::eval(QMakeProject *p, QHash<QString, QStringList> &place)
 {
     //save state
     parser_info pi = parser;
@@ -376,19 +375,19 @@ struct FunctionBlock : public ParsableBlock
 {
     FunctionBlock() : calling_place(0), scope_level(1), cause_return(false) { }
 
-    QMap<QString, QStringList> vars;
-    QMap<QString, QStringList> *calling_place;
+    QHash<QString, QStringList> vars;
+    QHash<QString, QStringList> *calling_place;
     QStringList return_value;
     int scope_level;
     bool cause_return;
 
     bool exec(const QList<QStringList> &args,
-              QMakeProject *p, QMap<QString, QStringList> &place, QStringList &functionReturn);
+              QMakeProject *p, QHash<QString, QStringList> &place, QStringList &functionReturn);
     virtual bool continueBlock() { return !cause_return; }
 };
 
 bool FunctionBlock::exec(const QList<QStringList> &args,
-                         QMakeProject *proj, QMap<QString, QStringList> &place,
+                         QMakeProject *proj, QHash<QString, QStringList> &place,
                          QStringList &functionReturn)
 {
     //save state
@@ -442,10 +441,10 @@ struct IteratorBlock : public ParsableBlock
     bool loop_forever, cause_break, cause_next;
     QStringList list;
 
-    bool exec(QMakeProject *p, QMap<QString, QStringList> &place);
+    bool exec(QMakeProject *p, QHash<QString, QStringList> &place);
     virtual bool continueBlock() { return !cause_next && !cause_break; }
 };
-bool IteratorBlock::exec(QMakeProject *p, QMap<QString, QStringList> &place)
+bool IteratorBlock::exec(QMakeProject *p, QHash<QString, QStringList> &place)
 {
     bool ret = true;
     QStringList::Iterator it;
@@ -621,12 +620,12 @@ QMakeProject::~QMakeProject()
 {
     if(own_prop)
         delete prop;
-    for(QMap<QString, FunctionBlock*>::iterator it = replaceFunctions.begin(); it != replaceFunctions.end(); ++it) {
+    for(QHash<QString, FunctionBlock*>::iterator it = replaceFunctions.begin(); it != replaceFunctions.end(); ++it) {
         if(!it.value()->deref())
             delete it.value();
     }
     replaceFunctions.clear();
-    for(QMap<QString, FunctionBlock*>::iterator it = testFunctions.begin(); it != testFunctions.end(); ++it) {
+    for(QHash<QString, FunctionBlock*>::iterator it = testFunctions.begin(); it != testFunctions.end(); ++it) {
         if(!it.value()->deref())
             delete it.value();
     }
@@ -635,7 +634,7 @@ QMakeProject::~QMakeProject()
 
 
 void
-QMakeProject::init(QMakeProperty *p, const QMap<QString, QStringList> *vars)
+QMakeProject::init(QMakeProperty *p, const QHash<QString, QStringList> *vars)
 {
     if(vars)
         base_vars = *vars;
@@ -650,14 +649,14 @@ QMakeProject::init(QMakeProperty *p, const QMap<QString, QStringList> *vars)
     reset();
 }
 
-QMakeProject::QMakeProject(QMakeProject *p, const QMap<QString, QStringList> *vars)
+QMakeProject::QMakeProject(QMakeProject *p, const QHash<QString, QStringList> *vars)
 {
     init(p->properties(), vars ? vars : &p->variables());
-    for(QMap<QString, FunctionBlock*>::iterator it = p->replaceFunctions.begin(); it != p->replaceFunctions.end(); ++it) {
+    for(QHash<QString, FunctionBlock*>::iterator it = p->replaceFunctions.begin(); it != p->replaceFunctions.end(); ++it) {
         it.value()->ref();
         replaceFunctions.insert(it.key(), it.value());
     }
-    for(QMap<QString, FunctionBlock*>::iterator it = p->testFunctions.begin(); it != p->testFunctions.end(); ++it) {
+    for(QHash<QString, FunctionBlock*>::iterator it = p->testFunctions.begin(); it != p->testFunctions.end(); ++it) {
         it.value()->ref();
         testFunctions.insert(it.key(), it.value());
     }
@@ -675,7 +674,7 @@ QMakeProject::reset()
 }
 
 bool
-QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int numLines)
+QMakeProject::parse(const QString &t, QHash<QString, QStringList> &place, int numLines)
 {
     // To preserve the integrity of any UTF-8 characters in .pro file, temporarily replace the
     // non-breaking space (0xA0) characters with another non-space character, so that
@@ -944,7 +943,7 @@ QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int num
                                         parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
                                 return false;
                             }
-                            QMap<QString, FunctionBlock*> *map = 0;
+                            QHash<QString, FunctionBlock*> *map = 0;
                             if(func == "defineTest")
                                 map = &testFunctions;
                             else
@@ -1184,7 +1183,7 @@ QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int num
 }
 
 bool
-QMakeProject::read(QTextStream &file, QMap<QString, QStringList> &place)
+QMakeProject::read(QTextStream &file, QHash<QString, QStringList> &place)
 {
     int numLines = 0;
     bool ret = true;
@@ -1227,7 +1226,7 @@ QMakeProject::read(QTextStream &file, QMap<QString, QStringList> &place)
 }
 
 bool
-QMakeProject::read(const QString &file, QMap<QString, QStringList> &place)
+QMakeProject::read(const QString &file, QHash<QString, QStringList> &place)
 {
     parser_info pi = parser;
     reset();
@@ -1520,7 +1519,7 @@ void QMakeProject::validateModes()
 }
 
 bool
-QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QStringList> *place)
+QMakeProject::isActiveConfig(const QString &x, bool regex, QHash<QString, QStringList> *place)
 {
     if(x.isEmpty())
         return true;
@@ -1594,7 +1593,7 @@ QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QString
 }
 
 bool
-QMakeProject::doProjectTest(QString str, QMap<QString, QStringList> &place)
+QMakeProject::doProjectTest(QString str, QHash<QString, QStringList> &place)
 {
     QString chk = remove_quotes(str);
     if(chk.isEmpty())
@@ -1623,13 +1622,13 @@ QMakeProject::doProjectTest(QString str, QMap<QString, QStringList> &place)
 
 bool
 QMakeProject::doProjectTest(QString func, const QString &params,
-                            QMap<QString, QStringList> &place)
+                            QHash<QString, QStringList> &place)
 {
     return doProjectTest(func, split_arg_list(params), place);
 }
 
 QMakeProject::IncludeStatus
-QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringList> &place)
+QMakeProject::doProjectInclude(QString file, uchar flags, QHash<QString, QStringList> &place)
 {
     enum { UnknownFormat, ProFormat, JSFormat } format = UnknownFormat;
     if(flags & IncludeFlagFeature) {
@@ -1766,14 +1765,14 @@ QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringL
 
 QStringList
 QMakeProject::doProjectExpand(QString func, const QString &params,
-                              QMap<QString, QStringList> &place)
+                              QHash<QString, QStringList> &place)
 {
     return doProjectExpand(func, split_arg_list(params), place);
 }
 
 QStringList
 QMakeProject::doProjectExpand(QString func, QStringList args,
-                              QMap<QString, QStringList> &place)
+                              QHash<QString, QStringList> &place)
 {
     QList<QStringList> args_list;
     for(int i = 0; i < args.size(); ++i) {
@@ -1788,7 +1787,7 @@ QMakeProject::doProjectExpand(QString func, QStringList args,
 static void
 populateDeps(const QStringList &deps, const QString &prefix,
              QHash<QString, QSet<QString> > &dependencies, QHash<QString, QStringList> &dependees,
-             QStringList &rootSet, QMap<QString, QStringList> &place)
+             QStringList &rootSet, QHash<QString, QStringList> &place)
 {
     foreach (const QString &item, deps)
         if (!dependencies.contains(item)) {
@@ -1808,7 +1807,7 @@ populateDeps(const QStringList &deps, const QString &prefix,
 
 QStringList
 QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
-                              QMap<QString, QStringList> &place)
+                              QHash<QString, QStringList> &place)
 {
     func = func.trimmed();
     if(replaceFunctions.contains(func)) {
@@ -1931,7 +1930,7 @@ QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
             QString file = args[0], seek_var = args[1];
             file = Option::fixPathToLocalOS(file);
 
-            QMap<QString, QStringList> tmp;
+            QHash<QString, QStringList> tmp;
             if(doProjectInclude(file, IncludeFlagNewParser, tmp) == IncludeSuccess) {
                 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
                     QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
@@ -1951,7 +1950,7 @@ QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
                     parser.file.toLatin1().constData(), parser.line_no);
 
         } else {
-            const QMap<QString, QStringList> *source = &place;
+            const QHash<QString, QStringList> *source = &place;
             if(args.count() == 2) {
                 if(args.at(1) == "Global") {
                     source = &vars;
@@ -1970,7 +1969,7 @@ QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
         QString tmp;
         tmp.sprintf(".QMAKE_INTERNAL_TMP_VAR_%d", x++);
         ret = QStringList(tmp);
-        QStringList &lst = (*((QMap<QString, QStringList>*)&place))[tmp];
+        QStringList &lst = (*((QHash<QString, QStringList>*)&place))[tmp];
         lst.clear();
         for(QStringList::ConstIterator arg_it = args.begin();
             arg_it != args.end(); ++arg_it)
@@ -2281,7 +2280,7 @@ QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
 }
 
 bool
-QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStringList> &place)
+QMakeProject::doProjectTest(QString func, QStringList args, QHash<QString, QStringList> &place)
 {
     QList<QStringList> args_list;
     for(int i = 0; i < args.size(); ++i) {
@@ -2294,7 +2293,7 @@ QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStrin
 }
 
 bool
-QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QString, QStringList> &place)
+QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QHash<QString, QStringList> &place)
 {
     func = func.trimmed();
 
@@ -2580,7 +2579,7 @@ QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QSt
         }
 
         bool ret = false;
-        QMap<QString, QStringList> tmp;
+        QHash<QString, QStringList> tmp;
         if(doProjectInclude(Option::fixPathToLocalOS(args[0]), IncludeFlagNewParser, tmp) == IncludeSuccess) {
             if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
                 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
@@ -2666,16 +2665,16 @@ QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QSt
             flags |= IncludeFlagFeature;
         IncludeStatus stat = IncludeFailure;
         if(!parseInto.isEmpty()) {
-            QMap<QString, QStringList> symbols;
+            QHash<QString, QStringList> symbols;
             stat = doProjectInclude(file, flags|IncludeFlagNewProject, symbols);
             if(stat == IncludeSuccess) {
-                QMap<QString, QStringList> out_place;
-                for(QMap<QString, QStringList>::ConstIterator it = place.begin(); it != place.end(); ++it) {
+                QHash<QString, QStringList> out_place;
+                for(QHash<QString, QStringList>::ConstIterator it = place.begin(); it != place.end(); ++it) {
                     const QString var = it.key();
                     if(var != parseInto && !var.startsWith(parseInto + "."))
                         out_place.insert(var, it.value());
                 }
-                for(QMap<QString, QStringList>::ConstIterator it = symbols.begin(); it != symbols.end(); ++it) {
+                for(QHash<QString, QStringList>::ConstIterator it = symbols.begin(); it != symbols.end(); ++it) {
                     const QString var = it.key();
                     if(!var.startsWith("."))
                         out_place.insert(parseInto + "." + it.key(), it.value());
@@ -2754,7 +2753,7 @@ QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QSt
 }
 
 bool
-QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringList> &place)
+QMakeProject::doProjectCheckReqs(const QStringList &deps, QHash<QString, QStringList> &place)
 {
     bool ret = false;
     for(QStringList::ConstIterator it = deps.begin(); it != deps.end(); ++it) {
@@ -2773,14 +2772,14 @@ QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringL
 bool
 QMakeProject::test(const QString &v)
 {
-    QMap<QString, QStringList> tmp = vars;
+    QHash<QString, QStringList> tmp = vars;
     return doProjectTest(v, tmp);
 }
 
 bool
 QMakeProject::test(const QString &func, const QList<QStringList> &args)
 {
-    QMap<QString, QStringList> tmp = vars;
+    QHash<QString, QStringList> tmp = vars;
     return doProjectTest(func, args, tmp);
 }
 
@@ -2788,7 +2787,7 @@ QStringList
 QMakeProject::expand(const QString &str)
 {
     bool ok;
-    QMap<QString, QStringList> tmp = vars;
+    QHash<QString, QStringList> tmp = vars;
     const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
     if(ok)
         return ret;
@@ -2803,7 +2802,7 @@ QMakeProject::expand(const QString &str, const QString &file, int line)
     parser.file = file;
     parser.line_no = line;
     parser.from_file = false;
-    QMap<QString, QStringList> tmp = vars;
+    QHash<QString, QStringList> tmp = vars;
     const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
     parser = pi;
     return ok ? ret.join(QString(Option::field_sep)) : QString();
@@ -2812,12 +2811,12 @@ QMakeProject::expand(const QString &str, const QString &file, int line)
 QStringList
 QMakeProject::expand(const QString &func, const QList<QStringList> &args)
 {
-    QMap<QString, QStringList> tmp = vars;
+    QHash<QString, QStringList> tmp = vars;
     return doProjectExpand(func, args, tmp);
 }
 
 bool
-QMakeProject::doVariableReplace(QString &str, QMap<QString, QStringList> &place)
+QMakeProject::doVariableReplace(QString &str, QHash<QString, QStringList> &place)
 {
     bool ret;
     str = doVariableReplaceExpand(str, place, &ret).join(QString(Option::field_sep));
@@ -2825,7 +2824,7 @@ QMakeProject::doVariableReplace(QString &str, QMap<QString, QStringList> &place)
 }
 
 QStringList
-QMakeProject::doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok)
+QMakeProject::doVariableReplaceExpand(const QString &str, QHash<QString, QStringList> &place, bool *ok)
 {
     QStringList ret;
     if(ok)
@@ -3015,7 +3014,7 @@ QMakeProject::doVariableReplaceExpand(const QString &str, QMap<QString, QStringL
     return ret;
 }
 
-QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList> &place)
+QStringList &QMakeProject::values(const QString &_var, QHash<QString, QStringList> &place)
 {
     QString var = varMap(_var);
     if(var == QLatin1String("LITERAL_WHITESPACE")) { //a real space in a token)
@@ -3185,7 +3184,7 @@ QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList
 
 bool QMakeProject::isEmpty(const QString &v)
 {
-    QMap<QString, QStringList>::ConstIterator it = vars.constFind(varMap(v));
+    QHash<QString, QStringList>::ConstIterator it = vars.constFind(varMap(v));
     return it == vars.constEnd() || it->isEmpty();
 }
 

diff --git a/qmake/project.h b/qmake/project.h
index d458dd9..8a49eb5 100644 (file)
--- a/qmake/project.h
+++ b/qmake/project.h
@@ -46,7 +46,7 @@
 #include <qtextstream.h>
 #include <qstring.h>
 #include <qstack.h>
-#include <qmap.h>
+#include <qhash.h>
 #include <qmetatype.h>
 
 QT_BEGIN_NAMESPACE
@@ -76,7 +76,7 @@ class QMakeProject
     QStack<FunctionBlock *> function_blocks;
     IteratorBlock *iterator;
     FunctionBlock *function;
-    QMap<QString, FunctionBlock*> testFunctions, replaceFunctions;
+    QHash<QString, FunctionBlock*> testFunctions, replaceFunctions;
 
     bool recursive;
     bool own_prop;
@@ -84,8 +84,8 @@ class QMakeProject
     QString pfile, cfile;
     QMakeProperty *prop;
     void reset();
-    QMap<QString, QStringList> vars, base_vars, cache;
-    bool parse(const QString &text, QMap<QString, QStringList> &place, int line_count=1);
+    QHash<QString, QStringList> vars, base_vars, cache;
+    bool parse(const QString &text, QHash<QString, QStringList> &place, int line_count=1);
 
     enum IncludeStatus {
         IncludeSuccess,
@@ -100,21 +100,21 @@ class QMakeProject
         IncludeFlagNewParser = 0x02,
         IncludeFlagNewProject = 0x04
     };
-    IncludeStatus doProjectInclude(QString file, uchar flags, QMap<QString, QStringList> &place);
+    IncludeStatus doProjectInclude(QString file, uchar flags, QHash<QString, QStringList> &place);
 
-    bool doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringList> &place);
-    bool doVariableReplace(QString &str, QMap<QString, QStringList> &place);
-    QStringList doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok=0);
-    void init(QMakeProperty *, const QMap<QString, QStringList> *);
-    QStringList &values(const QString &v, QMap<QString, QStringList> &place);
+    bool doProjectCheckReqs(const QStringList &deps, QHash<QString, QStringList> &place);
+    bool doVariableReplace(QString &str, QHash<QString, QStringList> &place);
+    QStringList doVariableReplaceExpand(const QString &str, QHash<QString, QStringList> &place, bool *ok=0);
+    void init(QMakeProperty *, const QHash<QString, QStringList> *);
+    QStringList &values(const QString &v, QHash<QString, QStringList> &place);
     void validateModes();
 
 public:
     QMakeProject() { init(0, 0); }
     QMakeProject(QMakeProperty *p) { init(p, 0); }
-    QMakeProject(QMakeProject *p, const QMap<QString, QStringList> *nvars=0);
-    QMakeProject(const QMap<QString, QStringList> &nvars) { init(0, &nvars); }
-    QMakeProject(QMakeProperty *p, const QMap<QString, QStringList> &nvars) { init(p, &nvars); }
+    QMakeProject(QMakeProject *p, const QHash<QString, QStringList> *nvars=0);
+    QMakeProject(const QHash<QString, QStringList> &nvars) { init(0, &nvars); }
+    QMakeProject(QMakeProperty *p, const QHash<QString, QStringList> &nvars) { init(p, &nvars); }
     ~QMakeProject();
 
     enum { ReadCache=0x01, ReadConf=0x02, ReadCmdLine=0x04, ReadProFile=0x08,
@@ -129,19 +129,19 @@ public:
     QString projectFile();
     inline QMakeProperty *properties() { return prop; }
 
-    bool doProjectTest(QString str, QMap<QString, QStringList> &place);
+    bool doProjectTest(QString str, QHash<QString, QStringList> &place);
     bool doProjectTest(QString func, const QString &params,
-                       QMap<QString, QStringList> &place);
+                       QHash<QString, QStringList> &place);
     bool doProjectTest(QString func, QStringList args,
-                       QMap<QString, QStringList> &place);
+                       QHash<QString, QStringList> &place);
     bool doProjectTest(QString func, QList<QStringList> args,
-                       QMap<QString, QStringList> &place);
+                       QHash<QString, QStringList> &place);
     QStringList doProjectExpand(QString func, const QString &params,
-                                QMap<QString, QStringList> &place);
+                                QHash<QString, QStringList> &place);
     QStringList doProjectExpand(QString func, QStringList args,
-                                QMap<QString, QStringList> &place);
+                                QHash<QString, QStringList> &place);
     QStringList doProjectExpand(QString func, QList<QStringList> args,
-                                QMap<QString, QStringList> &place);
+                                QHash<QString, QStringList> &place);
 
     QStringList expand(const QString &v);
     QString expand(const QString &v, const QString &file, int line);
@@ -149,20 +149,20 @@ public:
     bool test(const QString &v);
     bool test(const QString &func, const QList<QStringList> &args);
     bool isActiveConfig(const QString &x, bool regex=false,
-                        QMap<QString, QStringList> *place=NULL);
+                        QHash<QString, QStringList> *place=NULL);
 
     bool isSet(const QString &v); // No compat mapping, no magic variables
     bool isEmpty(const QString &v); // With compat mapping, but no magic variables
     QStringList &values(const QString &v); // With compat mapping and magic variables
     QString first(const QString &v); // ditto
-    QMap<QString, QStringList> &variables(); // No compat mapping and magic, obviously
+    QHash<QString, QStringList> &variables(); // No compat mapping and magic, obviously
 
     bool isRecursive() const { return recursive; }
 
 protected:
     friend class MakefileGenerator;
-    bool read(const QString &file, QMap<QString, QStringList> &place);
-    bool read(QTextStream &file, QMap<QString, QStringList> &place);
+    bool read(const QString &file, QHash<QString, QStringList> &place);
+    bool read(QTextStream &file, QHash<QString, QStringList> &place);
 
 };
 Q_DECLARE_METATYPE(QMakeProject*)
@@ -188,7 +188,7 @@ inline QString QMakeProject::first(const QString &v)
     return vals.first();
 }
 
-inline QMap<QString, QStringList> &QMakeProject::variables()
+inline QHash<QString, QStringList> &QMakeProject::variables()
 { return vars; }
 
 QT_END_NAMESPACE

diff --git a/qmake/property.cpp b/qmake/property.cpp
index 2bacc43..c1efef0 100644 (file)
--- a/qmake/property.cpp
+++ b/qmake/property.cpp
@@ -43,7 +43,6 @@
 #include "option.h"
 
 #include <qdir.h>
-#include <qmap.h>
 #include <qsettings.h>
 #include <qstringlist.h>
 #include <stdio.h>