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

**

** 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 <qregexp.h>

#include <qfile.h>

#include <qhash.h>

#include <qdir.h>

#include <time.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

void

UnixMakefileGenerator::init()

{

    if(init_flag)

        return;

    init_flag = true;

    if(project->isEmpty("QMAKE_EXTENSION_SHLIB")) {

        if(project->isEmpty("QMAKE_CYGWIN_SHLIB")) {

            project->values("QMAKE_EXTENSION_SHLIB").append("so");

        } else {

            project->values("QMAKE_EXTENSION_SHLIB").append("dll");

        }

    }

    if(!project->isEmpty("QMAKE_FAILED_REQUIREMENTS")) /* no point */

        return;

    QStringList &configs = project->values("CONFIG");

    if(project->isEmpty("ICON") && !project->isEmpty("RC_FILE"))

        project->values("ICON") = project->values("RC_FILE");

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

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

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

        project->values("QMAKE_COPY_FILE").append("$(COPY)");

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

        project->values("QMAKE_STREAM_EDITOR").append("sed");

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

        project->values("QMAKE_COPY_DIR").append("$(COPY) -R");

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

        project->values("QMAKE_INSTALL_FILE").append("$(COPY_FILE)");

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

        project->values("QMAKE_INSTALL_DIR").append("$(COPY_DIR)");

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

        project->values("QMAKE_INSTALL_PROGRAM").append("$(COPY_FILE)");

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

        project->values("QMAKE_LIBTOOL").append("libtool --silent");

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

        project->values("QMAKE_SYMBOLIC_LINK").append("ln -f -s");

    /* this should probably not be here, but I'm using it to wrap the .t files */

    if(project->first("TEMPLATE") == "app")

        project->values("QMAKE_APP_FLAG").append("1");

    else if(project->first("TEMPLATE") == "lib")

        project->values("QMAKE_LIB_FLAG").append("1");

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

        MakefileGenerator::init();

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

            project->values("MAKEFILE").append("Makefile");

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

            project->values("QMAKE_QMAKE").append("qmake");

        if(project->values("QMAKE_INTERNAL_QMAKE_DEPS").indexOf("qmake_all") == -1)

            project->values("QMAKE_INTERNAL_QMAKE_DEPS").append("qmake_all");

        return; /* subdirs is done */

    }

    //If the TARGET looks like a path split it into DESTDIR and the resulting TARGET

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

        project->values("TARGET") = escapeFilePaths(project->values("TARGET"));

        QString targ = unescapeFilePath(project->first("TARGET"));

        int slsh = qMax(targ.lastIndexOf('/'), targ.lastIndexOf(Option::dir_sep));

        if(slsh != -1) {

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

                project->values("DESTDIR").append("");

            else if(project->first("DESTDIR").right(1) != Option::dir_sep)

                project->values("DESTDIR") = QStringList(project->first("DESTDIR") + Option::dir_sep);

            project->values("DESTDIR") = QStringList(project->first("DESTDIR") + targ.left(slsh+1));

            project->values("TARGET") = QStringList(targ.mid(slsh+1));

        }

    }

    project->values("QMAKE_ORIG_TARGET") = project->values("TARGET");

    project->values("QMAKE_ORIG_DESTDIR") = project->values("DESTDIR");

    project->values("QMAKE_LIBS") += escapeFilePaths(project->values("LIBS"));

    project->values("QMAKE_LIBS_PRIVATE") += escapeFilePaths(project->values("LIBS_PRIVATE"));

    if((!project->isEmpty("QMAKE_LIB_FLAG") && !project->isActiveConfig("staticlib")) ||

       (project->isActiveConfig("qt") &&  project->isActiveConfig("plugin"))) {

        if(configs.indexOf("dll") == -1) configs.append("dll");

    } else if(!project->isEmpty("QMAKE_APP_FLAG") || project->isActiveConfig("dll")) {

        configs.removeAll("staticlib");

    }

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

        project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_INCREMENTAL");

    else if(!project->isEmpty("QMAKE_LFLAGS_PREBIND") &&

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

            project->isActiveConfig("dll"))

        project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_PREBIND");

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

        project->values("INCLUDEPATH") += project->values("QMAKE_INCDIR");

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

        const QStringList &libdirs = project->values("QMAKE_LIBDIR");

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

            if(!project->isEmpty("QMAKE_LFLAGS_RPATH") && project->isActiveConfig("rpath_libdirs"))

                project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + libdirs[i];

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

                project->values("QMAKE_LIBDIR_FLAGS") += "--userlibpath " + escapeFilePath(libdirs[i]);

            } else {

                project->values("QMAKE_LIBDIR_FLAGS") += "-L" + escapeFilePath(libdirs[i]);

            }

        }

    }

    if(project->isActiveConfig("macx") && !project->isEmpty("QMAKE_FRAMEWORKPATH")) {

        const QStringList &fwdirs = project->values("QMAKE_FRAMEWORKPATH");

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

            project->values("QMAKE_FRAMEWORKPATH_FLAGS") += "-F" + escapeFilePath(fwdirs[i]);

        }

    }

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

        const QStringList &rpathdirs = project->values("QMAKE_RPATHDIR");

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

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

                project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + escapeFilePath(QFileInfo(rpathdirs[i]).absoluteFilePath());

        }

    }

    project->values("QMAKE_FILETAGS") << "SOURCES" << "GENERATED_SOURCES" << "TARGET" << "DESTDIR";

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

        const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");

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

            project->values("QMAKE_FILETAGS") += project->values(quc[i]+".input");

    }

    if(project->isActiveConfig("GNUmake") && !project->isEmpty("QMAKE_CFLAGS_DEPS"))

        include_deps = true; //do not generate deps

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

        Option::obj_ext = ".lo"; //override the .o

    MakefileGenerator::init();

    QString comps[] = { "C", "CXX", "OBJC", "OBJCXX", QString() };

    for(int i = 0; !comps[i].isNull(); i++) {

        QString compile_flag = var("QMAKE_COMPILE_FLAG");

        if(compile_flag.isEmpty())

            compile_flag = "-c";

        if(doPrecompiledHeaders() && !project->isEmpty("PRECOMPILED_HEADER")) {

            QString pchFlags = var("QMAKE_" + comps[i] + "FLAGS_USE_PRECOMPILE");

            QString pchBaseName;

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

                pchBaseName = Option::fixPathToTargetOS(project->first("PRECOMPILED_DIR"));

                if(!pchBaseName.endsWith(Option::dir_sep))

                    pchBaseName += Option::dir_sep;

            }

            pchBaseName += project->first("QMAKE_ORIG_TARGET");

            // replace place holders

            pchFlags = pchFlags.replace("${QMAKE_PCH_INPUT}",

                                        fileFixify(project->first("PRECOMPILED_HEADER")));

            pchFlags = pchFlags.replace("${QMAKE_PCH_OUTPUT_BASE}", pchBaseName);

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

                // icc style

                pchFlags = pchFlags.replace("${QMAKE_PCH_OUTPUT}",

                                            pchBaseName + project->first("QMAKE_PCH_OUTPUT_EXT"));

            }

            if (!pchFlags.isEmpty())

                compile_flag += " " + pchFlags;

        }

        QString cflags;

        if(comps[i] == "OBJC" || comps[i] == "OBJCXX")

            cflags += " $(CFLAGS)";

        else

            cflags += " $(" + comps[i] + "FLAGS)";

        compile_flag += cflags + " $(INCPATH)";

        QString compiler = comps[i];

        if (compiler == "C")

            compiler = "CC";

        QString runComp = "QMAKE_RUN_" + compiler;

        if(project->isEmpty(runComp))

            project->values(runComp).append("$(" + compiler + ") " + compile_flag + " -o $obj $src");

        QString runCompImp = "QMAKE_RUN_" + compiler + "_IMP";

        if(project->isEmpty(runCompImp))

            project->values(runCompImp).append("$(" + compiler + ") " + compile_flag + " -o \"$@\" \"$<\"");

    }

    if(project->isActiveConfig("macx") && !project->isEmpty("TARGET") && !project->isActiveConfig("compile_libtool") &&

       ((project->isActiveConfig("build_pass") || project->isEmpty("BUILDS")))) {

        QString bundle;

        if(project->isActiveConfig("bundle") && !project->isEmpty("QMAKE_BUNDLE_EXTENSION")) {

            bundle = unescapeFilePath(project->first("TARGET"));

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

                bundle = unescapeFilePath(project->first("QMAKE_BUNDLE_NAME"));

            if(!bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION")))

                bundle += project->first("QMAKE_BUNDLE_EXTENSION");

        } else if(project->first("TEMPLATE") == "app" && project->isActiveConfig("app_bundle")) {

            bundle = unescapeFilePath(project->first("TARGET"));

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

                bundle = unescapeFilePath(project->first("QMAKE_APPLICATION_BUNDLE_NAME"));

            if(!bundle.endsWith(".app"))

                bundle += ".app";

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

                project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS");

            project->values("QMAKE_PKGINFO").append(project->first("DESTDIR") + bundle + "/Contents/PkgInfo");

            project->values("QMAKE_BUNDLE_RESOURCE_FILE").append(project->first("DESTDIR") + bundle + "/Contents/Resources/empty.lproj");

        } else if(project->first("TEMPLATE") == "lib" && !project->isActiveConfig("staticlib") &&

                  ((!project->isActiveConfig("plugin") && project->isActiveConfig("lib_bundle")) ||

                   (project->isActiveConfig("plugin") && project->isActiveConfig("plugin_bundle")))) {

            bundle = unescapeFilePath(project->first("TARGET"));

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

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

                    bundle = unescapeFilePath(project->first("QMAKE_PLUGIN_BUNDLE_NAME"));

                if(!project->isEmpty("QMAKE_BUNDLE_EXTENSION") && !bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION")))

                    bundle += project->first("QMAKE_BUNDLE_EXTENSION");

                else if(!bundle.endsWith(".plugin"))

                    bundle += ".plugin";

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

                    project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS");

            } else {

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

                    bundle = unescapeFilePath(project->first("QMAKE_FRAMEWORK_BUNDLE_NAME"));

                if(!project->isEmpty("QMAKE_BUNDLE_EXTENSION") && !bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION")))

                    bundle += project->first("QMAKE_BUNDLE_EXTENSION");

                else if(!bundle.endsWith(".framework"))

                    bundle += ".framework";

            }

        }

        if(!bundle.isEmpty()) {

            project->values("QMAKE_BUNDLE") = QStringList(bundle);

            project->values("ALL_DEPS") += project->first("QMAKE_PKGINFO");

            project->values("ALL_DEPS") += project->first("QMAKE_BUNDLE_RESOURCE_FILE");

        } else {

            project->values("QMAKE_BUNDLE").clear();

            project->values("QMAKE_BUNDLE_LOCATION").clear();

        }

    } else { //no bundling here

        project->values("QMAKE_BUNDLE").clear();

        project->values("QMAKE_BUNDLE_LOCATION").clear();

    }

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

        project->values("DISTFILES") += project->values("QMAKE_INTERNAL_INCLUDED_FILES");

    project->values("DISTFILES") += project->projectFile();

    init2();

    project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_LIBDIR_FLAGS" << "QMAKE_FRAMEWORKPATH_FLAGS" << "QMAKE_LIBS";

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

        bool ok;

        int max_files = project->first("QMAKE_MAX_FILES_PER_AR").toInt(&ok);

        QStringList ar_sublibs, objs = project->values("OBJECTS");

        if(ok && max_files > 5 && max_files < (int)objs.count()) {

            QString lib;

            for(int i = 0, obj_cnt = 0, lib_cnt = 0; i != objs.size(); ++i) {

                if((++obj_cnt) >= max_files) {

                    if(lib_cnt) {

                        lib.sprintf("lib%s-tmp%d.a",

                                    project->first("QMAKE_ORIG_TARGET").toLatin1().constData(), lib_cnt);

                        ar_sublibs << lib;

                        obj_cnt = 0;

                    }

                    lib_cnt++;

                }

            }

        }

        if(!ar_sublibs.isEmpty()) {

            project->values("QMAKE_AR_SUBLIBS") = ar_sublibs;

            project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_AR_SUBLIBS";

        }

    }

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

        const QString libtoolify[] = { "QMAKE_RUN_CC", "QMAKE_RUN_CC_IMP",

                                       "QMAKE_RUN_CXX", "QMAKE_RUN_CXX_IMP",

                                       "QMAKE_LINK_THREAD", "QMAKE_LINK", "QMAKE_AR_CMD", "QMAKE_LINK_SHLIB_CMD",

                                       QString() };

        for(int i = 0; !libtoolify[i].isNull(); i++) {

            QStringList &l = project->values(libtoolify[i]);

            if(!l.isEmpty()) {

                QString libtool_flags, comp_flags;

                if(libtoolify[i].startsWith("QMAKE_LINK") || libtoolify[i] == "QMAKE_AR_CMD") {

                    libtool_flags += " --mode=link";

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

                        libtool_flags += " -static";

                    } else {

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

                            int maj = project->first("VER_MAJ").toInt();

                            int min = project->first("VER_MIN").toInt();

                            int pat = project->first("VER_PAT").toInt();

                            comp_flags += " -version-info " + QString::number(10*maj + min) +

                                          ":" + QString::number(pat) + ":0";

                            if(libtoolify[i] != "QMAKE_AR_CMD") {

                                QString rpath = Option::output_dir;

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

                                    rpath = project->first("DESTDIR");

                                    if(QDir::isRelativePath(rpath))

                                        rpath.prepend(Option::output_dir + Option::dir_sep);

                                }

                                comp_flags += " -rpath " + Option::fixPathToTargetOS(rpath, false);

                            }

                        }

                    }

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

                        libtool_flags += " -module";

                } else {

                    libtool_flags += " --mode=compile";

                }

                l.first().prepend("$(LIBTOOL)" + libtool_flags + " ");

                if(!comp_flags.isEmpty())

                    l.first() += comp_flags;

            }

        }

    }

}

