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

**

** 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 "makefile.h"

#include "option.h"

#include "cachekeys.h"

#include "meta.h"

#include <qdir.h>

#include <qfile.h>

#include <qtextstream.h>

#include <qregexp.h>

#include <qhash.h>

#include <qdebug.h>

#include <qbuffer.h>

#include <qsettings.h>

#include <qdatetime.h>

#if defined(Q_OS_UNIX)

#include <unistd.h>

#else

#include <io.h>

#endif

#include <qdebug.h>

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

QT_BEGIN_NAMESPACE

// Well, Windows doesn't have this, so here's the macro

#ifndef S_ISDIR

#  define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)

#endif

bool MakefileGenerator::canExecute(const QStringList &cmdline, int *a) const

{

    int argv0 = -1;

    for(int i = 0; i < cmdline.count(); ++i) {

        if(!cmdline.at(i).contains('=')) {

            argv0 = i;

            break;

        }

    }

    if(a)

        *a = argv0;

    if(argv0 != -1) {

        const QString c = Option::fixPathToLocalOS(cmdline.at(argv0), true);

        if(exists(c))

            return true;

    }

    return false;

}

QString MakefileGenerator::mkdir_p_asstring(const QString &dir, bool escape) const

{

    QString ret =  "@$(CHK_DIR_EXISTS) ";

    if(escape)

        ret += escapeFilePath(dir);

    else

        ret += dir;

    ret += " ";

    if(isWindowsShell())

        ret += "$(MKDIR)";

    else

        ret += "|| $(MKDIR)";

    ret += " ";

    if(escape)

        ret += escapeFilePath(dir);

    else

        ret += dir;

    ret += " ";

    return ret;

}

bool MakefileGenerator::mkdir(const QString &in_path) const

{

    QString path = Option::fixPathToLocalOS(in_path);

    if(QFile::exists(path))

        return true;

    QDir d;

    if(path.startsWith(QDir::separator())) {

        d.cd(QString(QDir::separator()));

        path.remove(0, 1);

    }

    bool ret = true;

#ifdef Q_OS_WIN

    bool driveExists = true;

    if(!QDir::isRelativePath(path)) {

        if(QFile::exists(path.left(3))) {

            d.cd(path.left(3));

            path.remove(0, 3);

        } else {

            warn_msg(WarnLogic, "Cannot access drive '%s' (%s)",

                     path.left(3).toLatin1().data(), path.toLatin1().data());

            driveExists = false;

        }

    }

    if(driveExists)

#endif

    {

        QStringList subs = path.split(QDir::separator());

        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 {

                    ret = false;

                    break;

                }

            }

        }

    }

    return ret;

}

// ** base makefile generator

MakefileGenerator::MakefileGenerator() :

    init_opath_already(false), init_already(false), no_io(false), project(0)

{

}

void

MakefileGenerator::verifyCompilers()

{

    QMap<QString, QStringList> &v = project->variables();

    QStringList &quc = v["QMAKE_EXTRA_COMPILERS"];

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

        bool error = false;

        QString comp = quc.at(i);

        if(v[comp + ".output"].isEmpty()) {

            if(!v[comp + ".output_function"].isEmpty()) {

                v[comp + ".output"].append("${QMAKE_FUNC_FILE_IN_" + v[comp + ".output_function"].first() + "}");

            } else {

                error = true;

                warn_msg(WarnLogic, "Compiler: %s: No output file specified", comp.toLatin1().constData());

            }

        } else if(v[comp + ".input"].isEmpty()) {

            error = true;

            warn_msg(WarnLogic, "Compiler: %s: No input variable specified", comp.toLatin1().constData());

        }

        if(error)

            quc.removeAt(i);

        else

            ++i;

    }

}

void

MakefileGenerator::initOutPaths()

