Changeset 363 for trunk/qmake

Timestamp:

Nov 30, 2009, 6:52:30 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

global: Reverted r355, r356, r361, r362 (see #78).

Location:

trunk/qmake

Files:

• cachekeys.h (modified) (3 diffs)
• generators/makefile.cpp (modified) (11 diffs)
• generators/makefiledeps.cpp (modified) (2 diffs)
• generators/metamakefile.cpp (modified) (1 diff)
• generators/win32/winmakefile.cpp (modified) (1 diff)
• main.cpp (modified) (1 diff)
• meta.cpp (modified) (1 diff)
• project.cpp (modified) (2 diffs)

trunk/qmake/cachekeys.h

@@ -48 +48 @@
 #include <qfile.h>
 #include <qfileinfo.h>
-#include <qdir.h>
 #include <qhash.h>
 
@@ -108 +107 @@
             return true;
 
-#ifdef Q_OS_OS2
-        return QDir::isRelativePath(file);
-#else
         const QChar c0 = file.at(0);
         const QChar c1 = length >= 2 ? file.at(1) : QChar(0);
@@ -118 +114 @@
                 || (c0 == QLatin1Char('/') && c1 == QLatin1Char('/'))
                 || (c0 == QLatin1Char('\\') && c1 == QLatin1Char('\\')));
-#endif    
     }
 };

trunk/qmake/generators/makefile.cpp

@@ -125 +125 @@
     }
     bool ret = true;
-#if defined(Q_OS_WIN)
+#if defined(Q_OS_WIN) || defined(Q_OS_OS2)
     bool driveExists = true;
     if(!QDir::isRelativePath(path)) {
@@ -138 +138 @@
     }
     if(driveExists)
-#elif defined(Q_OS_OS2)
-    path = QFileInfo(path).absoluteFilePath();
-    QString drv = path.left(3);
-    if (!QFile::exists(drv))
-        warn_msg(WarnLogic, "Cannot access drive '%s' (%s)",
-                 drv.toLocal8Bit().data(), path.toLocal8Bit().data());
-    else
 #endif
     {
@@ -348 +341 @@
                         vpath += Option::output_dir;
                 }