void

UnixMakefileGenerator::processPrlVariable(const QString &var, const QStringList &l)

{

    if(var == "QMAKE_PRL_LIBS") {

        project->values("QMAKE_CURRENT_PRL_LIBS") += l;

    } else

        MakefileGenerator::processPrlVariable(var, l);

}

QStringList

&UnixMakefileGenerator::findDependencies(const QString &file)

{

    QStringList &ret = MakefileGenerator::findDependencies(file);

    // Note: The QMAKE_IMAGE_COLLECTION file have all images

    // as dependency, so don't add precompiled header then

    if(doPrecompiledHeaders() && !project->isEmpty("PRECOMPILED_HEADER")

       && file != project->first("QMAKE_IMAGE_COLLECTION")) {

        QString header_prefix;

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

            header_prefix = project->first("PRECOMPILED_DIR");

        header_prefix += project->first("QMAKE_ORIG_TARGET") + project->first("QMAKE_PCH_OUTPUT_EXT");

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

            // icc style

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

                if(file.endsWith(*it)) {

                    ret += header_prefix;

                    break;

                }

            }

        } else {

            // gcc style

            header_prefix += Option::dir_sep + project->first("QMAKE_PRECOMP_PREFIX");

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

                if(file.endsWith(*it)) {

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

                        QString precomp_c_h = header_prefix + "c";

                        if(!ret.contains(precomp_c_h))

                            ret += precomp_c_h;

                    }

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

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

                            QString precomp_objc_h = header_prefix + "objective-c";

                            if(!ret.contains(precomp_objc_h))

                                ret += precomp_objc_h;

                        }

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

                            QString precomp_objcpp_h = header_prefix + "objective-c++";

                            if(!ret.contains(precomp_objcpp_h))

                                ret += precomp_objcpp_h;

                        }

                    }

                    break;

                }

            }

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

                if(file.endsWith(*it)) {

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

                        QString precomp_cpp_h = header_prefix + "c++";

                        if(!ret.contains(precomp_cpp_h))

                            ret += precomp_cpp_h;

                    }

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

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

                            QString precomp_objcpp_h = header_prefix + "objective-c++";

                            if(!ret.contains(precomp_objcpp_h))

                                ret += precomp_objcpp_h;

                        }

                    }

                    break;

                }

            }

        }

    }

    return ret;

}