{

    if(init_opath_already)

        return;

    verifyCompilers();

    init_opath_already = true;

    QMap<QString, QStringList> &v = project->variables();

    //for shadow builds

    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 = QDir::fromNativeSeparators(root);

            if(!root.isEmpty()) {

                QFileInfo fi = fileInfo(Option::mkfile::cachefile);

                if(!fi.makeAbsolute()) {

                    QString cache_r = fi.path(), pwd = Option::output_dir;

                    if(pwd.startsWith(cache_r) && !pwd.startsWith(root)) {

                        pwd = root + pwd.mid(cache_r.length());

                        if(exists(pwd))

                            v.insert("QMAKE_ABSOLUTE_SOURCE_PATH", QStringList(pwd));

                    }

                }

            }

        }

    }

    if(!v["QMAKE_ABSOLUTE_SOURCE_PATH"].isEmpty()) {

        QString &asp = v["QMAKE_ABSOLUTE_SOURCE_PATH"].first();

        asp = QDir::fromNativeSeparators(asp);

        if(asp.isEmpty() || asp == Option::output_dir) //if they're the same, why bother?

            v["QMAKE_ABSOLUTE_SOURCE_PATH"].clear();

    }

    QString currentDir = qmake_getpwd(); //just to go back to

    //some builtin directories

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

        v["PRECOMPILED_DIR"] = v["OBJECTS_DIR"];

    QString dirs[] = { QString("OBJECTS_DIR"), QString("DESTDIR"), QString("QMAKE_PKGCONFIG_DESTDIR"),

                       QString("SUBLIBS_DIR"), QString("DLLDESTDIR"), QString("QMAKE_LIBTOOL_DESTDIR"),

                       QString("PRECOMPILED_DIR"), QString() };

    for(int x = 0; !dirs[x].isEmpty(); x++) {

        if(v[dirs[x]].isEmpty())

            continue;

        const QString orig_path = v[dirs[x]].first();

        QString &pathRef = v[dirs[x]].first();

        pathRef = fileFixify(pathRef, Option::output_dir, Option::output_dir);

#ifdef Q_OS_WIN

        // We don't want to add a separator for DLLDESTDIR on Windows (###why?)

        if(!(dirs[x] == "DLLDESTDIR"))

#endif

        {

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

                pathRef += Option::dir_sep;

        }

        if(noIO())

            continue;

        QString path = project->first(dirs[x]); //not to be changed any further

        path = fileFixify(path, currentDir, Option::output_dir);

        debug_msg(3, "Fixed output_dir %s (%s) into %s", dirs[x].toLatin1().constData(),

                  orig_path.toLatin1().constData(), path.toLatin1().constData());

        if(!mkdir(path))

            warn_msg(WarnLogic, "%s: Cannot access directory '%s'", dirs[x].toLatin1().constData(),

                     path.toLatin1().constData());

    }

    //out paths from the extra compilers

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

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

        QString tmp_out = project->values((*it) + ".output").first();

        if(tmp_out.isEmpty())

            continue;

        const QStringList &tmp = project->values((*it) + ".input");

        for(QStringList::ConstIterator it2 = tmp.begin(); it2 != tmp.end(); ++it2) {

            QStringList &inputs = project->values((*it2));

            for(QStringList::Iterator input = inputs.begin(); input != inputs.end(); ++input) {

                (*input) = fileFixify((*input), Option::output_dir, Option::output_dir);

                QString path = unescapeFilePath(replaceExtraCompilerVariables(tmp_out, (*input), QString()));

                path = Option::fixPathToTargetOS(path);

                int slash = path.lastIndexOf(Option::dir_sep);

                if(slash != -1) {

                    path = path.left(slash);

                    // Make out path only if it does not contain makefile variables

                    if(!path.contains("${"))

                        if(path != "." &&

                           !mkdir(fileFixify(path, qmake_getpwd(), Option::output_dir)))

                            warn_msg(WarnLogic, "%s: Cannot access directory '%s'",

                                     (*it).toLatin1().constData(), path.toLatin1().constData());

                }

            }

        }

    }

    if(!v["DESTDIR"].isEmpty()) {

        QDir d(v["DESTDIR"].first());

        if(Option::fixPathToLocalOS(d.absolutePath()) == Option::fixPathToLocalOS(Option::output_dir))

            v.remove("DESTDIR");

    }

}

QMakeProject

*MakefileGenerator::projectFile() const

{

    return project;

}

void

MakefileGenerator::setProjectFile(QMakeProject *p)

{

    if(project)

        return;

    project = p;

    init();

    usePlatformDir();

    findLibraries();

    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE &&

       project->isActiveConfig("link_prl")) //load up prl's'

        processPrlFiles();

}

QStringList

MakefileGenerator::findFilesInVPATH(QStringList l, uchar flags, const QString &vpath_var)

