1 files changed, 187 insertions, 104 deletions

diff --git a/qmake/project.cpp b/qmake/project.cpp
index 44eb503..834823d 100644
--- a/qmake/project.cpp
+++ b/qmake/project.cpp
@@ -67,7 +67,12 @@ static QString varMap(const QString &x)
 {
     QString ret(x);
-    ret.replace(QRegExp("^TMAKE"), "QMAKE");
+    if(ret.startsWith("TMAKE")) //tmake no more!
+        ret = "QMAKE" + ret.mid(5);
     if(ret == "INTERFACES")
         ret = "FORMS";
+    if(ret == "QMAKE_POST_BUILD")
+        ret = "QMAKE_POST_LINK";
+    if(ret == "TARGETDEPS")
+        ret = "POST_TARGETDEPS";
     return ret;
 }
@@ -123,8 +128,10 @@ QMakeProject::QMakeProject()
 
 bool
-QMakeProject::parse(QString t, QMap<QString, QStringList> &place)
+QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place)
 {
     QString s = t.simplifyWhiteSpace();
-    s.replace(QRegExp("#.*$"), ""); /* bye comments */
+    int hash_mark = s.find('#');
+    if(hash_mark != -1) //good bye comments
+        s = s.left(hash_mark);
     if(s.isEmpty()) /* blank_line */
         return TRUE;
@@ -155,6 +162,9 @@ QMakeProject::parse(QString t, QMap<QString, QStringList> &place)
     bool scope_failed = FALSE, else_line = FALSE, or_op=FALSE;
     int parens = 0, scope_count=0;
-    while(*d && *d != '=') {
-        if((*d == '+' || *d == '-' || *d == '*' || *d == '~')) {
+    while(*d) {
+        if(!parens) {
+            if(*d == '=')
+                break;
+            if(*d == '+' || *d == '-' || *d == '*' || *d == '~') {
             if(*(d+1) == '=') {
                 break;
@@ -164,9 +174,10 @@ QMakeProject::parse(QString t, QMap<QString, QStringList> &place)
                 if(*k == '=') {
                     QString msg;
-                    qmake_error_msg(*d + "must be followed immediatly by =");
+                        qmake_error_msg(*d + "must be followed immediately by =");
                     return FALSE;
                 }
             }
         }
+        }
 
         if ( *d == '(' )
@@ -218,5 +229,5 @@ QMakeProject::parse(QString t, QMap<QString, QStringList> &place)
                         }
                     } else {
-                        test = isActiveConfig(comp_scope.stripWhiteSpace());
+                        test = isActiveConfig(comp_scope.stripWhiteSpace(), TRUE);
                     }
                     if(invert_test)
@@ -356,5 +367,5 @@ QMakeProject::parse(QString t, QMap<QString, QStringList> &place)
 
 bool
-QMakeProject::read(QString file, QMap<QString, QStringList> &place)
+QMakeProject::read(const QString &file, QMap<QString, QStringList> &place)
 {
     parser_info pi = parser;
@@ -364,14 +375,14 @@ QMakeProject::read(QString file, QMap<QString, QStringList> &place)
     scope_block = 0;
 
-    file = Option::fixPathToLocalOS(file);
-    doVariableReplace(file, place);
+    QString filename = Option::fixPathToLocalOS(file);
+    doVariableReplace(filename, place);
     bool ret = FALSE, using_stdin = FALSE;
     QFile qfile;
-    if(!strcmp(file, "-")) {
+    if(!strcmp(filename, "-")) {
         qfile.setName("");
         ret = qfile.open(IO_ReadOnly, stdin);
         using_stdin = TRUE;
     } else {
-        qfile.setName(file);
+        qfile.setName(filename);
         ret = qfile.open(IO_ReadOnly);
     }
@@ -379,5 +390,5 @@ QMakeProject::read(QString file, QMap<QString, QStringList> &place)
         QTextStream t( &qfile );
         QString s, line;
-        parser.file = file;
+        parser.file = filename;
         parser.line_no = 0;
         while ( !t.eof() ) {
@@ -385,5 +396,9 @@ QMakeProject::read(QString file, QMap<QString, QStringList> &place)
             line = t.readLine().stripWhiteSpace();
             int prelen = line.length();
-            line.replace(QRegExp("#.*$"), ""); // bye comments
+            {
+                int hash_mark = line.find('#');
+                if(hash_mark != -1) //bye comments
+                    line = line.left(hash_mark);
+            }
             if(!line.isEmpty() && line.right(1) == "\\") {
                 line.truncate(line.length() - 1);
@@ -409,10 +424,19 @@ QMakeProject::read(QString file, QMap<QString, QStringList> &place)
 
 bool
-QMakeProject::read(QString project, QString)
+QMakeProject::read(const QString &project, const QString &, bool just_project)
 {
+    if(just_project) { //nothing more, nothing less
+        pfile = project;
+        if(pfile != "-" && !QFile::exists(pfile) && pfile.right(4) != ".pro")
+            pfile += ".pro";
+        return read(pfile, vars);
+    }
+
     if(cfile.isEmpty()) {
         // hack to get the Option stuff in there
         base_vars["QMAKE_EXT_CPP"] = Option::cpp_ext;
         base_vars["QMAKE_EXT_H"] = Option::h_ext;
+        if(!Option::user_template_prefix.isEmpty())
+            base_vars["TEMPLATE_PREFIX"] = Option::user_template_prefix;
 
         /* parse the cache */
@@ -442,18 +466,7 @@ QMakeProject::read(QString project, QString)
         QStringList mkspec_roots;
         /* prefer $QTDIR if it is set */
-        /* prefer QMAKESPECSDIR -cl */
-        
-        if (getenv("QTDIR")) {
+        if (getenv("QTDIR"))
             mkspec_roots << getenv("QTDIR");
-        }
         mkspec_roots << qInstallPathData();
-
-        if (Option::mkfile::qmakespec.isEmpty() && getenv("QMAKESPECSDIR")){
-                QString mkspec = QString(getenv("QMAKESPECSDIR")) + QDir::separator() +
-                                 QDir::separator() + "default";
-                if(QFile::exists(mkspec))
-                    Option::mkfile::qmakespec = mkspec;
-        }
-
         if(Option::mkfile::qmakespec.isEmpty()) {
             for(QStringList::Iterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
@@ -465,10 +478,9 @@ QMakeProject::read(QString project, QString)
                 }
             }
-        }
-
         if(Option::mkfile::qmakespec.isEmpty()) {
             fprintf(stderr, "QMAKESPEC has not been set, so configuration cannot be deduced.\n");
             return FALSE;
         }
+        }
 
         if(QDir::isRelativePath(Option::mkfile::qmakespec)) {
@@ -545,10 +557,12 @@ QMakeProject::read(QString project, QString)
     }
 
-    if(vars["TEMPLATE"].isEmpty())
-        vars["TEMPLATE"].append(QString("app"));
-    else
-        vars["TEMPLATE"].first().replace(QRegExp("\\.t$"), "");
-    if(!Option::user_template_prefix.isEmpty())
-        vars["TEMPLATE"].first().prepend(Option::user_template_prefix);
+    QStringList &templ = vars["TEMPLATE"];
+    if(templ.isEmpty())
+        templ.append(QString("app"));
+    else if(vars["TEMPLATE"].first().endsWith(".t"))
+        templ = QStringList(templ.first().left(templ.first().length() - 2));
+    if ( !Option::user_template_prefix.isEmpty() ) {
+        templ.first().prepend(Option::user_template_prefix);
+    }
 
     if(vars["TARGET"].isEmpty()) {
@@ -580,12 +594,11 @@ QMakeProject::read(QString project, QString)
 
 bool
-QMakeProject::isActiveConfig(const QString &x)
+QMakeProject::isActiveConfig(const QString &x, bool regex)
 {
     if(x.isEmpty())
         return TRUE;
 
-    QRegExp re(x, FALSE, TRUE);
-    if((Option::target_mode == Option::TARG_MACX_MODE || Option::target_mode == Option::TARG_QNX6_MODE || Option::target_mode == Option::TARG_UNIX_MODE) &&
-       x == "unix")
+    if((Option::target_mode == Option::TARG_MACX_MODE || Option::target_mode == Option::TARG_QNX6_MODE ||
+        Option::target_mode == Option::TARG_UNIX_MODE) && x == "unix")
         return TRUE;
     else if(Option::target_mode == Option::TARG_MACX_MODE && x == "macx")
@@ -602,7 +615,8 @@ QMakeProject::isActiveConfig(const QString &x)
 
 
+    QRegExp re(x, FALSE, TRUE);
     QString spec = Option::mkfile::qmakespec.right(Option::mkfile::qmakespec.length() -
                                                    (Option::mkfile::qmakespec.findRev(QDir::separator())+1));
-    if(re.exactMatch(spec))
+    if((regex && re.exactMatch(spec)) || (!regex && spec == x))
         return TRUE;
 #ifdef Q_OS_UNIX
@@ -617,5 +631,5 @@ QMakeProject::isActiveConfig(const QString &x)
             if(r.findRev('/') != -1)
                 r = r.mid(r.findRev('/') + 1);
-            if(re.exactMatch(r))
+            if((regex && re.exactMatch(r)) || (!regex && r == x))
                 return TRUE;
         }
@@ -626,4 +640,5 @@ QMakeProject::isActiveConfig(const QString &x)
     QStringList &configs = vars["CONFIG"];
     for(QStringList::Iterator it = configs.begin(); it != configs.end(); ++it) {
+        if((regex && re.exactMatch((*it))) || (!regex && (*it) == x))
         if(re.exactMatch((*it)))
             return TRUE;
@@ -633,5 +648,5 @@ QMakeProject::isActiveConfig(const QString &x)
 
 bool
-QMakeProject::doProjectTest(QString func, const QString &params, QMap<QString, QStringList> &place)
+QMakeProject::doProjectTest(const QString& func, const QString &params, QMap<QString, QStringList> &place)
 {
     QStringList args = split_arg_list(params);
@@ -645,5 +660,5 @@ QMakeProject::doProjectTest(QString func, const QString &params, QMap<QString, Q
 
 bool
-QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStringList> &place)
+QMakeProject::doProjectTest(const QString& func, QStringList args, QMap<QString, QStringList> &place)
 {
     for(QStringList::Iterator arit = args.begin(); arit != args.end(); ++arit) {
@@ -655,4 +670,14 @@ QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStrin
     if(func == "requires") {
         return doProjectCheckReqs(args, place);
+    } else if(func == "equals") {
+        if(args.count() != 2) {
+            fprintf(stderr, "%s:%d: equals(variable, value) requires two arguments.\n", parser.file.latin1(),
+                    parser.line_no);
+            return FALSE;
+        }
+        QString value = args[1];
+        if((value.left(1) == "\"" || value.left(1) == "'") && value.right(1) == value.left(1))
+            value = value.mid(1, value.length()-2);
+        return vars[args[0]].join(" ") == value;
     } else if(func == "exists") {
         if(args.count() != 1) {
@@ -808,4 +833,7 @@ QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStrin
         if(r) 
             vars["QMAKE_INTERNAL_INCLUDED_FILES"].append(file);
+        else
+            warn_msg(WarnParser, "%s:%d: Failure to include file %s.",
+                     pi.file.latin1(), pi.line_no, file.latin1());
         parser = pi;
         test_status = sc;
@@ -820,4 +848,9 @@ QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStrin
         }
         QString msg = args.first();
+        if((msg.startsWith("\"") || msg.startsWith("'")) && msg.endsWith(msg.left(1)))
+            msg = msg.mid(1, msg.length()-2);
+        msg.replace(QString("${QMAKE_FILE}"), parser.file.latin1());
+        msg.replace(QString("${QMAKE_LINE_NUMBER}"), QString::number(parser.line_no));
+        msg.replace(QString("${QMAKE_DATE}"), QDateTime::currentDateTime().toString());
         doVariableReplace(msg, place);
         fixEnvVariables(msg);
@@ -858,5 +891,5 @@ QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringL
             }
         } else {
-            test = isActiveConfig(chk);
+            test = isActiveConfig(chk, TRUE);
         }
         if(invert_test) {
@@ -878,72 +911,127 @@ QString
 QMakeProject::doVariableReplace(QString &str, const QMap<QString, QStringList> &place)
 {
-    for(int x = 0, rep; x < 5; x++) {
-        QRegExp reg_var;
-        reg_var.setMinimal(TRUE);
-        if( x == 0 ) //function blocked out by {}'s
-            reg_var = QRegExp("\\$\\$\\{([a-zA-Z0-9_]*)\\((\\(.|(.*)\\)*)\\)\\}");
-        else if( x == 1 ) //variables blocked out by {}'s
-            reg_var = QRegExp("\\$\\$\\{([a-zA-Z0-9_\\.-]*)\\}");
-        else if(x == 2) //environment
-            reg_var = QRegExp("\\$\\$\\(([a-zA-Z0-9_\\.-]*)\\)");
-        else if(x == 3) //function
-            reg_var = QRegExp("\\$\\$([a-zA-Z0-9_]*)\\((\\(.|(.*)\\)*)\\)");
-        else if(x == 4) //normal variable
-            reg_var = QRegExp("\\$\\$([a-zA-Z0-9_\\.-]*)");
-        while((rep = reg_var.search(str)) != -1) {
+    for(int var_begin, var_last=0; (var_begin = str.find("$$", var_last)) != -1; var_last = var_begin) {
+        if(var_begin >= int( str.length() + 2 ) ) {
+            break;
+        } else if(var_begin != 0 && str[var_begin-1] == '\\') {
+            str.replace(var_begin-1, 1, "");
+            var_begin += 1;
+            continue;
+        }
+
+        int var_incr = var_begin + 2;
+        bool in_braces = FALSE, as_env = FALSE;
+        if(str[var_incr] == '{') {
+            in_braces = TRUE;
+            var_incr++;
+            while(var_incr < int( str.length() ) &&
+                  (str[var_incr] == ' ' || str[var_incr] == '\t' || str[var_incr] == '\n'))
+                var_incr++;
+        }
+        if(str[var_incr] == '(') {
+            as_env = TRUE;
+            var_incr++;
+        }
+        QString val, args;
+        while(var_incr < int( str.length() ) &&
+              (str[var_incr].isLetter() || str[var_incr].isNumber() || str[var_incr] == '.' || str[var_incr] == '_'))
+            val += str[var_incr++];
+        if(as_env) {
+            if(str[var_incr] != ')') {
+                var_incr++;
+                warn_msg(WarnParser, "%s:%d: Unterminated env-variable replacement '%s' (%s)",
+                         parser.file.latin1(), parser.line_no,
+                         str.mid(var_begin, QMAX(var_incr - var_begin, int(str.length()))).latin1(), str.latin1());
+                var_begin += var_incr;
+                continue;
+            }
+            var_incr++;
+        } else if(str[var_incr] == '(') { //args
+            for(int parens = 0; var_incr < int( str.length() ); var_incr++) {
+                if(str[var_incr] == '(') {
+                    parens++;
+                    if(parens == 1)
+                        continue;
+                } else if(str[var_incr] == ')') {
+                    parens--;
+                    if(!parens) {
+                        var_incr++;
+                        break;
+                    }
+                }
+                args += str[var_incr];
+            }
+        }
+        if(var_incr > int( str.length() ) || (in_braces && str[var_incr] != '}')) {
+            var_incr++;
+            warn_msg(WarnParser, "%s:%d: Unterminated variable replacement '%s' (%s)",
+                     parser.file.latin1(), parser.line_no,
+                     str.mid(var_begin, QMAX(var_incr - var_begin, int( str.length() ))).latin1(), str.latin1());
+            var_begin += var_incr;
+            continue;
+        } else if(in_braces) {
+            var_incr++;
+        }
+
             QString replacement;
-            if(x == 2) {//environment
-                replacement = getenv(reg_var.cap(1));
-            } else if(x == 0 || x == 3) { //function
-                QStringList args = split_arg_list(reg_var.cap(2));
-                for(QStringList::Iterator arit = args.begin(); arit != args.end(); ++arit) {
+        if(as_env) {
+            replacement = getenv(val);
+        } else if(args.isEmpty()) {
+            if(val.left(1) == ".")
+                replacement = "";
+            else if(val == "LITERAL_WHITESPACE")
+                replacement = "\t";
+            else
+                replacement = place[varMap(val)].join(" ");
+        } else {
+            QStringList arg_list = split_arg_list(args);
+            for(QStringList::Iterator arit = arg_list.begin(); arit != arg_list.end(); ++arit) {
                     (*arit) = (*arit).stripWhiteSpace(); // blah, get rid of space
                     doVariableReplace((*arit), place);
                 }
-                debug_msg(1, "Running function: %s( %s )", reg_var.cap(1).latin1(), args.join("::").latin1());
-                if(reg_var.cap(1).lower() == "member") {
-                    if(args.count() < 1 || args.count() > 2) {
+            debug_msg(1, "Running function: %s( %s )", val.latin1(), arg_list.join("::").latin1());
+            if(val.lower() == "member") {
+                if(arg_list.count() < 1 || arg_list.count() > 2) {
                         fprintf(stderr, "%s:%d: member(var, place) requires two arguments.\n",
                                 parser.file.latin1(), parser.line_no);
                     } else {
                         uint pos = 0;
-                        if(args.count() == 2)
-                            pos = args[1].toInt();
-                        const QStringList &var = place[varMap(args.first())];
+                    if(arg_list.count() == 2)
+                        pos = arg_list[1].toInt();
+                    const QStringList &var = place[varMap(arg_list.first())];
                         if(var.count() >= pos)
                             replacement = var[pos];
                     }
-                } else if(reg_var.cap(1).lower() == "list") {
-                    if(args.count() != 1) {
-                        fprintf(stderr, "%s:%d: list(vals) requires one"
-                                "argument.\n", parser.file.latin1(), parser.line_no);
-                    } else {
+            } else if(val.lower() == "list") {
                         static int x = 0;
                         replacement.sprintf(".QMAKE_INTERNAL_TMP_VAR_%d", x++);
-                        (*((QMap<QString, QStringList>*)&place))[replacement] = split_value_list(args.first());
-                    }
-                } else if(reg_var.cap(1).lower() == "join") {
-                    if(args.count() < 1 || args.count() > 4) {
+                QStringList &lst = (*((QMap<QString, QStringList>*)&place))[replacement];
+                lst.clear();
+                for(QStringList::ConstIterator arg_it = arg_list.begin();
+                    arg_it != arg_list.end(); ++arg_it) 
+                    lst += split_value_list((*arg_it));
+            } else if(val.lower() == "join") {
+                if(arg_list.count() < 1 || arg_list.count() > 4) {
                         fprintf(stderr, "%s:%d: join(var, glue, before, after) requires four"
                                 "arguments.\n", parser.file.latin1(), parser.line_no);
                     } else {
                         QString glue, before, after;
-                        if(args.count() >= 2)
-                            glue = args[1].replace("\"", "" );
-                        if(args.count() >= 3)
-                            before = args[2].replace("\"", "" );
-                        if(args.count() == 4)
-                            after = args[3].replace("\"", "" );
-                        const QStringList &var = place[varMap(args.first())];
+                    if(arg_list.count() >= 2)
+                        glue = arg_list[1].replace("\"", "" );
+                    if(arg_list.count() >= 3)
+                        before = arg_list[2].replace("\"", "" );
+                    if(arg_list.count() == 4)
+                        after = arg_list[3].replace("\"", "" );
+                    const QStringList &var = place[varMap(arg_list.first())];
                         if(!var.isEmpty())
                             replacement = before + var.join(glue) + after;
                     }
-                } else if(reg_var.cap(1).lower() == "find") {
-                    if(args.count() != 2) {
+            } else if(val.lower() == "find") {
+                if(arg_list.count() != 2) {
                         fprintf(stderr, "%s:%d find(var, str) requires two arguments\n",
                                 parser.file.latin1(), parser.line_no);
                     } else {
-                        QRegExp regx(args[1]);
-                        const QStringList &var = place[varMap(args.first())];
+                    QRegExp regx(arg_list[1]);
+                    const QStringList &var = place[varMap(arg_list.first())];
                         for(QStringList::ConstIterator vit = var.begin();
                             vit != var.end(); ++vit) {
@@ -955,11 +1043,11 @@ QMakeProject::doVariableReplace(QString &str, const QMap<QString, QStringList> &
                         }
                     }
-                } else if(reg_var.cap(1).lower() == "system") {
-                    if(args.count() != 1) {
+            } else if(val.lower() == "system") {
+                if(arg_list.count() != 1) {
                         fprintf(stderr, "%s:%d system(execut) requires one argument\n",
                                 parser.file.latin1(), parser.line_no);
                     } else {
                         char buff[256];
-                        FILE *proc = QT_POPEN(args.join(" ").latin1(), "r");
+                    FILE *proc = QT_POPEN(arg_list.join(" ").latin1(), "r");
                         while(proc && !feof(proc)) {
                             int read_in = fread(buff, 1, 255, proc);
@@ -976,18 +1064,13 @@ QMakeProject::doVariableReplace(QString &str, const QMap<QString, QStringList> &
                 } else {
                     fprintf(stderr, "%s:%d: Unknown replace function: %s\n",
-                            parser.file.latin1(), parser.line_no, reg_var.cap(1).latin1());
-                }
-            } else { //variable
-                if(reg_var.cap(1).left(1) == ".")
-                    replacement = "";
-                else if(reg_var.cap(1) == "LITERAL_WHITESPACE")
-                    replacement = "\t";
-                else
-                    replacement = place[varMap(reg_var.cap(1))].join(" ");
+                        parser.file.latin1(), parser.line_no, val.latin1());
             }
-            debug_msg(2, "Project parser: %d (%s) :: %s -> %s", x, str.latin1(),
-                      reg_var.capturedTexts().join("::").latin1(), replacement.latin1());
-            str.replace(rep, reg_var.matchedLength(), replacement);
         }
+        //actually do replacement now..
+        int mlen = var_incr - var_begin;
+        debug_msg(2, "Project Parser [var replace]: '%s' :: %s -> %s", str.latin1(),
+                  str.mid(var_begin, mlen).latin1(), replacement.latin1());
+        str.replace(var_begin, mlen, replacement);
+        var_begin += replacement.length();
     }
     return str;