bool

UnixMakefileGenerator::findLibraries()

{

    QList<QMakeLocalFileName> libdirs, frameworkdirs;

    frameworkdirs.append(QMakeLocalFileName("/System/Library/Frameworks"));

    frameworkdirs.append(QMakeLocalFileName("/Library/Frameworks"));

    const QString lflags[] = { "QMAKE_LIBDIR_FLAGS", "QMAKE_FRAMEWORKPATH_FLAGS", "QMAKE_LFLAGS", "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", QString() };

    for(int i = 0; !lflags[i].isNull(); i++) {

        QStringList &l = project->values(lflags[i]);

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

            bool do_suffix = true;

            QString stub, dir, extn, opt = (*it).trimmed();

            if(opt.startsWith("-")) {

                if(opt.startsWith("-L")) {

                    QMakeLocalFileName f(opt.right(opt.length()-2));

                    if(!libdirs.contains(f))

                        libdirs.append(f);

                } else if(opt.startsWith("-l")) {

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

                        (*it) = "lib" + opt.mid(2) + ".so";

                    } else {

                        stub = opt.mid(2);

                    }

                } else if(Option::target_mode == Option::TARG_MACX_MODE && opt.startsWith("-F")) {

                    frameworkdirs.append(QMakeLocalFileName(opt.right(opt.length()-2)));

                } else if(Option::target_mode == Option::TARG_MACX_MODE && opt.startsWith("-framework")) {

                    if(opt.length() > 11) {

                        opt = opt.mid(11);

                    } else {

                        ++it;

                        opt = (*it);

                    }

                    do_suffix = false;

                    extn = "";

                    dir = "/System/Library/Frameworks/" + opt + ".framework/";

                    stub = opt;

                }

            } else {

                extn = dir = "";

                stub = opt;

                int slsh = opt.lastIndexOf(Option::dir_sep);

                if(slsh != -1) {

                    dir = opt.left(slsh);

                    stub = opt.mid(slsh+1);

                }

                QRegExp stub_reg("^.*lib(" + stub + "[^./=]*)\\.(.*)$");

                if(stub_reg.exactMatch(stub)) {

                    stub = stub_reg.cap(1);

                    extn = stub_reg.cap(2);

                }

            }

            if(!stub.isEmpty()) {

                if(do_suffix && !project->isEmpty("QMAKE_" + stub.toUpper() + "_SUFFIX"))

                    stub += project->first("QMAKE_" + stub.toUpper() + "_SUFFIX");

                bool found = false;

                QStringList extens;

                if(!extn.isNull())

                    extens << extn;

                else

                    extens << project->values("QMAKE_EXTENSION_SHLIB").first() << "a";

                for(QStringList::Iterator extit = extens.begin(); extit != extens.end(); ++extit) {

                    if(dir.isNull()) {

                        QString lib_stub;

                        for(QList<QMakeLocalFileName>::Iterator dep_it = libdirs.begin(); dep_it != libdirs.end(); ++dep_it) {

                            if(exists((*dep_it).local() + Option::dir_sep + "lib" + stub +

                                      "." + (*extit))) {

                                lib_stub = stub;

                                break;

                            }

                        }

                        if(!lib_stub.isNull()) {

                            (*it) = "-l" + lib_stub;

                            found = true;

                            break;

                        }

                    } else {

                        if(exists("lib" + stub + "." + (*extit))) {

                            (*it) = "lib" + stub + "." + (*extit);

                            found = true;

                            break;

                        }

                    }

                }

                if(!found && project->isActiveConfig("compile_libtool")) {

                    for(int dep_i = 0; dep_i < libdirs.size(); ++dep_i) {

                        if(exists(libdirs[dep_i].local() + Option::dir_sep + "lib" + stub + Option::libtool_ext)) {

                            (*it) = libdirs[dep_i].real() + Option::dir_sep + "lib" + stub + Option::libtool_ext;

                            found = true;

                            break;

                        }

                    }

                }

            }