{

    QStringList vpath;

    QMap<QString, QStringList> &v = project->variables();

    for(int val_it = 0; val_it < l.count(); ) {

        bool remove_file = false;

        QString &val = l[val_it];

        if(!val.isEmpty()) {

            QString file = fixEnvVariables(val);

            if(!(flags & VPATH_NoFixify))

                file = fileFixify(file, qmake_getpwd(), Option::output_dir);

            if (file.at(0) == '\"' && file.at(file.length() - 1) == '\"')

                file = file.mid(1, file.length() - 2);

            if(exists(file)) {

                ++val_it;

                continue;

            }

            bool found = false;

            if(QDir::isRelativePath(val)) {

                if(vpath.isEmpty()) {

                    if(!vpath_var.isEmpty())

                        vpath = v[vpath_var];

                    vpath += v["VPATH"] + v["QMAKE_ABSOLUTE_SOURCE_PATH"] + v["DEPENDPATH"];

                    if(Option::output_dir != qmake_getpwd())

                        vpath += Option::output_dir;

                }

                for(QStringList::Iterator vpath_it = vpath.begin();

                    vpath_it != vpath.end(); ++vpath_it) {

                    QString real_dir = Option::fixPathToLocalOS((*vpath_it));

                    if(exists(real_dir + QDir::separator() + val)) {

                        QString dir = (*vpath_it);

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

                            dir += Option::dir_sep;

                        val = dir + val;

                        if(!(flags & VPATH_NoFixify))

                            val = fileFixify(val);

                        found = true;

                        debug_msg(1, "Found file through vpath %s -> %s",

                                  file.toLatin1().constData(), val.toLatin1().constData());

                        break;

                    }

                }

            }

            if(!found) {

                QString dir, regex = val, real_dir;

                if(regex.lastIndexOf(Option::dir_sep) != -1) {

                    dir = regex.left(regex.lastIndexOf(Option::dir_sep) + 1);

                    real_dir = dir;

                    if(!(flags & VPATH_NoFixify))

                        real_dir = fileFixify(real_dir, qmake_getpwd(), Option::output_dir);

                    regex.remove(0, dir.length());

                }

                if(real_dir.isEmpty() || exists(real_dir)) {

                    QStringList files = QDir(real_dir).entryList(QStringList(regex));

                    if(files.isEmpty()) {

                        debug_msg(1, "%s:%d Failure to find %s in vpath (%s)",

                                  __FILE__, __LINE__,

                                  val.toLatin1().constData(), vpath.join("::").toLatin1().constData());

                        if(flags & VPATH_RemoveMissingFiles)

                            remove_file = true;

                        else if(flags & VPATH_WarnMissingFiles)

                            warn_msg(WarnLogic, "Failure to find: %s", val.toLatin1().constData());

                    } else {

                        l.removeAt(val_it);

                        QString a;

                        for(int i = (int)files.count()-1; i >= 0; i--) {

                            if(files[i] == "." || files[i] == "..")

                                continue;

                            a = dir + files[i];

                            if(!(flags & VPATH_NoFixify))

                                a = fileFixify(a);

                            l.insert(val_it, a);

                        }

                    }

                } else {

                    debug_msg(1, "%s:%d Cannot match %s%c%s, as %s does not exist.",

                              __FILE__, __LINE__, real_dir.toLatin1().constData(),

                              QDir::separator().toLatin1(),

                              regex.toLatin1().constData(), real_dir.toLatin1().constData());

                    if(flags & VPATH_RemoveMissingFiles)

                        remove_file = true;

                    else if(flags & VPATH_WarnMissingFiles)

                        warn_msg(WarnLogic, "Failure to find: %s", val.toLatin1().constData());

                }

            }

        }

        if(remove_file)

            l.removeAt(val_it);

        else

            ++val_it;

    }

    return l;

}

void

MakefileGenerator::initCompiler(const MakefileGenerator::Compiler &comp)

{

    QMap<QString, QStringList> &v = project->variables();

    QStringList &l = v[comp.variable_in];

    // find all the relevant file inputs

    if(!init_compiler_already.contains(comp.variable_in)) {

        init_compiler_already.insert(comp.variable_in, true);

        if(!noIO())

            l = findFilesInVPATH(l, (comp.flags & Compiler::CompilerRemoveNoExist) ?

                                 VPATH_RemoveMissingFiles : VPATH_WarnMissingFiles, "VPATH_" + comp.variable_in);

    }

}

