/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the qmake application of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "unixmake.h"

#include "option.h"

#include "meta.h"

#include <qregexp.h>

#include <qbytearray.h>

#include <qfile.h>

#include <qdir.h>

#include <qdatetime.h>

#include <qdebug.h>

#include <time.h>

QT_BEGIN_NAMESPACE

UnixMakefileGenerator::UnixMakefileGenerator() : MakefileGenerator(), init_flag(false), include_deps(false)

{

}

void

UnixMakefileGenerator::writePrlFile(QTextStream &t)

{

    MakefileGenerator::writePrlFile(t);

    // libtool support

    if(project->isActiveConfig("create_libtool") && project->first("TEMPLATE") == "lib") { //write .la

        if(project->isActiveConfig("compile_libtool"))

            warn_msg(WarnLogic, "create_libtool specified with compile_libtool can lead to conflicting .la\n"

                     "formats, create_libtool has been disabled\n");

        else

            writeLibtoolFile();

    }

    // pkg-config support

    if(project->isActiveConfig("create_pc") && project->first("TEMPLATE") == "lib")

        writePkgConfigFile();

}

bool

UnixMakefileGenerator::writeMakefile(QTextStream &t)

{

    writeHeader(t);

    if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {

        t << "QMAKE    = " << var("QMAKE_QMAKE") << endl;

        QStringList &qut = project->values("QMAKE_EXTRA_TARGETS");

        for(QStringList::ConstIterator it = qut.begin(); it != qut.end(); ++it)

            t << *it << " ";

        t << "first all clean install distclean uninstall qmake_all:" << "\n\t"

          << "@echo \"Some of the required modules ("

          << var("QMAKE_FAILED_REQUIREMENTS") << ") are not available.\"" << "\n\t"

          << "@echo \"Skipped.\"" << endl << endl;

        writeMakeQmake(t);

        if(project->isEmpty("QMAKE_NOFORCE"))

            t << "FORCE:" << endl << endl;

        return true;

    }

    if (project->values("TEMPLATE").first() == "app" ||

        project->values("TEMPLATE").first() == "lib") {

        if(Option::mkfile::do_stub_makefile && MakefileGenerator::writeStubMakefile(t))

            return true;

        writeMakeParts(t);

        return MakefileGenerator::writeMakefile(t);

    } else if(project->values("TEMPLATE").first() == "subdirs") {

        MakefileGenerator::writeSubDirs(t);

        return true;

    }

    return false;

}

void

UnixMakefileGenerator::writeMakeParts(QTextStream &t)