-                foreach(const QString &vp, vpath) {
-                    QString real_val = QDir(vp).absoluteFilePath(val);
-                    if (exists(real_val)) {
-                        val = real_val;
+                for(QStringList::Iterator vpath_it = vpath.begin();
+                    vpath_it != vpath.end(); ++vpath_it) {
+                    QString real_dir = Option::fixPathToLocalOS((*vpath_it));
+                    if(exists(real_dir + QDir::separator() + val)) {
+                        QString dir = (*vpath_it);
+                        if(dir.right(Option::dir_sep.length()) != Option::dir_sep)
+                            dir += Option::dir_sep;
+                        val = dir + val;
                         if(!(flags & VPATH_NoFixify))
                             val = fileFixify(val);
@@ -853 +850 @@
                     file = libinfo.first("QMAKE_PRL_TARGET");
                     if(QDir::isRelativePath(file))
-                        file = QDir(dir).absoluteFilePath(file);
+                        file.prepend(dir);
                 }
             }
@@ -2737 +2734 @@
 }
 
-inline static bool pathEquals(const QString &path1, const QString &path2)
-{
-#if defined(Q_OS_WIN) || defined(Q_OS_OS2)
-    return path1.compare(path2, Qt::CaseInsensitive) == 0;
-#else
-    return path1 == path2;
-#endif
-}
-
-inline static bool pathStartsWith(const QString &path1, const QString &path2)
-{
-#if defined(Q_OS_WIN) || defined(Q_OS_OS2)
-    return path1.toLower().startsWith(path2.toLower());
-#else
-    return path1.startsWith(path2);
-#endif
-}
-
 QString
 MakefileGenerator::fileFixify(const QString& file, const QString &out_d, const QString &in_d,
@@ -2785 +2764 @@
     if(fix == FileFixifyAbsolute || (fix == FileFixifyDefault && project->isActiveConfig("no_fixpath"))) {
         if(fix == FileFixifyAbsolute && QDir::isRelativePath(ret)) //already absolute
-            ret = QDir(pwd).absoluteFilePath(ret);
+            ret.prepend(pwd);
         ret = Option::fixPathToTargetOS(ret, false, canon);
     } else { //fix it..
@@ -2803 +2782 @@
         if(out_dir != in_dir || !qfileinfo.isRelative()) {
             if(qfileinfo.isRelative()) {
-                ret = QDir(in_dir).absoluteFilePath(qfile);
+                ret = in_dir + "/" + qfile;
                 qfileinfo.setFile(ret);
             }
             ret = Option::fixPathToTargetOS(ret, false, canon);
             if(canon && qfileinfo.exists() &&
-               pathEquals(file, Option::fixPathToTargetOS(ret, true, canon)))
+               file == Option::fixPathToTargetOS(ret, true, canon))
                 ret = Option::fixPathToTargetOS(qfileinfo.canonicalFilePath());
             QString match_dir = Option::fixPathToTargetOS(out_dir, false, canon);
-            if(pathEquals(ret, match_dir)) {
+            if(ret == match_dir) {
                 ret = "";
-            } else if(pathStartsWith(ret, match_dir + Option::dir_sep)) {
+            } else if(ret.startsWith(match_dir + Option::dir_sep)) {
                 ret = ret.mid(match_dir.length() + Option::dir_sep.length());
             } else {
@@ -2834 +2813 @@
                     if(match_dir.isEmpty())
                         break;
-                    if(pathStartsWith(ret, match_dir + Option::dir_sep)) {
+                    if(ret.startsWith(match_dir + Option::dir_sep)) {
                         //concat
                         int remlen = ret.length() - (match_dir.length() + 1);
@@ -3025 +3004 @@
         if(!file.fileName().isEmpty()) {
             if(QDir::isRelativePath(file.fileName()))
-                file.setFileName(QDir(Option::output_dir).absoluteFilePath(file.fileName())); //pwd when qmake was run
+                file.setFileName(Option::output_dir + "/" + file.fileName()); //pwd when qmake was run
             QFileInfo fi(fileInfo(file.fileName()));
             if(fi.isDir())
@@ -3038 +3017 @@
     }
     if(QDir::isRelativePath(file.fileName())) {
-        file.setFileName(QDir(Option::output_dir).absoluteFilePath(file.fileName())); //pwd when qmake was run
+        QString fname = Option::output_dir;  //pwd when qmake was run
+        if(!fname.endsWith("/"))
+            fname += "/";
+        fname += file.fileName();
+        file.setFileName(fname);
     }
     if(!build.isEmpty())
@@ -3056 +3039 @@
         od = Option::fixPathToTargetOS(od);
         if(QDir::isRelativePath(od))
-            od = QDir(Option::output_dir).absoluteFilePath(od);
+            od.prepend(Option::output_dir);
         Option::output_dir = od;
         return true;

trunk/qmake/generators/makefiledeps.cpp

@@ -625 +625 @@
                     if(try_local) {
                         QString dir = findFileInfo(file->file).path();
-                        QMakeLocalFileName f(QDir(dir).absoluteFilePath(lfn.local()));
+                        if(QDir::isRelativePath(dir))
+                            dir.prepend(qmake_getpwd() + "/");
+                        if(!dir.endsWith("/"))
+                            dir += "/";
+                        QMakeLocalFileName f(dir + lfn.local());
                         if(findFileInfo(f).exists()) {
                             lfn = fixPathForFile(f);
@@ -632 +636 @@
                     }
                     if(!exists) { //path lookup
-                        foreach(const QMakeLocalFileName &dd, depdirs) {
-                            QMakeLocalFileName f(QDir(dd.real()).absoluteFilePath(lfn.real()));
+                        for(QList<QMakeLocalFileName>::Iterator it = depdirs.begin(); it != depdirs.end(); ++it) {
+                            QMakeLocalFileName f((*it).real() + Option::dir_sep + lfn.real());
                             QFileInfo fi(findFileInfo(f));
                             if(fi.exists() && !fi.isDir()) {

trunk/qmake/generators/metamakefile.cpp

@@ -325 +325 @@
             sub->input_dir = subdir.absolutePath();
             if(subdir.isRelative() && old_output_dir != oldpwd) {
-                sub->output_dir = QDir(old_output_dir).absoluteFilePath(subdir.path());
+                sub->output_dir = old_output_dir + "/" + subdir.path();
                 printf("Reading %s [%s]\n", subdir.absoluteFilePath().toLatin1().constData(), sub->output_dir.toLatin1().constData());
             } else { //what about shadow builds?

trunk/qmake/generators/win32/winmakefile.cpp

@@ -246 +246 @@
                         tmp = opt;
                     for(QList<QMakeLocalFileName>::Iterator it = libdirs.begin(); it != libdirs.end(); ++it) {
-                        QString prl = QDir((*it).local()).absoluteFilePath(tmp);
+                        QString prl = (*it).local() + Option::dir_sep + tmp;
                         // the original is used as the key
                         QString orgprl = prl;

trunk/qmake/main.cpp

@@ -127 +127 @@
             Option::output_dir = dir;
         if(QDir::isRelativePath(Option::output_dir))
-            Option::output_dir = QDir(oldpwd).absoluteFilePath(Option::output_dir);
+            Option::output_dir.prepend(oldpwd);
         Option::output_dir = QDir::cleanPath(Option::output_dir);
     }

trunk/qmake/meta.cpp

@@ -163 +163 @@
                         QString targ = dirs[i] + (*lst_it);
                         if(QDir::isRelativePath(targ))
-                            targ = QDir(qmake_getpwd()).absoluteFilePath(targ);
+                            targ.prepend(qmake_getpwd() + QDir::separator());
                         vars["QMAKE_PRL_TARGET"] << targ;
                         found = true;

trunk/qmake/project.cpp

@@ -1457 +1457 @@
                 if (QFile::exists(qmakespec+"/qmake.conf")) {
                     Option::mkfile::qmakespec = QFileInfo(Option::mkfile::qmakespec).absoluteFilePath();
+                } else if (QFile::exists(Option::output_dir+"/"+qmakespec+"/qmake.conf")) {
+                    qmakespec = Option::mkfile::qmakespec = QFileInfo(Option::output_dir+"/"+qmakespec).absoluteFilePath();
                 } else {
-                    QString tmp = QDir(Option::output_dir).absoluteFilePath(qmakespec);
-                    if (QFile::exists(tmp+"/qmake.conf"))
-                        qmakespec = Option::mkfile::qmakespec = tmp;
-                    else {
-                        bool found_mkspec = false;
-                        foreach(const QString &root, mkspec_roots) {
-                            QString mkspec = QDir(root).absoluteFilePath(qmakespec);
-                            if(QFile::exists(mkspec)) {
-                                found_mkspec = true;
-                                Option::mkfile::qmakespec = qmakespec = mkspec;
-                                break;
-                            }
+                    bool found_mkspec = false;
+                    for(QStringList::ConstIterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
+                        QString mkspec = (*it) + QDir::separator() + qmakespec;
+                        if(QFile::exists(mkspec)) {
+                            found_mkspec = true;
+                            Option::mkfile::qmakespec = qmakespec = mkspec;
+                            break;
                         }
-                        if(!found_mkspec) {
-                            fprintf(stderr, "Could not find mkspecs for your QMAKESPEC(%s) after trying:\n\t%s\n",
-                                    qmakespec.toLatin1().constData(), mkspec_roots.join("\n\t").toLatin1().constData());
-                            return false;
-                        }
+                    }
+                    if(!found_mkspec) {
+                        fprintf(stderr, "Could not find mkspecs for your QMAKESPEC(%s) after trying:\n\t%s\n",
+                                qmakespec.toLatin1().constData(), mkspec_roots.join("\n\t").toLatin1().constData());
+                        return false;
                     }
                 }
@@ -1778 +1775 @@
             include_roots << qmake_getpwd();
         include_roots << Option::output_dir;
-        foreach(const QString &root, include_roots) {
-            QString testName = QDir(root).absoluteFilePath(file);
+        for(int root = 0; root < include_roots.size(); ++root) {
+            QString testName = QDir::toNativeSeparators(include_roots[root]);
+            if (!testName.endsWith(QString(QDir::separator())))
+                testName += QDir::separator();
+            testName += file;
             if(QFile::exists(testName)) {
                 file = testName;