void

MakefileGenerator::init()

{

    initOutPaths();

    if(init_already)

        return;

    verifyCompilers();

    init_already = true;

    QMap<QString, QStringList> &v = project->variables();

    QStringList &quc = v["QMAKE_EXTRA_COMPILERS"];

    //make sure the COMPILERS are in the correct input/output chain order

    for(int comp_out = 0, jump_count = 0; comp_out < quc.size(); ++comp_out) {

    continue_compiler_chain:

        if(jump_count > quc.size()) //just to avoid an infinite loop here

            break;

        if(project->variables().contains(quc.at(comp_out) + ".variable_out")) {

            const QStringList &outputs = project->variables().value(quc.at(comp_out) + ".variable_out");

            for(int out = 0; out < outputs.size(); ++out) {

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

                    if(comp_in == comp_out)

                        continue;

                    if(project->variables().contains(quc.at(comp_in) + ".input")) {

                        const QStringList &inputs = project->variables().value(quc.at(comp_in) + ".input");

                        for(int in = 0; in < inputs.size(); ++in) {

                            if(inputs.at(in) == outputs.at(out) && comp_out > comp_in) {

                                ++jump_count;

                                //move comp_out to comp_in and continue the compiler chain

                                quc.move(comp_out, comp_in);

                                comp_out = comp_in;

                                goto continue_compiler_chain;

                            }

                        }

                    }

                }

            }

        }

    }

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

        const QStringList &subs = v["QMAKE_SUBSTITUTES"];

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

            if(!subs.at(i).endsWith(".in")) {

                warn_msg(WarnLogic, "Substitute '%s' does not end with '.in'",

                         subs.at(i).toLatin1().constData());

                continue;

            }

            QFile in(fileFixify(subs.at(i))), out(fileInfo(subs.at(i)).fileName());

            if(out.fileName().endsWith(".in"))

                out.setFileName(out.fileName().left(out.fileName().length()-3));

            if(in.open(QFile::ReadOnly)) {

                QString contents;

                QStack<int> state;

                enum { IN_CONDITION, MET_CONDITION, PENDING_CONDITION };

                for(int count = 1; !in.atEnd(); ++count) {

                    QString line = QString::fromUtf8(in.readLine());

                    if(line.startsWith("!!IF ")) {

                        if(state.isEmpty() || state.top() == IN_CONDITION) {

                            QString test = line.mid(5, line.length()-(5+1));

                            if(project->test(test))

                                state.push(IN_CONDITION);

                            else

                                state.push(PENDING_CONDITION);

                        } else {

                            state.push(MET_CONDITION);

                        }

                    } else if(line.startsWith("!!ELIF ")) {

                        if(state.isEmpty()) {

                            warn_msg(WarnLogic, "(%s:%d): Unexpected else condition",

                                     in.fileName().toLatin1().constData(), count);

                        } else if(state.top() == PENDING_CONDITION) {

                            QString test = line.mid(7, line.length()-(7+1));

                            if(project->test(test))  {

                                state.pop();

                                state.push(IN_CONDITION);

                            }

                        } else if(state.top() == IN_CONDITION) {

                            state.pop();

                            state.push(MET_CONDITION);

                        }

                    } else if(line.startsWith("!!ELSE")) {

                        if(state.isEmpty()) {

                            warn_msg(WarnLogic, "(%s:%d): Unexpected else condition",

                                     in.fileName().toLatin1().constData(), count);

                        } else if(state.top() == PENDING_CONDITION) {

                            state.pop();

                            state.push(IN_CONDITION);

                        } else if(state.top() == IN_CONDITION) {

                            state.pop();

                            state.push(MET_CONDITION);

                        }

                    } else if(line.startsWith("!!ENDIF")) {

                        if(state.isEmpty())

                            warn_msg(WarnLogic, "(%s:%d): Unexpected endif",

                                     in.fileName().toLatin1().constData(), count);

                        else

                            state.pop();

                    } else if(state.isEmpty() || state.top() == IN_CONDITION) {

                        contents += project->expand(line).join(QString(Option::field_sep));

                    }

                }

                if(out.exists() && out.open(QFile::ReadOnly)) {