{

    QString deps = fileFixify(Option::output.fileName()), target_deps, prl;

    bool do_incremental = (project->isActiveConfig("incremental") &&

                           !project->values("QMAKE_INCREMENTAL").isEmpty() &&

                           (!project->values("QMAKE_APP_FLAG").isEmpty() ||

                            (!project->isActiveConfig("staticlib")))),

         src_incremental=false;

    t << "####### Compiler, tools and options" << endl << endl;

    t << "CC            = " << var("QMAKE_CC") << endl;

    t << "CXX           = " << var("QMAKE_CXX") << endl;

    t << "DEFINES       = "

      << varGlue("PRL_EXPORT_DEFINES","-D"," -D"," ")

      << varGlue("DEFINES","-D"," -D","") << endl;

    t << "CFLAGS        = " << var("QMAKE_CFLAGS") << " $(DEFINES)" << endl;

    t << "CXXFLAGS      = " << var("QMAKE_CXXFLAGS") << " $(DEFINES)" << endl;

    t << "INCPATH       = " << "-I" << specdir();

    if(!project->isActiveConfig("no_include_pwd")) {

        QString pwd = escapeFilePath(fileFixify(qmake_getpwd()));

        if(pwd.isEmpty())

            pwd = ".";

        t << " -I" << pwd;

    }

    {

        const QStringList &incs = project->values("INCLUDEPATH");

        for(int i = 0; i < incs.size(); ++i) {

            QString inc = escapeFilePath(incs.at(i));

            if(!inc.isEmpty())

                t << " " << "-I" << inc;

        }

    }

    if(!project->isEmpty("QMAKE_FRAMEWORKPATH_FLAGS"))

       t << " " << var("QMAKE_FRAMEWORKPATH_FLAGS");

    t << endl;

    if(!project->isActiveConfig("staticlib")) {

        t << "LINK          = " << var("QMAKE_LINK") << endl;

        t << "LFLAGS        = " << var("QMAKE_LFLAGS") << endl;

        t << "LIBS          = " << "$(SUBLIBS) " << var("QMAKE_FRAMEWORKPATH_FLAGS") << " "

          << var("QMAKE_LIBDIR_FLAGS") << " " << var("QMAKE_LIBS") << " " << var("QMAKE_LIBS_PRIVATE") << endl;

    }

    t << "AR            = " << var("QMAKE_AR") << endl;

    t << "RANLIB        = " << var("QMAKE_RANLIB") << endl;

    t << "QMAKE         = " << var("QMAKE_QMAKE") << endl;

    t << "TAR           = " << var("QMAKE_TAR") << endl;

    t << "COMPRESS      = " << var("QMAKE_GZIP") << endl;

    if(project->isActiveConfig("compile_libtool"))

        t << "LIBTOOL       = " << var("QMAKE_LIBTOOL") << endl;

    t << "COPY          = " << var("QMAKE_COPY") << endl;

    t << "SED           = " << var("QMAKE_STREAM_EDITOR") << endl;

    t << "COPY_FILE     = " << var("QMAKE_COPY_FILE") << endl;

    t << "COPY_DIR      = " << var("QMAKE_COPY_DIR") << endl;

    t << "STRIP         = " << var("QMAKE_STRIP") << endl;

    t << "INSTALL_FILE  = " << var("QMAKE_INSTALL_FILE") << endl;

    t << "INSTALL_DIR   = " << var("QMAKE_INSTALL_DIR") << endl;

    t << "INSTALL_PROGRAM = " << var("QMAKE_INSTALL_PROGRAM") << endl;

    t << "DEL_FILE      = " << var("QMAKE_DEL_FILE") << endl;

    t << "SYMLINK       = " << var("QMAKE_SYMBOLIC_LINK") << endl;

    t << "DEL_DIR       = " << var("QMAKE_DEL_DIR") << endl;

    t << "MOVE          = " << var("QMAKE_MOVE") << endl;

    t << "CHK_DIR_EXISTS= " << var("QMAKE_CHK_DIR_EXISTS") << endl;

    t << "MKDIR         = " << var("QMAKE_MKDIR") << endl;

    if(!project->isEmpty("QMAKE_MACOSX_DEPLOYMENT_TARGET"))

        t << "export MACOSX_DEPLOYMENT_TARGET = " //exported to children processes

          << project->first("QMAKE_MACOSX_DEPLOYMENT_TARGET") << endl;

    if (!project->isEmpty("QMAKE_SYMBIAN_SHLIB")) {

        t << "vpath %.dso " << project->values("QMAKE_LIBDIR").join(":") << endl;

        t << "vpath %.lib " << project->values("QMAKE_LIBDIR").join(":") << endl;

    }

    t << endl;

    t << "####### Output directory" << endl << endl;

    if (! project->values("OBJECTS_DIR").isEmpty())

        t << "OBJECTS_DIR   = " << var("OBJECTS_DIR") << endl;

    else

        t << "OBJECTS_DIR   = ./" << endl;

    t << endl;

    /* files */

    t << "####### Files" << endl << endl;

    t << "SOURCES       = " << valList(escapeFilePaths(project->values("SOURCES"))) << " "

      << valList(escapeFilePaths(project->values("GENERATED_SOURCES"))) << endl;

    if(do_incremental) {

        QStringList &objs = project->values("OBJECTS"), &incrs = project->values("QMAKE_INCREMENTAL"), incrs_out;

        t << "OBJECTS       = ";

        for(QStringList::Iterator objit = objs.begin(); objit != objs.end(); ++objit) {

            bool increment = false;

            for(QStringList::Iterator incrit = incrs.begin(); incrit != incrs.end(); ++incrit) {

                if((*objit).indexOf(QRegExp((*incrit), Qt::CaseSensitive,

                                    QRegExp::Wildcard)) != -1) {

                    increment = true;

                    incrs_out.append((*objit));

                    break;

                }

            }

            if(!increment)

                t << "\\\n\t\t" << (*objit);

        }

        if(incrs_out.count() == objs.count()) { //we just switched places, no real incrementals to be done!

            t << escapeFilePaths(incrs_out).join(" \\\n\t\t") << endl;

        } else if(!incrs_out.count()) {

            t << endl;

        } else {

            src_incremental = true;

            t << endl;

            t << "INCREMENTAL_OBJECTS = " << escapeFilePaths(incrs_out).join(" \\\n\t\t") << endl;

        }

    } else {

        t << "OBJECTS       = " << valList(escapeFilePaths(project->values("OBJECTS"))) << endl;

    }

    if(do_incremental && !src_incremental)

        do_incremental = false;

    t << "DIST          = " << valList(fileFixify(project->values("DISTFILES"))) << endl;

    t << "QMAKE_TARGET  = " << var("QMAKE_ORIG_TARGET") << endl;

    t << "DESTDIR       = " << var("DESTDIR") << endl;

    if(project->isActiveConfig("compile_libtool"))

        t << "TARGETL       = " << var("TARGET_la") << endl;

    t << "TARGET        = " << escapeFilePath(var("TARGET")) << endl;

    if(project->isActiveConfig("plugin")) {

        t << "TARGETD       = " << escapeFilePath(var("TARGET")) << endl;

    } else if(!project->isActiveConfig("staticlib") && project->values("QMAKE_APP_FLAG").isEmpty()) {

        t << "TARGETA       = " << escapeFilePath(var("TARGETA")) << endl;

        if(!project->isEmpty("QMAKE_BUNDLE")) {

            t << "TARGETD       = " << escapeFilePath(var("TARGET_x.y")) << endl;

            t << "TARGET0       = " << escapeFilePath(var("TARGET_")) << endl;

        } else if(!project->isEmpty("QMAKE_SYMBIAN_SHLIB")) {

            t << "TARGETD       = " << escapeFilePath(var("TARGET")) << endl;

        } else if(project->isEmpty("QMAKE_HPUX_SHLIB")) {

            t << "TARGETD       = " << escapeFilePath(var("TARGET_x.y.z")) << endl;

            t << "TARGET0       = " << escapeFilePath(var("TARGET_")) << endl;

            t << "TARGET1       = " << escapeFilePath(var("TARGET_x")) << endl;

            t << "TARGET2       = " << escapeFilePath(var("TARGET_x.y")) << endl;

        } else {

            t << "TARGETD       = " << escapeFilePath(var("TARGET_x")) << endl;

            t << "TARGET0       = " << escapeFilePath(var("TARGET_")) << endl;

        }

    }

    writeExtraCompilerVariables(t);

    writeExtraVariables(t);

    t << endl;

    // blasted includes

    QStringList &qeui = project->values("QMAKE_EXTRA_INCLUDES");

    QStringList::Iterator it;

    for(it = qeui.begin(); it != qeui.end(); ++it)

        t << "include " << (*it) << endl;

    /* rules */

    t << "first: all" << endl;

    t << "####### Implicit rules" << endl << endl;

    t << ".SUFFIXES: " << Option::obj_ext;

    for(QStringList::Iterator cit = Option::c_ext.begin(); cit != Option::c_ext.end(); ++cit)

        t << " " << (*cit);

    for(QStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit)

        t << " " << (*cppit);

    t << endl << endl;

    for(QStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit)

        t << (*cppit) << Option::obj_ext << ":\n\t" << var("QMAKE_RUN_CXX_IMP") << endl << endl;

    for(QStringList::Iterator cit = Option::c_ext.begin(); cit != Option::c_ext.end(); ++cit)

        t << (*cit) << Option::obj_ext << ":\n\t" << var("QMAKE_RUN_CC_IMP") << endl << endl;

    if(include_deps) {

        QString cmd=var("QMAKE_CFLAGS_DEPS") + " ";

        cmd += varGlue("DEFINES","-D"," -D","") + varGlue("PRL_EXPORT_DEFINES"," -D"," -D","");

        if(!project->isEmpty("QMAKE_ABSOLUTE_SOURCE_PATH"))

            cmd += " -I" + project->first("QMAKE_ABSOLUTE_SOURCE_PATH") + " ";

        cmd += " $(INCPATH) " + varGlue("DEPENDPATH", "-I", " -I", "");

        QString odir;

        if(!project->values("OBJECTS_DIR").isEmpty())

            odir = project->first("OBJECTS_DIR");

        t << "###### Dependencies" << endl << endl;

        t << odir << ".deps/%.d: %.cpp\n\t";

        if(project->isActiveConfig("echo_depend_creation"))

            t << "@echo Creating depend for $<" << "\n\t";

        t << mkdir_p_asstring("$(@D)") << "\n\t"

          << "@$(CXX) " << cmd << " $< | sed \"s,^\\($(*F).o\\):," << odir << "\\1:,g\" >$@" << endl << endl;

        t << odir << ".deps/%.d: %.c\n\t";

        if(project->isActiveConfig("echo_depend_creation"))

            t << "@echo Creating depend for $<" << "\n\t";

        t << mkdir_p_asstring("$(@D)") << "\n\t"

          << "@$(CC) " << cmd << " $< | sed \"s,^\\($(*F).o\\):," << odir << "\\1:,g\" >$@" << endl << endl;

        QString src[] = { "SOURCES", "GENERATED_SOURCES", QString() };

        for(int x = 0; !src[x].isNull(); x++) {

            QStringList &l = project->values(src[x]);

            for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {

                if(!(*it).isEmpty()) {

                    QString d_file;

                    for(QStringList::Iterator cit = Option::c_ext.begin();

                        cit != Option::c_ext.end(); ++cit) {

                        if((*it).endsWith((*cit))) {

                            d_file = (*it).left((*it).length() - (*cit).length());

                            break;

                        }

                    }

                    if(d_file.isEmpty()) {

                        for(QStringList::Iterator cppit = Option::cpp_ext.begin();

                            cppit != Option::cpp_ext.end(); ++cppit) {

                            if((*it).endsWith((*cppit))) {

                                d_file = (*it).left((*it).length() - (*cppit).length());

                                break;

                            }

                        }

                    }

                    if(!d_file.isEmpty()) {

                        d_file = odir + ".deps/" + d_file + ".d";

                        QStringList deps = findDependencies((*it)).filter(QRegExp(Option::cpp_moc_ext + "$"));

                        if(!deps.isEmpty())

                            t << d_file << ": " << deps.join(" ") << endl;

                        t << "-include " << d_file << endl;

                        project->values("QMAKE_DISTCLEAN") += d_file;

                    }

                }

            }

        }

    }

    t << "####### Build rules" << endl << endl;

    if(!project->values("SUBLIBS").isEmpty()) {

        QString libdir = "tmp/";

        if(!project->isEmpty("SUBLIBS_DIR"))

            libdir = project->first("SUBLIBS_DIR");

        t << "SUBLIBS       = ";

        QStringList &l = project->values("SUBLIBS");

        for(QStringList::Iterator it = l.begin(); it != l.end(); ++it)

            t << libdir << project->first("QMAKE_PREFIX_STATICLIB") << (*it) << "."

              << project->first("QMAKE_EXTENSION_STATICLIB") << " ";

        t << endl << endl;

    }

    if(project->isActiveConfig("depend_prl") && !project->isEmpty("QMAKE_PRL_INTERNAL_FILES")) {

        QStringList &l = project->values("QMAKE_PRL_INTERNAL_FILES");

        QStringList::Iterator it;

        for(it = l.begin(); it != l.end(); ++it) {

            QMakeMetaInfo libinfo;

            if(libinfo.readLib((*it)) && !libinfo.isEmpty("QMAKE_PRL_BUILD_DIR")) {

                QString dir;

                int slsh = (*it).lastIndexOf(Option::dir_sep);

                if(slsh != -1)

                    dir = (*it).left(slsh + 1);

                QString targ = dir + libinfo.first("QMAKE_PRL_TARGET");

                target_deps += " " + targ;

                t << targ << ":" << "\n\t"

                  << "@echo \"Creating '" << targ << "'\"" << "\n\t"

                  << "(cd " << libinfo.first("QMAKE_PRL_BUILD_DIR") << ";"

                  << "$(MAKE))" << endl;

            }

        }

    }

    if(!project->values("QMAKE_APP_FLAG").isEmpty()) {

        QString destdir = project->first("DESTDIR");

        if(!project->isEmpty("QMAKE_BUNDLE")) {

            QString bundle_loc = project->first("QMAKE_BUNDLE_LOCATION");

            if(!bundle_loc.isEmpty() && !bundle_loc.startsWith("/"))

                bundle_loc.prepend("/");

            if(!bundle_loc.endsWith("/"))

                bundle_loc += "/";

            destdir += project->first("QMAKE_BUNDLE") + bundle_loc;

        }

        if(do_incremental) {

            //incremental target

            QString incr_target = var("TARGET") + "_incremental";

            if(incr_target.indexOf(Option::dir_sep) != -1)

                incr_target = incr_target.right(incr_target.length() -

                                                (incr_target.lastIndexOf(Option::dir_sep) + 1));

            QString incr_deps, incr_objs;

            if(project->first("QMAKE_INCREMENTAL_STYLE") == "ld") {

                QString incr_target_dir = var("OBJECTS_DIR") + incr_target + Option::obj_ext;

                //actual target

                t << incr_target_dir << ": $(OBJECTS)" << "\n\t"

                  << "ld -r  -o "<< incr_target_dir << " $(OBJECTS)" << endl;

                //communicated below

                deps.prepend(incr_target_dir + " ");

                incr_deps = "$(INCREMENTAL_OBJECTS)";

                if(!incr_objs.isEmpty())

                    incr_objs += " ";

                incr_objs += incr_target_dir;

            } else {

                //actual target

                QString incr_target_dir = var("DESTDIR") + "lib" + incr_target + "." +

                                          project->values("QMAKE_EXTENSION_SHLIB").first();

                QString incr_lflags = var("QMAKE_LFLAGS_SHLIB") + " ";

                if(project->isActiveConfig("debug"))

                    incr_lflags += var("QMAKE_LFLAGS_DEBUG");

                else

                    incr_lflags += var("QMAKE_LFLAGS_RELEASE");

                t << incr_target_dir << ": $(INCREMENTAL_OBJECTS)" << "\n\t";

                if(!destdir.isEmpty())

                    t << "\n\t" << mkdir_p_asstring(destdir) << "\n\t";

                t << "$(LINK) " << incr_lflags << " -o "<< incr_target_dir <<

                    " $(INCREMENTAL_OBJECTS)" << endl;

                //communicated below

                if(!destdir.isEmpty()) {

                    if(!incr_objs.isEmpty())

                        incr_objs += " ";

                    incr_objs += "-L" + destdir;

                } else {

                    if(!incr_objs.isEmpty())

                        incr_objs += " ";

                    incr_objs += "-L" + qmake_getpwd();

                }

                if(!incr_objs.isEmpty())

                    incr_objs += " ";

                incr_objs += " -l" + incr_target;

                deps.prepend(incr_target_dir + " ");

                incr_deps = "$(OBJECTS)";

            }

            t << "all: " << escapeDependencyPath(deps) <<  " " << valGlue(escapeDependencyPaths(project->values("ALL_DEPS")),""," "," ") <<  "$(TARGET)"

              << endl << endl;

            //real target

            t << var("TARGET") << ": " << var("PRE_TARGETDEPS") << " " << incr_deps << " " << target_deps

              << " " << var("POST_TARGETDEPS") << "\n\t";

            if(!destdir.isEmpty())

                t << "\n\t" << mkdir_p_asstring(destdir) << "\n\t";

            if(!project->isEmpty("QMAKE_PRE_LINK"))

                t << var("QMAKE_PRE_LINK") << "\n\t";

            t << "$(LINK) $(LFLAGS) -o $(TARGET) " << incr_deps << " " << incr_objs << " $(OBJCOMP) $(LIBS)";

            if(!project->isEmpty("QMAKE_POST_LINK"))

                t << "\n\t" << var("QMAKE_POST_LINK");

            t << endl << endl;

        } else {

            t << "all: " << escapeDependencyPath(deps) <<  " " << valGlue(escapeDependencyPaths(project->values("ALL_DEPS")),""," "," ") <<  "$(TARGET)"

              << endl << endl;

            t << "$(TARGET): " << var("PRE_TARGETDEPS") << " $(OBJECTS) "

              << target_deps << " " << var("POST_TARGETDEPS") << "\n\t";

            if(!destdir.isEmpty())

                t << mkdir_p_asstring(destdir) << "\n\t";

            if(!project->isEmpty("QMAKE_PRE_LINK"))

                t << var("QMAKE_PRE_LINK") << "\n\t";

            t << "$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJCOMP) $(LIBS)";

            if(!project->isEmpty("QMAKE_POST_LINK"))

                t << "\n\t" << var("QMAKE_POST_LINK");

            t << endl << endl;

        }

    } else if(!project->isActiveConfig("staticlib")) {

        QString destdir = unescapeFilePath(project->first("DESTDIR")), incr_deps;

        if(!project->isEmpty("QMAKE_BUNDLE")) {

            QString bundle_loc = project->first("QMAKE_BUNDLE_LOCATION");

            if(!bundle_loc.isEmpty() && !bundle_loc.startsWith("/"))

                bundle_loc.prepend("/");

            if(!bundle_loc.endsWith("/"))

                bundle_loc += "/";

            destdir += project->first("QMAKE_BUNDLE") + bundle_loc;

        }

        destdir = escapeFilePath(destdir);

        if(do_incremental) {

            QString s_ext = project->values("QMAKE_EXTENSION_SHLIB").first();

            QString incr_target = var("QMAKE_ORIG_TARGET").replace(

                QRegExp("\\." + s_ext), "").replace(QRegExp("^lib"), "") + "_incremental";

            if(incr_target.indexOf(Option::dir_sep) != -1)

                incr_target = incr_target.right(incr_target.length() -

                                                (incr_target.lastIndexOf(Option::dir_sep) + 1));

            incr_target = escapeFilePath(incr_target);

            if(project->first("QMAKE_INCREMENTAL_STYLE") == "ld") {

                QString incr_target_dir = escapeFilePath(var("OBJECTS_DIR") + incr_target + Option::obj_ext);

                //actual target

                const QString link_deps = "$(OBJECTS) ";

                t << incr_target_dir << ": " << link_deps << "\n\t"

                  << "ld -r  -o " << incr_target_dir << " " << link_deps << endl;

                //communicated below

                QStringList &cmd = project->values("QMAKE_LINK_SHLIB_CMD");

                cmd.first().replace("$(OBJECTS) ", "$(INCREMENTAL_OBJECTS)"); //ick

                cmd.append(incr_target_dir);

                deps.prepend(incr_target_dir + " ");

                incr_deps = "$(INCREMENTAL_OBJECTS)";

            } else {

                //actual target

                QString incr_target_dir = escapeFilePath(destdir + "lib" + incr_target + "." + s_ext);

                QString incr_lflags = var("QMAKE_LFLAGS_SHLIB") + " ";

                if(!project->isEmpty("QMAKE_LFLAGS_INCREMENTAL"))

                    incr_lflags += var("QMAKE_LFLAGS_INCREMENTAL") + " ";

                if(project->isActiveConfig("debug"))

                    incr_lflags += var("QMAKE_LFLAGS_DEBUG");

                else

                    incr_lflags += var("QMAKE_LFLAGS_RELEASE");

                t << incr_target_dir << ": $(INCREMENTAL_OBJECTS)" << "\n\t";

                if(!destdir.isEmpty())

                    t << mkdir_p_asstring(destdir) << "\n\t";

                t << "$(LINK) " << incr_lflags << " -o "<< incr_target_dir <<

                    " $(INCREMENTAL_OBJECTS)" << endl;

                //communicated below

                QStringList &cmd = project->values("QMAKE_LINK_SHLIB_CMD");

                if(!destdir.isEmpty())

                    cmd.append(" -L" + destdir);

                cmd.append(" -l" + incr_target);

                deps.prepend(incr_target_dir + " ");

                incr_deps = "$(OBJECTS)";

            }

            t << "all: " << " " << escapeDependencyPath(deps) << " " << valGlue(escapeDependencyPaths(project->values("ALL_DEPS")),""," "," ")

              << " " << destdir << "$(TARGET)" << endl << endl;

            //real target

            t << destdir << "$(TARGET): " << var("PRE_TARGETDEPS") << " "

              << incr_deps << " $(SUBLIBS) " << target_deps << " " << var("POST_TARGETDEPS");

        } else {

            t << "all: " << escapeDependencyPath(deps) << " " << valGlue(escapeDependencyPaths(project->values("ALL_DEPS")),""," "," ") << " " <<

                destdir << "$(TARGET)" << endl << endl;

            t << destdir << "$(TARGET): " << var("PRE_TARGETDEPS")

              << " $(OBJECTS) $(SUBLIBS) $(OBJCOMP) " << target_deps

              << " " << var("POST_TARGETDEPS");

        }

        if(!destdir.isEmpty())

            t << "\n\t" << mkdir_p_asstring(destdir);

        if(!project->isEmpty("QMAKE_PRE_LINK"))

            t << "\n\t" << var("QMAKE_PRE_LINK");