missing a few qmake files

6 files changed, 2783 insertions, 0 deletions

diff --git a/qmake/generators/makefile.cpp b/qmake/generators/makefile.cpp
new file mode 100644
index 0000000..f490313
--- a/dev/null
+++ b/qmake/generators/makefile.cpp
@@ -0,0 +1,2085 @@
+/****************************************************************************
+** $Id$
+**
+** Definition of ________ class.
+**
+** Created : 970521
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the network module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition licenses may use this
+** file in accordance with the Qt Commercial License Agreement provided
+** with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "makefile.h"
+#include "option.h"
+#include <qdir.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qregexp.h>
+#include <qdict.h>
+#if defined(Q_OS_UNIX)
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+// Well, Windows doesn't have this, so here's the macro
+#ifndef S_ISDIR
+        #define S_ISDIR(m)(((m) & S_IFMT) == S_IFDIR)
+#endif
+
+static bool createDir(const QString& fullPath)
+{
+    QDir dirTmp;
+    bool ret = TRUE;
+    QString pathComponent, tmpPath;
+    QStringList hierarchy = QStringList::split(QString(Option::dir_sep), fullPath, TRUE);
+    for(QStringList::Iterator it = hierarchy.begin(); it != hierarchy.end(); ++it) {
+        pathComponent = *it + QDir::separator();
+        tmpPath += pathComponent;
+        if(!dirTmp.mkdir(tmpPath)) {
+            ret = FALSE;
+        //    break;
+        }
+    }
+    return ret;
+}
+
+
+MakefileGenerator::MakefileGenerator(QMakeProject *p) : init_opath_already(FALSE), 
+                                                        init_already(FALSE), moc_aware(FALSE), 
+                                                        no_io(FALSE), project(p)
+{
+}
+
+static char *gimme_buffer(off_t s)
+{
+    static char *big_buffer = NULL;
+    static int big_buffer_size = 0;
+    if(!big_buffer || big_buffer_size < s)
+         big_buffer = (char *)realloc(big_buffer, s);
+    return big_buffer;
+}
+
+bool
+MakefileGenerator::generateMocList(QString fn_target)
+{
+    if(!findMocDestination(fn_target).isEmpty())
+        return TRUE;
+
+    QString fn_local = Option::fixPathToLocalOS(fileFixify(fn_target, QDir::currentDirPath(), Option::output_dir));
+
+    int file = open(fn_local.latin1(), O_RDONLY);
+    if(file == -1)
+        return FALSE;
+
+    struct stat fst;
+    if(fstat(file, &fst) || S_ISDIR(fst.st_mode))
+        return FALSE; //shouldn't happen
+    char *big_buffer = gimme_buffer(fst.st_size);
+
+    int total_size_read;
+    for(int have_read = total_size_read = 0;
+        (have_read = read(file, big_buffer + total_size_read,
+                          fst.st_size - total_size_read));
+        total_size_read += have_read);
+    close(file);
+
+    bool ignore_qobject = FALSE;
+    int line_count = 1;
+ /* qmake ignore Q_OBJECT */
+#define COMP_LEN 8 //strlen("Q_OBJECT")
+#define OBJ_LEN 8 //strlen("Q_OBJECT")
+#define DIS_LEN 10 //strlen("Q_DISPATCH")
+    int x;
+    for(x = 0; x < (total_size_read-COMP_LEN); x++) {
+        if(*(big_buffer + x) == '/') {
+            x++;
+            if(total_size_read >= x) {
+                if(*(big_buffer + x) == '/') { //c++ style comment
+                    for( ;x < total_size_read && *(big_buffer + x) != '\n'; x++);
+                    line_count++;
+                } else if(*(big_buffer + x) == '*') { //c style comment
+                    for( ;x < total_size_read; x++) {
+                        if(*(big_buffer + x) == 't' || *(big_buffer + x) == 'q') { //ignore
+                            if(total_size_read >= (x + 20)) {
+                                if(!strncmp(big_buffer + x + 1, "make ignore Q_OBJECT", 20)) {
+                                    debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore Q_OBJECT\"",
+                                              fn_target.latin1(), line_count);
+                                    x += 20;
+                                    ignore_qobject = TRUE;
+                                }
+                            }
+                        } else if(*(big_buffer + x) == '*') {
+                            if(total_size_read >= (x+1) && *(big_buffer + (x+1)) == '/') {
+                                x += 2;
+                                break;
+                            }
+                        } else if(*(big_buffer + x) == '\n') {
+                            line_count++;
+                        }
+                    }
+                }
+            }
+        }
+#define SYMBOL_CHAR(x) ((x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z') || \
+                        (x <= '0' && x >= '9') || x == '_')
+
+        bool interesting = *(big_buffer+x) == 'Q' && (!strncmp(big_buffer+x, "Q_OBJECT", OBJ_LEN) ||
+                                                      !strncmp(big_buffer+x, "Q_DISPATCH", DIS_LEN));
+        if(interesting) {
+            int len = 0;
+            if(!strncmp(big_buffer+x, "Q_OBJECT", OBJ_LEN)) {
+                if(ignore_qobject) {
+                    debug_msg(2, "Mocgen: %s:%d Ignoring Q_OBJECT", fn_target.latin1(), line_count);
+                    interesting = FALSE;
+                }
+                len=OBJ_LEN;
+            } else if(!strncmp(big_buffer+x, "Q_DISPATCH", DIS_LEN)) {
+                len=DIS_LEN;
+            }
+            if(SYMBOL_CHAR(*(big_buffer+x+len)))
+                interesting = FALSE;
+            if(interesting) {
+                *(big_buffer+x+len) = '\0';
+                debug_msg(2, "Mocgen: %s:%d Found MOC symbol %s", fn_target.latin1(), line_count, big_buffer+x);
+
+                int ext_pos = fn_target.findRev('.');
+                int ext_len = fn_target.length() - ext_pos;
+                int dir_pos =  fn_target.findRev(Option::dir_sep, ext_pos);
+                QString mocFile;
+                if(!project->isEmpty("MOC_DIR"))
+                    mocFile = project->first("MOC_DIR");
+                else if(dir_pos != -1)
+                    mocFile = fn_target.left(dir_pos+1);
+
+                bool cpp_ext = FALSE;
+                for(QStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit) {
+                    if((cpp_ext = (fn_target.right(ext_len) == (*cppit))))
+                        break;
+                }
+                if(cpp_ext) {
+                    mocFile += fn_target.mid(dir_pos+1, ext_pos - dir_pos-1) + Option::moc_ext;
+                    findDependencies(fn_target).append(mocFile);
+                    project->variables()["_SRCMOC"].append(mocFile);
+                } else if(project->variables()["HEADERS"].findIndex(fn_target) != -1) {
+                    for(QStringList::Iterator hit = Option::h_ext.begin(); hit != Option::h_ext.end(); ++hit) {
+                        if((fn_target.right(ext_len) == (*hit))) {
+                            mocFile += Option::moc_mod + fn_target.mid(dir_pos+1, ext_pos - dir_pos-1) +
+                                       Option::cpp_ext.first();
+                            logicWarn(mocFile, "SOURCES");
+                            project->variables()["_HDRMOC"].append(mocFile);
+                            break;
+                        }
+                    }
+                }
+
+                if(!mocFile.isEmpty()) {
+                    mocFile = Option::fixPathToTargetOS(mocFile);
+                    mocablesToMOC[cleanFilePath(fn_target)] = mocFile;
+                    mocablesFromMOC[cleanFilePath(mocFile)] = fn_target;
+                }
+                break;
+            }
+        }
+
+        while(x < total_size_read && SYMBOL_CHAR(*(big_buffer+x)))
+            x++;
+        if(*(big_buffer+x) == '\n')
+            line_count++;
+    }
+#undef OBJ_LEN
+#undef DIS_LEN
+    return TRUE;
+}
+
+bool
+MakefileGenerator::generateDependencies(QPtrList<MakefileDependDir> &dirs, QString fn, bool recurse)
+{
+    fn = fileFixify(fn);
+    QStringList &fndeps = findDependencies(fn);
+    if(!fndeps.isEmpty())
+        return TRUE;
+
+    fn = Option::fixPathToLocalOS(fn, FALSE);
+    QString fix_env_fn = Option::fixPathToLocalOS(fn);
+    int file = open(fix_env_fn.latin1(), O_RDONLY);
+    if(file == -1)
+        return FALSE;
+    struct stat fst;
+    if(fstat(file, &fst) || S_ISDIR(fst.st_mode))
+        return FALSE; //shouldn't happen
+
+    QString fndir, fix_env_fndir;
+    int dl = fn.findRev(Option::dir_sep);
+    if(dl != -1)
+        fndir = fn.left(dl+1);
+    dl = fix_env_fn.findRev(Option::dir_sep);
+    if(dl != -1)
+        fix_env_fndir = fix_env_fn.left(dl + 1);
+
+    int line_count = 1;
+    char *big_buffer = gimme_buffer(fst.st_size);
+
+    int total_size_read;
+    for(int have_read = total_size_read = 0;
+        (have_read = read(file, big_buffer + total_size_read,
+                          fst.st_size - total_size_read));
+        total_size_read += have_read);
+    close(file);
+
+    bool ui_file = fn.endsWith(Option::ui_ext);
+    for(int x = 0; x < total_size_read; x++) {
+        QStringList *outdeps=&fndeps;
+        QString inc;
+        if(!ui_file) {
+            if(*(big_buffer + x) == '/') {
+                x++;
+                if(total_size_read >= x) {
+                    if(*(big_buffer + x) == '/') { //c++ style comment
+                        for( ; x < total_size_read && *(big_buffer + x) != '\n'; x++);
+                    } else if(*(big_buffer + x) == '*') { //c style comment
+                        for( ; x < total_size_read; x++) {
+                            if(*(big_buffer + x) == '*') {
+                                if(total_size_read >= (x+1) && *(big_buffer + (x+1)) == '/') {
+                                    x += 2;
+                                    break;
+                                }
+                            } else if(*(big_buffer + x) == '\n') {
+                                line_count++;
+                            }
+                        }
+                    }
+                }
+            }
+            if(*(big_buffer + x) == '#') {
+                x++;
+                while(x < total_size_read && //Skip spaces after hash
+                      (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t'))
+                    x++;
+                if(total_size_read >= x + 8 && !strncmp(big_buffer + x, "include ", 8)) {
+                    for(x+=8; //skip spaces after keyword
+                        x < total_size_read && (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t');
+                        x++);
+                    char term = *(big_buffer + x);
+                    if(term == '"');
+                    else if(term == '<')
+                        term = '>';
+                    else
+                        continue; //wtf?
+                    x++;
+
+                    int inc_len;
+                    for(inc_len = 0; *(big_buffer + x + inc_len) != term; inc_len++);
+                    *(big_buffer + x + inc_len) = '\0';
+                    inc = big_buffer + x;
+                } else if(total_size_read >= x + 14 && !strncmp(big_buffer + x,  "qmake_warning ", 14)) {
+                    for(x+=14; //skip spaces after keyword
+                        x < total_size_read && (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t');
+                        x++);
+                    char term = '\n';
+                    if(*(big_buffer + x) == '"')
+                        term = '"';
+                    if(*(big_buffer + x) == '\'')
+                        term = '\'';
+                    if(term != '\n')
+                        x++;
+
+                    int msg_len;
+                    for(msg_len = 0; *(big_buffer + x + msg_len) != term; msg_len++);
+                    *(big_buffer + x + msg_len) = '\0';
+                    QString msg = big_buffer + x;
+                    debug_msg(0, "%s:%d qmake_warning -- %s", fix_env_fn.latin1(),
+                              line_count, msg.latin1());
+                    *(big_buffer + x + msg_len) = term; //put it back
+                }
+            }
+        } else if(ui_file) {
+            // skip whitespaces
+            while(x < total_size_read &&
+                  (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t')) 
+                x++;
+            if(*(big_buffer + x) == '<') {
+                x++;
+                if(total_size_read >= x + 12 && !strncmp(big_buffer + x, "includehint", 11) &&
+                    (*(big_buffer + x + 11) == ' ' || *(big_buffer + x + 11) == '>')) {
+                    for(x += 12; *(big_buffer + x) != '>'; x++);
+                    int inc_len = 0;
+                    for(x += 1 ; *(big_buffer + x + inc_len) != '<'; inc_len++);
+                    *(big_buffer + x + inc_len) = '\0';
+                    inc = big_buffer + x;
+                } else if(total_size_read >= x + 8 && !strncmp(big_buffer + x, "include", 7) &&
+                    (*(big_buffer + x + 7) == ' ' || *(big_buffer + x + 7) == '>')) {
+                    for(x += 8; *(big_buffer + x) != '>'; x++) {
+                        if(total_size_read >= x + 9 && *(big_buffer + x) == 'i' && 
+                           !strncmp(big_buffer + x, "impldecl", 8)) {
+                            for(x += 8; *(big_buffer + x) != '='; x++);
+                            if(*(big_buffer + x) != '=')
+                                continue;
+                            for(x++; *(big_buffer+x) == '\t' || *(big_buffer+x) == ' '; x++);
+                            char quote = 0;
+                            if(*(big_buffer+x) == '\'' || *(big_buffer+x) == '"') {
+                                quote = *(big_buffer + x);
+                                x++;
+                            }
+                            int val_len;
+                            for(val_len = 0; TRUE; val_len++) {
+                                if(quote) {
+                                    if(*(big_buffer+x+val_len) == quote)
+                                        break;
+                                } else if(*(big_buffer + x + val_len) == '>' ||
+                                          *(big_buffer + x + val_len) == ' ') {
+                                    break;
+                                }
+                            }
+                            char saved = *(big_buffer + x + val_len);
+                            *(big_buffer + x + val_len) = '\0';
+                            QString where = big_buffer + x;
+                            *(big_buffer + x + val_len) = saved;
+                            if(where == "in implementation") {
+                                QString cpp = fn.left(fn.length() - Option::ui_ext.length()) +
+                                                      Option::cpp_ext.first();
+                                outdeps = &findDependencies(cpp);
+                            }
+                        }
+                    }
+                    int inc_len = 0;
+                    for(x += 1 ; *(big_buffer + x + inc_len) != '<'; inc_len++);
+                    *(big_buffer + x + inc_len) = '\0';
+                    inc = big_buffer + x;
+                }
+            }
+        }
+
+        if(!inc.isEmpty()) {
+            debug_msg(5, "%s:%d Found dependency to %s", fix_env_fn.latin1(),
+                      line_count, inc.latin1());
+            if(!project->isEmpty("SKIP_DEPENDS")) {
+                bool found = FALSE;
+                QStringList &nodeplist = project->values("SKIP_DEPENDS");
+                for(QStringList::Iterator it = nodeplist.begin();
+                    it != nodeplist.end(); ++it) {
+                    QRegExp regx((*it));
+                    if(regx.search(inc) != -1) {
+                        found = TRUE;
+                        break;
+                    }
+                }
+                if(found)
+                    continue;
+            }
+
+            QString fqn;
+            if(project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH") &&
+               !stat(fix_env_fndir + inc, &fst) && !S_ISDIR(fst.st_mode)) {
+                fqn = fndir + inc;
+            } else {
+                if((Option::target_mode == Option::TARG_MAC9_MODE && inc.find(':')) ||
+                   (Option::target_mode == Option::TARG_WIN_MODE && inc[1] != ':') ||
+                   ((Option::target_mode == Option::TARG_UNIX_MODE ||
+                     Option::target_mode == Option::TARG_QNX6_MODE ||
+                     Option::target_mode == Option::TARG_MACX_MODE) &&
+                    inc[0] != '/')) {
+                    for(MakefileDependDir *mdd = dirs.first(); mdd; mdd = dirs.next() ) {
+                        if(!stat(mdd->local_dir + QDir::separator() + inc, &fst) &&
+                           !S_ISDIR(fst.st_mode)) {
+                            fqn = mdd->real_dir + QDir::separator() + inc;
+                            break;
+                        }
+                    }
+                }
+            }
+            if(fqn.isEmpty()) {
+                //these are some hacky heuristics it will try to do on an include
+                //however these can be turned off at runtime, I'm not sure how
+                //reliable these will be, most likely when problems arise turn it off
+                //and see if they go away..
+                if(Option::mkfile::do_dep_heuristics && depHeuristics.contains(inc)) {
+                    fqn = depHeuristics[inc];
+                } else if(Option::mkfile::do_dep_heuristics) { //some heuristics..
+                    //is it a file from a .ui?
+                    QString inc_file = inc.section(Option::dir_sep, -1);
+                    int extn = inc_file.findRev('.');
+                    if(extn != -1 &&
+                       (inc_file.right(inc_file.length()-extn) == Option::cpp_ext.first() ||
+                        inc_file.right(inc_file.length()-extn) == Option::h_ext.first())) {
+                        QString uip = inc_file.left(extn) + Option::ui_ext;
+                        QStringList uil = project->variables()["FORMS"];
+                        for(QStringList::Iterator it = uil.begin(); it != uil.end(); ++it) {
+                            if((*it).section(Option::dir_sep, -1) == uip) {
+                                if(!project->isEmpty("UI_DIR"))
+                                    fqn = project->first("UI_DIR");
+                                else if(!project->isEmpty("UI_HEADERS_DIR"))
+                                    fqn = project->first("UI_HEADERS_DIR");
+                                else
+                                    fqn = (*it).section(Option::dir_sep, 0, -2);
+                                if(!fqn.isEmpty() && !fqn.endsWith(Option::dir_sep))
+                                    fqn += Option::dir_sep;
+                                fqn += inc_file;
+                                break;
+                            }
+                        }
+                    }
+                    if(fqn.isEmpty()) { //is it from a .y?
+                        QString rhs = Option::yacc_mod + Option::h_ext.first();
+                        if(inc.endsWith(rhs)) {
+                            QString lhs = inc.left(inc.length() - rhs.length()) + Option::yacc_ext;
+                            QStringList yl = project->variables()["YACCSOURCES"];
+                            for(QStringList::Iterator it = yl.begin(); it != yl.end(); ++it) {
+                                QString s = (*it), d;
+                                int slsh = s.findRev(Option::dir_sep);
+                                if(slsh != -1) {
+                                    d = s.left(slsh + 1);
+                                    s = s.right(s.length() - slsh - 1);
+                                }
+                                if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH"))
+                                    d = project->first("QMAKE_ABSOLUTE_SOURCE_PATH");
+                                if(s == lhs) {
+                                    fqn = d + inc;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    depHeuristics.insert(inc, fqn);
+                }
+                if(!Option::mkfile::do_dep_heuristics || fqn.isEmpty()) //I give up
+                    continue;
+            }
+
+            fqn = fileFixify(Option::fixPathToTargetOS(fqn, FALSE));
+            debug_msg(4, "Resolved dependancy of %s to %s", inc.latin1(), fqn.latin1());
+            if(outdeps && outdeps->findIndex(fqn) == -1)
+                outdeps->append(fqn);
+        }
+        //read past new line now..
+        for( ; x < total_size_read && (*(big_buffer + x) != '\n'); x++);
+        line_count++;
+    }
+
+    if(recurse) {
+        for(QStringList::Iterator fnit = fndeps.begin(); fnit != fndeps.end(); ++fnit) {
+            generateDependencies(dirs, (*fnit), recurse);
+            QStringList &deplist = findDependencies((*fnit));
+            for(QStringList::Iterator it = deplist.begin(); it != deplist.end(); ++it)
+                if(fndeps.findIndex((*it)) == -1)
+                    fndeps.append((*it));
+        }
+    }
+    debug_msg(2, "Dependancies: %s -> %s", fn.latin1(), fndeps.join(" :: ").latin1());
+    return TRUE;
+}
+
+void
+MakefileGenerator::initOutPaths()
+{
+    if(init_opath_already)
+        return;
+    init_opath_already = TRUE;
+    QMap<QString, QStringList> &v = project->variables();
+        if(!v.contains("QMAKE_ABSOLUTE_SOURCE_PATH")) {
+            if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty() &&
+               v.contains("QMAKE_ABSOLUTE_SOURCE_ROOT")) {
+                QString root = v["QMAKE_ABSOLUTE_SOURCE_ROOT"].first();
+                root = Option::fixPathToTargetOS( root );
+                if(!root.isEmpty()) {
+                    QFileInfo fi(Option::mkfile::cachefile);
+                    if(!fi.convertToAbs()) {
+                        QString cache_r = fi.dirPath(), pwd = Option::output_dir;
+                        if ( pwd.startsWith(cache_r) && !pwd.startsWith(root) ) {
+                            pwd = Option::fixPathToTargetOS(root + pwd.mid(cache_r.length()));
+                            if(QFile::exists(pwd))
+                                v.insert("QMAKE_ABSOLUTE_SOURCE_PATH", pwd);
+                        }
+                    }
+                }
+            }
+        }
+        if(!v["QMAKE_ABSOLUTE_SOURCE_PATH"].isEmpty()) {
+            QString &asp = v["QMAKE_ABSOLUTE_SOURCE_PATH"].first();
+            asp = Option::fixPathToTargetOS( asp );
+            if(asp.isEmpty() || asp == Option::output_dir) //if they're the same, why bother?
+                v["QMAKE_ABSOLUTE_SOURCE_PATH"].clear();
+        }
+        QString currentDir = QDir::currentDirPath();
+        QString dirs[] = { QString("OBJECTS_DIR"), QString("MOC_DIR"), QString("UI_HEADERS_DIR"),
+                           QString("UI_SOURCES_DIR"), QString("UI_DIR"), QString("DESTDIR"),
+                           QString("SUBLIBS_DIR"), QString::null };
+        for(int x = 0; dirs[x] != QString::null; x++) {
+            if ( !v[dirs[x]].isEmpty() ) {
+                QString orig_path = v[dirs[x]].first();
+                {
+                    QString &path = v[dirs[x]].first();
+                    path = fileFixify(path, Option::output_dir, Option::output_dir);
+                    if(path.right(Option::dir_sep.length()) != Option::dir_sep)
+                        path += Option::dir_sep;
+                }
+                if(noIO())
+                    continue;
+
+                QString path = project->first(dirs[x]); //not to be changed any further
+                path = Option::fixPathToTargetOS(fileFixify(path, QDir::currentDirPath(), Option::output_dir));
+                debug_msg(3, "Fixed output_dir %s (%s) into %s (%s)", dirs[x].latin1(), orig_path.latin1(),
+                          v[dirs[x]].join("::").latin1(), path.latin1());
+
+                QDir d;
+                if(path.startsWith(Option::dir_sep)) {
+                    d.cd(Option::dir_sep);
+                    path = path.right(path.length() - 1);
+                }
+#ifdef Q_WS_WIN
+                bool driveExists = TRUE;
+                if ( !QDir::isRelativePath( path ) ) {
+                    if ( QFile::exists( path.left( 3 ) ) ) {
+                        d.cd( path.left( 3 ) );
+                        path = path.right( path.length() - 3 );
+                    } else {
+                        warn_msg(WarnLogic, "%s: Cannot access drive '%s' (%s)", dirs[x].latin1(),
+                            path.left( 3 ).latin1(), path.latin1() );
+                        driveExists = FALSE;
+                    }
+                }
+                if ( driveExists ) {
+#endif
+                    QStringList subs = QStringList::split(Option::dir_sep, path);
+                    for(QStringList::Iterator subit = subs.begin(); subit != subs.end(); ++subit) {
+                        if(!d.cd(*subit)) {
+                            d.mkdir((*subit));
+                            if ( d.exists( (*subit) ) )
+                                d.cd((*subit));
+                            else {
+                                warn_msg(WarnLogic, "%s: Cannot access directory '%s' (%s)", dirs[x].latin1(),
+                                    (*subit).latin1(), path.latin1() );
+                                break;
+                            }
+                        }
+                    }
+#ifdef Q_WS_WIN
+                }
+#endif
+            }
+        }
+        QDir::current().cd( currentDir );
+}
+
+void
+MakefileGenerator::init()
+{
+    initOutPaths();
+    if(init_already)
+        return;
+    init_already = TRUE;
+
+    QMap<QString, QStringList> &v = project->variables();
+    QString paths[] = { QString("SOURCES"), QString("FORMS"), QString("YACCSOURCES"), QString("INCLUDEPATH"),
+                            QString("HEADERS"), QString("HEADERS_ORIG"),
+                            QString("LEXSOURCES"), QString("QMAKE_INTERNAL_INCLUDED_FILES"), QString::null };
+    for(int y = 0; paths[y] != QString::null; y++) {
+        QStringList &l = v[paths[y]];
+        if(!l.isEmpty())
+            l = fileFixify(l);
+    }
+
+    /* get deps and mocables */
+    QDict<void> cache_found_files;
+    QString cache_file(Option::output_dir + QDir::separator() + ".qmake.internal.cache");
+    if((Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT ||
+        Option::mkfile::do_deps || Option::mkfile::do_mocs) && !noIO()) {
+        QPtrList<MakefileDependDir> deplist;
+        deplist.setAutoDelete(TRUE);
+        if((Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT || Option::mkfile::do_deps) &&
+           doDepends()) {
+            QStringList incDirs = v["DEPENDPATH"] + v["QMAKE_ABSOLUTE_SOURCE_PATH"];
+            if(project->isActiveConfig("depend_includepath"))
+                incDirs += v["INCLUDEPATH"];
+            for(QStringList::Iterator it = incDirs.begin(); it != incDirs.end(); ++it) {
+                QString r = (*it), l = Option::fixPathToLocalOS((*it));
+                deplist.append(new MakefileDependDir(r.replace("\"",""),
+                                                     l.replace("\"","")));
+            }
+            debug_msg(1, "Dependancy Directories: %s", incDirs.join(" :: ").latin1());
+            if(Option::output.name() != "-" && project->isActiveConfig("qmake_cache")) {
+                QFile cachef(cache_file);
+                if(cachef.open(IO_ReadOnly | IO_Translate)) {
+                    QFileInfo cachefi(cache_file);
+                    debug_msg(2, "Trying internal cache information: %s", cache_file.latin1());
+                    QTextStream cachet(&cachef);
+                    QString line, file;
+                    enum { CacheInfo, CacheDepend, CacheMoc } state = CacheInfo;
+                    while (!cachet.eof()) {
+                        line = cachet.readLine().stripWhiteSpace();
+                        int sep = line.find('=');
+                        if(line == "[depend]") {
+                            state = CacheDepend;
+                        } else if(line == "[mocable]") {
+                            state = CacheMoc;
+                        } else if(line == "[check]") {
+                            state = CacheInfo;
+                        } else if(!line.isEmpty() && sep != -1) {
+                            file = line.left(sep).stripWhiteSpace();
+                            line = line.right(line.length() - sep - 1).stripWhiteSpace();
+                            if(state == CacheInfo) {
+                                if(file == "QMAKE_CACHE_VERSION") {
+                                    if(line != qmake_version())
+                                        break;
+                                } else {
+                                    const QStringList &l = project->variables()[file];
+                                    if(!l.isEmpty() && !line.isEmpty() && l.join(" ") != line)
+                                        break;
+                                }
+                            } else if(state == CacheDepend) {
+                                bool found = (bool)cache_found_files[file];
+                                QStringList files = QStringList::split(" ", line);
+                                if(!found) {
+                                    QFileInfo fi(fileFixify(file, QDir::currentDirPath(), Option::output_dir));
+                                    if(fi.exists() && fi.lastModified() < cachefi.lastModified()) {
+                                        cache_found_files.insert(file, (void *)1);
+                                        found = TRUE;
+                                    }
+                                }
+                                if(found) {
+                                    for(QStringList::Iterator dep_it = files.begin();
+                                        dep_it != files.end(); ++dep_it) {
+                                        if(!cache_found_files[(*dep_it)]) {
+                                            QFileInfo fi(fileFixify((*dep_it), QDir::currentDirPath(), Option::output_dir));
+                                            if(fi.exists() &&
+                                               fi.lastModified() < cachefi.lastModified()) {
+                                                cache_found_files.insert((*dep_it), (void *)1);
+                                            } else {
+                                                found = FALSE;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    if(found) {
+                                        debug_msg(2, "Dependancies (cached): %s -> %s", file.latin1(),
+                                                  files.join(" :: ").latin1());
+                                        findDependencies(file) = files;
+                                    }
+                                }
+                            } else {
+                                void *found = cache_found_files[file];
+                                if(found != (void *)2) {
+                                    if(found) {
+                                        cache_found_files.replace(file, (void *)2);
+                                    } else {
+                                        QFileInfo fi(fileFixify(file, QDir::currentDirPath(), Option::output_dir));
+                                        if(fi.exists() && fi.lastModified() < cachefi.lastModified()) {
+                                            cache_found_files.insert(file, (void *)2);
+                                            found = (void*)1;
+                                        }
+                                    }
+                                }
+                                if(found && line != "*qmake_ignore*") {
+                                    int ext_len = file.length() - file.findRev('.');
+                                    bool cpp_ext = FALSE;
+                                    for(QStringList::Iterator cppit = Option::cpp_ext.begin();
+                                        cppit != Option::cpp_ext.end(); ++cppit) {
+                                        if((cpp_ext = (file.right(ext_len) == (*cppit))))
+                                            break;
+                                    }
+                                    if(cpp_ext) {
+                                        project->variables()["_SRCMOC"].append(line);
+                                    } else if(project->variables()["HEADERS"].findIndex(file) != -1) {
+                                        for(QStringList::Iterator hit = Option::h_ext.begin();
+                                            hit != Option::h_ext.end(); ++hit) {
+                                            if((file.right(ext_len) == (*hit))) {
+                                                project->variables()["_HDRMOC"].append(line);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    debug_msg(2, "Mocgen (cached): %s -> %s", file.latin1(),
+                                              line.latin1());
+                                    mocablesToMOC[file] = line;
+                                    mocablesFromMOC[line] = file;
+                                }
+                            }
+                        }
+                    }
+                    cachef.close();
+                }
+            }
+        }
+        if(!noIO()) {
+            QString sources[] = { QString("OBJECTS"), QString("LEXSOURCES"), QString("YACCSOURCES"),
+                                  QString("HEADERS"), QString("SOURCES"), QString("FORMS"),
+                                  QString::null };
+            depHeuristics.clear();
+            bool write_cache = FALSE, read_cache = QFile::exists(cache_file);
+            for(int x = 0; sources[x] != QString::null; x++) {
+                QStringList vpath, &l = v[sources[x]];
+                for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
+                    if(!(*val_it).isEmpty()) {
+                        QString file = Option::fixPathToLocalOS((*val_it));
+                        if(!QFile::exists(file)) {
+                            bool found = FALSE;
+                            if(QDir::isRelativePath(file)) {
+                                if(vpath.isEmpty())
+                                    vpath = v["VPATH_" + sources[x]] + v["VPATH"] +
+                                            v["QMAKE_ABSOLUTE_SOURCE_PATH"] + v["DEPENDPATH"];
+
+                                for(QStringList::Iterator vpath_it = vpath.begin();
+                                    vpath_it != vpath.end(); ++vpath_it) {
+                                    QString real_dir = Option::fixPathToLocalOS((*vpath_it));
+                                    if(QFile::exists(real_dir + QDir::separator() + (*val_it))) {
+                                        QString dir = (*vpath_it);
+                                        if(dir.right(Option::dir_sep.length()) != Option::dir_sep)
+                                            dir += Option::dir_sep;
+                                        (*val_it) = fileFixify(dir + (*val_it));
+                                        found = TRUE;
+                                        debug_msg(1, "Found file through vpath %s -> %s",
+                                                  file.latin1(), (*val_it).latin1());
+                                        break;
+                                    }
+                                }
+                            }
+                            if(!found) {
+                                QString dir, regex = (*val_it), real_dir;
+                                if(regex.findRev(Option::dir_sep) != -1) {
+                                    dir = regex.left(regex.findRev(Option::dir_sep) + 1);
+                                    real_dir = fileFixify(Option::fixPathToLocalOS(dir), 
+                                                          QDir::currentDirPath(), Option::output_dir);
+                                    regex = regex.right(regex.length() - dir.length());
+                                }
+                                if(real_dir.isEmpty() || QFile::exists(real_dir)) {
+                                    QDir d(real_dir, regex);
+                                    if(!d.count()) {
+                                        debug_msg(1, "%s:%d Failure to find %s in vpath (%s)",
+                                                  __FILE__, __LINE__,
+                                                  (*val_it).latin1(), vpath.join("::").latin1());
+                                        warn_msg(WarnLogic, "Failure to find: %s", (*val_it).latin1());
+                                        continue;
+                                    } else {
+                                        (*val_it) = dir + d[0];
+                                        for(int i = 1; i < (int)d.count(); i++)
+                                            l.insert(val_it, dir + d[i]);
+                                    }
+                                } else {
+                                    debug_msg(1, "%s:%d Cannot match %s%c%s, as %s does not exist.",
+                                              __FILE__, __LINE__,
+                                              real_dir.latin1(), QDir::separator(), regex.latin1(),
+                                              real_dir.latin1());
+                                    warn_msg(WarnLogic, "Failure to find: %s", (*val_it).latin1());
+                                }
+                            }
+                        }
+
+                        QString val_file = fileFixify((*val_it));
+                        bool found_cache_moc = FALSE, found_cache_dep = FALSE;
+                        if(read_cache && Option::output.name() != "-" &&
+                           project->isActiveConfig("qmake_cache")) {
+                            if(!findDependencies(val_file).isEmpty())
+                                found_cache_dep = TRUE;
+                            if(cache_found_files[(*val_it)] == (void *)2)
+                                found_cache_moc = TRUE;
+                            if(!found_cache_moc || !found_cache_dep)
+                                write_cache = TRUE;
+                        }
+                        if(!found_cache_dep && sources[x] != "OBJECTS") {
+                            debug_msg(5, "Looking for dependancies for %s", (*val_it).latin1());
+                            generateDependencies(deplist, (*val_it), doDepends());
+                        }
+                        if(found_cache_moc) {
+                            QString moc = findMocDestination(val_file);
+                            if(!moc.isEmpty()) {
+                                for(QStringList::Iterator cppit = Option::cpp_ext.begin();
+                                    cppit != Option::cpp_ext.end(); ++cppit) {
+                                    if(val_file.endsWith((*cppit))) {
+                                        QStringList &deps = findDependencies(val_file);
+                                        if(!deps.contains(moc))
+                                            deps.append(moc);
+                                        break;
+                                    }
+                                }
+                            }
+                        } else if(mocAware() && (sources[x] == "SOURCES" || sources[x] == "HEADERS") &&
+                                  (Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT ||
+                                   Option::mkfile::do_mocs)) {
+                            generateMocList((*val_it));
+                        }
+                    }
+                }
+            }
+            if(project->isActiveConfig("qmake_cache") && (write_cache || !read_cache)) {
+                QFile cachef(cache_file);
+                if(cachef.open(IO_WriteOnly | IO_Translate)) {
+                    debug_msg(2, "Writing internal cache information: %s", cache_file.latin1());
+                    QTextStream cachet(&cachef);
+                    cachet << "[check]" << "\n"
+                           << "QMAKE_CACHE_VERSION = " << qmake_version() << "\n"
+                           << "QMAKE_ABSOLUTE_SOURCE_PATH = " << var("QMAKE_ABSOLUTE_SOURCE_PATH") << "\n"
+                           << "MOC_DIR = " << var("MOC_DIR") << "\n"
+                           << "UI_DIR = " <<  var("UI_DIR") << "\n"
+                           << "UI_HEADERS_DIR = " <<  var("UI_HEADERS_DIR") << "\n"
+                           << "UI_SOURCES_DIR = " <<  var("UI_SOURCES_DIR") << "\n";
+                    cachet << "[depend]" << endl;
+                    for(QMap<QString, QStringList>::Iterator it = depends.begin();
+                        it != depends.end(); ++it)
+                        cachet << depKeyMap[it.key()] << " = " << it.data().join(" ") << endl;
+                    cachet << "[mocable]" << endl;
+                    QString mc, moc_sources[] = { QString("HEADERS"), QString("SOURCES"), QString::null };
+                    for(int x = 0; moc_sources[x] != QString::null; x++) {
+                        QStringList &l = v[moc_sources[x]];
+                        for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
+                            if(!(*val_it).isEmpty()) {
+                                mc = mocablesToMOC[(*val_it)];
+                                if(mc.isEmpty())
+                                    mc = "*qmake_ignore*";
+                                cachet << (*val_it) << " = " << mc << endl;
+                            }
+                        }
+                    }
+                    cachef.close();
+                }
+            }
+        }
+    }
+    v["OBJECTS"] = createObjectList("SOURCES") + v["OBJECTS"]; // init variables
+
+    //lex files
+    {
+        QStringList &impls = v["LEXIMPLS"];
+        QStringList &l = v["LEXSOURCES"];
+        for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+            QString dir;
+            QFileInfo fi((*it));
+            if(fi.dirPath() != ".")
+                dir = fi.dirPath() + Option::dir_sep;
+            dir = fileFixify(dir, QDir::currentDirPath(), Option::output_dir);
+            if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep)
+                dir += Option::dir_sep;
+            QString impl = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first();
+            logicWarn(impl, "SOURCES");
+            logicWarn(impl, "SOURCES");
+            impls.append(impl);
+            if( ! project->isActiveConfig("lex_included")) {
+                v["SOURCES"].append(impl);
+                // attribute deps of lex file to impl file
+                QStringList &lexdeps = findDependencies((*it));
+                QStringList &impldeps = findDependencies(impl);
+                for(QStringList::ConstIterator d = lexdeps.begin(); d != lexdeps.end(); ++d) {
+                    if(!impldeps.contains(*d))
+                        impldeps.append(*d);
+                }
+                lexdeps.clear();
+            }
+        }
+        if( ! project->isActiveConfig("lex_included"))
+            v["OBJECTS"] += (v["LEXOBJECTS"] = createObjectList("LEXIMPLS"));
+    }
+    //yacc files
+    {
+        QStringList &decls = v["YACCCDECLS"], &impls = v["YACCIMPLS"];
+        QStringList &l = v["YACCSOURCES"];
+        for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+            QString dir;
+            QFileInfo fi((*it));
+            if(fi.dirPath() != ".")
+                dir = fi.dirPath() + Option::dir_sep;
+            dir = fileFixify(dir, QDir::currentDirPath(), Option::output_dir);
+            if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep)
+                dir += Option::dir_sep;
+            QString impl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::cpp_ext.first();
+            logicWarn(impl, "SOURCES");
+            QString decl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::h_ext.first();
+            logicWarn(decl, "HEADERS");
+
+            decls.append(decl);
+            impls.append(impl);
+            v["SOURCES"].append(impl);
+            QStringList &impldeps = findDependencies(impl);
+            impldeps.append(decl);
+            // attribute deps of yacc file to impl file
+            QStringList &yaccdeps = findDependencies((*it));
+            for(QStringList::ConstIterator d = yaccdeps.begin(); d != yaccdeps.end(); ++d) {
+                if(!impldeps.contains(*d))
+                    impldeps.append(*d);
+            }
+            if( project->isActiveConfig("lex_included")) {
+                // is there a matching lex file ? Transfer its dependencies.
+                QString lexsrc = fi.baseName(TRUE) + Option::lex_ext;
+                if(fi.dirPath() != ".")
+                    lexsrc.prepend(fi.dirPath() + Option::dir_sep);
+                if(v["LEXSOURCES"].findIndex(lexsrc) != -1) {
+                    QString trg = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first();
+                    impldeps.append(trg);
+                    impldeps += findDependencies(lexsrc);
+                    depends[lexsrc].clear();
+                }
+            }
+            yaccdeps.clear();
+        }
+        v["OBJECTS"] += (v["YACCOBJECTS"] = createObjectList("YACCIMPLS"));
+    }
+
+    //UI files
+    {
+        if(!project->isEmpty("UI_DIR"))
+            project->variables()["INCLUDEPATH"].append(project->first("UI_DIR"));
+        else if(!project->isEmpty("UI_HEADERS_DIR"))
+            project->variables()["INCLUDEPATH"].append(project->first("UI_HEADERS_DIR"));
+        QStringList &decls = v["UICDECLS"], &impls = v["UICIMPLS"];
+        QStringList &l = v["FORMS"];
+        for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+            QString impl, decl;
+            QFileInfo fi(Option::fixPathToLocalOS((*it)));
+            if ( !project->isEmpty("UI_DIR") ) {
+                impl = decl = project->first("UI_DIR");
+                QString d = fi.dirPath();
+                if( d == ".")
+                    d = QDir::currentDirPath();
+                d = fileFixify(d);
+                if( !project->variables()["INCLUDEPATH"].contains(d))
+                    project->variables()["INCLUDEPATH"].append(d);
+            } else {
+                if(decl.isEmpty() && !project->isEmpty("UI_HEADERS_DIR"))
+                    decl = project->first("UI_HEADERS_DIR");
+                if ( !decl.isEmpty() || (project->isEmpty("UI_HEADERS_DIR") && !project->isEmpty("UI_SOURCES_DIR")) ) {
+                    QString d = fi.dirPath();
+                    if( d == ".")
+                        d = QDir::currentDirPath();
+                    d = fileFixify(d);
+                    if( !project->variables()["INCLUDEPATH"].contains(d))
+                        project->variables()["INCLUDEPATH"].append(d);
+                }
+                if(impl.isEmpty() && !project->isEmpty("UI_SOURCES_DIR"))
+                    impl = project->first("UI_SOURCES_DIR");
+                if(fi.dirPath() != ".") {
+                    if(impl.isEmpty())
+                        impl = fi.dirPath() + Option::dir_sep;
+                    if(decl.isEmpty())
+                        decl = fi.dirPath() + Option::dir_sep;
+                }
+            }
+            impl += fi.baseName(TRUE) + Option::cpp_ext.first(),
+            decl += fi.baseName(TRUE) + Option::h_ext.first();
+            logicWarn(impl, "SOURCES");
+            logicWarn(decl, "HEADERS");
+            decls.append(decl);
+            impls.append(impl);
+            findDependencies(impl).append(decl);
+
+            QString mocable = Option::moc_mod + fi.baseName(TRUE) + Option::cpp_ext.first();
+            if(!v["MOC_DIR"].isEmpty())
+                mocable.prepend(v["MOC_DIR"].first());
+            else if(fi.dirPath() != ".")
+                mocable.prepend(fi.dirPath() + Option::dir_sep);
+            logicWarn(mocable, "SOURCES");
+            mocablesToMOC[cleanFilePath(decl)] = mocable;
+            mocablesFromMOC[cleanFilePath(mocable)] = decl;
+            v["_UIMOC"].append(mocable);
+        }
+        v["OBJECTS"] += (v["UICOBJECTS"] = createObjectList("UICDECLS"));
+    }
+
+    //Image files
+    if(!project->isEmpty("IMAGES")) {
+        if(project->isEmpty("QMAKE_IMAGE_COLLECTION"))
+            v["QMAKE_IMAGE_COLLECTION"].append("qmake_image_collection" + Option::cpp_ext.first());
+        QString imgfile = project->first("QMAKE_IMAGE_COLLECTION");
+        Option::fixPathToTargetOS(imgfile);
+        if(!project->isEmpty("UI_DIR") || !project->isEmpty("UI_SOURCES_DIR")) {
+            if(imgfile.find(Option::dir_sep) != -1)
+                imgfile = imgfile.right(imgfile.findRev(Option::dir_sep) + 1);
+            imgfile.prepend( (project->isEmpty("UI_DIR") ? project->first("UI_SOURCES_DIR") :
+                            project->first("UI_DIR")) );
+            v["QMAKE_IMAGE_COLLECTION"] = QStringList(imgfile);
+        }
+        logicWarn(imgfile, "SOURCES");
+        if(!noIO()) {
+            QStringList &l = v["IMAGES"];
+            for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+                if(!QFile::exists((*it))) {
+                    warn_msg(WarnLogic, "Failure to open: %s", (*it).latin1());
+                    continue;
+                }
+                findDependencies(imgfile).append(fileFixify((*it)));
+            }
+        }
+        v["OBJECTS"] += (v["IMAGEOBJECTS"] = createObjectList("QMAKE_IMAGE_COLLECTION"));
+    }
+
+    if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH"))
+        project->variables()["INCLUDEPATH"].append(Option::output_dir);
+
+    //moc files
+    if ( mocAware() ) {
+        if(!project->isEmpty("MOC_DIR"))
+            project->variables()["INCLUDEPATH"].append(project->first("MOC_DIR"));
+        v["OBJMOC"] = createObjectList("_HDRMOC") + createObjectList("_UIMOC");
+
+        QStringList &l = v["SRCMOC"];
+        l = v["_HDRMOC"] + v["_UIMOC"] + v["_SRCMOC"];
+        for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
+            if(!(*val_it).isEmpty())
+                (*val_it) = Option::fixPathToTargetOS((*val_it), FALSE);
+        }
+    }
+}
+
+bool
+MakefileGenerator::processPrlFile(QString &file)
+{
+    bool ret = FALSE, try_replace_file=FALSE;
+    QString prl_file;
+    if(file.endsWith(Option::prl_ext)) {
+        try_replace_file = TRUE;
+        prl_file = file;
+        file = "";
+    } else {
+        QString tmp = file;
+        int ext = tmp.findRev('.');
+        if(ext != -1)
+            tmp = tmp.left(ext);
+        prl_file = tmp + Option::prl_ext;
+    }
+    prl_file = fileFixify(prl_file);
+    if(!QFile::exists(fileFixify(prl_file, QDir::currentDirPath(), Option::output_dir)) && 
+       project->isActiveConfig("qt")) {
+        QString stem = prl_file, dir, extn;
+        int slsh = stem.findRev('/'), hadlib = 0;
+        if(slsh != -1) {
+            dir = stem.left(slsh + 1);
+            stem = stem.right(stem.length() - slsh - 1);
+        }
+        if(stem.startsWith("lib")) {
+            hadlib = 1;
+            stem = stem.right(stem.length() - 3);
+        }
+        int dot = stem.find('.');
+        if(dot != -1) {
+            extn = stem.right(stem.length() - dot);
+            stem = stem.left(dot);
+        }
+        if(stem == "qt" || stem == "qte" || stem == "qte-mt" || stem == "qt-mt") {
+            if(stem.endsWith("-mt"))
+                stem = stem.left(stem.length() - 3); //lose the -mt
+            else
+                stem += "-mt"; //try the thread case
+            prl_file = dir;
+            if(hadlib)
+                prl_file += "lib";
+            prl_file += stem + extn;
+            try_replace_file = TRUE;
+        }
+    }
+    QString real_prl_file = Option::fixPathToLocalOS(prl_file);
+    if(project->variables()["QMAKE_PRL_INTERNAL_FILES"].findIndex(prl_file) != -1) {
+        ret = TRUE;
+    } else if(!real_prl_file.isEmpty() &&
+              QFile::exists(fileFixify(real_prl_file, QDir::currentDirPath(), Option::output_dir))) {
+        project->variables()["QMAKE_PRL_INTERNAL_FILES"].append(prl_file);
+        QMakeProject proj;
+        debug_msg(1, "Processing PRL file: %s", real_prl_file.latin1());
+        if(!proj.read(fileFixify(real_prl_file, QDir::currentDirPath(), Option::output_dir),
+                      QDir::currentDirPath())) {
+            fprintf(stderr, "Error processing prl file: %s\n", real_prl_file.latin1());
+        } else {
+            ret = TRUE;
+            QMap<QString, QStringList> &vars = proj.variables();
+            for( QMap<QString, QStringList>::Iterator it = vars.begin(); it != vars.end(); ++it)
+                processPrlVariable(it.key(), it.data());
+            if(try_replace_file && !proj.isEmpty("QMAKE_PRL_TARGET")) {
+                QString dir;
+                int slsh = real_prl_file.findRev(Option::dir_sep);
+                if(slsh != -1)
+                    dir = real_prl_file.left(slsh+1);
+                file = dir + proj.first("QMAKE_PRL_TARGET");
+            }
+        }
+        if(ret)
+            project->variables()["QMAKE_INTERNAL_INCLUDED_FILES"].append(prl_file);
+    }
+    return ret;
+}
+
+void
+MakefileGenerator::processPrlVariable(const QString &var, const QStringList &l)
+{
+    if(var == "QMAKE_PRL_LIBS") {
+        QString where = "QMAKE_LIBS";
+        if(!project->isEmpty("QMAKE_INTERNAL_PRL_LIBS"))
+            where = project->first("QMAKE_INTERNAL_PRL_LIBS");
+        QStringList &out = project->variables()[where];
+        for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
+            if( out.findIndex((*it)) == -1)
+                out.append((*it));
+        }
+    } else if(var == "QMAKE_PRL_DEFINES") {
+        QStringList &out = project->variables()["DEFINES"];
+        for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
+            if(out.findIndex((*it)) == -1 &&
+               project->variables()["PRL_EXPORT_DEFINES"].findIndex((*it)) == -1)
+                out.append((*it));
+        }
+    }
+}
+
+void
+MakefileGenerator::processPrlFiles()
+{
+    QDict<void> processed;
+    for(bool ret = FALSE; TRUE; ret = FALSE) {
+        //read in any prl files included..
+        QStringList l_out;
+        QString where = "QMAKE_LIBS";
+        if(!project->isEmpty("QMAKE_INTERNAL_PRL_LIBS"))
+            where = project->first("QMAKE_INTERNAL_PRL_LIBS");
+        QStringList &l = project->variables()[where];
+        for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+            QString file = (*it);
+            if(!processed[file] && processPrlFile(file)) {
+                processed.insert(file, (void*)1);
+                ret = TRUE;
+            }
+            if(!file.isEmpty())
+                l_out.append(file);
+        }
+        if(ret)
+            l = l_out;
+        else
+            break;
+    }
+}
+
+void
+MakefileGenerator::writePrlFile(QTextStream &t)
+{
+    QString target = project->first("TARGET");
+    int slsh = target.findRev(Option::dir_sep);
+    if(slsh != -1)
+        target = target.right(target.length() - slsh - 1);
+    QString bdir = Option::output_dir;
+    if(bdir.isEmpty())
+        bdir = QDir::currentDirPath();
+    t << "QMAKE_PRL_BUILD_DIR = " << bdir << endl;
+
+    if(!project->projectFile().isEmpty() && project->projectFile() != "-")
+        t << "QMAKE_PRO_INPUT = " << project->projectFile().section('/', -1) << endl;
+
+    if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH"))
+        t << "QMAKE_PRL_SOURCE_DIR = " << project->first("QMAKE_ABSOLUTE_SOURCE_PATH") << endl;
+    t << "QMAKE_PRL_TARGET = " << target << endl;
+    if(!project->isEmpty("PRL_EXPORT_DEFINES"))
+        t << "QMAKE_PRL_DEFINES = " << project->variables()["PRL_EXPORT_DEFINES"].join(" ") << endl;
+    if(!project->isEmpty("CONFIG"))
+        t << "QMAKE_PRL_CONFIG = " << project->variables()["CONFIG"].join(" ") << endl;
+    if(project->isActiveConfig("staticlib") || project->isActiveConfig("explicitlib")) {
+        QStringList libs;
+        if(!project->isEmpty("QMAKE_INTERNAL_PRL_LIBS"))
+            libs = project->variables()["QMAKE_INTERNAL_PRL_LIBS"];
+        else
+            libs << "QMAKE_LIBS"; //obvious one
+        t << "QMAKE_PRL_LIBS = ";
+        for(QStringList::Iterator it = libs.begin(); it != libs.end(); ++it)
+            t << project->variables()[(*it)].join(" ") << " ";
+        t << endl;
+    }
+}
+
+bool
+MakefileGenerator::write()
+{
+    init();
+    findLibraries();
+    if((Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE || //write prl
+       Option::qmake_mode == Option::QMAKE_GENERATE_PRL) &&
+       project->isActiveConfig("create_prl") && project->first("TEMPLATE") == "lib" &&
+       !project->isActiveConfig("plugin")) {
+        QString prl = var("TARGET");
+        int slsh = prl.findRev(Option::dir_sep);
+        if(slsh != -1)
+            prl = prl.right(prl.length() - slsh);
+        int dot = prl.find('.');
+        if(dot != -1)
+            prl = prl.left(dot);
+        prl += Option::prl_ext;
+        if(!project->isEmpty("DESTDIR"))
+            prl.prepend(var("DESTDIR"));
+        QString local_prl = fileFixify(prl, QDir::currentDirPath(), Option::output_dir);
+        fixEnvVariables(local_prl);
+        QFile ft(local_prl);
+        if(ft.open(IO_WriteOnly)) {
+            project->variables()["ALL_DEPS"].append(prl);
+            project->variables()["QMAKE_INTERNAL_PRL_FILE"].append(prl);
+            QTextStream t(&ft);
+            writePrlFile(t);
+            ft.close();
+        }
+    }
+    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE &&
+       project->isActiveConfig("link_prl")) //load up prl's
+        processPrlFiles();
+
+    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
+       Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
+        QTextStream t(&Option::output);
+        writeMakefile(t);
+    }
+    return TRUE;
+}
+
+void
+MakefileGenerator::writeObj(QTextStream &t, const QString &obj, const QString &src)
+{
+    QStringList &objl = project->variables()[obj];
+    QStringList &srcl = project->variables()[src];
+
+    QStringList::Iterator oit = objl.begin();
+    QStringList::Iterator sit = srcl.begin();
+    QString stringSrc("$src");
+    QString stringObj("$obj");
+    for( ;sit != srcl.end() && oit != objl.end(); oit++, sit++) {
+        if((*sit).isEmpty())
+            continue;
+
+        if(!doDepends()) {
+            QString sdep, odep = (*sit) + " ";
+            QStringList deps = findDependencies((*sit));
+            for(QStringList::Iterator dit = deps.begin(); dit != deps.end(); dit++) {
+                if((*dit).endsWith(Option::moc_ext))
+                    odep += (*dit) + " ";
+                else
+                    sdep += (*dit) + " ";
+            }
+            t << (*sit) << ": " << sdep << endl
+              << (*oit) << ": " << odep ;
+        } else {
+            t << (*oit) << ": " << (*sit) << " " << findDependencies((*sit)).join(" \\\n\t\t");
+        }
+
+        QString comp, cimp;
+        for(QStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit) {
+            if((*sit).endsWith((*cppit))) {
+                comp = "QMAKE_RUN_CXX";
+                cimp = "QMAKE_RUN_CXX_IMP";
+                break;
+            }
+        }
+        if(comp.isEmpty()) {
+            comp = "QMAKE_RUN_CC";
+            cimp = "QMAKE_RUN_CC_IMP";
+        }
+        bool use_implicit_rule = !project->isEmpty(cimp);
+        if(use_implicit_rule) {
+            if(!project->isEmpty("OBJECTS_DIR")) {
+                use_implicit_rule = FALSE;
+            } else {
+                int dot = (*sit).findRev('.');
+                if(dot == -1 || ((*sit).left(dot) + Option::obj_ext != (*oit)))
+                    use_implicit_rule = FALSE;
+            }
+        }
+        if (!use_implicit_rule) {
+            QString p = var(comp);
+            p.replace(stringSrc, (*sit));
+            p.replace(stringObj, (*oit));
+            t << "\n\t" << p;
+        }
+        t << endl << endl;
+    }
+}
+
+
+void
+MakefileGenerator::writeUicSrc(QTextStream &t, const QString &ui)
+{
+    QStringList &uil = project->variables()[ui];
+    for(QStringList::Iterator it = uil.begin(); it != uil.end(); it++) {
+        QString deps = findDependencies((*it)).join(" \\\n\t\t"), decl, impl;
+        {
+            QString tmp = (*it);
+            decl = tmp.replace(QRegExp("\\" + Option::ui_ext + "$"), Option::h_ext.first());
+            tmp = (*it);
+            impl = tmp.replace(QRegExp("\\" + Option::ui_ext + "$"), Option::cpp_ext.first());
+                int dlen = (*it).findRev(Option::dir_sep) + 1;
+            if(!project->isEmpty("UI_DIR")) {
+                decl = project->first("UI_DIR") + decl.right(decl.length() - dlen);
+                impl = project->first("UI_DIR") + impl.right(impl.length() - dlen);
+            } else {
+                if(!project->isEmpty("UI_HEADERS_DIR"))
+                    decl = project->first("UI_HEADERS_DIR") + decl.right(decl.length() - dlen);
+                if(!project->isEmpty("UI_SOURCES_DIR"))
+                    impl = project->first("UI_SOURCES_DIR") + impl.right(impl.length() - dlen);
+            }
+        }
+        t << decl << ": " << (*it) << " " << deps << "\n\t"
+          << "$(UIC) " << (*it) << " -o " << decl << endl << endl;
+
+        QString mildDecl = decl;
+        int k = mildDecl.findRev( Option::dir_sep );
+        if ( k != -1 )
+            mildDecl = mildDecl.mid( k + 1 );
+
+        t << impl << ": " << decl << " " << (*it) << " " << deps << "\n\t"
+          << "$(UIC) " << (*it) << " -i " << mildDecl << " -o " << impl << endl << endl;
+    }
+}
+
+
+void
+MakefileGenerator::writeMocObj(QTextStream &t, const QString &obj, const QString &src)
+{
+    QStringList &objl = project->variables()[obj],
+                &srcl = project->variables()[src];
+    QStringList::Iterator oit = objl.begin(), sit = srcl.begin();
+    QString stringSrc("$src"), stringObj("$obj");
+    for( ;sit != srcl.end() && oit != objl.end(); oit++, sit++) {
+        QString hdr = findMocSource((*sit));
+        t << (*oit) << ": " << (*sit) << " "
+          << hdr << " " << findDependencies(hdr).join(" \\\n\t\t");
+        bool use_implicit_rule = !project->isEmpty("QMAKE_RUN_CXX_IMP");
+        if(use_implicit_rule) {
+            if(!project->isEmpty("OBJECTS_DIR") || !project->isEmpty("MOC_DIR")) {
+                use_implicit_rule = FALSE;
+            } else {
+                int dot = (*sit).findRev('.');
+                if(dot == -1 || ((*sit).left(dot) + Option::obj_ext != (*oit)))
+                    use_implicit_rule = FALSE;
+            }
+        }
+        if (!use_implicit_rule) {
+            QString p = var("QMAKE_RUN_CXX");
+            p.replace(stringSrc, (*sit));
+            p.replace(stringObj, (*oit));
+            t << "\n\t" << p;
+        }
+        t << endl << endl;
+    }
+}
+
+
+void
+MakefileGenerator::writeMocSrc(QTextStream &t, const QString &src)
+{
+    QStringList &l = project->variables()[src];
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QString m = Option::fixPathToTargetOS(findMocDestination(*it));
+        if ( !m.isEmpty()) {
+            QString deps;
+            if(!project->isActiveConfig("no_mocdepend"))
+                deps += "$(MOC) ";
+            deps += (*it);
+            t << m << ": " << deps << "\n\t"
+              << "$(MOC) " << (*it) << " -o " << m << endl << endl;
+        }
+    }
+}
+
+void
+MakefileGenerator::writeYaccSrc(QTextStream &t, const QString &src)
+{
+    QStringList &l = project->variables()[src];
+    if(project->isActiveConfig("yacc_no_name_mangle") && l.count() > 1)
+        warn_msg(WarnLogic, "yacc_no_name_mangle specified, but multiple parsers expected."
+                 "This can lead to link problems.\n");
+    QString default_out_h = "y.tab.h", default_out_c = "y.tab.c";
+    if(!project->isEmpty("QMAKE_YACC_HEADER"))
+        default_out_h = project->first("QMAKE_YACC_HEADER");
+    if(!project->isEmpty("QMAKE_YACC_SOURCE"))
+        default_out_c = project->first("QMAKE_YACC_SOURCE");
+    QString stringBase("$base");
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QFileInfo fi((*it));
+        QString dir = fileFixify(Option::output_dir);
+        if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep)
+            dir += Option::dir_sep;
+        QString impl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::cpp_ext.first();
+        QString decl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::h_ext.first();
+
+        QString yaccflags = "$(YACCFLAGS)", mangle = "y";
+        if(!project->isActiveConfig("yacc_no_name_mangle")) {
+            mangle = fi.baseName(TRUE);
+            yaccflags += " -p " + mangle;
+        } 
+        QString out_h = default_out_h, out_c = default_out_c;
+        if(!mangle.isEmpty()) {
+            out_h.replace(stringBase, mangle);
+            out_c.replace(stringBase, mangle);
+        }
+
+        t << impl << ": " << (*it) << "\n\t"
+          << "$(YACC) " << yaccflags << " " << (*it) << "\n\t"
+          << "-$(DEL_FILE) " << impl << " " << decl << "\n\t"
+          << "-$(MOVE) " << out_h << " " << decl << "\n\t"
+          << "-$(MOVE) " << out_c << " " << impl << endl << endl;
+        t << decl << ": " << impl << endl << endl;
+    }
+}
+
+void
+MakefileGenerator::writeLexSrc(QTextStream &t, const QString &src)
+{
+    QStringList &l = project->variables()[src];
+    if(project->isActiveConfig("yacc_no_name_mangle") && l.count() > 1)
+        warn_msg(WarnLogic, "yacc_no_name_mangle specified, but multiple parsers expected.\n"
+                 "This can lead to link problems.\n");
+    QString default_out_c = "lex.$base.c";
+    if(!project->isEmpty("QMAKE_LEX_SOURCE"))
+        default_out_c = project->first("QMAKE_LEX_SOURCE");
+    QString stringBase("$base");
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QFileInfo fi((*it));
+        QString dir = fileFixify(Option::output_dir);
+        if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep)
+            dir += Option::dir_sep;
+        QString impl = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first();
+
+        QString lexflags = "$(LEXFLAGS)", stub="yy";
+        if(!project->isActiveConfig("yacc_no_name_mangle")) {
+            stub = fi.baseName(TRUE);
+            lexflags += " -P" + stub;
+        }
+        QString out_c = default_out_c;
+        if(!stub.isEmpty()) 
+            out_c.replace(stringBase, stub);
+
+        t << impl << ": " << (*it) << " " << findDependencies((*it)).join(" \\\n\t\t") << "\n\t"
+          << ( "$(LEX) " + lexflags + " " ) << (*it) << "\n\t"
+          << "-$(DEL_FILE) " << impl << " " << "\n\t"
+          << "-$(MOVE) " << out_c << " " << impl << endl << endl;
+    }
+}
+
+void
+MakefileGenerator::writeImageObj(QTextStream &t, const QString &obj)
+{
+    QStringList &objl = project->variables()[obj];
+    QString stringSrc("$src");
+    QString stringObj("$obj");
+
+    QString uidir;
+    for(QStringList::Iterator oit = objl.begin(); oit != objl.end(); oit++) {
+        QString src(project->first("QMAKE_IMAGE_COLLECTION"));
+        t << (*oit) << ": " << src;
+        bool use_implicit_rule = !project->isEmpty("QMAKE_RUN_CXX_IMP");
+        if(use_implicit_rule) {
+            if(!project->isEmpty("OBJECTS_DIR") || !project->isEmpty("UI_DIR") || !project->isEmpty("UI_SOURCES_DIR")) {
+                use_implicit_rule = FALSE;
+            } else {
+                int dot = src.findRev('.');
+                if(dot == -1 || (src.left(dot) + Option::obj_ext != (*oit)))
+                    use_implicit_rule = FALSE;
+            }
+        }
+        if(!use_implicit_rule) {
+            QString p = var("QMAKE_RUN_CXX");
+            p.replace( stringSrc, src);
+            p.replace( stringObj, (*oit));
+            t << "\n\t" << p;
+        }
+        t << endl << endl;
+    }
+}
+
+
+void
+MakefileGenerator::writeImageSrc(QTextStream &t, const QString &src)
+{
+    QStringList &l = project->variables()[src];
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QString gen = project->first("MAKEFILE_GENERATOR");
+        if ( gen == "MSVC" ) {
+            t << (*it) << ": " << findDependencies((*it)).join(" \\\n\t\t") << "\n\t"
+                << "$(UIC)  -o " << (*it) << " -embed " << project->first("QMAKE_ORIG_TARGET")
+                << " -f <<\n" << findDependencies((*it)).join(" ") << "\n<<" << endl << endl;
+        } else if ( gen == "BMAKE" ) {
+            t << (*it) << ": " << findDependencies((*it)).join(" \\\n\t\t") << "\n\t"
+                << "$(UIC) " << " -embed " << project->first("QMAKE_ORIG_TARGET")
+                << " -f &&|\n" << findDependencies((*it)).join(" ") << "\n| -o " << (*it) << endl << endl;
+        } else {
+            t << (*it) << ": " << findDependencies((*it)).join(" \\\n\t\t") << "\n\t"
+                << "$(UIC) " << " -embed " << project->first("QMAKE_ORIG_TARGET")
+                << " " << findDependencies((*it)).join(" ") << " -o " << (*it) << endl << endl;
+        }
+    }
+}
+
+
+void
+MakefileGenerator::writeInstalls(QTextStream &t, const QString &installs)
+{
+    QString all_installs, all_uninstalls;
+    QStringList &l = project->variables()[installs];
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QString pvar = (*it) + ".path";
+        if(project->variables()[pvar].isEmpty()) {
+            warn_msg(WarnLogic, "%s is not defined: install target not created\n", pvar.latin1());
+            continue;
+        }
+
+        bool do_default = TRUE;
+        QString target, dst="$(INSTALL_ROOT)" + Option::fixPathToTargetOS(project->variables()[pvar].first(), FALSE);
+        if(dst.right(1) != Option::dir_sep)
+            dst += Option::dir_sep;
+         QStringList tmp, &uninst = project->variables()[(*it) + ".uninstall"];
+         //other
+         tmp = project->variables()[(*it) + ".extra"];
+         if(!tmp.isEmpty()) {
+            do_default = FALSE;
+            if(!target.isEmpty())
+                target += "\n\t";
+             target += tmp.join(" ");
+         }
+         //masks
+         tmp = project->variables()[(*it) + ".files"];
+         if(!tmp.isEmpty()) {
+            if(!target.isEmpty())
+                target += "\n";
+            do_default = FALSE;
+            for(QStringList::Iterator wild_it = tmp.begin(); wild_it != tmp.end(); ++wild_it) {
+                QString wild = Option::fixPathToLocalOS((*wild_it), FALSE), wild_var = fileFixify(wild);
+                if(QFile::exists(wild)) { //real file
+                    QFileInfo fi(wild);
+                    target += QString("\t-") + (fi.isDir() ? "$(COPY_DIR)" : "$(COPY_FILE)") +
+                              " \"" + Option::fixPathToTargetOS(fileFixify(wild), FALSE) + "\" \"" + fileFixify(dst) + "\"\n";
+                    if(!project->isActiveConfig("debug") &&
+                       !fi.isDir() && fi.isExecutable() && !project->isEmpty("QMAKE_STRIP"))
+                        target += QString("\t") + var("QMAKE_STRIP") + " \"" + fileFixify(dst + wild) + "\"\n";
+                    uninst.append(QString("-$(DEL_FILE) -r") + " \"" + fileFixify(dst + wild) + "\"");
+                    continue;
+                }
+                        QString dirstr = QDir::currentDirPath(), f = wild;          //wild
+                int slsh = f.findRev(Option::dir_sep);
+                if(slsh != -1) {
+                    dirstr = f.left(slsh+1);
+                    f = f.right(f.length() - slsh - 1);
+                }
+                if(dirstr.right(Option::dir_sep.length()) != Option::dir_sep)
+                    dirstr += Option::dir_sep;
+                if(!uninst.isEmpty())
+                    uninst.append("\n\t");
+                uninst.append(QString("-$(DEL_FILE) -r") + " " + fileFixify(dst + f) + "");
+                
+                QDir dir(dirstr, f);
+                for(uint x = 0; x < dir.count(); x++) {
+                    QString file = dir[x];
+                    if(file == "." || file == "..") //blah
+                        continue;
+                    QFileInfo fi(file);
+                    target += QString("\t-") + (fi.isDir() ? "$(COPY_DIR)" : "$(COPY_FILE)") +
+                              " \"" + Option::fixPathToTargetOS(fileFixify(dirstr + file), FALSE) +
+                              "\" \"" + fileFixify(dst) + "\"\n";
+                    if(!project->isActiveConfig("debug") &&
+                       !fi.isDir() && fi.isExecutable() && !project->isEmpty("QMAKE_STRIP"))
+                        target += QString("\t") + var("QMAKE_STRIP") + " \"" + fileFixify(dst + file) + "\"\n";
+                }
+            }
+         }
+         //default?
+        if(do_default)
+            target = defaultInstall((*it));
+
+        if(!target.isEmpty()) {
+            t << "install_" << (*it) << ": " << "\n\t"
+              << "@test -d " << dst << " || mkdir -p " << dst << "\n\t"
+              << target << endl << endl;
+            all_installs += QString("install_") + (*it) + " ";
+            if(!uninst.isEmpty()) {
+                t << "uninstall_" << (*it) << ": " << "\n\t"
+                  << uninst.join(" ") << "\n\t"
+                  << "-$(DEL_DIR) \"" << dst << "\"" << endl << endl;
+                all_uninstalls += "uninstall_" + (*it) + " ";
+            }
+            t << endl;
+        }   else {
+            debug_msg(1, "no definition for install %s: install target not created",(*it).latin1());
+        }
+    }
+    t << "install: all " << all_installs << "\n\n";
+    t << "uninstall: " << all_uninstalls << "\n\n";
+}
+
+QString
+MakefileGenerator::var(const QString &var)
+{
+    return val(project->variables()[var]);
+}
+
+QString
+MakefileGenerator::val(const QStringList &varList)
+{
+    return valGlue(varList, "", " ", "");
+}
+
+QString
+MakefileGenerator::varGlue(const QString &var, const QString &before, const QString &glue, const QString &after)
+{
+    return valGlue(project->variables()[var], before, glue, after);
+}
+
+QString
+MakefileGenerator::valGlue(const QStringList &varList, const QString &before, const QString &glue, const QString &after)
+{
+    QString ret;
+    for(QStringList::ConstIterator it = varList.begin(); it != varList.end(); ++it) {
+        if(!(*it).isEmpty()) {
+            if(!ret.isEmpty())
+                ret += glue;
+            ret += (*it);
+        }
+    }
+    return ret.isEmpty() ? QString("") : before + ret + after;
+}
+
+
+QString
+MakefileGenerator::varList(const QString &var)
+{
+    return valList(project->variables()[var]);
+}
+
+QString
+MakefileGenerator::valList(const QStringList &varList)
+{
+    return valGlue(varList, "", " \\\n\t\t", "");
+}
+
+
+QStringList
+MakefileGenerator::createObjectList(const QString &var)
+{
+    QStringList &l = project->variables()[var], ret;
+    QString objdir, dir;
+    if(!project->variables()["OBJECTS_DIR"].isEmpty())
+        objdir = project->first("OBJECTS_DIR");
+    for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+        QFileInfo fi(Option::fixPathToLocalOS((*it)));
+        if(objdir.isEmpty() && project->isActiveConfig("object_with_source")) {
+            QString fName = Option::fixPathToTargetOS((*it), FALSE);
+            int dl = fName.findRev(Option::dir_sep);
+            if(dl != -1)
+                dir = fName.left(dl + 1);
+        } else {
+            dir = objdir;
+        }
+        ret.append(dir + fi.baseName(TRUE) + Option::obj_ext);
+    }
+    return ret;
+}
+
+bool
+MakefileGenerator::writeMakefile(QTextStream &t)
+{
+    t << "####### Compile" << endl << endl;
+    writeObj(t, "OBJECTS", "SOURCES");
+    writeUicSrc(t, "FORMS");
+    writeObj(t, "UICOBJECTS", "UICIMPLS");
+    writeMocObj(t, "OBJMOC", "SRCMOC" );
+    writeMocSrc(t, "HEADERS");
+    writeMocSrc(t, "SOURCES");
+    writeMocSrc(t, "UICDECLS");
+    writeYaccSrc(t, "YACCSOURCES");
+    writeLexSrc(t, "LEXSOURCES");
+    writeImageObj(t, "IMAGEOBJECTS");
+    writeImageSrc(t, "QMAKE_IMAGE_COLLECTION");
+
+    t << "####### Install" << endl << endl;
+    writeInstalls(t, "INSTALLS");
+    return TRUE;
+}
+
+QString MakefileGenerator::buildArgs()
+{
+    static QString ret;
+    if(ret.isEmpty()) {
+        //special variables
+        if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH"))
+            ret += " QMAKE_ABSOLUTE_SOURCE_PATH=\"" + project->first("QMAKE_ABSOLUTE_SOURCE_PATH") + "\"";
+
+        //warnings
+        else if(Option::warn_level == WarnNone)
+            ret += " -Wnone";
+        else if(Option::warn_level == WarnAll)
+            ret += " -Wall";
+        else if(Option::warn_level & WarnParser)
+                ret += " -Wparser";
+        //other options
+        if(!Option::user_template.isEmpty())
+            ret += " -t " + Option::user_template;
+        if(!Option::mkfile::do_cache)
+            ret += " -nocache";
+        if(!Option::mkfile::do_deps)
+            ret += " -nodepend";
+        if(!Option::mkfile::do_mocs)
+            ret += " -nomoc";
+        if(!Option::mkfile::do_dep_heuristics)
+            ret += " -nodependheuristics";
+        if(!Option::mkfile::qmakespec_commandline.isEmpty())
+            ret += " -spec " + Option::mkfile::qmakespec_commandline;
+
+        //arguments
+        for(QStringList::Iterator it = Option::before_user_vars.begin();
+            it != Option::before_user_vars.end(); ++it) {
+            if((*it).left(qstrlen("QMAKE_ABSOLUTE_SOURCE_PATH")) != "QMAKE_ABSOLUTE_SOURCE_PATH")
+                ret += " \"" + (*it) + "\"";
+        }
+        if(Option::after_user_vars.count()) {
+            ret += " -after ";
+            for(QStringList::Iterator it = Option::after_user_vars.begin();
+                it != Option::after_user_vars.end(); ++it) {
+                if((*it).left(qstrlen("QMAKE_ABSOLUTE_SOURCE_PATH")) != "QMAKE_ABSOLUTE_SOURCE_PATH")
+                    ret += " \"" + (*it) + "\"";
+            }
+        }
+    }
+    return ret;
+}
+
+//could get stored argv, but then it would have more options than are
+//probably necesary this will try to guess the bare minimum..
+QString MakefileGenerator::build_args()
+{
+    static QString ret;
+    if(ret.isEmpty()) {
+        ret = "$(QMAKE)";
+
+        // general options and arguments
+        ret += buildArgs();
+
+        //output
+        QString ofile = Option::fixPathToTargetOS(fileFixify(Option::output.name()));
+        if (!ofile.isEmpty() && ofile != project->first("QMAKE_MAKEFILE"))
+            ret += " -o " + ofile;
+
+        //inputs
+        QStringList files = fileFixify(Option::mkfile::project_files);
+        ret += " " + files.join(" ");
+    }
+    return ret;
+}
+
+bool
+MakefileGenerator::writeHeader(QTextStream &t)
+{
+    time_t foo = time(NULL);
+    t << "#############################################################################" << endl;
+    t << "# Makefile for building: " << var("TARGET") << endl;
+    t << "# Generated by qmake (" << qmake_version() << ") on: " << ctime(&foo);
+    t << "# Project:  " << fileFixify(project->projectFile()) << endl;
+    t << "# Template: " << var("TEMPLATE") << endl;
+    t << "# Command: " << build_args() << endl;
+    t << "#############################################################################" << endl;
+    t << endl;
+    return TRUE;
+}
+
+
+//makes my life easier..
+bool
+MakefileGenerator::writeMakeQmake(QTextStream &t)
+{
+    QString ofile = Option::fixPathToTargetOS(fileFixify(Option::output.name()));
+    if(project->isEmpty("QMAKE_FAILED_REQUIREMENTS") &&
+       !project->isEmpty("QMAKE_INTERNAL_PRL_FILE")) {
+        QStringList files = fileFixify(Option::mkfile::project_files);
+        t << project->first("QMAKE_INTERNAL_PRL_FILE") << ": " << "\n\t"
+          << "@$(QMAKE) -prl " << buildArgs() << " " << files.join(" ") << endl;
+    }
+
+    QString pfile = project->projectFile();
+    if(pfile != "(stdin)") {
+        QString qmake = build_args();
+        if(!ofile.isEmpty() && !project->isActiveConfig("no_autoqmake")) {
+            t << ofile << ": " << fileFixify(pfile) << " ";
+            if(Option::mkfile::do_cache)
+                t <<  fileFixify(Option::mkfile::cachefile) << " ";
+            if(!specdir().isEmpty())
+                t << specdir() << Option::dir_sep << "qmake.conf" << " ";
+            t << project->variables()["QMAKE_INTERNAL_INCLUDED_FILES"].join(" \\\n\t\t") << "\n\t"
+              << qmake <<endl;
+        }
+        if(project->first("QMAKE_ORIG_TARGET") != "qmake") {
+            t << "qmake: " <<
+                project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].join(" \\\n\t\t") << "\n\t"
+              << "@" << qmake << endl << endl;
+        }
+    }
+    return TRUE;
+}
+
+QStringList
+MakefileGenerator::fileFixify(const QStringList& files, const QString &out_dir, const QString &in_dir, bool force_fix) const
+{
+    if(files.isEmpty())
+        return files;
+    QStringList ret;
+    for(QStringList::ConstIterator it = files.begin(); it != files.end(); ++it) {
+        if(!(*it).isEmpty())
+            ret << fileFixify((*it), out_dir, in_dir, force_fix);
+    }
+    return ret;
+}
+
+QString
+MakefileGenerator::fileFixify(const QString& file0, const QString &out_d, const QString &in_d, bool force_fix) const
+{
+    QString file = file0;
+    if(file.isEmpty())
+        return file;
+    int depth = 4;
+    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
+       Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
+        if(project && !project->isEmpty("QMAKE_PROJECT_DEPTH"))
+            depth = project->first("QMAKE_PROJECT_DEPTH").toInt();
+        else if(Option::mkfile::cachefile_depth != -1)
+            depth = Option::mkfile::cachefile_depth;
+    }
+
+    QChar quote;
+    if((file.startsWith("'") || file.startsWith("\"")) && file.startsWith(file.right(1))) {
+        quote = file.at(0);
+        file = file.mid(1, file.length() - 2);
+    }
+    QString orig_file = file;
+    if(!force_fix && project->isActiveConfig("no_fixpath")) {
+        if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH")) { //absoluteify it
+            QString qfile = Option::fixPathToLocalOS(file);
+            if(QDir::isRelativePath(file)) { //already absolute
+                QFileInfo fi(qfile);
+                if(!fi.convertToAbs()) //strange
+                    file = fi.filePath();
+            }
+        }
+    } else { //fix it..
+        QString qfile(Option::fixPathToLocalOS(file, TRUE)), in_dir(in_d), out_dir(out_d);
+        {
+            if(out_dir.isNull())
+                out_dir = Option::output_dir;
+            if(out_dir == ".")
+                out_dir = QDir::currentDirPath();
+            if(in_dir.isEmpty() || in_dir == ".")
+                in_dir = QDir::currentDirPath();
+            if(!QDir::isRelativePath(in_dir) || !QDir::isRelativePath(out_dir)) {
+                QFileInfo in_fi(in_dir);
+                if(!in_fi.convertToAbs())
+                    in_dir = in_fi.filePath();
+                QFileInfo out_fi(out_dir);
+                if(!out_fi.convertToAbs())
+                    out_dir = out_fi.filePath();
+            }
+        }
+        if(out_dir != in_dir || !QDir::isRelativePath(qfile)) {
+            if(QDir::isRelativePath(qfile)) {
+                if(file.left(Option::dir_sep.length()) != Option::dir_sep &&
+                   in_dir.right(Option::dir_sep.length()) != Option::dir_sep)
+                    file.prepend(Option::dir_sep);
+                file.prepend(in_dir);
+            }
+            file = Option::fixPathToTargetOS(file, FALSE);
+            QString match_dir = Option::fixPathToTargetOS(out_dir, FALSE);
+            if(file == match_dir) {
+                file = "";
+            } else if(file.startsWith(match_dir) &&
+               file.mid(match_dir.length(), Option::dir_sep.length()) == Option::dir_sep) {
+                file = file.right(file.length() - (match_dir.length() + 1));
+            } else {
+                for(int i = 1; i <= depth; i++) {
+                    int sl = match_dir.findRev(Option::dir_sep);
+                    if(sl == -1)
+                        break;
+                    match_dir = match_dir.left(sl);
+                    if(match_dir.isEmpty())
+                        break;
+                    if(file.startsWith(match_dir) &&
+                       file.mid(match_dir.length(), Option::dir_sep.length()) == Option::dir_sep) {
+                        //concat
+                        int remlen = file.length() - (match_dir.length() + 1);
+                        if (remlen < 0)
+                            remlen = 0;
+                        file = file.right(remlen);
+                        //prepend
+                        for(int o = 0; o < i; o++)
+                            file.prepend(".." + Option::dir_sep);
+                    }
+                }
+            }
+        }
+    }
+    file = Option::fixPathToTargetOS(file, FALSE);
+    if(!quote.isNull())
+        file = quote + file + quote;
+    debug_msg(3, "Fixed %s :: to :: %s (%d)", orig_file.latin1(), file.latin1(), depth);
+    return file;
+}
+
+QString
+MakefileGenerator::cleanFilePath(const QString &file) const
+{
+    return fileFixify(Option::fixPathToTargetOS(file));
+}
+
+void MakefileGenerator::logicWarn(const QString &f, const QString &w)
+{
+    if(!(Option::warn_level & WarnLogic))
+        return;
+    QString file = f;
+    int slsh = f.findRev(Option::dir_sep);
+    if(slsh != -1)
+        file = file.right(file.length() - slsh - 1);
+    QStringList &l = project->variables()[w];
+    for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
+        QString file2((*val_it));
+        slsh = file2.findRev(Option::dir_sep);
+        if(slsh != -1)
+            file2 = file2.right(file2.length() - slsh - 1);
+        if(file2 == file) {
+            warn_msg(WarnLogic, "Found potential symbol conflict of %s (%s) in %s",
+                     file.latin1(), (*val_it).latin1(), w.latin1());
+            break;
+        }
+    }
+}
+
+QStringList
+&MakefileGenerator::findDependencies(const QString &file)
+{
+    QString key = file;
+    Option::fixPathToTargetOS(key);
+    if(key.find(Option::dir_sep))
+        key = key.right(key.length() - key.findRev(Option::dir_sep) - 1);
+    if(!depKeyMap.contains(key))
+        depKeyMap.insert(key, file);
+    return depends[key];
+}
+
+
+QString
+MakefileGenerator::specdir()
+{
+    if(!spec.isEmpty())
+        return spec;
+    spec = Option::mkfile::qmakespec;
+    const char *d = getenv("QTDIR");
+    if(d) {
+        QString qdir = Option::fixPathToTargetOS(QString(d));
+        if(qdir.endsWith(QString(QChar(QDir::separator()))))
+            qdir.truncate(qdir.length()-1);
+        //fix path
+        QFileInfo fi(spec);
+        QString absSpec(fi.absFilePath());
+        absSpec = Option::fixPathToTargetOS(absSpec);
+        //replace what you can
+        if(absSpec.startsWith(qdir)) {
+            absSpec.replace(0, qdir.length(), "$(QTDIR)");
+            spec = absSpec;
+        }
+    }
+    return spec;
+}
+
+bool
+MakefileGenerator::openOutput(QFile &file) const
+{
+    {
+        QString outdir;
+        if(!file.name().isEmpty()) {
+            QFileInfo fi(file);
+            if(fi.isDir())
+                outdir = file.name() + QDir::separator();
+        }
+        if(!outdir.isEmpty() || file.name().isEmpty()) {
+            QString fname = "Makefile";
+            if(!project->isEmpty("MAKEFILE"))
+               fname = project->first("MAKEFILE");
+            file.setName(outdir + fname);
+        }
+    }
+    if(QDir::isRelativePath(file.name()))
+        file.setName(Option::output_dir + file.name()); //pwd when qmake was run
+    if(project->isEmpty("QMAKE_MAKEFILE"))
+        project->variables()["QMAKE_MAKEFILE"].append(file.name());
+    int slsh = file.name().findRev(Option::dir_sep);
+    if(slsh != -1)
+        createDir(file.name().left(slsh));
+    if(file.open(IO_WriteOnly | IO_Translate)) {
+        QFileInfo fi(Option::output);
+        QString od = Option::fixPathToTargetOS((fi.isSymLink() ? fi.readLink() : fi.dirPath()) );
+        if(QDir::isRelativePath(od))
+            od.prepend(Option::output_dir);
+        Option::output_dir = od;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
+
+//Factory thing
+#include "unixmake.h"
+#include "borland_bmake.h"
+#include "msvc_nmake.h"
+#include "msvc_dsp.h"
+#include "msvc_vcproj.h"
+#include "metrowerks_xml.h"
+#include "pbuilder_pbx.h"
+#include "projectgenerator.h"
+
+MakefileGenerator *
+MakefileGenerator::create(QMakeProject *proj)
+{
+    if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
+        return new ProjectGenerator(proj);
+
+    MakefileGenerator *mkfile = NULL;
+    QString gen = proj->first("MAKEFILE_GENERATOR");
+    if(gen.isEmpty()) {
+        fprintf(stderr, "No generator specified in config file: %s\n",
+                proj->projectFile().latin1());
+    } else if(gen == "UNIX") {
+        mkfile = new UnixMakefileGenerator(proj);
+    } else if(gen == "MSVC") {
+            // Visual Studio =< v6.0
+        if(proj->first("TEMPLATE").find(QRegExp("^vc.*")) != -1)
+            mkfile = new DspMakefileGenerator(proj);
+        else
+            mkfile = new NmakeMakefileGenerator(proj);
+    } else if(gen == "MSVC.NET") {
+            // Visual Studio >= v7.0
+        if(proj->first("TEMPLATE").find(QRegExp("^vc.*")) != -1)
+            mkfile = new VcprojGenerator(proj);
+        else
+            mkfile = new NmakeMakefileGenerator(proj);
+    } else if(gen == "BMAKE") {
+        mkfile = new BorlandMakefileGenerator(proj);
+    } else if(gen == "METROWERKS") {
+        mkfile = new MetrowerksMakefileGenerator(proj);
+    } else if(gen == "PROJECTBUILDER") {
+        mkfile = new ProjectBuilderMakefileGenerator(proj);
+    } else {
+        fprintf(stderr, "Unknown generator specified: %s\n", gen.latin1());
+    }
+    return mkfile;
+}
diff --git a/qmake/generators/makefile.h b/qmake/generators/makefile.h
new file mode 100644
index 0000000..1d19d98
--- a/dev/null
+++ b/qmake/generators/makefile.h
@@ -0,0 +1,173 @@
+/****************************************************************************
+** $Id$
+**
+** Definition of ________ class.
+**
+** Created : 970521
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the network module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition licenses may use this
+** file in accordance with the Qt Commercial License Agreement provided
+** with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#ifndef __MAKEFILE_H__
+#define __MAKEFILE_H__
+
+#include "option.h"
+#include "project.h"
+#include <qtextstream.h>
+
+class MakefileGenerator
+{
+    QString spec;
+    bool init_opath_already, init_already, moc_aware, no_io;
+    QStringList createObjectList(const QString &var);
+    QString build_args();
+    QMap<QString, QString> depHeuristics, depKeyMap;
+    QMap<QString, QString> mocablesToMOC, mocablesFromMOC;
+    QMap<QString, QStringList> depends;
+
+protected:
+    void writeObj(QTextStream &, const QString &obj, const QString &src);
+    void writeUicSrc(QTextStream &, const QString &ui);
+    void writeMocObj(QTextStream &, const QString &obj, const QString &src);
+    void writeMocSrc(QTextStream &, const QString &src);
+    void writeLexSrc(QTextStream &, const QString &lex);
+    void writeYaccSrc(QTextStream &, const QString &yac);
+    void writeInstalls(QTextStream &t, const QString &installs);
+    void writeImageObj(QTextStream &t, const QString &obj);
+    void writeImageSrc(QTextStream &t, const QString &images);
+
+protected:
+
+    QMakeProject *project;
+
+    class MakefileDependDir {
+    public:
+        MakefileDependDir(QString r, QString l) : real_dir(r), local_dir(l) { }
+        QString real_dir, local_dir;
+    };
+    bool generateDependencies(QPtrList<MakefileDependDir> &dirs, QString x, bool recurse);
+
+    QString buildArgs();
+
+    QString specdir();
+    QString cleanFilePath(const QString &file) const;
+    bool generateMocList(QString fn);
+
+    QString findMocSource(const QString &moc_file) const;
+    QString findMocDestination(const QString &src_file) const;
+    QStringList &findDependencies(const QString &file);
+
+    void setNoIO(bool o);
+    bool noIO() const;
+
+    void setMocAware(bool o);
+    bool mocAware() const;
+    void logicWarn(const QString &, const QString &);
+
+    virtual bool doDepends() const { return Option::mkfile::do_deps; }
+    bool writeHeader(QTextStream &);
+    virtual bool writeMakefile(QTextStream &);
+    virtual bool writeMakeQmake(QTextStream &);
+    void initOutPaths();
+    virtual void init();
+
+    //for installs
+    virtual QString defaultInstall(const QString &);
+
+    //for prl
+    bool processPrlFile(QString &);
+    virtual void processPrlVariable(const QString &, const QStringList &);
+    virtual void processPrlFiles();
+    virtual void writePrlFile(QTextStream &);
+
+    //make sure libraries are found
+    virtual bool findLibraries();
+
+    QString var(const QString &var);
+    QString varGlue(const QString &var, const QString &before, const QString &glue, const QString &after);
+    QString varList(const QString &var);
+    QString val(const QStringList &varList);
+    QString valGlue(const QStringList &varList, const QString &before, const QString &glue, const QString &after);
+    QString valList(const QStringList &varList);
+
+
+    QString fileFixify(const QString& file, const QString &out_dir=QString::null, 
+                    const QString &in_dir=QString::null, bool force_fix=FALSE) const;
+    QStringList fileFixify(const QStringList& files, const QString &out_dir=QString::null, 
+                    const QString &in_dir=QString::null, bool force_fix=FALSE) const;
+public:
+    MakefileGenerator(QMakeProject *p);
+    virtual ~MakefileGenerator();
+
+    static MakefileGenerator *create(QMakeProject *);
+    bool write();
+    virtual bool openOutput(QFile &) const;
+};
+
+inline QString MakefileGenerator::findMocSource(const QString &moc_file) const
+{
+    QString tmp = cleanFilePath(moc_file);
+    if (mocablesFromMOC.contains(tmp))
+        return mocablesFromMOC[tmp];
+    else
+        return QString("");
+}
+
+inline QString MakefileGenerator::findMocDestination(const QString &src_file) const
+{
+    QString tmp = cleanFilePath(src_file);
+    if (mocablesToMOC.contains(tmp))
+        return mocablesToMOC[tmp];
+    else
+        return QString("");
+}
+
+inline void MakefileGenerator::setMocAware(bool o)
+{ moc_aware = o; }
+
+inline bool MakefileGenerator::mocAware() const
+{ return moc_aware; }
+
+inline void MakefileGenerator::setNoIO(bool o)
+{ no_io = o; }
+
+inline bool MakefileGenerator::noIO() const
+{ return no_io; }
+
+inline QString MakefileGenerator::defaultInstall(const QString &)
+{ return QString(""); }
+
+inline bool MakefileGenerator::findLibraries()
+{ return TRUE; }
+
+inline MakefileGenerator::~MakefileGenerator()
+{ }
+
+
+#endif /* __MAKEFILE_H__ */
diff --git a/qmake/generators/projectgenerator.cpp b/qmake/generators/projectgenerator.cpp
new file mode 100644
index 0000000..5ff6250
--- a/dev/null
+++ b/qmake/generators/projectgenerator.cpp
@@ -0,0 +1,462 @@
+/****************************************************************************
+** $Id$
+**
+** Definition of ________ class.
+**
+** Created : 970521
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the network module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition licenses may use this
+** file in accordance with the Qt Commercial License Agreement provided
+** with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "projectgenerator.h"
+#include "option.h"
+#include <qdir.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+
+
+ProjectGenerator::ProjectGenerator(QMakeProject *p) : MakefileGenerator(p), init_flag(FALSE)
+{
+}
+
+void
+ProjectGenerator::init()
+{
+    if(init_flag)
+        return;
+    int file_count = 0;
+    init_flag = TRUE;
+
+    QMap<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);
+    v["TEMPLATE_ASSIGN"] += templ;
+
+    //figure out target
+    if(Option::output.name() == "-" || Option::output.name().isEmpty())
+        v["TARGET"] = QStringList("unknown");
+
+    //the scary stuff
+    if(project->first("TEMPLATE_ASSIGN") != "subdirs") {
+        QString builtin_regex;
+        { //calculate the builtin regular expression..
+            QStringList builtin_exts(".c");
+            builtin_exts << Option::ui_ext << Option::yacc_ext << Option::lex_ext;
+            builtin_exts += Option::h_ext + Option::cpp_ext;
+            for(QStringList::Iterator ext_it = builtin_exts.begin(); 
+                ext_it != builtin_exts.end(); ++ext_it) {
+                if(!builtin_regex.isEmpty())
+                    builtin_regex += "; ";
+                builtin_regex += QString("*") + (*ext_it);
+            }
+        }
+        QStringList dirs = Option::projfile::project_dirs;
+        if(Option::projfile::do_pwd)
+            dirs.prepend(QDir::currentDirPath());
+
+        for(QStringList::Iterator pd = dirs.begin(); pd != dirs.end(); pd++) {
+            QString dir, regex;
+            bool add_depend = FALSE;
+            if(QFile::exists((*pd))) {
+                QFileInfo fi((*pd));
+                if(fi.isDir()) {
+                    dir = (*pd);
+                    add_depend = TRUE;
+                    if(dir.right(1) != Option::dir_sep)
+                        dir += Option::dir_sep;
+                    if(Option::projfile::do_recursive) {
+                        QDir d(dir);
+                        d.setFilter(QDir::Dirs);
+                        for(int i = 0; i < (int)d.count(); i++) {
+                            if(d[i] != "." && d[i] != "..") 
+                                dirs.append(dir + d[i] + QDir::separator() + builtin_regex);
+                        }
+                    }
+                    regex = builtin_regex;
+                } else {
+                    QString file = (*pd);
+                    int s = file.findRev(Option::dir_sep);
+                    if(s != -1)
+                        dir = file.left(s+1);
+                    if(addFile(file)) {
+                        add_depend = TRUE;
+                        file_count++;
+                    }
+                }
+            } else { //regexp
+                regex = (*pd);
+            }
+            if(!regex.isEmpty()) {
+                int s = regex.findRev(Option::dir_sep);
+                if(s != -1) {
+                    dir = regex.left(s+1);
+                    regex = regex.right(regex.length() - (s+1));
+                }
+                if(Option::projfile::do_recursive) {
+                    QDir d(dir);
+                    d.setFilter(QDir::Dirs);
+                    for(int i = 0; i < (int)d.count(); i++) {
+                        if(d[i] != "." && d[i] != "..") 
+                            dirs.append(dir + d[i] + QDir::separator() + regex);
+                    }
+                }
+                QDir d(dir, regex);
+                for(int i = 0; i < (int)d.count(); i++) {
+                    QString file = dir + d[i];
+                    if (addFile(file)) {
+                        add_depend = TRUE;
+                        file_count++;
+                    }
+                }
+            }
+            if(add_depend && !dir.isEmpty() && !v["DEPENDPATH"].contains(dir)) {
+                QFileInfo fi(dir);
+                if(fi.absFilePath() != QDir::currentDirPath()) {
+                    v["DEPENDPATH"] += fileFixify(dir);
+                }
+            }
+        }
+    }
+    if(!file_count) { //shall we try a subdir?
+        QStringList dirs = Option::projfile::project_dirs;
+        if(Option::projfile::do_pwd)
+            dirs.prepend(".");
+        for(QStringList::Iterator pd = dirs.begin(); pd != dirs.end(); pd++) {
+            if(QFile::exists((*pd))) {
+                QString newdir = (*pd);
+                QFileInfo fi(newdir);
+                if(fi.isDir()) {
+                    newdir = fileFixify(newdir);
+                    QStringList &subdirs = v["SUBDIRS"];
+                    if(QFile::exists(fi.filePath() + QDir::separator() + fi.fileName() + ".pro") &&
+                       !subdirs.contains(newdir)) {
+                        subdirs.append(newdir);
+                    } else {
+                        QDir d(newdir, "*.pro");
+                        d.setFilter(QDir::Files);
+                        for(int i = 0; i < (int)d.count(); i++) {
+                            QString nd = newdir + QDir::separator() + d[i];
+                            fileFixify(nd);
+                            if(d[i] != "." && d[i] != ".." && !subdirs.contains(nd)) {
+                                if(newdir + d[i] != Option::output_dir + Option::output.name())
+                                    subdirs.append(nd);
+                            }
+                        }
+                    }
+                    if(Option::projfile::do_recursive) {
+                        QDir d(newdir);
+                        d.setFilter(QDir::Dirs);
+                        for(int i = 0; i < (int)d.count(); i++) {
+                            QString nd = fileFixify(newdir + QDir::separator() + d[i]);
+                            if(d[i] != "." && d[i] != ".." && !dirs.contains(nd))
+                                dirs.append(nd);
+                        }
+                    }
+                }
+            } else { //regexp
+                QString regx = (*pd), dir;
+                int s = regx.findRev(Option::dir_sep);
+                if(s != -1) {
+                    dir = regx.left(s+1);
+                    regx = regx.right(regx.length() - (s+1));
+                }
+                QDir d(dir, regx);
+                d.setFilter(QDir::Dirs);
+                QStringList &subdirs = v["SUBDIRS"];
+                for(int i = 0; i < (int)d.count(); i++) {
+                    QString newdir(dir + d[i]);
+                    QFileInfo fi(newdir);
+                    if(fi.fileName() != "." && fi.fileName() != "..") {
+                        newdir = fileFixify(newdir);
+                        if(QFile::exists(fi.filePath() + QDir::separator() + fi.fileName() + ".pro") &&
+                           !subdirs.contains(newdir)) {
+                           subdirs.append(newdir);
+                        } else {
+                            QDir d(newdir, "*.pro");
+                            d.setFilter(QDir::Files);
+                            for(int i = 0; i < (int)d.count(); i++) {
+                                QString nd = newdir + QDir::separator() + d[i];
+                                fileFixify(nd);
+                                if(d[i] != "." && d[i] != ".." && !subdirs.contains(nd)) {
+                                    if(newdir + d[i] != Option::output_dir + Option::output.name())
+                                        subdirs.append(nd);
+                                }
+                            }
+                        }
+                        if(Option::projfile::do_recursive && !dirs.contains(newdir))
+                            dirs.append(newdir);
+                    }
+                }
+            }
+        }
+        v["TEMPLATE_ASSIGN"] = "subdirs";
+        return;
+    }
+
+    QPtrList<MakefileDependDir> deplist;
+    deplist.setAutoDelete(TRUE);
+    {
+        QStringList &d = v["DEPENDPATH"];
+        for(QStringList::Iterator it = d.begin(); it != d.end(); ++it) {
+            QString r = (*it), l = Option::fixPathToLocalOS((*it));
+            deplist.append(new MakefileDependDir(r, l));
+        }
+    }
+    QStringList &h = v["HEADERS"];
+    bool no_qt_files = TRUE;
+    QString srcs[] = { "SOURCES", "YACCSOURCES", "LEXSOURCES", "INTERFACES", QString::null };
+    for(int i = 0; !srcs[i].isNull(); i++) {
+        QStringList &l = v[srcs[i]];
+        for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
+            if(generateDependencies(deplist, (*val_it), TRUE)) {
+                QStringList &tmp = findDependencies((*val_it));
+                if(!tmp.isEmpty()) {
+                    for(QStringList::Iterator dep_it = tmp.begin(); dep_it != tmp.end(); ++dep_it) {
+                        QString file_no_path = (*dep_it).right(
+                            (*dep_it).length() - ((*dep_it).findRev(Option::dir_sep)+1));
+                        if(no_qt_files && file_no_path.find(QRegExp("^q[a-z_0-9].h$")) != -1)
+                            no_qt_files = FALSE;
+                        QString h_ext;
+                        for(QStringList::Iterator hit = Option::h_ext.begin(); hit != Option::h_ext.end(); ++hit) {
+                            if((*dep_it).endsWith((*hit))) {
+                                h_ext = (*hit);
+                                break;
+                            }
+                        }
+                        if(!h_ext.isEmpty()) {
+                            if((*dep_it).left(1).lower() == "q") {
+                                QString qhdr = (*dep_it).lower();
+                                if(file_no_path == "qthread.h")
+                                    addConfig("thread");
+                            }
+                            for(QStringList::Iterator cppit = Option::cpp_ext.begin();
+                                cppit != Option::cpp_ext.end(); ++cppit) {
+                                QString src((*dep_it).left((*dep_it).length() - h_ext.length()) + (*cppit));
+                                if(QFile::exists(src)) {
+                                    bool exists = FALSE;
+                                    QStringList &srcl = v["SOURCES"];
+                                    for(QStringList::Iterator src_it = srcl.begin(); src_it != srcl.end(); ++src_it) {
+                                        if((*src_it).lower() == src.lower()) {
+                                            exists = TRUE;
+                                            break;
+                                        }
+                                    }
+                                    if(!exists)
+                                        srcl.append(src);
+                                }
+                            }
+                        } else if((*dep_it).endsWith(Option::lex_ext) &&
+                                  file_no_path.startsWith(Option::lex_mod)) {
+                            addConfig("lex_included");
+                        }
+                        if(!h.contains((*dep_it))) {
+                            if(generateMocList((*dep_it)) && !findMocDestination((*dep_it)).isEmpty())
+                                h += (*dep_it);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if(h.isEmpty())
+        addConfig("moc", FALSE);
+
+    //if we find a file that matches an forms it needn't be included in the project
+    QStringList &u = v["INTERFACES"];
+    QString no_ui[] = { "SOURCES", "HEADERS", QString::null };
+    {
+        for(int i = 0; !no_ui[i].isNull(); i++) {
+            QStringList &l = v[no_ui[i]];
+            for(QStringList::Iterator val_it = l.begin(); val_it != l.end(); ) {
+                bool found = FALSE;
+                for(QStringList::Iterator ui_it = u.begin(); ui_it != u.end(); ++ui_it) {
+                    QString s1 = (*val_it).right((*val_it).length() - ((*val_it).findRev(Option::dir_sep) + 1));
+                    if(s1.findRev('.') != -1)
+                        s1 = s1.left(s1.findRev('.')) + Option::ui_ext;
+                    QString u1 = (*ui_it).right((*ui_it).length() - ((*ui_it).findRev(Option::dir_sep) + 1));
+                    if(s1 == u1) {
+                        found = TRUE;
+                        break;
+                    }
+                }
+                if(!found && (*val_it).endsWith(Option::moc_ext))
+                    found = TRUE;
+                if(found)
+                    val_it = l.remove(val_it);
+                else
+                    ++val_it;
+            }
+        }
+    }
+}
+
+
+bool
+ProjectGenerator::writeMakefile(QTextStream &t)
+{
+    t << "######################################################################" << endl;
+    t << "# Automatically generated by qmake (" << qmake_version() << ") " << QDateTime::currentDateTime().toString() << endl;
+    t << "######################################################################" << endl << endl;
+    QStringList::Iterator it;
+    for(it = Option::before_user_vars.begin(); it != Option::before_user_vars.end(); ++it)
+        t << (*it) << endl;
+    t << getWritableVar("TEMPLATE_ASSIGN", FALSE);
+    if(project->first("TEMPLATE_ASSIGN") == "subdirs") {
+        t << endl << "# Directories" << "\n"
+          << getWritableVar("SUBDIRS");
+    } else {
+        t << getWritableVar("TARGET")
+          << getWritableVar("CONFIG", FALSE)
+          << getWritableVar("CONFIG_REMOVE", FALSE)
+          << getWritableVar("DEPENDPATH") << endl;
+
+        t << "# Input" << "\n";
+        t << getWritableVar("HEADERS") 
+          << getWritableVar("INTERFACES") 
+          << getWritableVar("LEXSOURCES") 
+          << getWritableVar("YACCSOURCES") 
+          << getWritableVar("SOURCES");
+    }
+    for(it = Option::after_user_vars.begin(); it != Option::after_user_vars.end(); ++it)
+        t << (*it) << endl;
+    return TRUE;
+}
+
+bool
+ProjectGenerator::addConfig(const QString &cfg, bool add)
+{
+    QString where = "CONFIG";
+    if(!add)
+        where = "CONFIG_REMOVE";
+    if(!project->variables()[where].contains(cfg)) {
+        project->variables()[where] += cfg;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
+bool
+ProjectGenerator::addFile(QString file)
+{
+    file = fileFixify(file, QDir::currentDirPath());
+    QString dir;
+    int s = file.findRev(Option::dir_sep);
+    if(s != -1)
+        dir = file.left(s+1);
+    if(file.mid(dir.length(), Option::moc_mod.length()) == Option::moc_mod)
+        return FALSE;
+
+    QString where;
+    for(QStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit) {
+        if(file.endsWith((*cppit))) {
+            if(QFile::exists(file.left(file.length() - (*cppit).length()) + Option::ui_ext))
+                return FALSE;
+            else
+                where = "SOURCES";
+            break;
+        }
+    }
+    if(where.isEmpty()) {
+        for(QStringList::Iterator hit = Option::h_ext.begin(); hit != Option::h_ext.end(); ++hit) {
+            if(file.endsWith((*hit))) {
+                where = "HEADERS";
+                break;
+            }
+        }
+    }
+    if(where.isEmpty()) {
+        if(file.endsWith(Option::ui_ext))
+            where = "INTERFACES";
+        else if(file.endsWith(".c"))
+            where = "SOURCES";
+        else if(file.endsWith(Option::lex_ext))
+            where = "LEXSOURCES";
+        else if(file.endsWith(Option::yacc_ext))
+            where = "YACCSOURCES";
+    }
+
+    QString newfile = fileFixify(file);
+    if(!where.isEmpty() && !project->variables()[where].contains(file)) {
+        project->variables()[where] += newfile;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
+QString
+ProjectGenerator::getWritableVar(const QString &v, bool /*fixPath*/)
+{
+    QStringList &vals = project->variables()[v];
+    if(vals.isEmpty())
+        return "";
+
+    QString ret;
+    if(v.endsWith("_REMOVE"))
+        ret = v.left(v.length() - 7) + " -= ";
+    else if(v.endsWith("_ASSIGN"))
+        ret = v.left(v.length() - 7) + " = ";
+    else
+        ret = v + " += ";
+    QString join = vals.join(" ");
+    if(ret.length() + join.length() > 80) {
+        QString spaces;
+        for(unsigned int i = 0; i < ret.length(); i++)
+            spaces += " ";
+        join = vals.join(" \\\n" + spaces);
+    } 
+    // ### Commented out for now so that project generation works.
+    // Sam: can you look at why this was needed?
+    /*    if(fixPath)
+        join = join.replace("\\", "/");*/
+    return ret + join + "\n";
+}
+
+bool
+ProjectGenerator::openOutput(QFile &file) const
+{
+    QString outdir;
+    if(!file.name().isEmpty()) {
+        QFileInfo fi(file);
+        if(fi.isDir())
+            outdir = fi.dirPath() + QDir::separator();
+    }
+    if(!outdir.isEmpty() || file.name().isEmpty()) {
+        QString dir = QDir::currentDirPath();
+        int s = dir.findRev('/');
+        if(s != -1)
+            dir = dir.right(dir.length() - (s + 1));
+        file.setName(outdir + dir + ".pro");
+    }
+    return MakefileGenerator::openOutput(file);
+}
diff --git a/qmake/generators/projectgenerator.h b/qmake/generators/projectgenerator.h
new file mode 100644
index 0000000..055a784
--- a/dev/null
+++ b/qmake/generators/projectgenerator.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+** $Id$
+**
+** Definition of ________ class.
+**
+** Created : 970521
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the network module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition licenses may use this
+** file in accordance with the Qt Commercial License Agreement provided
+** with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#ifndef __PROJECTGENERATOR_H__
+#define __PROJECTGENERATOR_H__
+
+#include "makefile.h"
+
+class ProjectGenerator : public MakefileGenerator
+{
+    bool init_flag;
+    bool addFile(QString);
+    bool addConfig(const QString &, bool add=TRUE);
+    QString getWritableVar(const QString &, bool fixPath=TRUE);
+protected:
+    virtual void init();
+    virtual bool writeMakefile(QTextStream &);
+public:
+    ProjectGenerator(QMakeProject *p);
+    ~ProjectGenerator();
+    virtual bool openOutput(QFile &) const;
+};
+
+inline ProjectGenerator::~ProjectGenerator()
+{ }
+
+
+#endif /* __PROJECTGENERATOR_H__ */
diff --git a/qmake/include/qmake/qconfig.h b/qmake/include/qmake/qconfig.h
new file mode 100644
index 0000000..bba8fbd
--- a/dev/null
+++ b/qmake/include/qmake/qconfig.h
@@ -0,0 +1 @@
+/* All features enabled while building qmake */
diff --git a/qmake/include/qmake/qmodules.h b/qmake/include/qmake/qmodules.h
new file mode 100644
index 0000000..ce5fcc7
--- a/dev/null
+++ b/qmake/include/qmake/qmodules.h
@@ -0,0 +1 @@
+/* All modules enabled while building qmake */